Keygen EMU8086

From UIC

Keygen EMU8086

Keygen EMU8086
Author:	Andrew10111989
Email:	none
Website:	none
Date:	12/06/2010 (dd/mm/yyyy)
Level:
Language:	Italian
Comments:

Tools

OllyDbg 1.10
PEiD 0.95

Link e Riferimenti

• http://www.emu8086.com

Introduzione

In questo tutorial proveremo a creare un keygen per un compilatore assembly, è un ottimo programma, gira tranquillamente su Seven e ha un aspetto molto più user-friendly dei vari tasm, masm, ecc… si chiama emu8086 (versione 4.08) e presenta un limite di utilizzo di 14 giorni. Questo non è un tutorial ASM né tantomeno di ollydbg, dovete essere ben preparati su questi due argomenti perché molte cose le prenderò per scontate…

Essay

Una volta avviato il programma presenta un nag-screen con al centro un grosso pulsante per effettuare la registrazione, clicchiamoci sopra e vediamo apparire un form di registrazione con due campi; Nome Licenza e Chiave di Registrazione. Proviamo a mettere dei dati casuali, tipo Andrew e 111222333444, click su OK e una finestra ci avvisa che il codice inserito non è corretto ( non ci speravamo più di tanto alla fine ^^ ). Bene, prima di attaccare con le maniere forti il programma in questione, diamo un’ occhiata al PEiD, l’ eseguibile risulta essere compilato in Microsoft Visual Basic 5.0/6.0 ( un compilatore ASM scritto in VB lol :P ), questo come vedremo sarà un punto a nostro favore perché le funzioni matematiche, logiche, e di manipolazione delle stringhe verranno tutte richiamate dalla DLL MSVBVM60, e i loro nomi saranno abbastanza espliciti per capire a cosa servono… Ok, ora che abbiamo qualche info in più apriamo il caro olly ( io userò la versione 1.10 ), proviamo a lanciare l’eseguibile emu8086 ma c’è qualcosa che non va, il debugger si blocca, e il programma non vuole saperne di avviarsi! No problem, chiudiamo olly, eseguiamo emu8086, apriamo la finestra di registrazione, quindi riapriamo olly e dal menu File->Attach selezioniamo il processo (C:\emu8086\emu8086.exe nel mio caso), F9 o Run, e siamo pronti per davvero… A questo punto proviamo a settare qualche bps, da Command Line provo il mio preferito, bp GetWindowTextA, Nome:Andrew Key:111222333444 ( per ora mettete solo caratteri, niente numeri o altri simboli, anzi se inserite anche voi Andrew rendete il tutto più semplice ), click su OK, e voilà eccoci nella nostra USER32.GetWindowTextA, facciamo qualche colpo di ctrl-F9 ed F8 per steppare velocemente le chiamate fra la libreria di VB (MSVBVM60) e la User32, ad un certo punto finalmente rientriamo nel modulo emu8086, precisamente all’ indirizzo-istruzione

A questo punto steppiamo velocemente con F8 vedendo scorrere nello stack i nostri dati inseriti nel form, arriviamo senza troppi se e ma fino all’ indirizzo

Dopo questa call ci sono due mov, un test e un salto condizionato, provando a steppare fino al salto vedremo da olly che Jump is Taken, un gran peccato perché proprio sotto avevamo il codice che stampava:

Mentre con questo salto finiamo a

Bene abbiamo capito che in quella call avviene ciò che fa la differenza fra giusto e sbagliato, bene o male, registrato o fottuto . Alt-B e togliamo il bp al GetWindowTextA, impostiamone invece uno all’ indirizzo 005D8E26, quindi continuiamo l’esecuzione del programma con F9, OK sulla finestra di errore e di nuovo l’OK alla registrazione. Ora se tutto è andato bene siamo di nuovo in

Questa volta con F7 entriamo nella chiamata e vediamo che succede… Prima di arrivare al punto critico abbiamo una miriade di istruzioni che copiano qua e là i nostri dati, non sembrano istruzioni che facciano calcoli o algoritmi, quindi semplicemente controlliamo ogni qual volta viene eseguita una call che non sia una funzione della MSVBVM60 per vedere se succede qualcosa di strano… Per motivi spazio-temporali vi indico subito che il nostro obiettivo è situato in

