Troviamo il seriale per questo programma in un mare di chiamate molto simili tra loro.

NetBus v2.0 Pro
(Jungle e pesca del seriale)

Written by Quequero

Il NetBus fino alla sua precedente versione era considerato un buon trojan, ossia uno di quei programmi che senza farsene accorgere si installano su un pc trasformandolo in uan specie di mini server accessibile praticamente a tutti, in questa versione il temine "trojan" è venuto meno dando spazio ad una buona utility che trasforma un pc in un server ma sotto la piena consapevolezza di colui che esegue il programma, possiamo infatti decidere che tipo di accesso far avere sul nostro computer (Basic, Spy, Full) se proteggerci con una pass in modo da permettere il collegamento solo a chi conosciamo ecc....... 

La protezione che stiamo per affrontare sarebbe stata un vero inferno se solo il codice finale non fosse visualizzato nei registri, in sostanza un paio di xor e qualche shift ci avrebbero reso la vita molto più complicata.

IDA Pro 3.8x

SoftIce 3.2x

L'URL non lo ricordo, andate su altavista e se scrivete "Netbus 2.0 Pro" vi ritrovate alla home dell'autore, da lì lo scaricate e.....Lo crackate :)))

Installate il programma e giocateci un po' per prenderci confidenza, se vi interessa alla UIC c'è anche un lungo essay abbastanza dettagliato su come usare tutte le sue funzioni :).

Come potete notare all'inizio uno stupido nag ci fa attendere per ben 5 secondi l'avvio del programma, oltre a ciò la funzione più bella cioè: Chached password è disattivata...Mmmmm non mi piace mica tanto, vediamo di porre rimedio, andiamo nel menu "Help | Register" e vediamo cosa ci chiede....Nome, Compagnia e Key, hehehe, per antonomasia il campo Company non serve a nulla al fine della generazione dela chiave, ma proviamo comunque ad inserire qualcosa in tutti e tre i campi,

 

Nome: Quequero

Company: UIC

Key: 666111666 

 

Premiamo register e......DHO! Non appare nessun messagebox....Male, apriamo Sice e mettiamo un bp su GetDlgItemTextA, usciamo e ripremiamo Register.....DHO! Non poppa, proviamo allora con GetWindowTextA...Niente, ma cavolo è allergico ai breakpoint?????

Vabbè, facendo un resoconto possiamo vedere che il programma non usa le API comunemente impiegate per prendere il testo da un EditBox, non ci dà un messaggio di serial errato, non ci scrive in alto se è registrato o meno, neanche nell'about box dice se è registrato per di più ci da un nag all'inizio ma non possiamo neanche utilizzarlo come pista per attaccare il programma perchè potrebbe benissimo apparire anche una volta registrato, ma allora che facciamo, è inattaccabile????? No, credo proprio di no, questo programma sembra protetto molto bene ma non lo è, apriamo la nostra adorata IDA ed iniziamo un disassembly, mettetevi comodi che ci vorranno almeno 10-15 minuti....ZzZZZzzzZzZZZZzzZZZZZzzzZZZ

Ha finito!!! Ottimo, andiamo nel menu "View | Names" e cerchiamo qualche good string....A circa metà della finestra troviamo una possibile good string, doppioclickiamoci sopra e....Tadàààààà eccola:

 

CODE:004B329F                  outsb
CODE:004B32A0                 db 6Bh,73h,0,0 ; <BAD> imul esi, [ebx+0], 0
CODE:004B32A4                  str->ThanksForRegist db 'Thanks for registering NetBus Pro.',0
CODE:004B32A4                                                             ; DATA XREF: CODE:004B3213
CODE:004B32C7                  align 4
  

clickiamo, anzi doppioclickiamo sulla XREF ed arriviamo ad una locazione parecchio interessante:

 

CODE:004B3203                  call CODE_4AA960                           ; Questa chiamata genera  il seriale
CODE:004B3208                  test al, al
CODE:004B320A                  jz short CODE_4B3224                    ; Serial errato? Salta
CODE:004B320C                  push 40h
CODE:004B320E                  mov ecx, offset CODE_4B329C
CODE:004B3213                  mov edx, offset str->ThanksForRegist
 

