3D Mark 2005

From UIC

3D Mark 2005 - procedure di generazione e controllo del seriale

Infos
Author:	Gotterdamerung
Email:	die.gotterdamerung(AT)gmail.com
Website:
Date:	05/08/2005 (dd/mm/yyyy)
Level:
Language:	Italian
Comments:	Que: Grazie gotter, bel tute! Ma levami una curiosita'.... È stata una scelta artistica quella di far derivare verso destra il tutorial man mano che si scende con la pagina oppure no? Nel dubbio l'ho lasciato cosi! PS: ho notato che questa feature è visibile solo da DreamWeaver, Firefox non la visualizza ;p

Introduzione

Ho comprato un po' di pezzi nuovi per il PC: scheda video, processore, scheda madre e RAM, quindi ho deciso che dovevo assolutamente testarli e ho scaricato questo spettacolare programma di benchmark. Quando ho visto la finestra di registrazione mi sono detto 'Beh, non so fare ancora nulla, ma potrebbe comunque servire da esercizio, proviamo!', e questo è il risultato...

Tools

Per questo tutorial vi servirà solamente OllyDBG, infatti debuggeremo e modificheremo il programma direttamente con questo versatilissimo debugger/decompiler.
Certo potrebbe essere _molto_ utile una connessione a banda larga, date le dimensioni del download... (283 MB!!)

Link e Riferimenti

Potete trovare questo famoso benchmark sul sito del produttore: http://www.futuremark.com/, la versione a cui faccio riferimento in questo tutorial è la 1.2.0

Essay

Benissimo, siete pronti a cominciare? Scaricate la demo del programma, installatelo (alla richiesta del seriale lasciate in bianco) e una volta completata l'installazione lanciatelo.
Dopo lo splash screen apparirà una simpatica finestra che chiede solamente un seriale... bene, allora diamoglielo!
Lanciate OllyDBG e attaccate la finestra (da olly File -> Attach, poi scegliete dalla lista il processo con nome 3DMark05), per fortuna non ci appare nessun messaggio che indica che il file sia packato/criptato, quindi riusciremo a fare modifiche al programma senza doverlo unpackare (meno male, la lezione sul manual unpacking la devo ancora fare :D ).
Settate un breakpoint sulla funzione GetWindowTextA con il metodo che preferite, io ad esempio uso la command line di Que e bpx GetWindowTextA, quindi fate ripartire il programma con F9 e inserite un seriale a caso.
Dopo aver clickato sul bottone Register vi ritroverete in Olly, nel modulo USER32 (lo vedete dal titolo della finestra) che è quello che gestisce la maggior parte delle funzioni di windows, premete due volte ^F9 (Ctrl+F9, serve per eseguire il codice fino al successivo return) e poi F8 o F7 (per eseguire il comando successivo ovvero il RETN su cui vi troverete); a questo punto arriverete nel programma vero e proprio (lo vedete sempre dal titolo della finestra) in mezzo a questo codice:

Questa parte però ci interessa poco... infatti quelle che vediamo sono tutte chiamate a funzioni che fanno parte di librerie esterne (MFC e MSVCP) e che quindi difficilmente comprenderanno la routine di generazione e controllo del seriale (fidatevi, è così in questo caso :D ), steppate oltre il RETN a 0045C8F2 premendo ^F9 e F8 e vi ritroverete in una parte del codice decisamente più importante:

Finalmente siamo arrivati alla routine che vogliamo attaccare, infatti all'indirizzo 00424595 viene chiamata la parte del programma che controlla che il nostro seriale sia nella forma corretta, ne genera uno valido e poi controlla che il nostro lo sia.
Quello che ci può far venire il sospetto che questa sia la chiamata giusta è il fatto che è la prima chiamata che troviamo che rimanga all'interno del codice del programma, quindi, visto che vi ho detto che il controllo non viene fatto esternamente, deve essere questa la funzione che ci serve. In generale comunque potete utilizzare un po' di intuito, zen, fortuna e, col tempo, esperienza. Se utilizzate il plugin Ultra String Reference (click destro sul codice, Ultra String Reference -> Find ASCII) potrete anche notare che poche righe sotto la CALL incriminata ci sono delle stringhe piuttosto esplicative che riempiranno il mesasaggio di registrazione avvenuta, oppure un messaggio di errore nel caso in cui stiamo tentando di registrare il programma senza essere amministratori di sistema (che sicurezza che dà Windows...), inoltre nella parte successiva del codice (che non ho riportato per evitare troppa pesantezza) si possono notare anche il messaggio di registrazione per la versione Pro e il messaggio di seriale errato.
Il controllo che viene fatto su AL subito al ritorno dalla call viene utilizzato dal programma per controllare se il codice inserito è per una licenza Business oppure per una Professional e per spedirci eventualmente al messaggio di codice errato; al fine delle funzionalità del programma non ci sono differenze tra le due modalità di registrazione, a parte il fatto che la prima vi permetterà di pubblicare i risultati che otterrete, cosa che comunque vi sconsiglio visto come la otterrete, inoltre se proprio dobbiamo registrarlo, registriamolo per bene, no?
OK, allora diamoci dentro, arriviamo fino alla CALL in 00424595 premendo ripetutamente F8 ed entriamo al suo interno premendo F7.
Vi consiglio di settare un breakpoint sull'istruzione in cui arriverete e di disabilitare il bp su GetWindowTextA, in modo da poter ricominciare da qui nel caso in cui facciate ripartire il programma per eventuali tentativi.
All'interno della chiamata il codice di controllo del seriale non è molto complesso, ben di più invece lo è quello di generazione; da qui alla fine ho diviso l'intera CALL in più parti, in modo da poterla analizzare facilmente, vediamole una ad una:

Il primo blocco si occupa di controllare che il seriale inserito sia nella forma corretta e a sua volta si può dividere in due parti più piccole: la prima arriva fino a 004104C8 e nella sua esecuzione prima punta ECX alla zona di memoria in cui si trova il seriale, chiama una funzione (004104BF) che ne misura la lunghezza e la inserisce in EAX, quindi confronta EAX con 1Dh ovvero 29 decimale; se il seriale non è della lunghezza giusta ci fa saltare con l'istruzione successiva ad un messaggio di seriale errato.
La seconda parte del primo controllo va a cercare in alcune posizioni predefinite del seriale, che per la precisione sono i vari PUSH: 5h, Bh, 11h, 17h che corrispondono alle posizioni 6, 12, 18 e 24; ho scritto i commenti solo per il primo controllo, ma potete facilmente notare che hanno tutti la stessa identica struttura, e ogni volta il programma controlla che nella posizione specificata sia presente il carattere che corrisponde a 2Dh (CMP BYTE PTR DS:[EAX],2D) ovvero che il carattere in questione sia un meno '-'.
Adesso sappiamo quindi che il nostro seriale deve essere di 29 caratteri e ogni 5 caratteri deve esserci un meno, ma questo non sarà una grande sorpresa per chi ha osservato che poco dopo sono presenti, in ASCII, due seriali d'esempio...

Passiamo quindi al secondo blocco e ci rendiamo conto che i due seriali non sono proprio di esempio, bensì vengono caricati in memoria e confrontati con quello da noi inserito... che gentili i programmatori della Futuremark!
Evidentemente questi devono essere dei seriali non regolari e molto usati per registrare in modo non legale il programma (copio spudoratamente un'espressione che ho trovato su un tutorial che ho letto per entrare nel mondo del cracking, non ricordo quale, ma chiedo scusa all'autore per aver deturpato le sue parole...)(PS: ora editando ho notato che è uno dei primi tute riformattati del wiki, ovvero quello di Bender0 su Hex Workshop 4.23), ovviamente se il confronto risultasse positivo verremmo spediti verso il messaggio di errore, ma se il risultato non fosse quello aspettato? :)

Nella terza parte viene preparata la memoria per la routine di controllo; questo blocco e i successivi due contengono la generazione e il controllo vero e proprio, viene infatti generata una stringa di 33 caratteri tramite la CALL in 0041055E, che verrà utilizzata nella parte successiva della funzione, quindi la CALL in 00410570 prepara un'intera zona di memoria su cui verranno scritti i risultati del controllo e inoltre con le altre CALL calcola diversi dati come la lunghezza del seriale (nonostante ci abbia già fatto un controllo...) e la lunghezza della stringa generata prima.
In effetti il programma non genererà un seriale corretto, e quindi non potremo fare fishing (andare a "pescare" il seriale nella memoria usata dal programma), ma si servirà di questa stringa e dell'area di memoria allocata, nell'algoritmo di controllo.

Questa è la vera e propria routine di controllo del seriale, che ovviamente si presenta come un ciclo; ad ogni ripetizione viene caricato in EAX il nostro seriale tramite la call in 00410593 e poi ne viene estratta la prima lettera, e cancellata dalla locazione originale spostando la stringa di un byte a sinistra (00410599), praticamene ad ogni ciclo toglie la prima lettera, facendo si che al ciclo successivo la prima lettera sarà in realtà quella che al ciclo precedente era la seconda, certo è più facile fare un paio di cicli e vederlo che dirlo... e scusate se vi ho ingarbugliato le idee...
Successivamente, facendo un pesante uso delle funzioni esterne del modulo MSVCP71, viene generato un valore dal seriale e la stringa generata nella parte precedente; questo valore viene poi memorizzato nella zona di memoria preparata se risulta essere esatto, mentre altrimenti viene memorizzato il valore -1 (FFFFFFFF).
Se volete comprendere l'algoritmo di controllo per trovare un seriale valido dovrete addentrarvi in queste funzioni... e buona fortuna!
Le ultime quattro righe realizzano il ciclo: la CALL calcola la lunghezza del seriale (sempre 1D), questa viene confrontata con EBX che viene incrementato di uno ad ogni esecuzione del ciclo (due istruzioni sopra) e se risulta maggiore salta all'inizio del ciclo.

