CFX è un pacchetto di calcolo numerico destinato alle simulazioni termofluidodinamiche. Se state progettando la fusoliera della navetta Venture Star per conto della NASA e i recenti tagli al bilancio non vi consentono di poter disporre di una galleria del vento ipersonica, CFX potrebbe essere un software giusto per voi. Potete usarlo anche per studiare la combustione e la fluidodinamica interna del motore della DUNA, ma mi pare che quella volta alla FIAT avessero usato un altro programma... mi pare girasse su Gameboy... :-))) No ti sbagli, girava sul Vic20, sul gameboy ora ci gira anche FinalFantasy se ci avessero progettato la Duna ora non avrebbe un Fan Club di disperati ;p NdQue.

Quello che conta di più, però, è che CFX utilizza FLEXlm, il sistema di licensing distribuito più famoso al mondo.... :-)))

...Dunque, l'introduzione è la parte iniziale di un rapporto sessuale, in cui lui (lui chi? non certo io, purtroppo...) ...Uhm, no, forse Quequero non intendeva questo... (hihihi) :-)

Vabbè, soffochiamo la mia latente follia (conosciuta tra gli amici come: eccesso di testosterone causato dalla mancanza di un individuo di sesso (preferibilmente) femminile utilizzabile come corpo riproduttore (aka: pezzo di carne gratis e consenziente) ;p, questa mia nota te la metto in corsivo invece che nel solito rosso cosi non risalta subito agli occhi che sei affetto da una cosi grave (seppur diffusa) mancanza :PPPP NdQue) ed iniziamo a parlare di reversing... Come ho già detto prima, CFX è un programma di simulazioni termo-fluidodinamiche protetto con FLEXlm, che è un sistema di licensing distribuito. Non mi soffermerò su cosa significhi "licensing distribuito", visto che il target di questo tutorial non prevede il niubbone tontolone, in ogni caso google può soddisfare tutte le vostre domande. Il primo approccio con tale sistema è stato mooolto timoroso, visto lo scarso numero di crack che si trovano in rete e la complessità di impostazione di tutto l'ambaradan. Mi sono tirato su il morale (e di molto) quando ho trovato su +Fravia una serie di articoli che trattavano proprio il reversing dei sistemi flexlm.

In realtà, le prime avvisaglie del fatto che il FLEXlm non fosse impossibile da crackare l'ho avuto reversando un crack trovato su eMule. Nonostante questo crack, prima che lo rimaneggiassi io, funzionasse (e male) solo su Win2000 e non su XP e successivi, il suo disassemblato mostrava come le chiavi da inserire nel file di licenza si potessero pescare dalla memoria con un po' di serial fishing....

Direi, che per un sistema tanto famoso e sempre più osannato e utilizzato, la cosa è a dir poco scandalosa!!! :O