Ricordiamo anche questo indirizzo, una volta arrivati qui infatti prima di entrare nella chiamata proviamo ad eseguire con F8 lo step successivo, e date un’ occhiata alla Stack window… Beh interessante, il nostro ESP punta a

Ma salendo su, quindi scendendo come indirizzi guarda un po’ cosa esce…

Non fate quello che state pensando di fare!!! Non vorrete rovinarvi tutto il bello vero :D ???!! Ebbene si ragazzi, quello non è nient’ altro che il nostro seriale scritto in chiaro nello Stack! Non male come fishing eh? Per il momento fidatevi che è il seriale giusto ( se avete messo come nome Andrew ), non provatelo altrimenti registrate il programma e addio KeyGen  … E’ chiaro che dentro quella call avvengano processi interessanti… Togliamo tutti i bps, e impostiamone uno solo su 005DA697, di nuovo eseguiamo il programma, rifacciamo OK sul form di registrazione ed eccoci sulla call incriminata. Questa volta F7 e arriviamo in un’altra sezione di codice, nemmeno qui si nota nulla di interessante, a colpi di F8 vediamo di capire quando viene generato questo benedetto seriale, cascata di F8 fino a

Dopo questa chiamata spunta il nostro seriale nello Stack, siamo di nuovo al punto giusto, ci siamo quasi non vi angosciate :D , solita formula: via tutti i bps, bp su 005DAA36 , Run, quindi di nuovo OK e siamo su 005DAA36, F7 per entrarci, e vediamo un po’ che succede:

Caspita la situazione si fa interessante, mettevi comodi, chi deve andare in bagno lo faccia ora, armatevi di birra e patatine, coca e pop corn o nachos, perchè inizia lo spettacolo :P Come prima cosa vi consiglio di fare tasto destro sullo Stack e selezionare “Lock stack”, in questo modo potete evitare lo scorrimento dello stack ogni volta che il codice chiama una push o una pop e concentrare l’attenzione invece sulla parte di stack subito sopra l’indirizzo puntato da EBP…

Questo print dello Stack l’ ho effettuato con il debugger fermo all’indirizzo

Da adesso in poi:

Con Buffer1 intenderò la stringa: Z9RTASDF01823ASJFSD1234346GFHPLMASDR613412QWERX ( 0012D974 nello stack )

Con Buffer2 la stringa: QW10PASDFGHJKLZXCVBNMERTYU ( 0012D978 nello stack )

Con Buffer3 la stringa: JKASERKKN837C3FRTQZX ( 0012D950 nello stack )

Nelle chiamate precedenti quelle belle stringhe sono state copiate da qualche parte in memoria, e nello Stack sono stati salvati gli indirizzi di memoria, vediamo ora di commentare il pezzo di codice successivo:

I punti salienti sono:

005DABDE -> rtcUpperCaseVar Prende il nome inserito ed esegue l’uppercase dei caratteri, cioè li imposta tutti in maiuscolo, quindi Andrew = ANDREW.

005DAC12 -> questa call inverte il nome in maiuscolo, quindi ANDREW = WERDNA.

005DAC3E -> questa è una variabile booleana che vedremo cambiare valore da 0 a 1, ora è settata a 1.

Bene in questi primi passi sembra proprio che voglia manipolare la nostra stringa, da adesso inizia l’algoritmo principale di creazione del seriale, vediamo le prossime istruzioni:

005DAC44 -> questo indirizzo è importante perchè il ciclo che esegue l’algortimo di codifica ricomincia sempre da questo indirizzo. 005DAC4B -> il valore nello Stack a

Viene salvato in ESI.

005DAC4F -> copio l’indirizzo che contiene il nome manipolato in EDX.

005DAC53 -> viene richiamata la funzione vbaBStrLen, e prima viene pushato l’indirizzo di WERDNA, il vostro nome manipolato, indovinate cosa fa questa funzione? Bravi, calcola la lunghezza della stringa e salva il valore in EAX.