Questa parte della CALL prepara i registri calcolando quali siano i valori corretti che si dovrebbero ottenere con un seriale valido; i registri verranno poi usati nella parte successiva, per essere confrontati con i risultati scritti in memoria.
La parte esaminata è anche l'ultima che riguarda la generazione dei valori da controllare, insieme ai due "pezzi" precedenti; per via dell'uso piuttosto massiccio delle librerie esterne lo studio dell'algoritmo, come ho già detto, risulta piuttosto astioso!

Per l'appunto, questa è l'ultima parte importante della funzione di controllo e penso che sia talmente semplice da non necessitare di commenti: vengono effettuati ben nove controlli di fila, caricando di volta in volta nel registro di turno il valore corretto calcolato nella parte precedente e confrontandolo con quelli ottenuti tramite il seriale da noi inserito e scritti in memoria (da ESI+10 a ESI+70, è la memoria allocata tre blocchi fa), ovviamente qualora uno dovesse risultare non valido verremmo spediti alla beggar off tramite i relativi JNZ, potete infatti notare che tutti i salti puntano alla stessa istruzione, che in realtà è una picola routine che vedremo alla fine e che fa sì che al ritorno da questa funzione venga presentato il messaggio di seriale errato.

Eccoci quindi alla fine, la parte fino al RETN in 00410788 viene eseguita se tutto è andato bene e quindi abbiamo inserito il seriale corretto; vengono ricaricate le condizioni in cui era il programma prima della CALL che abbiamo esaminato e notate come AL venga settato a 1 in 00410777, per soddisfare il controllo che avevamo visto all'inizio e quindi mostrare il messaggio di registrazione avvenuta.
Se invece qualcosa è andato male si finisce nella parte successiva (l'istruzione è quella a cui puntano tutti i JNZ dello scorso blocco); vengono di nuovo ripristinate le condizioni iniziali, ma AL questa volta viene XORato con se stesso, un metodo comune per portare il suo valore a 0 e fare si che il controllo di cui sopra fallisca, portandoci infine al messaggio di seriale errato.

Adesso che abbiamo analizzato attentamente l'intero controllo potete scegliere uno dei tanti metodi di attacco, il più semplice è senz'altro quello di prendere uno dei due seriali che gli autori del programma ci hanno detto di non usare e NOPpare il jump di controllo, oppure trasformarlo in un JZ, permettendovi così di ottenere una facile registrazione; in alternativa potete NOPpare tutti i JNZ dell'ultima parte, in modo da rendere vani tutti i controlli e poter inserire un qualsiasi seriale che sia nella forma corretta (ricordo 5 gruppi di 5 caratteri separati da meno) come potrebbe essere ad esempio -=Göt-terdä-merun-g_RuL-Ez!=- (quanto sono modesto, eh? :D ), oppure se volete sbizzarrirvi con un seriale fantasioso potete NOPpare anche i jump relativi ai controlli iniziali sulla lunghezza del seriale e la presenza dei meno, infine, lavorino da nulla... potete sbizzarrirvi a trovare un seriale analizzando tutta la routine di generazione e di controllo, questo è sicuramente il metodo che vi porterà via più tempo.
Dopo aver scelto il vostro metodo preferito modificate il codice direttamente da Olly: evidenziate la riga che avete intenzione di modificare e premete spazio, apparirà una finestra in cui inserire il codice con cui volete sostituire l'originale.
Una volta effettuate tutte le modifiche necessarie fate click destro sulla finestra del codice e selezionate 'Copy to Executable -> All modifications', quindi selezionate "Copy All" dalla finestra di dialogo e chiudete la finestra che appare successivamente (con evidenziate le modifiche), clickate "Si" e scegliete un nome per il file patchato.
È importante effettuare le modifiche al file e non registrarsi solo cambiando un paio di flags durante l'esecuzione perché ogni volta che 3D Mark viene riavviato o tutte le volte che si seleziona un'opzione utilizzabile solamente nelle versioni registrate, il controllo viene nuovamente effettuato.

Ecco fatto, avete finito, adesso fate puntare la shortcut sul vostro desktop all'eseguibile patchato e mettete alla prova il vostro PC!

Note Finali

Un ringraziamento a tutta la UIC, in particolare a Quequero e AndreaGeddon per i loro tutorial e corsi per niubbi che mi hanno aiutato tantissimo, infatti questo tutorial è fatto con un po' meno fortuna e decisamente più studio di quello precedente :)
Un ringraziamento speciale anche alla Futuremark per questo bell'esercizio durato all'incirca una settimana.

Disclaimer