vedete la chiamata a 004B3203? Bhè ritroviamola col debugger ed esaminiamola, ma come ci arriviamo se non sappiamo come attaccarlo? Semplice, prima vi avevo detto di giocare col programma per prenderci confidenza ed ora torna utile il mio consiglio, ricordate che la funzione "Cached Password" era disabilitata e ci dava un messagebox? Bhè il 90% dei programmi registra il proprio seriale nel registro di winzoz, il NetBus lo mette in: HKEY_CURRENT_USER\NETBUS\License, tutti questi programmi se hanno delle limitazioni disabilitano le varie funzioni in due modi:

1)  facendo diventare grigio il pulsante che le attiva

2)  facendo apparire una messagebox che ci dice che la funzione non è attiva

il nostro pupillo usa il secondo modo, ma come fa a sapere se la deve attivare o meno al momento della pressione del pulsante? Lo fa in un modo banale cioè aprendo il registro e controllando se il serial che stà lì combacia con il nome inserito, se si allora la fa paritire. Avete capito? Come no!!! Mettete un breakpoint su RegOpenKeyA (a questo proposito leggete il mio tutorial sul RegOpenKey Attack) e clickate sulla nostra funzione, sice popperà e dopo un po' di step vi ritroverete proprio all'indirizzo 004B3203, hehehe cancellate tutti i bp e mettetene uno lì, entrate ora nella chiamata con F8 e vediamo che sucede:

 

CODE:004AA961         CODE_4AA961:                                             ; CODE XREF: CODE:004AA91D
CODE:004AA961                                                  mov ebp, esp                                 ; Arriviamo qui
CODE:004AA963                                                  add esp, 0FFFFFDE8h
CODE:004AA969                                                  xor eax, eax
CODE:004AA96B                                                  mov [ebp+var_118], eax
CODE:004AA971                                                  lea eax, [ebp+var_14]
CODE:004AA974                                                  mov edx, ds:CODE_4AA7F4
CODE:004AA97A                                                  call CODE_404480
CODE:004AA97F                                                  xor eax, eax
CODE:004AA981                                                  push ebp
CODE:004AA982                                                  push offset CODE_4AAA50
CODE:004AA987                                                  push dword ptr fs:[eax]
CODE:004AA98A                                                  mov fs:[eax], esp
CODE:004AA98D                                                  lea eax, [ebp+var_14]
CODE:004AA990                                                  call CODE_4AA828
CODE:004AA995         CODE_4AA995:                                                ; CODE XREF: CODE:004AA920
CODE:004AA995                                                  xor ecx, ecx
CODE:004AA997                                                  mov dl, 1
CODE:004AA999                                                  mov eax, ds:CODE_4A9A84
CODE:004AA99E                                                  call CODE_4AA444
CODE:004AA9A3                                                  mov [ebp+var_8], eax
CODE:004AA9A6                                                  xor eax, eax
CODE:004AA9A8                                                  push ebp
CODE:004AA9A9                                                  push offset CODE_4AAA22
CODE:004AA9AE                                                  push dword ptr fs:[eax]
CODE:004AA9B1                                                  mov fs:[eax], esp
CODE:004AA9B4                                                  lea eax, [ebp+var_118]
CODE:004AA9BA                                                  mov ecx, [ebp+var_10]

