Attaccare DeBabelizerPro 4.5
(Ma si.. facciamoci anche questo programma ;)

18/03/00

by "**SCiaMaNo**"

UIC's Home Page

Published by Quequero

Bravo sciamano, un bel tute e soprattutto è stata battuta una tecnica credo mai analizzata alla UIC, magari però la prossima volta non usare HIEW per far vedere il codice disassemblato ma prova ad usare W32DASM :))))))))))

E-mail: [email protected]

Uin: 57813248

Difficoltà

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

Introduzione

Tools usati

URL o FTP del programma

Come primo tentativo per sproteggere questo programma ho utilizzato Exescope 4.5, ho aperto DeBabelizerProDemo.exe e come sospettavo ho trovato l'immagine che viene sovrapposta alle altre: la scritta "Equilibrium". L'ho subito esportata, modificata in modo da eliminare la scritta e reimportata, ma quando già pensavo di aver risolto il problema mi sono accorto che i programmatori avevano previsto questa mossa; una volta lanciato il programma, aperto una nuova immagine, invece della scritta sovrapposta compare questa volta una specie di X rossa!!! Evidentemente il programma controlla se le caratteristiche dell'immagine "Equilibrium" sono quelle che devono essere ed agisce di conseguenza.
Bene, sarei stato deluso se fosse stato cosi' semplice! Non sarebbe stato per niente istruttivo ed utile ad i nostri scopi, quindi diamoci da fare ;-)
Se curiosiamo con exescope ci accorgiamo che esistono due loghi d'avvio, infatti oltre a quello con su scritto "Demo" vi è un'altro per la versione registrata; visto che ci siamo, sempre con exescope, esportiamo il logo "registrato" e lo importiamo sovrapponendolo a quello "Demo", ora all'avvio del programma comparirà il logo giusto :)
Continuando a curiosare tra le "string" notiamo un GetStartupInfoA, mettiamo quindi un bpx in softice su questa chiamata e lanciamo il programma a caccia del nag iniziale. Sice poppa nella kernel32.dll, pigiamo 15 volte circa F11 e ci troviamo in DeBabelizer esattamente qui:

.005BA53F: test      b,[ebp][-0030],001  ---------- da qui steppiamo con F10
.005BA543: je       .0005BA54F
.005BA545: mov       eax,[ebp][-002C]
.005BA548: and       eax,00000FFFF
.005BA54D: jmps     .0005BA554
.005BA54F: mov       eax,00000000A
.005BA554: push      eax
.005BA555: push      esi
.005BA556: push      000
.005BA558: push      000
.005BA55A: call      GetModuleHandleA ;KERNEL32.dll
.005BA560: push      eax
.005BA561: call     .0005BA650           ----------- porta al nag

appena superato l'indirizzo 005bA561 ci si trova d'avanti al nag, digitiamo un bc* e settiamo un bpx su questa call, usciamo con F5, rilanciamo il programma e una volta in sice entriamo nella call con F8 ed ecco dove ci troviamo:

.005BA650: push      d,[esp][00010]
.005BA654: push      d,[esp][00010]
.005BA658: push      d,[esp][00010]
.005BA65C: push      d,[esp][00010]
.005BA660: call     .0005BA6B4            ----------- porta al nag
.005BA665: retn      00010
.005BA691: push      esi
..........
..........
..........
.005BA6B4: jmp       MFC42.1576           ----------- dritto nella dll
.005BA6BA: int       3
.005BA6BB: int       3

steppiamo sino a 005BA660 call in cui compare nuovamente il nag, ancora un nuovo bpx, ed F8 e ci ritroviamo un po piu sotto in 005BA6B4 jmp che ci porta all'interno della MFC42.dll in .57409958 push, steppiamo per qualche linea di codice sino ad una nuova comparsa del nag all'indirizzo 5F40999C call, ancora F8 in questa call e torniamo in DeBabelizer:

.00442A10: push      ebp                  ----------- ci ritroviamo qua
.00442A11: mov       ebp,esp
.00442A13: push      0FF
..........
..........
..........
.00442DFB: call     .0005B8B82            ----------- ultima routine per il Nag
.00442E00: mov       [ebp][-0074],eax
.00442E03: cmp       d,[ebp][-0074],001
.00442E07: je       .000442E3C            ----------- se "Accept" allora Salta e parte
.00442E09: mov       d,[ebp][0FFFFFE48],0             il programma, se no ("Decline")
.00442E13: mov       b,[ebp][-0004],002               esce
.00442E17: lea       ecx,[ebp][0FFFFFE88]
.00442E1D: call     .0005B8C78
..........
..........
.00442E3C: call     .0005B96B6
.00442E41: test      eax,eax

Bene bene.. con un po' di F10 troviamo finalmente la 00442DFB call, responsabile della comparsa del nag, a questo punto dobbiamo nopparla e forzare il 00442E07 je in un jmp al fine di far partire il programma; e con questo il nag di avvio è finalmente ELIMINATO :)

