Guida all'Assembly per le Traduzioni

ROL <destinazione>, <volte> RCL <destinazione>, <volte> ROR <destinazione>, <volte> RCR <destinazione>, <volte> SAL <destinazione>, <volte> SHL <destinazione>, <volte> SAR <destinazione>, <volte> SHR <destinazione>, <volte>

Uno dei requisiti più ostici per chi vuole imparare l'assembly è una capacità di astrazione (ben superiore a quella richiesta per linguaggi di altro livello) non da poco. Il reverser (colui che fa reversing-engineering, ossia quello che dovreste fare voi) deve fare una conversione da linguaggio assembly a linguaggio naturale, e può non essere facile (specie nel caso di algoritmi complessi) visto che a differenza degli altri linguaggi in asm un'istruzione può avere infiniti utilizzi (insomma, può servire per fare le cose più disparate).
Come fare allora per cercare di impadronirsi di questa capacità di astrazione? Un buon trucco può essere quello di allenarsi a guardare dei sorgenti (in linguaggi evoluti) di programmi e confrontarli con il codice asm del file compilato.
Prenderò come esempio OmakeBMP, un piccolo programmino che ho realizzato in c. Non è nè lungo nè complicato, quindi dovrebbe fare al caso nostro.
Il programma prende in input un file ne restituisce un altro uguale al primo, fatta eccezione per i primi 999 byte che sono maggiori di 0x90 rispetto ai byte originali.
Segue il suo sorgente c commentato...

#include <stdio.h>
#include <string.h>        // Per poter usare strcat()
int main()
{
char path[255];          // Che file trattare?
FILE *File1, *File2;     // Puntatori a strutture FILE
printf("Questo programmino \"decripta\" i file di SENTIMENTAL SHOOTING che\ncomparirebbero nella cartella OMAKE sconfiggendo il SuperBoss dopo un livello.\n\n");
printf("La criptazione e' veramente stupida... le immagini sono normali BMP\ncon l'unica differenza che il valore dei primi 999 byte e' minore di quello\ngiusto di 0x90. ");
printf("I file in questione sono quelli con estensione *.pcg .\nPer usare questo programma, occorre che sia nella stessa cartella dei file\n(o volete scrivervi tutto il percorso?).\n\n");
printf("\nInserisci il nome del file senza l'estensione *.pcg\n");
scanf("%s", path);
strcat(path,".pcg");     // Aggiunge automaticamente l'estensione PCG
if ((File1 = fopen(path, "rb")) == NULL)      // Controllo su apertura file
    printf("\nImpossibile aprire il file");
else
{
    printf("\nFile aperto correttamente.\nElaborazione in corso...");
    int c;
    strcat(path,".bmp");         // Aggiunge l'estensione BMP
    File2 = fopen(path, "wb");   // Apre il File2 (scrittura-binaria)
/*
Questo ciclo l'ho voluto fare in una maniera un po' "particolare
per sperimentare:
Un while in questo modo genera cicli infiniti, ma è possibile
interromperli con un "break"
Questo break entra in azione dopo che è stato letto l'ultimo
byte del File Sorgente (File1)
Sarebbe stata la stessa cosa scrivere
while (!feof(File1)){}
*/
    while (1)
    {
      if (feof(File1)) break;    // Legge tutti i byte
      c = fgetc(File1);          // Mette in c il byte letto
      if (ftell(File2) < 1000)   // Controlla se il byte è criptato
        c+=0x90;                 // Se sì, somma al byte il valore 90h
      fputc(c, File2);           // Quindi lo scrive in File2
    }
    fclose(File1);               // Chiude tutto
    fclose(File2);

}
return 0;                      // E il programma termina
}

Beh, mi sembra chiaro, no?
Ora diamo un'occhiata al codice asm del programma compilato (vado subito nella parte interessante, tralasciando le librerie e tutte le altre cose inserite dal compilatore).
Cercate di seguire i miei commenti e capire il perchè delle varie istruzioni assembly.