SoftICE (per la versione, tenete presente che CFX si puo' installare solo su Windows NT/2000/XP)

FLEXlm SDK (http://www.macrovision.com/products/flexlm/index.shtml)

http://www.aeat.com/cfx/

Se siete ingegneri meccanici o aeronautici, potrebbe interessarvi il CFX, altrimenti non penso vi possa servire, a meno che non vogliate utilizzarlo per studiare il flusso d'aria nel vostro condotto anale per perfezionare le vostre prestazioni nelle gare di "culinaria" (nel senso di "culi"+"in"+"aria", cioè gare di scorregge....) :-)

Il FLEXlm, invece può tornarvi molto utile, visto che sono sempre più numerosi i programmi che lo adottano, anche se in molti casi le software house si accontentano di generare file di licenza locali...

Di buffonate ne ho già dette abbastanza vedo che almeno su una cosa siamo d'accordo ;p NdQue, quindi mettiamoci al lavoro! L'oggetto principale dei nostri studi sarà la libreria lmgr325c.dll che si occupa di fare da tramite tra il programma (nella fattispecie il CFX) ed "license daemon" locale, che è un client TCP/IP in grado di collegarsi con il "license server" remoto (nel mio caso è anch'esso locale... :-) )

SERVER nome_host host_id porta
DAEMON CFDS CFXd.exe
#Prima feature
INCREMENT   CFX-POST    CFDS  5.200 22-nov-2010 999 00000000000000000000 ISSUER=UIC
#Seconda feature
INCREMENT   CFX-BUILD   CFDS  5.200 22-nov-2010 999 00000000000000000000 ISSUER=UIC
#Terza feature
INCREMENT NOME_FEATURE VENDOR VERSIONE  DATA  NUM_LIC    SIGNATURE       ISSUER=UIC
.... eccetera ....

Nome_host, host_Id (che spesso è l'indirizzo MAC della scheda di rete), la porta in listening ecc... sono tutti parametri di "configurazione" che possono essere trovati facilmente con lmtool (che serve a configurare il license daemon), con netstat (per la porta), ecc. Per gli altri parametri, confrontate la terza feature con le prime due. VERSIONE indica la versione del FLEXlm con cui è stata creata la licenza, non la versione del software protetto (si fa' per dire...) dal FLEXlm...

I parametri che noi dobbiamo trovare sono il NOME_FEATURE e soprattutto la SIGNATURE. Per fare ciò, carichiamo lmgr325c.dll con il symbol loader di SoftICE e settiamo un bpx su lc_checkout. Ecco il prototipo di questa funzione (tratto dal SDK di FLEXlm):

status = lc_checkout(job, feature, version, num_lic, flag, code, dup_group)

Di tutti i parametri passati, per ora, ci interessa solo feature. Dobbiamo pensare a feature e signature come ad una coppia username a password e, visto che ci sono 22 coppie di questo tipo in CFX 5.5 (sempre che si vogliano abilitare tutte le opzioni!!! ;-) ) è opportuno mantenere un certo ordine. Fissato il breakpoint, apriamo CFX e facciamo partire qualcosa (Build, Solver o Post, indifferentemente). Appena CFX chiede un checkout di una certa fiaciur, SoftICE poppa mostrandoci l'inizio della routine lc_checkout.

Dove troviamo la tanto agognata feature? Beh, siccome tutti i parametri sono a 32bit e ci troviamo dentro la funzione, sappiamo che lo stack pointer contiene l'indirizzo di ritorno, [ESP+4] contiene il primo parametro, [ESP+8] il secondo e così via... In particolare, [ESP+8] contiene l'indirizzo di memoria in cui è contenuta la feature string in questione. Scrivetela su un pezzo di carta. Ora ci manca la signature, quindi togliamo il breakpoint da lc_checkout e lo mettiamo in l_extract_date. Che c'entra la data? Nulla, hihihi, ma guardate la sorpresona!!! :-)

Facciamo poppare sulla nuova funzione, usciamone con F12 e steppiamo in scioltezza con F10 finchè, premendo F10 sopra un'istruzione di call ci troviamo davanti al seguente listato:

E87F7DFFFF   call    l_extract_date   <---- in EBX c'è la vendorkey5
83C404       add     esp, 4
50           push    eax
57           push    edi
56           push    esi
E8326BFFFF   call    sub_demoniaca
83C410       add     esp, 10h <---- da qui in poi, [EAX] contiene la signature!!!

In pratica, l'ultima funzione su cui abbiamo premuto F10 chiamava al suo interno l_extract_date: ci saremmo trovati qui anche premendo CTRL+D! :-) Prima di steppare avanti, scriviamoci il contenuto di EBX, chiamiamolo vendorkey5 (il perchè lo vedremo più avanti...). Ora steppiamo con F10 fino all'ultima riga riportata. Al ritorno dalla funzione demoniaca, cioè quella in bianco, avremo in [EAX] l'indirizzo della stringa contenente la signature relativa alla feature richiesta!!!

SBALORDITIVO! Sembra un sistema di licensing tanto sofisticato, e poi si scopre che i codici girano IN CHIARO per la memoria!!!! :-OOOO

Bene, ora possiamo ripetere il procedimento per tutte le varie features che vengono richieste dal programma, ma vediamo di aggiungere qualcosa. Togliamo il breakpoint su l_extract_date e rimettiamolo su lc_checkout! Facciamo poppare il SoftICE e guardiamo meglio i parametri passati a tale funzione. Per comodità ne ripropongo il prototipo:

status = lc_checkout(job, feature, version, num_lic, flag, code, dup_group)

All'indirizzo [ESP+18h] (fate un po' di conti...) c'è l'indirizzo di memoria contenente la variabile code. Cos'è 'sto code? E' tutto ciò che ci serve per creare un bel keygenerator senza star lì a smaronarci per dover scrivere numeri su un fogliaccio di carta... :-) Prelevando dai sorgenti inclusi nel FLEXlm SDK, ecco cosa possiamo aspettare di trovarci all'indirizzo di memoria contenuto in [ESP+18h]:

typedef struct vendorcode5 {
     short type;            /* Type of structure */
     unsigned long data[2]; /* 64-bit code */
     unsigned long keys[4]; 
     short flexlm_version;
     short flexlm_revision;
     char flexlm_patch[2];
#define LM_MAX_BEH_VER 4
     char behavior_ver[LM_MAX_BEH_VER + 1];
} VENDORCODE5;

In particolare abbiamo:

int type;                   /* Non ci interessa */
int (seed1)^(vendorkey5);   /* seed 1 for Flexlm checksum */
int (seed2)^(vendorkey5);   /* seed 2 for Flexlm checksum */
int vendorkey1;             /* vendor key 1 */
int vendorkey2;             /* vendor key 2 */
int vendorkey3;             /* vendor key 3 */
int vendorkey4;             /* vendor key 4 */
short flexlm_version;       /* Non ci interessa */
short flexlm_revision;      /* Non ci interessa */

Come possiamo vedere, l'unica cosa cosa che ci manca è la vendorkey5, ma in realtà l'abbiamo pescata prima!!! Cosa sono queste chiavi? Hihihi, basta leggere l' SDK! Sono tutto quello che serve a generare le signature per qualiasi feature!!! :-) Se apriamo la sottodirectory machind all'interno della directory del FLEXlm SDK, troviamo anche i sorgenti in C per farci il nostro keygen!!! :-) In particolare apriamo il file lm_code.h:

#define VENDOR_KEY1 0x0
#define VENDOR_KEY2 0x0
#define VENDOR_KEY3 0x0
#define VENDOR_KEY4 0x0
#define VENDOR_KEY5 0x0
#define VENDOR_NAME "demo"	
#define LM_SEED1 0x12345678
#define LM_SEED2 0x87654321
#define LM_SEED3 0xabcdef01  <---- questo non viene usato nel nostro caso!

Basta che mettiamo "CFDS" come vendor name, inseriamo le chiavi pescate, compiliamo e usiamo lmcrypt.c! Riporto solo parte dell'intestazione del sorgente per mostrare come funziona e cosa fa':

 /*
 * [...SNIP..]
 *
 *  Module: $Id: lmcrypt.c,v 1.29 2002/01/08 20:56:12 daniel Exp $
 *
 *  Description: Reads an existing license file and fills in the
 *               encryption codes in the FEATURE and FEATURESET lines.
 *
 * Usage:        lmcrypt [iofiles] [-i inputfile] [-o outputfile]
 *
 * [..SNIP...]
 */			

Bene! Che altro c'è da dire? Beh, possiamo vedere un po' meglio da dove viene fuori la vendorkey5, ad esempio! Riprendiamo il pezzo di codice che ho già mostrato prima, ma mostriamo anche l'antefatto! Se invece che correre come delle belve con F10, avessimo seguito con un po' più attenzione l'andamento del programma con F8, ci saremmo ritrovati davanti questo...

E81D0B0000   call    sub_malefica <---- Questa funzione torna vendorkey5 in EAX!
83C408       add     esp, 8
D8           mov     ebx, eax <-------- vendorkey5 viene immagazzinato in EBX!
8D45B8       lea     eax, [ebp+var_48]
6A20         push    20h
57           push    edi
50           push    eax
E89CB70000   call    _memcpy
83C40C       add     esp, 0Ch
8B4704       mov     eax, [edi+4] <---- Preleva il (seed1^key5) dalla licenza
33C3         xor     eax, ebx <--------- (seed1^key5)^key5 -> seed1 "liscio"
8D4DB8       lea     ecx, [ebp+var_48]
51           push    ecx
8945BC       mov     [ebp+var_44], eax<--- Memorizza il seed1 "liscio"
8B4708       mov     eax, [edi+8] <---- Preleva il (seed2^key5) dalla licenza
8B7D0C       mov     edi, [ebp+arg_4]
33C3         xor     eax, ebx <--------- (seed2^key5)^key5 -> seed2 "liscio"
8945C0       mov     [ebp+var_40], eax<--- Memorizza il seed2 "liscio"
8D4748       lea     eax, [edi+48h]
50           push    eax
E87F7DFFFF   call    l_extract_date
83C404       add     esp, 4<--- Questo è il punto in cui ci siamo ritrovati prima!

Bene bene, direi che questo tutorial può concludersi qui... :-) I punti cardine li ho delineati, per gli approfondimenti ci sono i manuali in pdf inseriti nella SDK. Se volete analizzare per intero l'algoritmo di criptazione, ora sapete dove puntare il vostro SoftICE (...e complimenti in anticipo a chi riesce a farcela anche con OllyDbg!), ma tenete presente che da una versione all'altra l'algoritmo può cambiare mentre le API, per ovvie ragioni di compatibilità, devono restare quelle! Tenete presente che io ho usato la versione 8.1 del FLEXlm SDK, mentre la licenza di CFX è stata generata con la versione 5.12... :-)

Mi sono volutamente astenuto dal riportare signatures, vendorkeys e seeds funzionanti. Ho strippato anche le indicazioni di offset del codice che ho riportato, lasciando gli opcodes delle istruzioni. Che ci volete fare? Sto diventando paranoico!!! :-) In ogni caso, facendo una binary search sugli opcodes delle istruzioni è possibile pervenire rapidamente alla parte di codice riportata! ;-)

Ringrazio AndreaGeddon, kOrn[CSA], Quequero e tutta la UIC!