CODE:004AA9BD         CODE_4AA9BD:                                              ; CODE XREF: CODE:004AA95B
CODE:004AA9BD                                                  mov edx, offset CODE_4AAA68
CODE:004AA9C2                                                  call CODE_403F48
CODE:004AA9C7                                                  mov edx, [ebp+var_118]
CODE:004AA9CD                                                  lea eax, [ebp+var_114]
CODE:004AA9D3                                                  mov ecx, 0FFh
CODE:004AA9D8                                                  call CODE_403ED8
CODE:004AA9DD                                                  lea eax, [ebp+var_114]
CODE:004AA9E3                                                   push eax
CODE:004AA9E4                                                   lea eax, [ebp+var_218]
CODE:004AA9EA                                                   mov edx, [ebp+var_14]
CODE:004AA9ED                                                  mov ecx, 0FFh
CODE:004AA9F2                                                   call CODE_403ED8
CODE:004AA9F7                                                   lea edx, [ebp+var_218]
CODE:004AA9FD                                                  mov eax, [ebp+var_8]
CODE:004AAA00                                                  pop ecx
CODE:004AAA01                                                  call CODE_4AA2DC   ; Il mio sesto senso mi dice di tracciare                                                                                                                            ; qui dentro andiamoci con F8
CODE:004AAA06                                                  test eax, eax
CODE:004AAA08                                                  setz [ebp+var_1]
CODE:004AAA0C                                                  xor eax, eax
CODE:004AAA0E                                                  pop edx

arrivati qui cancellate tutti i bp precedenti e mettetene uno all'indirizzo 004AAA01, entrate lì dentro con F8 ed avrete questo:

 

CODE:004AA2DC        push ebp
CODE:004AA2DD        mov ebp, esp
CODE:004AA2DF        add esp, 0FFFFFFB4h
CODE:004AA2E2        push esi
CODE:004AA2E3        push edi
CODE:004AA2E4        mov esi, ecx
CODE:004AA2E6        lea edi, [ebp+var_E]
CODE:004AA2E9        xor ecx, ecx
CODE:004AA2EB        mov cl, [esi]              ; Esi punta al seriale che è diventato $666111666 di 10 caratteri
CODE:004AA2ED        cmp cl, 9                   ; In CL c'è la lunghezza del serial quindi CL = 0Ah
CODE:004AA2F0        jb    short CODE_4AA2F4  ; salta se CL < 9
CODE:004AA2F2        mov cl, 9
CODE:004AA2F4 CODE_4AA2F4:        ; CODE XREF: CODE_4AA2DC+14
CODE:004AA2F4        mov [edi],    cl
CODE:004AA2F6        inc esi
CODE:004AA2F7        inc edi
CODE:004AA2F8        repe movsb
CODE:004AA2FA        mov esi, edx            ; ESI contiene il nostro nome preceduto dal numero dei suoi                                                                           ; caratteri, cioè:       08 51 75 65 71 75 65 72 6F

                                                                ; significa in ASCII:  .    Q   u   e    q    u    e   r    o  
CODE:004AA2FC        lea edi, [ebp+var_4B]
CODE:004AA2FF        xor ecx, ecx
CODE:004AA301        mov cl, [esi]            ; in CL il numero di caratteri del nostro nome
CODE:004AA303        cmp cl, 32h             ; confronta la lunghezza del nome con 32h cioè 50
CODE:004AA306        jb    short CODE_4AA30A    ; salta se CL < 32h
CODE:004AA308        mov cl, 32h
CODE:004AA30A CODE_4AA30A:        ; CODE XREF: CODE_4AA2DC+2A
CODE:004AA30A        mov [edi],    cl
CODE:004AA30C        inc esi
CODE:004AA30D        inc edi
CODE:004AA30E        repe movsb
CODE:004AA310        mov [ebp+var_4], eax
CODE:004AA313        xor eax, eax
CODE:004AA315        mov al, [ebp+var_4B]     ; lunghezza del nome in AL      (AL = 8)
CODE:004AA318        inc eax                            
CODE:004AA319        cmp eax, 32h                   ; confronta ancora la lunghezza con 50
CODE:004AA31C        jg    short CODE_4AA332    ; salta se il nome è più lungo
CODE:004AA31E        mov [ebp+var_18], eax           ; lunghezza del nome in ebp-18 (var_18 = -18) quindi                                                                                            ; ebp+var_18 è uguale a ebp-18
CODE:004AA321 CODE_4AA321:        ; CODE XREF: CODE_4AA2DC+54
CODE:004AA321        mov eax, [ebp+var_18]       ; lunghezza ancora in eax
CODE:004AA324        mov [ebp+eax+var_4B], 2Ah ; muovi 2ah cioè 42 o in ASCII un asterisco (*) nel valore                                                                                            ; puntato da: lunghezza_del_nome+lunghezza_del_nome
CODE:004AA329        inc [ebp+var_18]                     ; incrementa la lunghezza del nome
CODE:004AA32C        cmp [ebp+var_18], 33h          ; incrementa la lunghezza del nome finchè è uguale a 33h

 