.text:0040153E ; ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦ S U B R O U T I N E ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦
.text:0040153E
.text:0040153E ; Attributes: bp-based frame
.text:0040153E
.text:0040153E sub_40153E proc near ; CODE XREF: sub_401080+EBp
.text:0040153E
.text:0040153E var_118 = dword ptr -118h
.text:0040153E var_114 = dword ptr -114h
.text:0040153E var_110 = dword ptr -110h
.text:0040153E var_10C = dword ptr -10Ch
.text:0040153E var_108 = byte ptr -108h
.text:0040153E
.text:0040153E push ebp
.text:0040153F mov ebp, esp
.text:00401541 sub esp, 118h
.text:00401547 and esp, 0FFFFFFF0h
.text:0040154A mov eax, 0
.text:0040154F mov [ebp+var_118], eax
.text:00401555 mov eax, [ebp+var_118]
.text:0040155B call sub_402D90
.text:00401560 call sub_4017D0
.text:00401565 sub esp, 0Ch
.text:00401568 push offset aQuestoProgramm ; "Questo programmino \"decripta\" i file di"...
.text:0040156D call printf ; Mette la stringa (parametro) nello stack e poi la passa alla funzione prinf
.text:00401572 add esp, 10h ; \
.text:00401575 sub esp, 0Ch ; \=> e già qui si vede come sarebbe possibile ottimizzare il codice ;)
.text:00401578 push offset aLaCriptazioneE ; "La criptazione e' veramente stupida... "...
.text:0040157D call printf ; Come sopra, va nello stack per poi diventare parametro della funzione printf
.text:00401582 add esp, 10h
.text:00401585 sub esp, 0Ch
.text:00401588 push offset aIFileInQuestio ; "I file in questione sono quelli con est"...
.text:0040158D call printf
.text:00401592 add esp, 10h
.text:00401595 sub esp, 0Ch
.text:00401598 push offset aInserisciIlNom ; "\nInserisci il nome del file senza l'est"...
.text:0040159D call printf
.text:004015A2 add esp, 10h
.text:004015A5 sub esp, 8
.text:004015A8 lea eax, [ebp+var_108] ; [1] ; vabbè, abbiamo finito a stampare i messaggini stupidi
.text:004015AE push eax ; cominciamo a leggere il nome del file da elaborare.
.text:004015AF push offset aS ; "%s"
.text:004015B4 call scanf ; ma chissà cosa farà mai "scanf"... questi nomi strani :)
.text:004015B9 add esp, 10h
.text:004015BC sub esp, 8
.text:004015BF push offset a_pcg ; ".pcg" ; [2]
.text:004015C4 lea eax, [ebp+var_108] ; [1]
.text:004015CA push eax
.text:004015CB call strcat ; Beh, si tratta della strcat che prende i parametri [1] e [2]

Ricordarsi sempre che i listati asm dal c hanno sempre prima gli ultimi parametri... e infine vogliono i primi (come qui... prima c'è il [2] e poi c'è [1]). Invece se disassemblate un prog in Pascal vedrete che è l'esatto contrario. Vabbè... andiamo avanti.

