Nulla di difficoltoso...

Keygen:

Reversing Norpius Crackme v1.0 & v2.0
Written by active85k

Allegati

Introduzione... macché introduzione...

Mancava poco che indovinavo il serial senza programmi -.-
Cmq ho usato IDA...

Boh...

Due semplice crackme da registrare.

Iniziamo disassemblando il primo l'eseguibile. Non vi allarmate... non serve nemmeno il softice. Cerchiamo una GetDlgItemTextA nel codice... la prima che ci capita sotto le mani è quella giusta. Vediamo un po' di cosa si tratta:

push 200h
push offset username
push 6
push [ebp+hWnd]
call GetDlgItemTextA ;Ritira l'username

push 0
push 0
push 7
push [ebp+hWnd]
call GetDlgItemInt   ; Ritira il serial da noi inserito

mov ebx, eax         ; Il serial da noi inserito viene salvato in EBX
xor eax, eax
lea esi, username    ; ESI punta al nome

Fin qua niente di particolare... oddio... Procediamo per vedere che cosa viene fatto a questo nome:

_loop1:
    mov al, [esi]        ; AL = username[ESI]
    test al, al          ; Il nome è finito?
    jz short _end_loop1  ; SI: finisce il loop
    add ecx, eax         ; NO: ECX = ECX + username[ESI]
    inc esi              ; Incrementa il contatore
    jmp short _loop1     ; Passa al char successivo

_end_loop1:
    call proc1           ; Chiamata a una procedura
    cmp eax, ebx         ; Alla fine in EAX abbiamo il serial corretto.

Anche fin qua è facile. Adesso analizziamo che cosa succede dentro a "proc1":

proc1 proc near
    mov eax, ecx         ; EAX = somma dei caratteri
    add eax, 1Bh         ; EAX = EAX + 0x1B
    call proc2           ; Chiamata a Proc2
    retn                 ; Fine di tutto; EAX = serial corretto
proc1 endp

proc2 proc near
    mov ecx, 4Eh         ; ECX = 0x4E;
    mul ecx              ; EAX = EAX * 0x4E; 
    xor eax, 4D2h        ; EAX = EAX ^ 0x4D2;
    retn                 ; Fine
proc2 endp

Benissimo... abbiamo finito. In poche parole prima viene presa la somma dei caratteri del nome... viene fatta un'addizione, una moltiplicazione e uno xoring per ottenere il seriale. Vediamo di fare lo stesso in C:

int keygen(const char *username)
{
    int c = 0;

    int l = strlen(username);
    for(int i=0; i<l; i++)
    {
        c += username[i];
    }

    ((c += 0x1B) *= 0x4E) ^= 0x4D2;
    return c;
}

Ed ecco fatto il nostro generatore di chiavi. Possiamo visualizzare il risultato della procedura con una SetDlgItemInt, e siamo appost! :-)

Adesso passiamo al secondo eseguibile. A quanto ho capito dovrebbe essere più difficile del primo. Siccome sono praticamente identici, mi limito ad inserire il codice asm commentando le differenze che ci sono tra i due:

push 200h
push offset username
push 6
push [ebp+hWnd]
call GetDlgItemTextA

xor ebx, ebx
push 0
push 0
push 7
push [ebp+hWnd]
call GetDlgItemInt

mov ebx, eax
xor eax, eax      ;
xor ecx, ecx      ; Prima differenza... stavolta viene azzerato qualche registro in +
lea esi, username

_loop2:
    mov al, [esi]
    test al, al
    jz short _end_loop2
    add ecx, eax   ; Somma username[ESI] con ECX
    sub ecx, 30h   ; Sottrae 0x30 da ECX
    xor ecx, 11D7h ; Lo xora con 0x11D7
    add ecx, 20h   ; Gli riaggiunge 0x20
    inc esi
    jmp short _loop2

_end_loop2:
    call proc1    ; Chiamata a proc1
    cmp eax, ebx  ; EAX contiene il serial corretto

Anche stavolta guardiamo dentro a proc1:

proc1 proc near  ;
    mov eax, ecx ;
    add eax, 1Bh ;
    call proc2   ;
    retn         ;
proc1 endp       ; Questa è identica a quella del primo crackme

proc2 proc near
    mov ecx, 4Eh
    mul ecx
    xor eax, 4D2h
    sub eax, 17h  ; L'unica differenza è che sottrae 0x17 al serial.
    retn
proc2 endp

Morale della favola:

int Keygen2(const char *username)
{
    int c = 0;

    int l = strlen(username);
    for(int i=0; i<l; i++)
    {
        (((c += username[i]) -= 0x30) ^= 0x11D7) += 0x20;
    }

    (((c += 0x1B) *= 0x4E) ^= 0x4D2) -= 0x17;
    return c;
}

Abbiamo finito i due generatori di chiavi e abbiamo scritto il tutorial di fine anno! :)
Ci vediamo alla prossima! :D

active85k - La morte ti attende!

Ringgraziamenti a Quequero, il Geddus, Yado bla bla bla... e a tutta la gente di #crack-it!

Qui inserirete con questo carattere il vostro piccolo disclaimer, non è obbligatorio però è meglio per voi se c'è. Dovete scrivere qualcosa di simile a: vorrei ricordare che il software va comprato e  non rubato, dovete registrare il vostro prodotto dopo il periodo di valutazione. Non mi ritengo responsabile per eventuali danni causati al vostro computer determinati dall'uso improprio di questo tutorial. Questo documento è stato scritto per invogliare il consumatore a registrare legalmente i propri programmi, e non a fargli fare uso dei tantissimi file crack presenti in rete, infatti tale documento aiuta a comprendere lo sforzo immane che ogni singolo programmatore ha dovuto portare avanti per fornire ai rispettivi consumatori i migliori prodotti possibili.

Noi reversiamo al solo scopo informativo e di miglioramento del linguaggio Assembly.