Nelle istruzioni successive avviene il confronto fra ESI (1) e EAX (6) che setta BL a 1 se ESI > EAX, quindi esegue la stessa operazione considerando come stringa il Buffer3 ( se non sapete a cosa mi riferisco non siete stati attenti, tornate su! ) , EAX = 14h = 20 ( la lunghezza della stringa ) e riesegue il compare fra ESI ed EAX, in questo caso setta CL a 1 se ESI > EAX, a questo punto fa l’OR fra BL e CL. Quindi TEST EBX,EBX e JNZ. Che significa in altre parole questa porzione di codice? In pratica se la lunghezza del seriale che sto scrivendo ( e vedremo dopo come ) è maggiore della lunghezza del mio nome (WERDNA = 6) oppure del Buffer3 ( = 20) finisce un certo algoritmo ed eventualmente si effettuano altre operazioni. Per farla breve, se avete inserito un nome lungo più di 20 caratteri, tronca l’algoritmo ai primi 20, mentre se è minore di 20, esegue un certo algoritmo sui caratteri del nome, e poi effettua un’ altra operazione che vedremo dopo. Ora dobbiamo capire cosa succede in questo ciclo.

Siamo arrivati a 005DAC79, per ora non si salta, quindi scendiamo in 005DACCE. Qui si richiama un’ altra funzione di VB, la Mid() o rctMidCharVar che restituisce una sottostringa a una data stringa specificando carattere di partenza e lunghezza. Non è proprio immediato capire come funziona questa funzione, e naturalmente non è nell’ interesse di Microsoft spiegare come operano le funzioni della MSVBVM60.dll, prima di chiamare la funzione però si pushano dei dati interessanti come

Che pusha nello stack il valore di edx che è 1, quindi la nostra sottostringa avrà inizio a partire dal primo carattere della stringa sorgente.

Facciamo una piccola forzatura e andiamo uno step avanti dopo la funzione Mid, ora in EAX abbiamo un indirizzo stack, 0012D924, a questo indirizzo dobbiamo aggiungere 8 byte, arriviamo a 0012D92C , questo indirizzo stack contiene un indirizzo di memoria, tasto destro su quest’ ultimo, “Follow in Dump” e nella finestra accanto troviamo che a quell’ indirizzo è salvata la W, ovvero il primo carattere della stringa WERDNA! Se vi chiedete come facevo a saperlo provate a chiedere a google cosa ne pensa della rctMidCharVar ;-) . Abbiamo capito che a ogni ciclo viene selezionato un carattere del nostro nome manipolato. Ma cosa ne fa l’algoritmo di questo carattere? Proseguiamo nella lettura del codice.

005DACEA -> ecco un’altra funzione di VB, la vbaInStrVar che prende in ingresso una stringa sorgente, una di destinazione, e dà in output l’indice della posizione della prima stringa nella seconda, se è presente, se no restituisce 0. Quali stringhe vengono passate alla funzione? Due indirizzi di Stack, uno molto prossimo alla stringa Alfabeto, e uno che contiene l’indirizzo della nostra lettera W … Risultato dell’operazione? Leggiamo ECX = 17h = 23, ovvero la posizione di W nell’ alfabeto! Bene le cose iniziano a farsi più chiare… Cosa se ne fa l’algoritmo di questo indice? Intanto lo salva in

Quindi a 005DAD1C confronta 17 con 0, e a 005DAD21 salta se 17 <= 0, OVVERO SE IL CARATTERE INSERITO NON E’ PRESENTE NELL’ALFABETO, QUINDI NON E’ UNA LETTERA! Questo è molto importante, perché come vedremo l’introduzione di numeri o altri simboli comporteranno piccole modifiche all’ algoritmo… W è presente nell’ alfabeto, quindi continuiamo nella discesa fino a 005DAD33 attraverso cui, dopo aver confrontato un indirizzo nello stack con 1, saltiamo a

La prossima funzione che incontriamo è 005DAE33, un’altra Mid(), che parametri passa questa volta? Posizionandoci sulla funzione vediamo che nello stack, pushando da EDX c’è il valore 17h, ma da quale stringa seleziona il carattere? Iniziate a capire vero? Eseguiamo uno step con F8. In EAX abbiamo 0012D924, quindi sommando 8…