.text:004015D0 add esp, 10h
.text:004015D3 sub esp, 8
.text:004015D6 push offset aRb ; "rb" ; modalità
.text:004015DB lea eax, [ebp+var_108] ; [1] : la stringa letta con scanf
.text:004015E1 push eax
.text:004015E2 call fopen ; Apriamo il nostro bel file...
.text:004015E7 add esp, 10h
.text:004015EA mov [ebp+var_10C], eax ; Memorizza il risultato (eax) su File1 => File1 = fopen(...)
.text:004015F0 cmp [ebp+var_10C], 0 ; IF = NULL
.text:004015F7 jnz short loc_40160E ; Se no, vai lì... ELSE prosegui
.text:004015F9 sub esp, 0Ch
.text:004015FC push offset aImpossibileApr ; "\nImpossibile aprire il file"
.text:00401601 call printf
.text:00401606 add esp, 10h
.text:00401609 jmp loc_4016DF ; e finisce tutto
.text:0040160E ; ---------------------------------------------------------------------------
.text:0040160E
.text:0040160E loc_40160E: ; CODE XREF: sub_40153E+B9j
.text:0040160E sub esp, 0Ch ; LOL siamo ancora alla 28° riga... :D
.text:00401611 push offset aFileApertoCorr ; "\nFile aperto correttamente.\nElaborazion"...
.text:00401616 call printf
.text:0040161B add esp, 10h
.text:0040161E sub esp, 8
.text:00401621 push offset a_bmp ; ".bmp"
.text:00401626 lea eax, [ebp+var_108] ; [1]
.text:0040162C push eax
.text:0040162D call strcat ; Solita storia del primo strcat
.text:00401632 add esp, 10h
.text:00401635 sub esp, 8
.text:00401638 push offset aWb ; "wb" ; modalità
.text:0040163D lea eax, [ebp+var_108] ; [1] sempre quella... la nostra variabile Path
.text:00401643 push eax
.text:00401644 call fopen ; e apriamo il file...
.text:00401649 add esp, 10h
.text:0040164C mov [ebp+var_110], eax ; invece qua si tratta di File2 = fopen(...)
.text:00401652
.text:00401652 loc_401652: ; CODE XREF: sub_40153E+17Dj
.text:00401652 sub esp, 0Ch ; e da qui si nota che parte un ciclo...
.text:00401655 push [ebp+var_10C] ; [ebp+var_10C] è File1
.text:0040165B call feof ; feof non sto a spiegarvelo :P
.text:00401660 add esp, 10h
.text:00401663 test eax, eax ; condizione del ciclo... se feof ha restituito 0...
.text:00401665 jz short loc_401669 ; ...esegui ciclo,
.text:00401667 jmp short loc_4016BD ; altrimenti finisci
.text:00401669 ; ---------------------------------------------------------------------------
.text:00401669
.text:00401669 loc_401669: ; CODE XREF: sub_40153E+127j
.text:00401669 sub esp, 0Ch
.text:0040166C push [ebp+var_10C]
.text:00401672 call fgetc ; prende da File1 un carattere
.text:00401677 add esp, 10h
.text:0040167A mov [ebp+var_114], eax ; in pratica si tratta della nostra variabile c
.text:00401680 sub esp, 0Ch
.text:00401683 push [ebp+var_110] ; parametro per ftell: File1
.text:00401689 call ftell ; chiama ftell(File1)
.text:0040168E add esp, 10h
.text:00401691 cmp eax, 3E7h ; com'è eax rispetto al numero 999?
.text:00401696 jg short loc_4016A4 ; Se è più grande vuol dire che i byte non sono criptati
.text:00401698 lea eax, [ebp+var_114]
.text:0040169E add dword ptr [eax], 90h ; Se non è così aggiungi a c, 90h
.text:004016A4
.text:004016A4 loc_4016A4: ; CODE XREF: sub_40153E+158j
.text:004016A4 sub esp, 8 ; Copia il carattere da c a File2
.text:004016A7 push [ebp+var_110] ; File2
.text:004016AD push [ebp+var_114] ; c
.text:004016B3 call fputc ; fputc(c,File2)
.text:004016B8 add esp, 10h
.text:004016BB jmp short loc_401652 ; ritorna al ciclo
.text:004016BD ; ---------------------------------------------------------------------------
.text:004016BD
.text:004016BD loc_4016BD: ; CODE XREF: sub_40153E+129j
.text:004016BD sub esp, 0Ch
.text:004016C0 push [ebp+var_10C]
.text:004016C6 call fclose ; Chiude File1
.text:004016CB add esp, 10h
.text:004016CE sub esp, 0Ch
.text:004016D1 push [ebp+var_110]
.text:004016D7 call fclose ; Chiude File2
.text:004016DC add esp, 10h
.text:004016DF
.text:004016DF loc_4016DF: ; CODE XREF: sub_40153E+CBj
.text:004016DF mov eax, 0
.text:004016E4 leave
.text:004016E5 retn
.text:004016E5 sub_40153E endp ; FINE :)