Adesso inizia un lungo loop, per evitare di fare step per 23 volte clickate col mouse una volta su 004AA332 e alla riga di comando scrivete: here

vi ritroverete così alla fine del loop

CODE:004AA330        jnz short CODE_4AA321
CODE:004AA332 CODE_4AA332:       ; CODE XREF: CODE_4AA2DC+40
CODE:004AA332        lea ecx, [ebp+var_E]       ; in ECX il numero $666111666 preceduto dalla sua lunghezza
CODE:004AA335        lea edx, [ebp+var_4B]   ; in EDX il nome preceduto dalla sua lunghezza
CODE:004AA338        mov eax, [ebp+var_4]
CODE:004AA33B        call CODE_4AA218      ; questa chiamata tramite altre 20-25 chiamate genera in base al                                                                                   ; nome ed al numero una stringa, nel mio caso: $201AF3D7

                                                                                ; entriamoci però dentro
CODE:004AA340        test al, al                          ; la call di sopra riporta 1 in AL se il serial è esatto e 0 se non lo   CODE:004AA342        jz     short CODE_4AA3B2 ; AL = 0 cioè serial sbagliato? Salta ed esci dal form
CODE:004AA344        xor eax, eax

Oki entriamo allora nella call a 004AA33B, non ve la racconto tutta perchè è identica alle precedenti, steppade fino ad arrivare qui:

 

CODE:004AA25C        push eax
CODE:004AA25D        mov eax, [ebp+var_4]
CODE:004AA260        mov cl, [eax+375h]
CODE:004AA266        lea edx, [ebp+var_42]
CODE:004AA269        mov eax, [ebp+var_4]
CODE:004AA26C        call CODE_4A9FEC          ; qui viene generato il vero seriale
CODE:004AA271        lea eax, [ebp+var_50]         ; in softice scrivete "d ebp-50" e vedrete il vostro serial
CODE:004AA274        lea edx, [ebp+var_E]
CODE:004AA277        xor ecx, ecx
CODE:004AA279        mov cl, [eax]
CODE:004AA27B        inc ecx
CODE:004AA27C        call CODE_402BB8          ; qui si decide se il programma è shareware o meno
CODE:004AA281        setz [ebp+var_F]

 

Abbiamo detto che se questa call riportava 1 allora il serial veniva visto come esatto, se invece in AL trovavamo 0 il seriale era sbagliato, ma andiamo ancora più in profondità e vediamo cosa succede dove viene deciso se il programma girerà come shareware oppure come completo, cioè all'indirizzo 004AA27C, entriamo in quella call con F8 e troviamo: 

 

