Corso 5 NewBies
(spiegazione "algo" + keygen)


6/NOV/00

by "nocz"

 

 

UIC's Home Page

Published by Quequero


Domanda di un leim:

Ho fatto un po di fatica a leggere questo tutorial, che più che altro sembra un listato, cmq apprezzo l'impegno per aver creato un tale keygenerator......Che comunque potevi ottimizzare parecchio e stai pur certo che tutti l'avrebbero capito :PPPP cmq sei agli inizi, quindi nulla da biasimare :))

Ma quanti "x" ha questo cd?
UIC's form
E-mail: nocz@hotmail.com
#crack-it
UIC's form

Difficoltà

(X)NewBies ( )Intermedio ( )Avanzato ( )Master

 

Corso 5 NewBies
(spiegazione "algo" + keygen)
Written by nocz

Scaricate qui il KeyGen compilato

Introduzione

Per le persone che non hanno mai fatto un keygenerator questo crackme é un´occasione da non perdere.

Tools usati

Softice & Win32Dasm

URL o FTP del programma

UIC

Notizie sul programma 

Crackme by Andreageddon

Essay

Eccoci al quinto corso newbies... eccoci con un crackme dall´aspetto comune
eccoci con una gran voglia di reversare... eccoci in casa perché fuori fa un tempo da
schifo... insomma, eccoci qua cioé qui oppure quo o tutto insieme.
Siccome non sono in ospedale e non ho un laptop da 4 soldi useró anche il SIW
Prendo l´estathe gelato dal frizzer e si parte.
Allora: abbiamo un crackme che vuole 6 caratteri per il nick... porcodi il mio nick ne ha solo 4!
Niente, allora useró un´altro nick. chessó "pirata" va bene.
Dopo aver messo un fake serial mettiamo un breakpoint su GetDlgItemTextA (non uso HmemCpy perché
mi fa male il dito) e clikkiamo su Check...
prendiamoci il bel indirizzetto della call e apriamo il crackme con wdasm.
Ecco qui cos´abbiamo:
:004017D0 Call 00401B46 ;Call GetDlgItemTextA
:004017D5 xor esi, esi
:004017D7 xor edi, edi
Jump at Address:
:0040182D(C)
:004017D9 mov al, byte ptr [ebp+esi-00000088] ;controlla se primo carattere nick equivale a zero
:004017E0 cmp al, 00
:004017E2 je 0040184A
:004017E4 mov cl, byte ptr [ebp+esi-00000040] ;carica il cl il valore della tabella [ebp+esi-00000040]
:004017EB xor al, cl ;xor il valore con il primo carattere del nick
:004017ED mov cl, byte ptr [ebp+esi-00000020] ;fa la stessa cosa ma con
:004017F4 xor al, cl ;un valore di un´altra tabella
:004017F6 mov cl, byte ptr [ebp+esi-00000060] ;idem per qui
:004017FD xor al, cl ; " " "
:004017FF mov bl, byte ptr [ebp+edi-000000D0] ;carica in bl un carattere del serial
:00401806 sub bl, 30 ;e gli sottrae 30
:00401809 cmp bl, 09 ;controlla se bl é >= 9
:0040180C jle 00401811 ;se si salta
:0040180E sub bl, 07 ;sottrae da bl 7
Jump at Address:
:0040180C(C)
:00401811 mov dl, byte ptr [ebp+edi-000000CF] ;carica in dl il secondo carattere del serial
:00401818 sub dl, 30 ;sottrae 30 dal secondo carattere
:0040181B cmp dl, 09 ;controlla se dl é <= di 9
:0040181E jle 00401823
:00401820 sub dl, 07 ;se si sottrae da dl 7
Jump at Address:
:0040181E(C)
:00401823 shl bl, 04 ;shiftleft di 4 su bl
:00401826 add dl, bl ;aggiunge bl a dl
:00401828 inc esi ;incrementa i vari counter
:00401829 inc edi ; " " "
:0040182A inc edi ; " " "
:0040182B cmp al, dl ;controlla se al equivale a dl
:0040182D je 004017D9 ;se si salta
:0040182F mov [ebp-01], FF ;carica FF in ebp-01
Jump at Address:
:0040183D(C)
:00401833 mov al, byte ptr [ebp+esi-00000088] ;carica in al il secondo carattere del nome
:0040183A inc esi ;incrementa il counter
:0040183B cmp al, 00 ;controlla se al equivale a 0
:0040183D jne 00401833 ;se non equivale a 0 salta
:0040183F cmp esi, 00000006 ;se si controlla se esi equivale a 6
:00401842 jge 00401857 ;se esi é uguale o piú grande di 6 salta
:00401844 mov [ebp-01], DD ;carica DD in ebp-01
:00401848 jmp 00401857 ;salta
Jump at Address:
:004017E2(C)
:0040184A mov [ebp-01], CC ;carica in [ebp-01] CC
:0040184E cmp esi, 00000006 ;controlla se esi equivale o é più grande di 6
:00401851 jge 00401857 ;se si salta
:00401853 mov [ebp-01], DD ;se no metti DD in ebp-01
Jump at Addresses:
:00401842(C), :00401848(U), :00401851(C)
:00401857 mov bl, byte ptr [ebp-01] ;carica il byte di ebp-01 in bl
:0040185A cmp bl, FF ;controlla se il byte equivale a FF
:0040185D jne 00401893 ;se non equivale a FF non visualizzare la msgbox dei lamers
:0040185F mov esi, dword ptr [ebp-64]
:00401862 push 00000010
StringData "Leim :-("
:00401864 push 004030D4
StringData "Serial errato. Lavora ancora!"
:00401869 push 004030B4
:0040186E mov ecx, esi
Reference To: MFC42.MFC42:NoName0087, Ord:1080h
:00401870 Call 00401B40
:00401875 push 00000000
:00401877 push 000003EB
:0040187C mov ecx, esi
Reference To: MFC42.MFC42:NoName0086, Ord:1741h
:0040187E Call 00401B3A
:00401883 push 00000000
:00401885 push 000003EA
:0040188A mov ecx, esi
Reference To: MFC42.MFC42:NoName0086, Ord:1741h
:0040188C Call 00401B3A
:00401891 jmp 00401896
Jump at Address:
:0040185D(C)
:00401893 mov esi, dword ptr [ebp-64] ;se il serial é giusto oppure se abbiamo meno di 6 caratteri per il nick arrivamo a questo punto del code
Jump at Address:
:00401891(U)
:00401896 cmp bl, DD ;se in bl é caricato il byte con il valore DD ci becchiamo dell´ignorante
:00401899 jne 004018CE
:0040189B push 00000040
StringData "Leim ignorante >:-("
:0040189D push 004030A0
StringData "Sai leggere? ALMENO 6 CARATTERI!"
:004018A2 push 0040307C
:004018A7 mov ecx, esi
Reference To: MFC42.MFC42:NoName0087, Ord:1080h
:004018A9 Call 00401B40
:004018AE push 00000000
:004018B0 push 000003EB
:004018B5 mov ecx, esi
Reference To: MFC42.MFC42:NoName0086, Ord:1741h
:004018B7 Call 00401B3A
:004018BC push 00000000
:004018BE push 000003EA
:004018C3 mov ecx, esi
Reference To: MFC42.MFC42:NoName0086, Ord:1741h
:004018C5 Call 00401B3A
:004018CA cmp bl, bl
:004018CC je 00401908
Jump at Address:
:00401899(C)
:004018CE cmp bl, FF ;controlla ancora se il serial e sbagliato
:004018D1 je 00401908 ;se si salta
:004018D3 push 00000030 ;se no... siamo dei cool guys!!!
StringData "Now you're a cool guy"
:004018D5 push 00403064
StringData "Serial azzeccato! Complimenti!"
:004018DA push 00403044
:004018DF mov ecx, esi
Reference To: MFC42.MFC42:NoName0087, Ord:1080h
:004018E1 Call 00401B40
StringData "Brought to you by:"
:004018E6 push 00403030
:004018EB push 000003EB
:004018F0 mov ecx, esi
Reference To: MFC42.MFC42:NoName0086, Ord:1741h
:004018F2 Call 00401B3A
StringData "AndreaGeddon"
:004018F7 push 00403020
:004018FC push 000003EA
:00401901 mov ecx, esi
In pratica se in [ebp-01] viene salvato DD vuoldire che siamo degli ignoranti perché
il nome deve essere >= di 6.
Se invece viene caricato FF in [ebp-01] siamo ugualmente degli ignoranti
perché "ignoriamo" il serial giusto.
Allora le cose stanno così che il prog si prende i caratteri del nick uno per uno
e esegue un semplice xor ai medesimi caratteri.
I valori in [ESI+EBP-40] sono:
10-12-14-16-18-20-22-24... (quelli che sanno la tabellina del 2 sanno andare avanti)
I valori in [ESI+EBP-20] sono:
11-13-15-17-19-21-23-25-27...
I valori in [ESI+EBP-60] :
FF-FE-FD-FC-FB-FA-EF-EE...
Il primo carattere viene xorato con 10-11-FF il secondo con 12-13-FE...
capish'?
per il nostro nick pirata il serial giusto é allora:
p i r a t a
8E 96 8E 9c 8E 9A
clikkiamo su check e... serial azzeccato!
Per farvi felici ho pensato di pubblicare un keygen
il codice é un po lunghetto perché ho duvuto ogni volta assegnare altri valori da xorare.
Sicuro che avrei potuto farlo molto + corto con tre buffer delle tre tabelle.
Sicuro che avrei potuto generare serials per nicks di 7 e + caratteri.
Ma non so se é altrettanto sicuro che sarete poi riusciti a capire il keygen.....:)))
.MODEL small
.STACK 100h ;diamo 100h di spazio allo stack
.386
.DATA;qui inizia il nostro segmento dati
lnfd DB 10,13,'$' ; Line feed
messaggio DB "Nick (di 6 caratteri)",13,10,'$'
buffer DB 7 ;qui ci carichiamo i nostri bytes ottenuti
.CODE ;qui inizia il nostro segmento code
inizio proc near ;apriamo la procedura "inizio"
mov ax,@data ;puntiamo i nostri dati (nel .DATA)
mov ds,ax ;nel segmento dati
mov es,ax ;e nel segmento extra
mov dx,OFFSET messaggio
mov ah,09h
int 21h ; fa vedere il messaggio sullo schermo grazie alla funzione 9 dell´ int21
mov ah,1
int 21h ;il pc legge un carattere dalla tastiera
xor al,10h ;xora il carattere letto con 10h
xor al,11h ;xora il carattere letto con 11h
xor al,0ffh ;xora il carattere letto con 0FFh
mov dl,al ;mette il risultato il dl
shr dl,4h ;shiftright di 4 posizioni (es: se ho 1 ottengo 10)
cmp dl,9h ;se dl <= di 9h
jle a ;salta
add dl,7h ;se é > aggiungi a dl 7h
a: add dl,30h ;aggiungi ancora 30h
mov byte ptr [buffer+1],2Dh ;mette un trattino nella prima posizione del buffer
mov byte ptr [buffer+2],dl ;carica nella seconda posizione del buffer il carattere in dl
mov dl,al ;carica il carattere letto in dl
shl dl,4h ;shiftleft di 4 in dl
shr dl,4h ;shiftright di 4 in dl
cmp dl,9h ;se dl <= di 9h
jle aa ;salta
add dl,7h ;se é > aggiungi a dl 7h
aa: add dl,30h ;aggiungi ancora 30h
mov byte ptr [buffer+3],dl ;mette il risultato nella terza posizione del buffer
mov byte ptr [buffer+4],'$' ;mette un '$' nella quarta pos. del buffer (sta per string e serve alla funzione 9 di int21)
lea dx,buffer
mov ah,9h
int 21h
LEA DX, [lnfd] ;Write a linefeed
MOV AH,9h
INT 21h
;a partire da qui é tutta una ripetizione unica solo con altri bytes per i xor
mov ah,1
int 21h
xor al,12h
xor al,13h
xor al,0feh
mov dl,al
shr dl,4h
cmp dl,9h
jle b
add dl,7h
b: add dl,30h
mov byte ptr [buffer+1],2Dh
mov byte ptr [buffer+2],dl
mov dl,al
shl dl,4h
shr dl,4h
cmp dl,9h
jle bb
add dl,7h
bb: add dl,30h
mov byte ptr [buffer+3],dl
mov byte ptr [buffer+4],'$'
lea dx,buffer
mov ah,9h
int 21h
LEA DX, [lnfd] ; Write a linefeed
MOV AH,9h
INT 21h
mov ah,1
int 21h
xor al,14h
xor al,15h
xor al,0fdh
mov dl,al
shr dl,4h
cmp dl,9h
jle c
add dl,7h
c: add dl,30h
mov byte ptr [buffer+1],2Dh
mov byte ptr [buffer+2],dl
mov dl,al
shl dl,4h
shr dl,4h
cmp dl,9h
jle cc
add dl,7h
cc: add dl,30h
mov byte ptr [buffer+3],dl
mov byte ptr [buffer+4],'$'
lea dx,buffer
mov ah,9h
int 21h
LEA DX, [lnfd] ; Write a linefeed
MOV AH,9h
INT 21h
mov ah,1
int 21h
xor al,16h
xor al,17h
xor al,0fch
mov dl,al
shr dl,4h
cmp dl,9h
jle d
add dl,7h
d: add dl,30h
mov byte ptr [buffer+1],2Dh
mov byte ptr [buffer+2],dl
mov dl,al
shl dl,4h
shr dl,4h
cmp dl,9h
jle dd
add dl,7h
dd: add dl,30h
mov byte ptr [buffer+3],dl
mov byte ptr [buffer+4],'$'
lea dx,buffer
mov ah,9h
int 21h
LEA DX, [lnfd] ; Write a linefeed
MOV AH,9h
INT 21h
mov ah,1
int 21h
xor al,18h
xor al,19h
xor al,0fbh
mov dl,al
shr dl,4h
cmp dl,9h
jle e
add dl,7h
e: add dl,30h
mov byte ptr [buffer+1],2Dh
mov byte ptr [buffer+2],dl
mov dl,al
shl dl,4h
shr dl,4h
cmp dl,9h
jle ee
add dl,7h
ee: add dl,30h
mov byte ptr [buffer+3],dl
mov byte ptr [buffer+4],'$'
lea dx,buffer
mov ah,9h
int 21h
LEA DX, [lnfd] ; Write a linefeed
MOV AH,9h
INT 21h
mov ah,1
int 21h
xor al,20h
xor al,21h
xor al,0fah
mov dl,al
shr dl,4h
cmp dl,9h
jle f
add dl,7h
f: add dl,30h
mov byte ptr [buffer+1],2Dh
mov byte ptr [buffer+2],dl
mov dl,al
shl dl,4h
shr dl,4h
cmp dl,9h
jle ff
add dl,7h
ff: add dl,30h
mov byte ptr [buffer+3],dl
mov byte ptr [buffer+4],'$'
lea dx,buffer
mov ah,9h
int 21h
MOV AH,4ch
INT 21h
ENDP inizio
end

Note finali

Prendo l´occasione di salutare tutta la UIC e specialmente il founder Que
saluto anche il mio migliore amico *olaz* e la mia migliore amica Claudia Schiffrer

Disclaimer

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.
Capitoooooooo????? Bhè credo di si ;))))