Come vedete il codice è facilmente riconducibile al listato in c... vi sembra ancora così incomprensibile? ;)
Sapere come "ragiona" un compilatore (cioè come trasforma da sorgente a binario un file) è utile per decifrare poi più facilmente le istruzioni asm. Più pratica fate e col passare del tempo la conversione da codice asm al linguaggio naturale vi sarà sempre più immediata.

Però voi potreste dire... "Sì Syxtem, però qua ci abbiamo sottomano il sorgente! E' ovvio che è più facile capirlo!"
E allora vi propongo un altro esempio... questa volta il sorgente non c'è, lo dobbiamo ricostruire noi dalle istruzioni assembly.
Cerchiamo di seguire questa parte di programma. Si tratta di un piccolo programmino gratuito (un giochino) il cui scopo è riuscire a trovare un seriale. Per quanto sia perfettamente legale il programma, non lo sfrutteremo per carpirne il seriale (infatti pasto solo il codice relativo alla manipolazione del seriale, come si arrivi lì non è necessario saperlo per quello che dobbiamo fare noi), ma lo utilizzeremo come esercizio per imparare a capire il codice asm e per esercitarci a districarci tra le varie istruzioni.

.text:004031AD ; ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦ S U B R O U T I N E ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦

.text:004031AD

.text:004031AD ; Attributes: bp-based frame

.text:004031AD

.text:004031AD sub_4031AD proc near ; CODE XREF: sub_4021F0+Fp

.text:004031AD ; sub_40266E+BCp ...

.text:004031AD

.text:004031AD var_4 = dword ptr -4

.text:004031AD arg_0 = dword ptr 8

.text:004031AD

.text:004031AD push ebp

.text:004031AE mov ebp, esp

.text:004031B0 sub esp, 4

.text:004031B3 push ebx

.text:004031B4 push esi

.text:004031B5 push edi

.text:004031B6 mov eax, [ebp+arg_0] ; Eax = questo è il seriale inserito, prendete per buona la cosa e non chiedetemi come faccio a dirlo... vi ricordo che ho omesso del codice precedente.

.text:004031B9 xor ecx, ecx ; Xor di un registro con lo stesso --> Registro = 0 (a volte è fatto per inizializzazione)

.text:004031BB mov cl, [eax+7] ; Se il seriale è più lungo di 7 caratteri esci.

.text:004031BE test ecx, ecx ; Se ecx = 0 allora si continua, altrimenti "Seriale non corretto"
.text:004031C0 jz loc_4031CD

Prende la 7+1 lettera (la prima lettera sarebbe [eax] ), e vede se il suo byte è 0x00. Quando c'è un test X,X vuol dire che si confronta con 0 e se è così allora si mette il flag Z a 1, altrimenti lo si mette a 0. Quindi con queste 2 operazioni il programma guarda se il seriale inserito è lungo 7 caratteri, visto che il byte di fine stringa è 0x00