CODE:00402BB8        push ebx
CODE:00402BB9        push esi
CODE:00402BBA        push ecx
CODE:00402BBB        mov esi, ecx
CODE:00402BBD        shr esi, 2
CODE:00402BC0        jz    short CODE_402BE8
CODE:00402BC2 CODE_402BC2:       ; CODE XREF: CODE_402BB8+26
CODE:00402BC2        mov ecx, [eax]      ; qui sta il dummy number
CODE:00402BC4        mov ebx, [edx]      ; qua invece il serial esatto
CODE:00402BC6        cmp ecx, ebx        ; tadàààà confrontali
CODE:00402BC8        jnz short CODE_402C0F  ; non sono uguali? Salta!!!
CODE:00402BCA        dec esi
CODE:00402BCB        jz    short CODE_402BE2
CODE:00402BCD        mov ecx, [eax+4]      ; 6 caratteri del dummy in ecx
CODE:00402BD0        mov ebx, [edx+4]      ; 6 caratteri del serial vero in ebx
CODE:00402BD3        cmp ecx, ebx              ; controllali
CODE:00402BD5        jnz short CODE_402C0F   ; salta se non sono uguali
CODE:00402BD7        add eax, 8
CODE:00402BDA        add edx, 8
CODE:00402BDD        dec esi
CODE:00402BDE        jnz short CODE_402BC2     ; salta se esi è uguale a 0
CODE:00402BE0        jmp short CODE_402BE8
CODE:00402BE2 CODE_402BE2:       ; CODE XREF: CODE_402BB8+13
CODE:00402BE2        add eax, 4
CODE:00402BE5        add edx, 4
CODE:00402BE8 CODE_402BE8:        ; CODE XREF: CODE_402BB8+8
CODE:00402BE8                 ; CODE_402BB8+28
CODE:00402BE8        pop esi
CODE:00402BE9        and esi, 3
CODE:00402BEC        jz    short CODE_402C24
CODE:00402BEE        mov cl, [eax] ; gli ultimi due numeri del vero serial in cl
CODE:00402BF0        cmp cl, [edx] ; controlla le ultime due cifre del serial con le rispettive ultime del dummy
CODE:00402BF2        jnz short CODE_402C24  ; salta se non sono uguali
CODE:00402BF4        dec esi                                 ; combacia tutto?
CODE:00402BF5        jz    short CODE_402C0A   ; Se si salta alla good_guy
CODE:00402BF7        mov cl, [eax+1]
CODE:00402BFA        cmp cl, [edx+1]
CODE:00402BFD        jnz short CODE_402C24
CODE:00402BFF        dec esi
CODE:00402C00        jz    short CODE_402C0A
CODE:00402C02        mov cl, [eax+2]
CODE:00402C05        cmp cl, [edx+2]
CODE:00402C08        jnz short CODE_402C24
CODE:00402C0A CODE_402C0A:       ; CODE XREF: CODE_402BB8+3D
CODE:00402C0A                 ; CODE_402BB8+48
CODE:00402C0A        xor eax, eax
CODE:00402C0C        pop esi
CODE:00402C0D        pop ebx
CODE:00402C0E        retn 

 

le soluzioni che possiamo utilizzare ora sono due cioè:

1) utilizzare il programma come auto-keygenerator

2) patcharlo

sinceramente ho provato ad usare la prima, in pratica ho modificato il programma in modo da far apparire una messagebox una volta premuto il pulsante "Register" con dentro il seriale esatto ma una volta premuto ok appare un innocuo messaggio di errore, il programma resta in piedi ma sembrerebbe poi un crack fatto alla buona, ho optato quindi per la seconda opzione cioè patcharlo, per farlo basta cambiare 4 jmp in questa ultima call, comunque ve li elenco in una tabella:

 

Virtual Address	Offset	Istruzione crackata
00402BC8	1FC8	NOP (90h)
00402BD5	1FD5	NOP (90h)
00402BF2	1FF2	NOP (90h)
00402BE5	1FF5	JMP (EBh)

************************************************************************************

il programma ora è completamente crackato, ma chi volesse sapere come si ad ottenere una messagebox con il seril dentro dovrebbe fare più o meno così: andare all'indirizzo 00402BC8 ed in softice scrivere: a 00402BC8, in questo modo possiamo cambiare il codice e sostiruirlo con:

 

push 10            ; vuol dire: push MB_OK OR MB_ICONHAND (pulsante di ok e icona di stop)

push 0074FB06  ; offset del serial usato come caption della messagebox

push 0074FB06  ; offset del serial usato come testo della messagebox

push 0                 ; push NULL, handle della finestra genitrice, ma a noi non serve quindi è 0

call MessageBoxA ; chiamata alla funzione MessageBoxA

nop   ; questi nop servono ad aggiustare il codice che viene dopo

nop

 

potete usare questa tecnica ma dovete far in modo di non far crashare l'applicazione e magari dovete trovare una locazione migliore nella quale piazzare il codice.

************************************************************************************

