CFX and FLEXlm
From UIC
CFX & FLEXlm cracking!
Contents |
| Infos | |
|---|---|
| Author: | fantoibed |
| Email: | fantoibed@libero.it |
| Website: | http://digilander.libero.it/fantoibed |
| Date: | 23/10/2003 (dd/mm/yyyy) |
| Level: | 
|
| Language: | Italian 
|
| Comments: | |
Introduction
...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... 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 pò di serial fishing....
Direi, che per un sistema tanto famoso e sempre più osannato e utilizzato, la cosa è a dir poco scandalosa!!! :O
Tools
SoftICE (per la versione, tenete presente che CFX si può installare solo su Windows NT/2000/XP)
FLEXlm SDK http://www.macrovision.com/products/flexlm/index.shtml
Link e Riferimenti
http://www.aeat.com/cfx/ per trovare CFX.
Notizie sul Programma
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.... :-)))
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...
Essay
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... :-) ) Vediamo il formato del file della licenza (license.dat):
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):
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:
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 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:
All'indirizzo [ESP+18h] (fate un pò di conti...) c'è l'indirizzo di memoria contenente la variabile code. Cos'è 'sto code? È 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]:
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];
<nowiki>#</nowiki>define LM_MAX_BEH_VER 4
char behavior_ver[LM_MAX_BEH_VER + 1];
} VENDORCODE5;
In particolare abbiamo:
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:
<nowiki>#</nowiki>define VENDOR_KEY2 0x0
<nowiki>#</nowiki>define VENDOR_KEY3 0x0
<nowiki>#</nowiki>define VENDOR_KEY4 0x0
<nowiki>#</nowiki>define VENDOR_KEY5 0x0
<nowiki>#</nowiki>define VENDOR_NAME "demo"
<nowiki>#</nowiki>define LM_SEED1 0x12345678
<nowiki>#</nowiki>define LM_SEED2 0x87654321
<nowiki>#</nowiki>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:
<nowiki>*</nowiki> [...SNIP..]
<nowiki>*</nowiki>
<nowiki>*</nowiki> Module: $Id: lmcrypt.c,v 1.29 2002/01/08 20:56:12 daniel Exp $
<nowiki>*</nowiki>
<nowiki>*</nowiki> Description: Reads an existing license file and fills in the
<nowiki>*</nowiki> encryption codes in the FEATURE and FEATURESET lines.
<nowiki>*</nowiki>
<nowiki>*</nowiki> Usage: lmcrypt [iofiles] [-i inputfile] [-o outputfile]
<nowiki>*</nowiki>
<nowiki>*</nowiki> [..SNIP...]
<nowiki>*</nowiki>/
Bene! Che altro c'è da dire? Beh, possiamo vedere un pò 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 pò più attenzione l'andamento del programma con F8, ci saremmo ritrovati davanti questo...
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... :-)
Note Finali
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!
Disclaimer
I documenti qui pubblicati sono da considerarsi pubblici e liberamente distribuibili, a patto che se ne citi la fonte di provenienza. Tutti i documenti presenti su queste pagine sono stati scritti esclusivamente a scopo di ricerca, nessuna di queste analisi è stata fatta per fini commerciali, o dietro alcun tipo di compenso. I documenti pubblicati presentano delle analisi puramente teoriche della struttura di un programma, in nessun caso il software è stato realmente disassemblato o modificato; ogni corrispondenza presente tra i documenti pubblicati e le istruzioni del software oggetto dell'analisi, è da ritenersi puramente casuale. Tutti i documenti vengono inviati in forma anonima ed automaticamente pubblicati, i diritti di tali opere appartengono esclusivamente al firmatario del documento (se presente), in nessun caso il gestore di questo sito, o del server su cui risiede, può essere ritenuto responsabile dei contenuti qui presenti, oltretutto il gestore del sito non è in grado di risalire all'identità del mittente dei documenti. Tutti i documenti ed i file di questo sito non presentano alcun tipo di garanzia, pertanto ne è sconsigliata a tutti la lettura o l'esecuzione, lo staff non si assume alcuna responsabilità per quanto riguarda l'uso improprio di tali documenti e/o file, è doveroso aggiungere che ogni riferimento a fatti cose o persone è da considerarsi PURAMENTE casuale. Tutti coloro che potrebbero ritenersi moralmente offesi dai contenuti di queste pagine, sono tenuti ad uscire immediatamente da questo sito.
Vogliamo inoltre ricordare che il Reverse Engineering è uno strumento tecnologico di grande potenza ed importanza, senza di esso non sarebbe possibile creare antivirus, scoprire funzioni malevoli e non dichiarate all'interno di un programma di pubblico utilizzo. Non sarebbe possibile scoprire, in assenza di un sistema sicuro per il controllo dell'integrità, se il "tal" programma è realmente quello che l'utente ha scelto di installare ed eseguire, né sarebbe possibile continuare lo sviluppo di quei programmi (o l'utilizzo di quelle periferiche) ritenuti obsoleti e non più supportati dalle fonti ufficiali.