.text:004031C6 xor eax, eax ; Eax = 0 (per il boolean sul seriale. Se eax=0 il seriale non è corretto, altrimenti sì.

.text:004031C8 jmp loc_403312

.text:004031CD ; ---------------------------------------------------------------------------

.text:004031CD

.text:004031CD loc_4031CD: ; CODE XREF: sub_4031AD+13j

.text:004031CD mov [ebp+var_4], 0 ; I = 0 (variabile settata a 0... la chiamiamo I per convenienza)

.text:004031D4 jmp loc_4031DC

.text:004031D9 ; ---------------------------------------------------------------------------

.text:004031D9

.text:004031D9 loc_4031D9: ; CODE XREF: sub_4031AD+5Fj

.text:004031D9 inc [ebp+var_4] ; I++

.text:004031DC

.text:004031DC loc_4031DC: ; CODE XREF: sub_4031AD+27j

.text:004031DC cmp [ebp+var_4], 7 ; I >= 7 ?

.text:004031E0 jge loc_403211 ; Se sì salta, altrimenti continua

.text:004031E6 mov eax, [ebp+var_4] ; eax = I

.text:004031E9 mov ecx, [ebp+arg_0] ; ecx = seriale

.text:004031EC mov al, [eax+ecx] ; al = seriale[I]
Da questo capiamo che eax = Lettera del Seriale perchè quando eax = 0 si ha che al = [ecx] (prima lettera), quando eax = 1, al = [ecx+1] (seconda lettera)
Al diventa solo una lettera perchè, come vi ho spiegato precedentemente, Al ha la dimensione di 1 byte.

.text:004031EF push eax ; Passiamo allo stack la lettera del seriale

.text:004031F0 call sub_403317 ; E la elaboriamo in questa Routine

.text:004031F5 add esp, 4

.text:004031F8 xor ecx, ecx

.text:004031FA mov cl, al ; cl = Lettera modificata del seriale

.text:004031FC cmp ecx, 24h ; Se è una lettera o un numero o “[“ continua, (il perchè ho commentato così lo vedrete dopo)

.text:004031FF jle loc_40320C ; altrimenti "seriale non valido"

.text:00403205 xor eax, eax

.text:00403207 jmp loc_403312

.text:0040320C ; ---------------------------------------------------------------------------

.text:0040320C

.text:0040320C loc_40320C: ; CODE XREF: sub_4031AD+52j

.text:0040320C jmp loc_4031D9

.text:0040320C ; ---------------------------------------------------------------------------

.text:00403312 loc_403312: ; CODE XREF: sub_4031AD+1Bj

.text:00403312 ; sub_4031AD+5Aj ...

.text:00403312 pop edi

.text:00403313 pop esi

.text:00403314 pop ebx

.text:00403315 leave

.text:00403316 retn

.text:00403316 sub_4031AD endp ; Esci

.text:00403317 ; ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦ S U B R O U T I N E ¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦¦

.text:00403317

.text:00403317 ; Attributes: bp-based frame

.text:00403317

.text:00403317 sub_403317 proc near ; CODE XREF: sub_4031AD+43p

.text:00403317 ; sub_4031AD+6Bp ...

.text:00403317

.text:00403317 arg_0 = byte ptr 8

.text:00403317

.text:00403317 push ebp

.text:00403318 mov ebp, esp

.text:0040331A push ebx

.text:0040331B push esi

.text:0040331C push edi

.text:0040331D xor eax, eax
.text:0040331F mov al, [ebp+arg_0] ; al = Seriale[I]

.text:00403322 cmp eax, 61h ; A

.text:00403325 jl loc_403336 ; |

.text:0040332B xor eax, eax ; | Se è minuscola converte in maiuscolo,

.text:0040332D mov al, [ebp+arg_0] ; | altrimenti continua

.text:00403330 sub eax, 20h ; |

.text:00403333 mov [ebp+arg_0], al ; V
Infatti, se la lettera ha un codice ASCII maggiore o uguale a 0x61 (a) vuol dire che probabilmente si tratta di una lettera è minuscola. Quindi la converte in maiuscola (0x61 - 0x20 = 0x41 (A) ). Quindi continua.

.text:00403336

.text:00403336 loc_403336: ; CODE XREF: sub_403317+Ej

.text:00403336 xor eax, eax ; A

.text:00403338 mov al, [ebp+arg_0] ; |

.text:0040333B cmp eax, 41h ; | Se è >= “A” (leggasi "se è una lettera"), sottrai 7 al codice

.text:0040333E jl loc_40334F ; | della lettera.

.text:00403344 xor eax, eax ; | altrimenti continua

.text:00403346 mov al, [ebp+arg_0] ; |

.text:00403349 sub eax, 7 ; |

.text:0040334C mov [ebp+arg_0], al ; V

.text:0040334F

.text:0040334F loc_40334F: ; CODE XREF: sub_403317+27j

.text:0040334F xor eax, eax

.text:00403351 mov al, [ebp+arg_0]

.text:00403354 sub eax, 30h ; Sottrai comunque 30h al codice della lettera.

.text:00403357 jmp $+5

.text:0040335C pop edi

.text:0040335D pop esi

.text:0040335E pop ebx

.text:0040335F leave

.text:00403360 retn ; eax contiene il codice della lettera

.text:00403360 sub_403317 endp ; modificata.

.text:00403211 ; ---------------------------------------------------------------------------

.text:00403211
A questo punto può essere comodo farsi una tabellina per vedere come il codice delle varie lettere venga modificato.
Scrivo solo quelle che possono essere utili (come vedrete dal loro codice le altre farebbero scattare immediatamente un "seriale non valido")

TABELLA DELLE LETTERE MODIFICATE:

0: 0

1: 1

2: 2

3: 3

4: 4

5: 5

6: 6

7: 7

8: 8

9: 9

:: A A

;: B |

<: C | Escluse

=: D | xkè

>: E | doppi.

?: F |

@: 10 V
A: A

B: B

C: C

D: D

E: E
F: F
G: 10
H: 11
I: 12
J: 13
K: 14
L: 15
M: 16

N: 17
O: 18
P: 19
Q: 1A

R: 1B
S: 1C
T: 1D
U: 1E
V: 1F
W: 20

X: 21
Y: 22
Z: 23
[: 24

Dal di qua si capisce che:

: = A

; = B

< = C

= = D

> = E

? = F

@ = G

.text:00403211 loc_403211: ; CODE XREF: sub_4031AD+33j

.text:00403211 mov eax, [ebp+arg_0] ; eax = seriale

.text:00403214 mov al, [eax+5] ; al = 6° lettera del seriale

.text:00403217 push eax

.text:00403218 call sub_403317

.text:0040321D add esp, 4

.text:00403220 xor ebx, ebx

.text:00403222 mov bl, al ; bl = 6° lettera modificata

.text:00403224 mov eax, [ebp+arg_0]

.text:00403227 mov al, [eax+2] ; al = 3° lettera del seriale

.text:0040322A push eax

.text:0040322B call sub_403317

.text:00403230 add esp, 4

.text:00403233 xor ecx, ecx

.text:00403235 mov cl, al ; cl = 3° lettera modificata

.text:00403237 mov esi, 24h

.text:0040323C lea eax, [ecx+ebx*2+1Ch]

.text:00403240 cdq

.text:00403241 idiv esi ; Guardatevi come funzionano queste istruzioni nei capitoli precedenti.

.text:00403243 mov ebx, edx ; ebx = eax mod 24h [6|3]

.text:00403245 mov eax, [ebp+arg_0]

.text:00403248 mov al, [eax] ; al = 1° lettera del seriale

.text:0040324A push eax

.text:0040324B call sub_403317

.text:00403250 add esp, 4

.text:00403253 xor ecx, ecx

.text:00403255 mov cl, al ; cl = 1° lettera modificata

.text:00403257 cmp ebx, ecx ; se ebx (mod[6|3]) non è = alla prima

.text:00403259 jnz loc_40330B ; lettera modificata, vai a "Seriale non valido"

.text:0040325F mov eax, [ebp+arg_0]

.text:00403262 mov al, [eax+4] ; al = 5° lettera del seriale

.text:00403265 push eax

.text:00403266 call sub_403317

.text:0040326B add esp, 4

.text:0040326E xor ebx, ebx

.text:00403270 mov bl, al ; bl = 5° lettera modificata

.text:00403272 mov eax, [ebp+arg_0]

.text:00403275 mov al, [eax+1] ; al = 2° lettera del seriale

.text:00403278 push eax

.text:00403279 call sub_403317

.text:0040327E add esp, 4

.text:00403281 xor ecx, ecx

.text:00403283 mov cl, al ; cl = 2° lettera modificata

.text:00403285 mov esi, 24h

.text:0040328A lea eax, [ecx+ebx*2+1Ch]

.text:0040328E cdq

.text:0040328F idiv esi

.text:00403291 mov ebx, edx ; ebx = eax mod 24h [5|2]

.text:00403293 mov eax, [ebp+arg_0]

.text:00403296 mov al, [eax+6] ; al = 7° lettera del seriale

.text:00403299 push eax

.text:0040329A call sub_403317

.text:0040329F add esp, 4

.text:004032A2 xor ecx, ecx

.text:004032A4 mov cl, al ; cl = 7° lettera modificata

.text:004032A6 cmp ebx, ecx ; se ebx (mod[5|2]) non è = alla settima

.text:004032A8 jnz loc_40330B ; lettera modificata, vai a "Seriale non valido"

.text:004032AE mov eax, [ebp+arg_0]

.text:004032B1 mov al, [eax+6] ; al = 7° lettera del seriale

.text:004032B4 push eax

.text:004032B5 call sub_403317

.text:004032BA add esp, 4

.text:004032BD xor ebx, ebx

.text:004032BF mov bl, al ; bl = 7° lettera modificata

.text:004032C1 mov eax, [ebp+arg_0]

.text:004032C4 mov al, [eax] ; al = 1° lettera del seriale

.text:004032C6 push eax

.text:004032C7 call sub_403317

.text:004032CC add esp, 4

.text:004032CF xor ecx, ecx

.text:004032D1 mov cl, al ; cl = 1° lettera modificata

.text:004032D3 mov esi, 24h

.text:004032D8 lea eax, [ecx+ebx*2+1Ch]

.text:004032DC cdq

.text:004032DD idiv esi

.text:004032DF mov ebx, edx ; ebx = eax mod 24h [7|1]

.text:004032E1 mov eax, [ebp+arg_0]

.text:004032E4 mov al, [eax+3] ; al = 4° lettera del seriale

.text:004032E7 push eax

.text:004032E8 call sub_403317

.text:004032ED add esp, 4

.text:004032F0 xor ecx, ecx

.text:004032F2 mov cl, al ; cl = 4° lettera modificata

.text:004032F4 cmp ebx, ecx ; se ebx (mod[5|2] non è = alla quarta

.text:004032F6 jnz loc_40330B ; lettera modificata, vai a "Seriale non valido"

.text:004032FC mov eax, 1 ; altrimenti setta il flag a 1:

.text:00403301 jmp loc_403312 ; seriale corretto.

.text:00403306 ; ---------------------------------------------------------------------------

.text:00403306 jmp loc_403312

.text:0040330B ; ---------------------------------------------------------------------------

.text:0040330B

.text:0040330B loc_40330B: ; CODE XREF: sub_4031AD+ACj

.text:0040330B ; sub_4031AD+FBj ...

.text:0040330B xor eax, eax

.text:0040330D jmp $+5

.text:00403312

.text:00403312 loc_403312: ; CODE XREF: sub_4031AD+1Bj

.text:00403312 ; sub_4031AD+5Aj ...

.text:00403312 pop edi

.text:00403313 pop esi

.text:00403314 pop ebx

.text:00403315 leave

.text:00403316 retn

.text:00403316 sub_4031AD endp ; Esci :)

Bene, abbiamo reversato un controllo di un seriale. Vi pare ancora così difficile? Sì? Beh, il trucco sta nell'esercitarsi con buona costanza. Dovete cercare di far vostri i concetti spiegati e vedere codice di alto livello su quello asm (azz... sembra quasi un discorso alla Matrix. Io ci vedo brunette... :D)