Possiamo iniziare ora nostra la caccia alla routine che inserisce la scritta "Equilibrium" sulle immagini aperte.
Per poppare in vicinanza della routine che ci interessa ho usato la chiamata lstrcmpA, ma prima di settare il bpx dobbiamo lanciare il programma, file/open/image, entrare un sice con ctrl-d, impostare il bpx lstrcmpA, F5 per uscire e solo ora selezionare l'immagine; in questo modo sice poppa un po' prima della visualizzazione nella finestra di "preview". Premiamo ora 14 volte circa F12 sino a che non siamo nel programma all'indirizzo 004F894 test eax, eax; (non togliete ancora il bpx lstrcmpA) da qui incolliamo il dito su F10 e dopo un po' ci troveremo all'interno della mfc42.dll, ora F12 sino a tornare in DeBabelizer:

.004FC3F3: call     .0005B9F2C
.004FC3F8: test      eax,eax                ----------- ci troviamo qua
.004FC3FA: je       .0004FC40A
.004FC3FC: lea       eax,[esp][00034]
..........
..........
.004FC432: call     .00045C3B0              ----------- carica l'immagine
.004FC437: ebp,eax
..........
..........
.004FC4B6: push      ecx
.004FC4B7: call      UpdateWindow ;USER32.dll -------- visualizza l'immagine

(In realtà l'immagine è già presente solo che windows ancora nonha ricevuto il

comando di fare il redraw della finestra, questo compito viene infatti assolto

dall'API UpdateWindow NdQuequero)

Ci accorgiamo che mentre steppiamo, appena eseguita la 004FC432 call viene caricata l'immagine dal programma, ma non viene visualizzata nella finestra di preview sino all'indirizzo 004FC4B7. Cancelliamo quindi tutti i break point precedenti settiamo uno sulla 004FC432 call per poi accedervi con F8:

.0045C3B0: mov       eax,fs:[000000000]     ----------- si riparte da qui
..........
..........
..........
.0045C4D5: jle      .00045C4FA              -----------  non salta
.0045C4D7: mov       ecx,[esp][00000010C]
.0045C4DE: mov       eax,[esi]
.0045C4E0: push      ecx
.0045C4E1: mov       ecx,esi
.0045C4E3: call      d,[eax][00070]         ----------- viene caricato qualcosa
..........
..........
.0045C51A: jne      .00045C56A              ----------- se forzato porta al retn
.0045C51C: mov       ecx,edi
.0045C51E: call     .0004CEF00              ----------- viene caricato qualcosa
.0045C523: mov       ebx,eax
.0045C525: cmp       ebx,ebp
.0045C527: jne      .00045C56A              ----------- se forzato porta al retn, dopo
.0045C529: mov       ecx,edi                            aver eseguito la 0045C51E call
.0045C52B: call     .00045A1C0
.0045C530: push      eax
..........
..........
..........
.0045C565: call     .000450A20
.0045C56A: mov       eax,ebx
.0045C56C: jmps     .00045C573
.0045C56E: mov       eax,000000001
.0045C573: mov       ecx,[esp][0000000F4]
.0045C57A: pop       edi
.0045C57B: pop       esi
.0045C57C: pop       ebp
.0045C57D: mov       fs:[000000000],ecx
.0045C584: pop       ebx
.0045C585: add       esp,0000000F0
.0045C58B: retn      0000C

Bene, a partire dal 0045C3B0 iniziamo a steppare con F10 sino a quando notiamo che, prima nella 0045C4E3 call, poi in maniera più evidente nella 0045C51E call viene caricata l'immagine o parte di essa. Controllando la seconda call che sembra più interessante, possiamo vedere che prima e dopo questa call vi sono due salti condizionati che portano dritti al retn; come primo tentativo ho provato a forzare 0045C51A jne in jmp, ho premuto F5 e con mia grande sorpresa l'immagine è apparsa nel preview senza più la scritta "Equilibrium" ma con un piccolo problema, non venivano visualizzate le immagini più elaborate (ad es. foto) :-/
quindi nelle call che vengono saltate sino al retn vi è sia la routine che fa comparire la scritta, sia quella necessaria per vedere correttamente le foto più "complesse", visto che siamo sulla strada giusta non ci resta che continuare la nostra caccia ;)
Togliamo le modifiche fatte e riprendiamo a controllare la 0045C51E call. Forziamo quindi in jmp il 0045C527 jne, in questo modo verrà eseguita solo la nostra call prima del retn. Premiamo F5 e scopriamo che la "scritta" ricompare e le immagini "elaborate" tornano a vedersi... ok, lasciamo momentaneamente così com'è il jmp creato per evitare che eventuali altre chiamate che fanno comparire la scritta possano interferire, settiamo un bpx sulla nostra call e vi entriamo dentro con F8; steppando con F10 ci segnamo su di un pezzo di carta le call che incontriamo sul nostro cammino sino al ret successivo.., sono esattamente sette:

.004CEF00: mov       eax,fs:[000000000]       ----------- ci troviamo qui
.004CEF06: push      0FF
..........
..........
.004CEF21: call     .00045A1C0
.004CEF26: mov       ecx,eax
.004CEF28: call     .00040A330
.004CEF2D: mov       edi,eax
.004CEF2F: test      edi,edi
..........
..........
.004CEFC4: call     .000570900
.004CEFC9: mov       ebp,eax
..........
..........
..........
.004CF151: call     .00045A1C0                ----------- ci permette di visualizzare
.004CF156: push      eax                                  le immagini più "elaborate"
.004CF157: lea       ecx,[esp][00050]
.004CF15B: call     .0004D02C0
.004CF160: mov       d,[esp][0004C],0005EAA70
..........
..........
..........
.004CF177: call     .00044F7C0                ----------- contiene la routine che fa
.004CF17C: lea       ecx,[esp][0004C]                     comparire la
.004CF180: mov       d,[esp][000000134],0FFFFFFFF         scritta "Equilibrium"
.004CF18B: call     .00044F790
.004CF190: mov       ecx,[esp][00000012C]
.004CF197: pop       edi
.004CF198: mov       eax,ebp
.004CF19A: pop       esi
.004CF19B: pop       ebp
.004CF19C: mov       fs:[000000000],ecx
.004CF1A3: pop       ebx
.004CF1A4: add       esp,000000128
.004CF1AA: retn

Il modo di procedere che ho utilizzato per individuare le routine che ci interessano è semplice, dopo ogni singola call, iniziando dalla penultima, ho creato un jmp all'indirizzo 004CF197 che porta al ret, in questo modo ho impedito che venisse eseguita l'ultima call, poi le ultime due, le ultime tre... e così via; ho scoperto in questo modo che saltando la 004CF177 call la scritta "Equilibrium" non compare più e tutte le immagini si vedono perfettamente, basterebbe quindi nopparla e tutto sarebbe a posto :)))

Questo si che si chiama bruteforce :)))))....Mi sarebbe piaciuto vederti a fare una cosa simile con 300 chiamate :)))) NdQuequero
Ci potremmo fermare qui, ma noi non ci accontentiamo e andiamo a curiosare dentro a questa routine per non rischiare così di saltare codice che potrebbe essere importante, perciò nuovo bpx ed F8 sulla 004CF177 call:

.0044F7C0: mov      eax,fs:[000000000]        ----------- partenza
..........
.0044F7E3: mov      esi,ecx
.0044F7E5: jne     .00044F81E                 ----------- salta solo se non è stata
..........                                                modificata
..........                                                la scritta "Equilibrium"
..........
.0044F818: je      .00044F89E                 ----------- salta alla routine che crea la
.0044F81E: mov      ecx,esi                               X rossa
.0044F820: call    .0004D39A0                             sull'immagine (nop? ;-)
..........
.0044F82A: call    .00056F290
..........
.0044F83C: call    .00045E2C0
..........
.0044F864: call    .000571490                 ----------- contiene la routine che fa
..........                                                comparire la
.0044F87C: call    .00056F320                             scritta "Equilibrium"
..........
..........
.0044F919: pop      esi
.0044F91A: add      esp,000000114
.0044F920: retn

Usando sempre lo stesso metodo dei jmp inseriti dopo ogni call, individuiamo questa volta la 0044F864 call, ancora una volta F8:

.00571490: push      0FF                       ----------- iniziamo a steppare da qui
..........
..........
..........
.00571602: test      eax,eax
.00571604: je       .000571611                 ----------- salta la routine che fa
.00571606: mov       ecx,edi                               comparire la scritta
.00571608: call     .000570000                             "Equilibrium" e porta al ret
.0057160D: test      eax,eax
.0057160F: jne      .0005715A2                 ----------- torna su e crea un ciclo che
.00571611: push      001                                   porta alla comparsa della
..........                                                 scritta indesiderata
..........
.0057162B: add       esp,014
.0057162E: retn      00014

Eccoci alla fine, la soluzione è evidente: o forziamo in jmp il 00571604 je, oppure noppiamo il 0057160F jne, il risultato non cambia e DeBabelizer è MORTO :)))

---

RIEPILOGO.
Per eliminare il Nag di avvio:

1. noppare la 00442DFB call
2. modificare in jmp il 00442E07 je

Per eliminare la scritta "Equilibrium" che si sovrappone all'immagine:

1. modificare in jmp il 00571604 je
2. 
   
   
   

   This is the End

                                                                                                                 **SCiaMaNo**

Anche questa è fatta... Un ringraziamento obbligato va a Quequero per aver creato la UIC e a tutti coloro che si impegnano a diffondere in rete le loro conoscenze

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.