Corso UIC Newbies 05 Nocz
From UIC
Corso UIC Newbies 05 Nocz
Contents |
| Infos | |
|---|---|
| Author: | Nocz |
| Email: | |
| Website: | Home page |
| Date: | 30/11/2000 (dd/mm/yyyy) |
| Level: | 
|
| Language: | Italian 
|
| Comments: | |
Tools
- Softice oppure OllyDbg v1.10
Link e Riferimenti
Questo è il Corso UIC Newbies n°05 disponibile alla pagina Corsi UIC Newbies
Introduzione
Per le persone che non hanno mai fatto un keygenerator questo crackme é un´occasione da non perdere.
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:
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.....:)))
Keygen
.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
I documenti qui pubblicati sono da considerarsi pubblici e liberamente distribuibili, a patto che se ne citi la fonte di provenienza. Tutti i documenti presenti su queste pagine sono stati scritti esclusivamente a scopo di ricerca, nessuna di queste analisi è stata fatta per fini commerciali, o dietro alcun tipo di compenso. I documenti pubblicati presentano delle analisi puramente teoriche della struttura di un programma, in nessun caso il software è stato realmente disassemblato o modificato; ogni corrispondenza presente tra i documenti pubblicati e le istruzioni del software oggetto dell'analisi, è da ritenersi puramente casuale. Tutti i documenti vengono inviati in forma anonima ed automaticamente pubblicati, i diritti di tali opere appartengono esclusivamente al firmatario del documento (se presente), in nessun caso il gestore di questo sito, o del server su cui risiede, può essere ritenuto responsabile dei contenuti qui presenti, oltretutto il gestore del sito non è in grado di risalire all'identità del mittente dei documenti. Tutti i documenti ed i file di questo sito non presentano alcun tipo di garanzia, pertanto ne è sconsigliata a tutti la lettura o l'esecuzione, lo staff non si assume alcuna responsabilità per quanto riguarda l'uso improprio di tali documenti e/o file, è doveroso aggiungere che ogni riferimento a fatti cose o persone è da considerarsi PURAMENTE casuale. Tutti coloro che potrebbero ritenersi moralmente offesi dai contenuti di queste pagine, sono tenuti ad uscire immediatamente da questo sito.
Vogliamo inoltre ricordare che il Reverse Engineering è uno strumento tecnologico di grande potenza ed importanza, senza di esso non sarebbe possibile creare antivirus, scoprire funzioni malevoli e non dichiarate all'interno di un programma di pubblico utilizzo. Non sarebbe possibile scoprire, in assenza di un sistema sicuro per il controllo dell'integrità, se il "tal" programma è realmente quello che l'utente ha scelto di installare ed eseguire, né sarebbe possibile continuare lo sviluppo di quei programmi (o l'utilizzo di quelle periferiche) ritenuti obsoleti e non più supportati dalle fonti ufficiali.
Categories: Nocz | 2000