Cosa c’è a quest’ indirizzo?

Un 4… Qual’ è il 17h ovvero 23° carattere del Buffer1?? Un 4! Bene, le cose iniziano a farsi più chiare, abbiamo scoperto che il primo carattere calcolato è un 4, cosa succede adesso? Ora inizia la fase di rotazione delle stringhe di Buffer…

Ogni CALL emu8086.005DB190 esegue questa operazione, data una stringa alla funzione, prende l’ultimo carattere della stringa e lo posiziona all’inizio. Esegue questa operazione sui 3 Buffer, alla fine di questa serie di istruzioni avremo nello stack:

Il Buffer1 è ruotato di un carattere, il Buffer2 di 2 caratteri, il Buffer3 di 1 carattere.

Buffer1 stringa: XZ9RTASDF01823ASJFSD1234346GFHPLMASDR613412QWER ( 0012D974 nello stack )

Buffer2 stringa: YUQW10PASDFGHJKLZXCVBNMERT ( 0012D978 nello stack )

Buffer3 stringa: XJKASERKKN837C3FRTQZ ( 0012D950 nello stack )

Steppiamo sul JMP finale tornando su 005DAC44. Vediamo le differenze con il primo step. Innanzitutto ESI ora contiene 2, quindi funge da contatore, ma l’avevamo già intuito, arrivati a 005DACCE si passa alla funzione 2, quindi selezioniamo il secondo carattere di WERDNA, cioè la E. A 005DACEA si passa la E appena trovata e si trova la posizione 5 nell’ alfabeto, perfetto. Ora avviene una differenza con il primo passo. In

Il salto si era verificato, mentre questa volta il compare ha dato esito positivo e

Risultano essere uguali, infatti [EBP-54] ha cambiato valore in 005DAD2E ma cosa comporta questo?

Questo è il nuovo pezzo di codice che eseguiamo adesso, in 005DAD88 abbiamo una nuova funzione Mid() alla quale si passa la posizione di E nell’alfabeto, ovvero 5, e cosa abbiamo di ritorno in EAX? 0012D924, + 8 =

Ovvero:

1??? Qual è il 5° carattere del nuovo Buffer2 ruotato? Un 1!!!

Procediamo su 005DADA0, dopo questa funzione spunta fuori nello stack il primo pezzo di chiave,

Che viene copiata quindi in:

Arrivati a 005DADDF si salta nuovamente qui

E ricomincia la fase di rotazione dei Buffer, vediamo alla fine cosa otteniamo. Velocemente F8 fino al JMP e quindi si torna in 005DAC44, come sono cambiati i nostri Buffer?

Buffer1 stringa: RXZ9RTASDF01823ASJFSD1234346GFHPLMASDR613412QWE ( 0012D974 nello stack )

Buffer2 stringa: TYUQW10PASDFGHJKLZXCVBNMER ( 0012D978 nello stack )

Buffer3 stringa: QZXJKASERKKN837C3FRT ( 0012D950 nello stack )

Il primo è ruotato sempre di 1, il 2 di un carattere e il 3 di uno solo. Questo è l’andamento, ogni volta che si crea una lettera di codice pescata una volta dal Buffer1, un’altra volta dal Buffer2, il Buffer1 ruota sempre di un carattere, il buffer2 ruota prima di 1 carattere, e alla lettera successiva di 2, il Buffer3 prima ruota di 2 e alla lettera successiva di 1, e così via… L’andamento di selezione dal Buffer1 o 2 all’ altro e di rotazione di 2 o 1 volta per il Buffer2 e 3 è dettato dalla variabile in [EBP-54] ovvero in 0012D94C . A questo punto l’algoritmo seleziona la R, posizione 12h nell’alfabeto, si pesca il 18° carattere dal buffer1 ( J ), si ruota Buffer1 di 1, Buffer2 di 2, Buffer3 di 1,

Buffer1 stringa: ERXZ9RTASDF01823ASJFSD1234346GFHPLMASDR613412QW ( 0012D974 nello stack )

Buffer2 stringa: ERTYUQW10PASDFGHJKLZXCVBNM ( 0012D978 nello stack )