una cosa continua però a darci fastidio cioè quel nag iniziale che dura troppo, vogliamo toglierlo? Siiiii, andiamo, per prima cosa chiudete tutte le applicazioni che girano in background, poi mettete un breakpoint su DrawTextA, doppioclickate su NetBus.exe e vedrete sice poppare, a questo punto premete 6 volte F5, una volta F11, cancellate il bp su DrawTextA e da questo momento premete 12 volte F12 e circa 54 F10 dovreste essere arrivati qui:

 

CODE:004CA1BB        call CODE_4AAA6C
CODE:004CA1C0        mov ds:BSS_4CFCB8,     eax
CODE:004CA1C5        mov eax, ds:BSS_4CFCB8
CODE:004CA1CA        call CODE_44B350                   ; questa è la call maledetta che genera il nag iniziale
CODE:004CA1CF        mov eax, ds:BSS_4CFCB8
CODE:004CA1D4        mov edx, [eax]
CODE:004CA1D6        call dword    ptr [edx+84h]
CODE:004CA1DC        mov ecx, ds:DATA_4CCC54
CODE:004CA1E2        mov eax, ds:DATA_4CCEB4
CODE:004CA1E7        mov eax, [eax]
CODE:004CA1E9        mov edx, ds:CODE_4C65F8
CODE:004CA1EF        call CODE_44E9A8 

 

come avete capito disattivare un nag non è poi troppo difficile, basta brekkare sulla funzione che lo crea e steppare finchè viene disegnato, una volta raggiunta la call che lo fa apparire su schermo basta nopparla ed il gioco è fatto, ora resta da disattivare il timer di 5 secondi che fa apparire la finestra del programma, però per questo vi rimando ad un futuro tutorial, ciauz

                                                                                                                                        Quequero

Con questo tutorial abbiamo imparato a depistare un tipo di protezione detto "jungle", dove cioè il seriale non è protetto da alcuna tecnica particolare ma da una vera e propria giungla di codice creata apposta per confonderci, abbiamo imparato anche a cambiare il programma in modo da farlo diventare un auto-keygenerator risparmiando quindi molto tempo rispetto alla creazione di un keymaker fatto "a mano", abbiamo imparato anche come disattivare un nag, cosa volevate di più, la luna?????? :))))) bye bye by Quequero :))))))) 

 

Vorrei salutare Neural_Noise per la sua infinità bontà, +Malattia per la sua sempre enorme disponibilità (hei mala com'è andato l'esame ?), +Xoanon perchè è un tizio molto molto strano (MaxInquietance.jpg ti dice qualcosa?)  :)))) Kill3xx che ha pubblicato i miei tutorial su ringzer0 senza preoccuparsi di una probabile perdita di visitatori per colpa mia :), RigorMortem per aver voluto ospitare un mirror della UIC sul suo sito, YanOrel perchè è stata la prima persona ad ospitare un link alla mia pagina, alt255 che è troppo simpatico, ^courier perchè è un grande amico, T3x che è un grande, Oldiron61 che a mia insaputa mi ha fatto membro del suo gruppo :), Briga che fidandosi mi ha chiesto di scrivere il tutorial su IDA e poi è scomparso senza farsi più sentire, Guybrush che è sempre su irc ma in realtà non c'è mai ;), Tin_Man che risponde alle domande sul forum della UIC e che ad agosto inizia il nuovo lavoro (in bocca al lupo), insomma tutti quelli di #crack-it e tutti i visitatori japponesi del mio sito, che non so perchè ma sono tanti e ciauz a tuttiiiiiiiiiii :))).....Ahhhh saluto anche la mia ragazza che passa le sue ore su internet a chattare con qualche maniaco sconosciuto ed a cercare foto di Brad Pitt nudo, ciauz bella :))), saluto anche la bionda che oggi sul bus mi ha fissato per 20 minuti e mi ha anche detto che avevo classe, ciauzzzzzzzzz

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

UIC's page of reverse engineering, scegli dove andare:


Home   Assembly   CrackMe   IRC   Links   NewBies
News   Forum  Hacking   Tools
Tutorial 

UIC