Keygen de IzyWeb 1.0
Par Nody
Intro.
Logiciel : Izyweb 1.0
Source : http://perso.club-internet.fr/julienpo
Outils : Soft-Ice 3.2, W32Dasm 8.9, Tasm 5.0, Borland Resource WorkShop 4.5
Protection : S/N
Niveau : Apprenti
Commentaires :
Comme on est en vacances, je vous propose un tut un peu plus long qu'ordinaire qui se construit de cette faτon :
1/ La recherche du s/n
2/ La keygen en asm 32 bits avec une zolie DialogBoxParamA pour changer de l'infΓme keygen sous DOS.
I/ A la Recherche du Serial Number
DΦs le dΘmarrage de IzyWeb, on voit une sorte de Dialog Box qui nous rappelle que c'est un shareware, bla bla bla. .....
Il nous propose de s'enregistrer .... chose qu'on va tenter de faire, donc cliquez sur "S'enregistrer ..."
Mettez votre nom, et un s/n bidon et posez vos bpx. (bpx getdlgitemtexta, bpx getwindowtexta pour ceux qui auraient oubliΘ, et pour les courageux, n'oubliez pas les api 16 bits qui ne serviront α rien ici).
Cliquez sur le bouton "OK" et on tombe (⌠ quelle surprise) sous Soft Ice. Appuyez sur F12 pour voir qui appelle l'API GetWindowTextA et vous voyez si tout va bien MFC42.DLL, qui est la librairie de Ms Visual C++. Appuyez sur Ctrl-D car nous allons avoir 2 appels de l'api (car il y a 2 Edit Box). On retombe encore sous SI et un coup de F12 nous renvoit dans MFC42.
Il faut maintenant remonter dans le programme car de toute maniΦre, c'est izyweb.exe qui a appelΘ une fonction de MFC42 qui utilise GetWindowTextA. Appuyez donc sur F12 pas mal de fois (vous tombez successivement sur Izyweb (mais sur un ret!), MFC42, kernel32, user, MFC42 et enfin Izyweb) et on arrive en 0x0040752E.
Le prog dΘsassemblΘ est :
:0040752E lea
ecx, dword ptr [ebp-18] <= ICI
:00407531 call 00408560
:00407536 mov [ebp-04], 01
:0040753A lea eax, dword ptr [ebp-1C] <=
INTERESSANT
:0040753D push eax
:0040753E lea ecx, dword ptr [ebp-18]
:00407541 call 004085A1
:00407546 lea ecx, dword ptr [ebp-18]
:00407549 call 004085BD <= IMPORTANT !
:0040754E test eax, eax
:00407550 je 00407884
:00407556 lea ecx, dword ptr [ebp-18]
:00407559 call 004085BD <= BINGO !
:0040755E cmp eax, dword ptr [ebp-20]
:00407561 jne 00407884
Commentaires de la source :
ICI : c'est lα o∙ on arrive
INTERRESSANT : α partir de lα, eax pointe vers le nom. (pour le vΘrifier, tapez "dd eax" qui vous donnera une adresse mΘm. et si vous faites "d adresse mΘm" vous verrez votre nom !)
IMPORTANT :
Voilα la routine appelΘe :
:004085BD push
ebp
:004085BE mov ebp, esp
:004085C0 push ecx
:004085C1 mov dword ptr [ebp-04], ecx
:004085C4 mov ecx, dword ptr [ebp-04]
:004085C7 add ecx, 00000008
:004085CA call 00406430
:004085CF test eax, eax
:004085D1 jne 004085E3
:004085D3 mov ecx, dword ptr [ebp-04]
:004085D6 add ecx, 00000008
:004085D9 call 004063F0
:004085DE cmp eax, 00000008 <= ICI eax = longueur(nom)
:004085E1 jge 004085E7
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:004085D1(C)
|
:004085E3 xor eax, eax
:004085E5 jmp 004085F5
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:004085E1(C)
|
:004085E7 mov ecx, dword ptr [ebp-04]
:004085EA call 004085F9
:004085EF mov eax, dword ptr [ebp-04]
:004085F2 mov eax, dword ptr [eax+04]
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:004085E5(U)
|
:004085F5 mov esp, ebp
:004085F7 pop ebp
:004085F8 ret
Cette routine sert α vΘrifier la longueur de notre nom et il faut que celle-ci soit supΘrieure ou Θgale α 8 (car il y a un JGE).
Si le nom est infΘrieur α 8 caractΦres, un test de flag (0040754E) nous envoie sur la MessageBoxA "Code Invalide".
BINGO ! :
Cette routine calcule le s/n ... Vous ne me croyez pas ?
Passez au-dessus avec F10 et on tombe sur un cmp eax, dword ptr [ebp-20]
Faites "d ebp-20" et vous tombez sur le s/n que vous avez entrΘ (en hexa) et si vous faites "? eax", vous verrez le vrai s/n qui faut rentrer !
Donc pour tout ceux qui Θtait intΘressΘ uniquement α ce s/n, vous pouvez passer votre chemin, pour les autres (les vrais crackers), l'aventure continue ....
On a donc trouver le plus important : la routine de calcule du s/n ! Passons α l'acte II
II/ La Keygen
╟a risque d'Ωtre assez long ici .....
1) Le calcul du s/n
Voilα la routine :
*
Referenced by a CALL at Addresses:
|:00406192 , :004061A8 , :00407549 , :00407559
|
:004085BD push ebp
:004085BE mov ebp, esp
:004085C0 push ecx
:004085C1 mov dword ptr [ebp-04], ecx
:004085C4 mov ecx, dword ptr [ebp-04]
:004085C7 add ecx, 00000008
:004085CA call 00406430
:004085CF test eax, eax
:004085D1 jne 004085E3
:004085D3 mov ecx, dword ptr [ebp-04]
:004085D6 add ecx, 00000008
:004085D9 call 004063F0
:004085DE cmp eax, 00000008 <= encore une vΘrif de la longueur
du nom
:004085E1 jge 004085E7
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:004085D1(C)
|
:004085E3 xor eax, eax
:004085E5 jmp 004085F5
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:004085E1(C)
|
:004085E7 mov ecx, dword ptr [ebp-04]
:004085EA call 004085F9 <= sous routine qui calcule...
:004085EF mov eax, dword ptr [ebp-04]
:004085F2 mov eax, dword ptr [eax+04]
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:004085E5(U)
|
:004085F5 mov esp, ebp
:004085F7 pop ebp
:004085F8 ret
Et la sous-routine avec les commentaires :
*
Referenced by a CALL at Address:
|:004085EA
|
:004085F9 push ebp
:004085FA mov ebp, esp
:004085FC sub esp, 00000030
:004085FF mov dword ptr [ebp-30], ecx
:00408602 mov ecx, dword ptr [ebp-30]
:00408605 add ecx, 00000008
:00408608 call 004063F0
:0040860D mov dword ptr [ebp-04], eax
:00408610 mov [ebp-28], 00000000
:00408617 jmp 00408622
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408641(U)
|
:00408619 mov eax, dword ptr [ebp-28]
:0040861C add eax, 00000001
:0040861F mov dword ptr [ebp-28], eax
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408617(U)
|
:00408622 cmp dword ptr [ebp-28], 00000004
:00408626 jge 00408643
:00408628 mov ecx, dword ptr [ebp-28]
:0040862B push ecx
:0040862C mov ecx, dword ptr [ebp-30]
:0040862F add ecx, 00000008
:00408632 call 00406450
:00408637 movsx edx, al
:0040863A mov eax, dword ptr [ebp-28]
:0040863D mov dword ptr [ebp+4*eax-24], edx
:00408641 jmp 00408619
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408626(C)
|
:00408643 mov ecx, dword ptr [ebp-04]
:00408646 sub ecx, 00000001
:00408649 mov dword ptr [ebp-2C], ecx
:0040864C jmp 00408660
Cette 1Φre partie est moyennement intΘressante : elle chope le nom & le s/n entrΘs.
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408684(U)
|
:0040864E mov edx, dword ptr [ebp-2C]
:00408651 sub edx, 00000001
:00408654 mov dword ptr [ebp-2C], edx
:00408657 mov eax, dword ptr [ebp-28]
:0040865A add eax, 00000001
:0040865D mov dword ptr [ebp-28], eax
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:0040864C(U)
|
:00408660 mov ecx, dword ptr [ebp-04]
:00408663 sub ecx, 00000005
:00408666 cmp dword ptr [ebp-2C], ecx
:00408669 jle 00408686
:0040866B mov edx, dword ptr [ebp-2C]
:0040866E push edx
:0040866F mov ecx, dword ptr [ebp-30]
:00408672 add ecx, 00000008
:00408675 call 00406450
:0040867A movsx eax, al
:0040867D mov ecx, dword ptr [ebp-28]
:00408680 mov dword ptr [ebp+4*ecx-24], eax
:00408684 jmp 0040864E
╟a devient intΘressant ici, le prog commence α choper les lettres du nom.
Comme il faut que le nom soit > α 8 et que le mien est "Nody", je vais prendre qqn au hasard .... disons "Pass Partout" au pif.
Le prog. dΘcompose le nom de cette faτon :
| ebp-24 "P" | ebp-20 "a" | ebp-1C "s" | ebp-18 "s" |
| ebp-14 "t" | ebp-10 "u" | ebp-0C "o" | ebp-08 "t" |
Il ne choppe en fait que les 4 premiΦres lettres et les 4 derniΘres (qu'il inverse)...
On remplacera cette partie par une autre routine pour notre keygen.
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408669(C)
|
:00408686 mov edx, dword ptr [ebp-24] edx =
"P"
:00408689 add edx, 00004CF2 edx = edx +
19698
:0040868F mov dword ptr [ebp-24], edx ebp-24 = edx
:00408692 mov eax, dword ptr [ebp-24] eax = ebp-24
:00408695 imul eax, 00007D00 eax = eax * 32000
:0040869B mov ecx, dword ptr [ebp-20]ecx = "a"
:0040869E sub ecx, eax ecx = ecx - eax
:004086A0 mov dword ptr [ebp-20], ecx ebp-20 = ecx
:004086A3 mov edx, dword ptr [ebp-10] edx =
"u"
:004086A6 imul edx, dword ptr [ebp-20] edx = edx *
ebp-20
:004086AA mov eax, dword ptr [ebp-1C] eax =
"s"
:004086AD add eax, edx eax = eax + edx
:004086AF mov dword ptr [ebp-1C], eax ebp-1C = eax
:004086B2 mov ecx, dword ptr [ebp-0C] ecx =
"o"
:004086B5 imul ecx, 000087E2 ecx = ecx * 34786
:004086BB mov edx, dword ptr [ebp-08] edx =
"t"
:004086BE add edx, ecx edx = edx + ecx
:004086C0 mov eax, dword ptr [ebp-18] eax = "s"
:004086C3 sub eax, edx eax = eax - edx
:004086C5 mov dword ptr [ebp-18], eax ebp-18 = eax
:004086C8 mov ecx, dword ptr [ebp-1C] ecx = ebp-1C
:004086CB imul ecx, 000039A4 ecx = ecx * 14756
:004086D1 mov edx, dword ptr [ebp-18] edx = ebp-18
:004086D4 sub edx, ecx edx = edx - ecx
:004086D6 mov eax, dword ptr [ebp-14] eax =
"t"
:004086D9 add eax, edx eax = eax + edx
:004086DB mov dword ptr [ebp-14], eax ebp-14 = eax
:004086DE mov ecx, dword ptr [ebp-10] ecx =
"u"
:004086E1 imul ecx, 0000000E ecx = ecx * 14
:004086E4 mov edx, dword ptr [ebp-10] edx =
"u"
:004086E7 sub edx, ecx edx = edx - ecx
:004086E9 mov dword ptr [ebp-10], edx ebp-10 = edx
:004086EC mov eax, dword ptr [ebp-08] eax =
"t"
:004086EF imul eax, 00003A98 eax = eax * 15000
:004086F5 imul eax, dword ptr [ebp-14] eax = eax *
ebp-14
:004086F9 mov ecx, dword ptr [ebp-0C] ecx =
"o"
:004086FC add ecx, eax ecx = ecx + eax
:004086FE mov dword ptr [ebp-0C], ecx ebp-c = ecx
:00408701 mov edx, dword ptr [ebp-20] edx = ebp-20
:00408704 imul edx, dword ptr [ebp-10] edx = edx *
ebp-10
:00408708 mov eax, dword ptr [ebp-24] eax = ebp-24
:0040870B add eax, edx eax = eax + edx
:0040870D mov ecx, dword ptr [ebp-08] ecx =
"t"
:00408710 sub ecx, eax ecx = ecx - eax
:00408712 mov dword ptr [ebp-08], ecx ebp-8 = ecx
C'est la premiΦre partie du code qui sert vΘritablement α calculer un bout du s/n.
Il n'y a rien de bien compliquer, que de l'arithmΘtique.
On gardera cette routine pour notre keygen (en remplaτant les ebp-xx par un tableau de valeurs).
:00408715
mov edx, dword ptr [ebp-30]
:00408718 mov [edx+04], 00000000
Mets α zΘro une variable qui pointe α [ebp-30]+4.
En va mettre τa dans notre keygen : mov dword ptr [VAR1], 0
:0040871F
mov [ebp-28], 00000000
Mets α zΘro une 2Φme variable qui pointe α [ebp-28]
En va mettre τa dans notre keygen : mov dword ptr [VAR2], 0
:00408726
jmp 00408731
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408759(U)
|
:00408728 mov eax, dword ptr [ebp-28] eax = [VAR2]
:0040872B add eax, 00000001 eax = eax + 1
:0040872E mov dword ptr [ebp-28], eax [VAR2] = eax
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408726(U)
|
:00408731 cmp dword ptr [ebp-28], 00000008 [VAR2] = 8 ??
:00408735 jge 0040875B
:00408737 mov ecx, dword ptr [ebp-28] ecx = [VAR2]
:0040873A add ecx, 00000001 ecx = ecx + 1
:0040873D imul ecx, 0000029A ecx = ecx * 666
:00408743 mov edx, dword ptr [ebp-28] edx = [VAR2]
:00408746 imul ecx, dword ptr [ebp+4*edx-24]
ici, ecx = ecx * (i)*4 + ebp-24 pour i variant de 0 α 7, ce qui correspond α notre "tableau de valeurs" (ebp-xx)
:0040874B mov eax, dword ptr [ebp-30] /eax = [VAR1]
:0040874E mov edx, dword ptr [eax+04] /
:00408751 add edx, ecx edx = edx + ecx
:00408753 mov eax, dword ptr [ebp-30] / eax =
[VAR1]
:00408756 mov dword ptr [eax+04], edx /
:00408759 jmp 00408728 et on recommence jusqu'α [VAR2] = 8
* Referenced by a (U)nconditional or (C)onditional Jump at
Address:
|:00408735(C)
|
:0040875B mov esp, ebp
:0040875D pop ebp
:0040875E ret
A partir de lα, on retourne en 004085EF o∙ il y a τa :
:004085EF
mov eax, dword ptr [ebp-04]
:004085F2 mov eax, dword ptr [eax+04]
Ce qui correpsond pour nous α : eax = [VAR1]
Voilα la routine qui nous servira α calculer le s/n pour la keygen :
donnΘes de la routine :
NOM
: string qui contient le nom
SN : "tableau" qui correspond aux ebp-xx pour placer
les lettres du nom tel que :
ebp-24 ~ SN
ebp-20 ~ SN+4
ebp-1C ~ SN+8
[...]
ebp-08 ~ SN+28
VAR1 & VAR2 : 2 double mots (cf au-dessus)
SN2 : variable temporaire pour la conversion hexa <=> dΘc.
Calcul_SN Proc
push offset NOM
call lstrlen
cmp eax, 8
jl Byebye
mov bl, byte ptr [NOM]
movsx ebx, bl
mov dword ptr [SN], ebx
mov bl, byte ptr [NOM+1]
movsx ebx, bl
mov dword ptr [SN+4], ebx
mov bl, byte ptr [NOM+2]
movsx ebx, bl
mov dword ptr [SN+8], ebx
mov bl, byte ptr [NOM+3]
movsx ebx, bl
mov dword ptr [SN+12], ebx
mov bl, byte ptr [NOM+eax-1]
movsx ebx, bl
mov dword ptr [SN+16], ebx
mov bl, byte ptr [NOM+eax-2]
movsx ebx, bl
mov dword ptr [SN+20], ebx
mov bl, byte ptr [NOM+eax-3]
movsx ebx, bl
mov dword ptr [SN+24], ebx
mov bl, byte ptr [NOM+eax-4]
movsx ebx, bl
mov dword ptr [SN+28], ebx
Cette partie place les 4 premiΦres lettres et les 4 derniΦres dans le tableau SN.
mov edx, dword ptr [SN]
add edx, 00004CF2h
mov dword ptr [SN], edx
mov eax, dword ptr [SN]
imul eax, 00007D00h
mov ecx, dword ptr [SN+4]
sub ecx, eax
mov dword ptr [SN+4], ecx
mov edx, dword ptr [SN+20]
imul edx, dword ptr [SN+4]
mov eax, dword ptr [SN+8]
add eax, edx
mov dword ptr [SN+8], eax
mov ecx, dword ptr [SN+24]
imul ecx, 000087E2h
mov edx, dword ptr [SN+28]
add edx, ecx
mov eax, dword ptr [SN+12]
sub eax, edx
mov dword ptr [SN+12], eax
mov ecx, dword ptr [SN+8]
imul ecx, 000039A4h
mov edx, dword ptr [SN+12]
sub edx, ecx
mov eax, dword ptr [SN+16]
add eax, edx
mov dword ptr [SN+16], eax
mov ecx, dword ptr [SN+20]
imul ecx, 0000000Eh
mov edx, dword ptr [SN+20]
sub edx, ecx
mov dword ptr [SN+20], edx
mov eax, dword ptr [SN+28]
imul eax, 00003A98h
imul eax, dword ptr [SN+16]
mov ecx, dword ptr [SN+24]
add ecx, eax
mov dword ptr [SN+24], ecx
mov edx, dword ptr [SN+4]
imul edx, dword ptr [SN+20]
mov eax, dword ptr [SN]
add eax, edx
mov ecx, dword ptr [SN+28]
sub ecx, eax
mov dword ptr [SN+28], ecx
Simple copier/coller du code original.
mov dword ptr [VAR1], 0
mov dword ptr [VAR2], 0
jmp adr_408731
adr_408728 :
mov eax, dword ptr [VAR2]
add eax, 00000001
mov dword ptr [VAR2], eax
adr_408731 :
cmp dword ptr [VAR2], 00000008
jge adr_40875B
mov ecx, dword ptr [VAR2]
add ecx, 00000001
imul ecx, 0000029Ah
mov edx, dword ptr [VAR2]
imul ecx, dword ptr [SN+4*edx]
mov edx, dword ptr [VAR1]
add edx, ecx
mov eax, dword ptr [ebp-30]
mov dword ptr [VAR1], edx
jmp adr_408728
adr_40875B :
mov eax, dword ptr [VAR1]
Ici aussi, c'est presque un copier/coller, sauf qu'on a mis nos variables VAR1 & VAR2.
A partir d'ici, eax = le bon s/n mais en hexa.
XOR ECX,ECX
XOR EBX,EBX
MOV ebx, 10
MOV ECX,0AH
BOUCLE:
XOR EDX,EDX
DIV ECX
ADD DL,30H
CMP DL,3AH
JL POST
ADD DL,7
POST:
DEC ebx
MOV byte ptr [SN2+ebx],DL
OR EAX,EAX
JNZ BOUCLE
Cette routine convertit de l'hexa en dΘcimal. (routine pompΘe sur le tut de micky mouse sur mirc :-) )
mov eax, offset [SN2]
add eax, ebx
Maintenant, eax pointe vers le bon s/n en dΘcimal.
push offset eax
push offset MESS
call lstrcat
On concatΦne MESS ("Votre s/n est : ") avec le s/n
push MB_OK
push offset TITRE
push offset MESS
push 0
call MessageBoxA
et on affiche le tout !
xor eax, eax
xor edx, edx
Zeros :
mov byte ptr [NOM+eax], dh
mov byte ptr [SN2+eax], dh
inc al
cmp al, 40
jl Zeros
push offset MESS2
push offset MESS
call lstrcpy
On remet α 0 nos tableaux au cas o∙ le user voudrait plus d'un s/n.
jmp Byebye_2
Byebye :
push MB_OK
push offset TITRE
push offset ERR_1
push 0
call MessageBoxA
Message d'erreur (nom < 8 caractΦres)
Byebye_2 :
ret
endp
Voilα, c'est fini pour la partie calculant le s/n.
On va maintenant faire une zolie Dialog Box .....
2) CrΘation de la DialogBoxParamA
Pour crΘer une dialog box, il vous faut un Θditeur de ressources comme Borland Resource Workshop 4.5.
Il est assez facile d'emploi.... Commencez par crΘer un nouveau projet (un fichier *.RC), il vous demande le nom et mettez izyweb par exemple.
Maintenant, faites Resource/New et choisissez "Dialog", puis "Windows Dialog, buttons on right...".
Voilα, on peut maintenant Θditer la dialog box. La mienne ressemble α τa :
Elle contient 3 boutons, un "edit text", un "static text".
Enregistrez-votre dialog box et vous obtenez un fichier *.RC de ce style :
/****************************************************************************
test.rc
produced by Borland Resource Workshop
*****************************************************************************/
#define DIALOG_1 1
#define IDC_EDIT1 101
#define IDC_BUTTON_ABOUT 102
DIALOG_1 DIALOG 6, 15, 207, 111
STYLE DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION |
WS_SYSMENU
CAPTION "IzyWeb 1.0 Keygen par Nody"
FONT 8, "MS Sans Serif"
{
DEFPUSHBUTTON "OK", IDOK, 148, 6, 50, 14
PUSHBUTTON "Cancel", IDCANCEL, 148, 24, 50, 14
EDITTEXT IDC_EDIT1, 53, 86, 97, 13
LTEXT "Entrez votre nom ci-dessous : ", -1, 52, 69,
103, 9
PUSHBUTTON "A propos de", IDC_BUTTON_ABOUT, 148, 43,
50, 15
}
Il faut maintenant "compiler" votre fichier *.RC en un *.RES. Chez moi, Borland Workshop merde un peu pour le faire alors j'utilise brc32.exe de cette faτon :
brc32 izyweb.rc
╟a y est le RC est compilΘ....
Il faut aussi une procΘdure qu'on mettra dans le code asm pour la DialogBoxParamA. Je vous propose τa (merci Enkhyl :-) ) :
DialogProc
Proc
ARG Hwnd:dword, Msg:dword, Wparam:dword, Lparam:dword
mov eax, Msg
cmp eax, WM_COMMAND <= bouton pressΘ ??
je wmcommand <= oui, tachons de savoir lequel
...
cmp eax, WM_CLOSE <= croix pressΘe ?
je wmclose <= oui, on se casse alors ...
jmp MsgNonTraite <= il ne s'est rien passΘ
wmcommand:
mov eax, Wparam
cmp eax, IDOK <= bouton OK ?
je boutton_ok
cmp eax, IDCANCEL <= bouton CANCEL ?
je boutton_cancel
cmp eax, IDC_BUTTON_ABOUT <= ou bouton ABOUT ?
je boutton_about
jmp MsgTraite
boutton_ok:
; il faut alors, lire l'edit_box, calculer le s/n
boutton_cancel:
; il faut alors quitter
boutton_about:
; on affiche une simple messageboxa
wmclose:
push 01
push Hwnd
call EndDialog
MsgTraite:
xor eax, eax
inc eax
ret
MsgNonTraite:
xor eax, eax
ret
endp
Voilα, il n'y a plus quα remplir et faire l'appel .....
Voilα maintenant la source complΦte de la Keygen :
(que vous pouvez compiler, mais pas me voler :-) )
;
************************************************************************
; IzyWeb 1.0
; Keygen par Nody 20/07/1999
; Tous droits rΘservΘs :-)
;
; α compiler comme τa (si le fichier asm est izyweb_k.asm et le
fichier
; de ressource izyweb.res) :
;
; tasm32 -ml -m5 -q izyweb_k
; tlink32 -Tpe -aa -x -c izyweb_k ,,, import32 ,, izyweb
;
;
************************************************************************
.386p
.model flat, stdCALL
EXTRN ExitProcess:PROC
EXTRN MessageBoxA:PROC
EXTRN DialogBoxParamA:PROC
EXTRN GetModuleHandleA:PROC
EXTRN EndDialog:PROC
EXTRN GetDlgItemTextA:PROC
EXTRN lstrlen:PROC
EXTRN lstrcat:PROC
EXTRN lstrcpy:PROC
INCLUDE WINDOWS.INC
.DATA
NULL EQU 0
WM_COMMAND EQU 0111h
WM_CLOSE EQU 0010h
Handle DD ?
; ne pas oublier les constantes :
DIALOG_1 EQU 1
IDOK EQU 1
IDCANCEL EQU 2
IDC_EDIT1 EQU 101
IDC_BUTTON_ABOUT EQU 102
TITRE DB 'IzyWeb 1.0 Keygen',0
NOM DB 40 DUP (0)
MESS_CANCEL DB 'Tchaoo...',0
MESS_ABOUT DB 'IzyWeb 1.0 Keygen',13,10
DB '--------------------------------',13,10
DB 13,10
DB 'Par Nody - nodless@usa.net',13,10
DB 0
MESS DB 'Votre s/n est :
',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
MESS2 DB 'Votre s/n est :
',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
ERR_1 DB 'Votre nom doit faire au moins 8 caractΦres !',0
SN DB 80h DUP (0)
VAR1 DD 0
VAR2 DD 0
SN2 DD 40 DUP (0)
.CODE
START:
push 0
call GetModuleHandleA
mov Handle, eax
push 0
push offset DialogProc
push 0
push DIALOG_1
push Handle
call DialogBoxParamA
PUSH NULL
CALL ExitProcess
; PremiΦre ProcΘdure
Calcul_SN Proc
push offset NOM
call lstrlen
cmp eax, 8
jl Byebye
mov bl, byte ptr [NOM]
movsx ebx, bl
mov dword ptr [SN], ebx
mov bl, byte ptr [NOM+1]
movsx ebx, bl
mov dword ptr [SN+4], ebx
mov bl, byte ptr [NOM+2]
movsx ebx, bl
mov dword ptr [SN+8], ebx
mov bl, byte ptr [NOM+3]
movsx ebx, bl
mov dword ptr [SN+12], ebx
mov bl, byte ptr [NOM+eax-1]
movsx ebx, bl
mov dword ptr [SN+16], ebx
mov bl, byte ptr [NOM+eax-2]
movsx ebx, bl
mov dword ptr [SN+20], ebx
mov bl, byte ptr [NOM+eax-3]
movsx ebx, bl
mov dword ptr [SN+24], ebx
mov bl, byte ptr [NOM+eax-4]
movsx ebx, bl
mov dword ptr [SN+28], ebx
mov edx, dword ptr [SN]
add edx, 00004CF2h
mov dword ptr [SN], edx
mov eax, dword ptr [SN]
imul eax, 00007D00h
mov ecx, dword ptr [SN+4]
sub ecx, eax
mov dword ptr [SN+4], ecx
mov edx, dword ptr [SN+20]
imul edx, dword ptr [SN+4]
mov eax, dword ptr [SN+8]
add eax, edx
mov dword ptr [SN+8], eax
mov ecx, dword ptr [SN+24]
imul ecx, 000087E2h
mov edx, dword ptr [SN+28]
add edx, ecx
mov eax, dword ptr [SN+12]
sub eax, edx
mov dword ptr [SN+12], eax
mov ecx, dword ptr [SN+8]
imul ecx, 000039A4h
mov edx, dword ptr [SN+12]
sub edx, ecx
mov eax, dword ptr [SN+16]
add eax, edx
mov dword ptr [SN+16], eax
mov ecx, dword ptr [SN+20]
imul ecx, 0000000Eh
mov edx, dword ptr [SN+20]
sub edx, ecx
mov dword ptr [SN+20], edx
mov eax, dword ptr [SN+28]
imul eax, 00003A98h
imul eax, dword ptr [SN+16]
mov ecx, dword ptr [SN+24]
add ecx, eax
mov dword ptr [SN+24], ecx
mov edx, dword ptr [SN+4]
imul edx, dword ptr [SN+20]
mov eax, dword ptr [SN]
add eax, edx
mov ecx, dword ptr [SN+28]
sub ecx, eax
mov dword ptr [SN+28], ecx
mov dword ptr [VAR1], 0
mov dword ptr [VAR2], 0
jmp adr_408731
adr_408728 :
mov eax, dword ptr [VAR2]
add eax, 00000001
mov dword ptr [VAR2], eax
adr_408731 :
cmp dword ptr [VAR2], 00000008
jge adr_40875B
mov ecx, dword ptr [VAR2]
add ecx, 00000001
imul ecx, 0000029Ah
mov edx, dword ptr [VAR2]
imul ecx, dword ptr [SN+4*edx]
mov edx, dword ptr [VAR1]
add edx, ecx
mov eax, dword ptr [ebp-30]
mov dword ptr [VAR1], edx
jmp adr_408728
adr_40875B :
mov eax, dword ptr [VAR1]
XOR ECX,ECX
XOR EBX,EBX
MOV ebx, 10
MOV ECX,0AH
BOUCLE:
XOR EDX,EDX
DIV ECX
ADD DL,30H
CMP DL,3AH
JL POST
ADD DL,7
POST:
DEC ebx
MOV byte ptr [SN2+ebx],DL
OR EAX,EAX
JNZ BOUCLE
mov eax, offset [SN2]
add eax, ebx
push offset eax
push offset MESS
call lstrcat
push MB_OK
push offset TITRE
push offset MESS
push 0
call MessageBoxA
xor eax, eax
xor edx, edx
Zeros :
mov byte ptr [NOM+eax], dh
mov byte ptr [SN2+eax], dh
inc al
cmp al, 40
jl Zeros
push offset MESS2
push offset MESS
call lstrcpy
jmp Byebye_2
Byebye :
push MB_OK
push offset TITRE
push offset ERR_1
push 0
call MessageBoxA
Byebye_2 :
ret
endp
; ProcΘdure de la DialogBoxParamA
DialogProc Proc
ARG Hwnd:dword, Msg:dword, Wparam:dword, Lparam:dword
mov eax, Msg
cmp eax, WM_COMMAND
je wmcommand
cmp eax, WM_CLOSE
je wmclose
jmp MsgNonTraite
wmcommand:
mov eax, Wparam
cmp eax, IDOK
je boutton_ok
cmp eax, IDCANCEL
je boutton_cancel
cmp eax, IDC_BUTTON_ABOUT
je boutton_about
jmp MsgTraite
boutton_ok:
push 40
push offset NOM
push IDC_EDIT1
push Hwnd
call GetDlgItemTextA
cmp eax, 0
je MsgNonTraite
call Calcul_SN
jmp MsgTraite
boutton_cancel:
push MB_OK
push offset TITRE
push offset MESS_CANCEL
push 0
call MessageBoxA
jmp wmclose
boutton_about:
push MB_OK
push offset TITRE
push offset MESS_ABOUT
push 0
call MessageBoxA
jmp MsgTraite
wmclose:
push 01
push Hwnd
call EndDialog
MsgTraite:
xor eax, eax
inc eax
ret
MsgNonTraite:
xor eax, eax
ret
endp
END START
;
************************************************************************
;
************************************************************************
Voilα, α partir d'aujourd'hui je veux voir uniquement des keygen en asm 32 bits (et τa prend pas trop de place : 8ko) !!!!!
Merci α :
Enkhyl
Mickey Mouse
Etmc