Buffer3 stringa: TQZXJKASERKKN837C3FR ( 0012D950 nello stack )

e via di nuovo, seleziona D, posizione 4, seleziono il 4° carattere dal Buffer2 (Y) e ruoto, Buffer1 di 1, Buffer2 di 1, Buffer3 di 2. In questo modo otteniamo eseguendo altre 2 volte la procedura, questa situazione nello Stack:

E mi ritrovo al solito inizio in

Cosa succede ora che abbiamo finito le lettere del nome manipolato WERDNA???

Innanzitutto il famoso compare di ESI con la lunghezza della stringa, restituisce che effettivamente abbiamo finito i caratteri,

Quindi arrivati all’ ultima istruzione si salta e si arriva in questa nuova area di codice:

Se vi state chiedendo a cosa servisse il buffer3, ecco la risposta, questo ciclo, come potrete vedere steppando man mano, non fa altro che copiare i caratteri mancanti al nostro codice 41JY1B quelli prelevati dal Buffer3, quindi all’inizio del ciclo avremo nello Stack:

E alla fine:

Da Q a 3 sono interamente copiati dal Buffer3! Una volta copiati questi caratteri, il salto

Che confronta ESI con la lunghezza del Buffer3 ci porta in questa parte di codice

Questo codice prende il vostro seriale e lo ruota su se stesso per ben 63h volte! E sapete qual’ è l’effetto di tutto ciò? Prendere dal codice trovato prima il primo carattere e sbatterlo alla fine! Quindi 41JY1BQZXJKASERKKN83 diventa 1JY1BQZXJKASERKKN834 !!! Sembrerebbe che abbiamo tutte le carte in regola per creare il nostro KeyGen, manca una sola cosa, la gestione dei numeri e simboli! Cosa succede in questo caso??? Lascio a voi come compito per casa il “piacere” di capire cosa fa nel dettaglio l’algoritmo, se volete provarci da soli non leggete le prossime righe fin quando non avrete capito oppure vi sarete rotti :P … Bene se state leggendo vuol dire che avete già capito, forse, comunque diciamo che quando l’algoritmo incontra un altro simbolo non presente nell’alfabeto, non può selezionare il codice dai due buffer, allora cosa succede? Niente! Lo salta e non calcola nessun carattere al suo posto! Maaaaaaaaaaa… c’è una piccola difficoltà, che in presenza di questo carattere estraneo Buffer1 e 2 non ruotano, ma il 3°, quello che si copia alla fine SI! E di quanto ruota? Dipende dalla solita variabile in [EBP-54] ovvero 0012D94C nello stack, che cambia da 0 a 1 e viceversa ogni volta che un carattere viene calcolato da uno dei due Buffer!Quindi Buffer3 ruota di quanto aveva ruotato l’ultima volta che è stato cambiato un carattere, se l’ultima volta aveva ruotato di 1, ruota di 1, se aveva ruotato di 2 continua di 2! Ora finalmente possiamo scrivere il nostro KeyGen :D …

Keygen

Ho scelto il Vb.Net come piattaforma, ho creato un form con 2 TextBox e un pulsante, e questo è il codice, i commenti li includo nel sorgente stesso:

L’ unica accortezza che ho dimenticato e lascio a voi gestire è quando il nome inserito è più lungo del Buffer3!

Note Finali

Come avete potuto vedere la funzione non era sto granchè una volta scritta in Vb.Net, ma capire bene come funzionano le cose col reversing in tempi inferiori a ere geologiche e senza troppi esaurimenti nervosi, necessita una conoscenza dell’ assembly più che dignitosa, in questo caso le funzioni in Vb ci hanno dato una mano a capire cosa succedeva ogni volta, ma non sempre sarà così… Un saluto a tutti voi che avete avuto la pazienza di leggere fino alla fine, un ringraziamento finale a Evolution che ha trovato il byte per crackare l’eseguibile in 10 minuti, e a sparpacillon che altrettanto velocemente aveva fishato il seriale per il suo nome, e senza dei quali forse questo tutorial non avrebbe preso vita… Ciao e alla prossima! ^_^

A_19

Disclaimer