ษอออออออออออออออออออออออออออออออออออป
บ         KeygenMe hccc #5          บ
ศอออออออออออออออออออออออออออออออออออผ


Dispo: www.multimania.com/hccc
~~~~~~
Toolz: SoftICE, Delphi5 (pour le keygen)
~~~~~~


Intro:
~~~~~~
Un ptit tut de keygening sur le crackme de hccc5, tres facile a keygenner, il y egalement un petit anti-softice a cracker, alors.. Let's go! :)

Anti-SI:
~~~~~~~~

Bon pas de probleme pour ca, Lancez FrogsICE puis le crackme, et la FrogsICE nous donne ceci:
=> Keygenme    
** SoftICE detection **  code 07, at  FCB2:0040FCB2     
Interrupt:68h >eax=00004300h  ebx=0063FB56h  ecx=00000000h
               edx=00000000h  esi=00008B7Ah  edi=0063FB0Ch  ebp=0063FB04h

Donc une detection par int68h, pour cracker ca je me suis pas fait chier, j'ai pris W32Dasm et fait une recherche sur int 68h :), je trouve donc ceci:

:00401317 B443                    mov ah, 43
:00401319 CD68                    int 68
:0040131B 663D86F3                cmp ax, F386  << SoftICE?
:0040131F 7405                    je 00401326   << Oui, on degage
:00401321 E9CC000000              jmp 004013F2  << Non, on continue

Il suffit donc de mettre 2 nop (90) a la place du 'je' et le programme ne detectera plus SoftICE...
I nous est aussi demande de faire un memory patcher donc vous pouvez (je pense) utilisez le risc process patcher sinon vous en faites un a partir du source de Christal dans son tut pour hccc5.


Keygen:
~~~~~~~
Pour le keygen rentrez votre nom (Kahel pour moi) puis un serial bidon,placez un bpx sur getdlgitemtexta et enregistrez vous.SoftICE break faites F5 une fois, F11 une fois, vous devriez arriver en 004010BD
La commencez a tracer...
:004010BD 0FBE155C6A4000          movsx edx, byte ptr [00406A5C]
:004010C4 85D2                    test edx, edx <<Teste si il y a un nom
:004010C6 751B                    jne 004010E3  << Oui, On continue
:004010C8 6A00                    push 00000000
:004010CA 68B4614000              push 004061B4 << KeygenMe
:004010CF 6898614000              push 00406198 << "Vous devez entrez un Nom"
:004010D4 8B4508                  mov eax, dword ptr [ebp+08]
:004010D7 50                      push eax
:004010D8 FF15B8504000            Call dword ptr [004050B8] << Message d'erreur

[.....]

:004010E3 0FBE0D046B4000          movsx ecx, byte ptr [00406B04] <<Meme chose avec le serial
:004010EA 85C9                    test ecx, ecx
:004010EC 751B                    jne 00401109 << Ya un serial donc on continue

[.....]

:00401109 BF5C6A4000              mov edi, 00406A5C			<<<-
:0040110E 83C9FF                  or ecx, FFFFFFFF				}
:00401111 33C0                    xor eax, eax					}
:00401113 F2                      repnz						}
:00401114 AE                      scasb						} Cette routine teste
:00401115 F7D1                    not ecx					} Si le nom
:00401117 83C1FF                  add ecx, FFFFFFFF				} Fait plus de 4 chars
:0040111A 890D586A4000            mov dword ptr [00406A58], ecx			} Sinon on a le droit a
:00401120 833D586A400004          cmp dword ptr [00406A58], 00000004		} un message d'erreur...
:00401127 7D1B                    jge 00401144				<<<-

[.....]

:00401144 68E4604000              push 004060E4 << "KeygenMe"
:00401149 685C6A4000              push 00406A5C
:0040114E 68DC604000              push 004060DC << "Hccc"

La ce sont 2 tables de caracteres, nous verrons tout a l' heure a quoi elles servent...

:0040115D E80E030000              call 00401470 << Met "Hccc" avant le nom & "KeygenMe" apres ("HcccKahelKeygenMe")
:00401162 83C414                  add esp, 00000014
:00401165 C705506A400000000000    mov dword ptr [00406A50], 00000000
:0040116F EB0F                    jmp 00401180 << On va vers la routine de generation du serial

Apres le jmp 00401180 on arrive a la (1ere) routine du serial:
:00401180 8B15506A4000            mov edx, dword ptr [00406A50]
:00401186 0FBE82386B4000          movsx eax, byte ptr [edx+00406B38] <<On a fait toutes les lettres?
:0040118D 85C0                    test eax, eax
:0040118F 7456                    je 004011E7 <<Oui, on se casse
:00401191 8B0D506A4000            mov ecx, dword ptr [00406A50] <<Met le nom dans ecx
:00401197 0FBE91386B4000          movsx edx, byte ptr [ecx+00406B38] <<Met la valeur des lettres du nom dans edx
:0040119E 8915946A4000            mov dword ptr [00406A94], edx <<Edx dans un buffer
:004011A4 A1946A4000              mov eax, dword ptr [00406A94] <<Le buffer dans eax
:004011A9 83C009                  add eax, 00000009 		<<ajoute 9 a la valeur de eax
:004011AC A3946A4000              mov dword ptr [00406A94], eax <<met eax dans un buffer
:004011B1 8B0D946A4000            mov ecx, dword ptr [00406A94] <<met le buffer dans ecx
:004011B7 6BC90E                  imul ecx, 0000000E		<<multiplie ecx par 14
:004011BA 890D946A4000            mov dword ptr [00406A94], ecx <<ecx dans un buffer
:004011C0 A1946A4000              mov eax, dword ptr [00406A94] <<le buffer dans eax
:004011C5 99                      cdq				<<cdq
:004011C6 83E203                  and edx, 00000003		<<aucune utilite, le cdq met edx a 0 a chaque fois
:004011C9 03C2                    add eax, edx			<<aucune utilite, eax+0=eax
:004011CB C1F802                  sar eax, 02			<<sar eax,02
:004011CE A3946A4000              mov dword ptr [00406A94], eax <<met eax dans un buffer
:004011D3 8B15006B4000            mov edx, dword ptr [00406B00] <<met a derniere valeur generee dans edx
:004011D9 0315946A4000            add edx, dword ptr [00406A94] <<ajoute a edx un buffer (eax)
:004011DF 8915006B4000            mov dword ptr [00406B00], edx <<met cette valeur dans un buffer
:004011E5 EB8A                    jmp 00401171                  <<on continue tant qu'on a pas fait ttes les lettres

Bon la dedans ya pas mal de trucs qui servent a rien, par exemple le and edx, 03 apres un cdq qui l'a remis a zero :x... On peut simplifier la routine:

Routine:

	movzx eax, byte ptr [ebx+edx-01]
	add eax,09
	imul eax, eax, 0Eh
	sar eax, 02
	add edi, eax
	inc edx
	dec esi
	jne Routine
Voila, c'est deja plus clair et c'est le meme resultat :). Donc la routine prends les valeurs ascii de chacune des lettres de "Hccc"Votre Nom"KeygenMe (HcccKahelKeygenMe) elle 
ajoute 9 a cette valeur la mutiplie par 0E (14) et fais un sar 02 (decalage a droite avec signe) Et ajoute a chaque fois la valeur obtenue dans un buffer (ici edi).

En continuant de tracer on arrive a la 2eme partie de generation du serial:
:00401200 8B0D506A4000            mov ecx, dword ptr [00406A50]
:00401206 0FBE91386B4000          movsx edx, byte ptr [ecx+00406B38]
:0040120D 85D2                    test edx, edx << on a fait toutes les letres?
:0040120F 7433                    je 00401244 <<oui on se casse
:00401211 A1506A4000              mov eax, dword ptr [00406A50] <<HcccKahelKeygenMe dans eax
:00401216 0FBE88386B4000          movsx ecx, byte ptr [eax+00406B38] <<debut de la routine
:0040121D 890D946A4000            mov dword ptr [00406A94], ecx <<valeur de ecx dans un buffer
:00401223 8B15946A4000            mov edx, dword ptr [00406A94] <<valeur du buffer dans edx
:00401229 83F209                  xor edx, 00000009		<<xor edx,9
:0040122C 8915946A4000            mov dword ptr [00406A94], edx <<edx dans un buffer (tjs le meme)
:00401232 A1986A4000              mov eax, dword ptr [00406A98] <<met la valeur de la derniere operation dans eax
:00401237 0305946A4000            add eax, dword ptr [00406A94] <<ajoute la valeur a eax
:0040123D A3986A4000              mov dword ptr [00406A98], eax <<ajoute eax a un buffer
:00401242 EBAF                    jmp 004011F3 <<on continue tant qu'on a pas traite ttes les lettres

Une fois encore il y a beaucoup de code a supprimer, on peut donc reduire cette routine a:

Routine2:
	movzx eax, byte ptr [ebx+edx-01]
	xor eax, 09
	add edi, eax
	inc edx
	dec esi
	Jne Routine2
Donc le prog prend la valeur ascii de chacune des lettres de notre nom (HcccKahelKeygenMe), et leur fait subir un xor puis les ajoute dans un buffer (ici edi). Une fois la routine terminee le programme jump en 401244:

:00401244 8B0D986A4000            mov ecx, dword ptr [00406A98] <<valeur generee par la premiere routine
:0040124A 51                      push ecx                      <<ecx dans la pile
:0040124B 8B15006B4000            mov edx, dword ptr [00406B00] <<valeur generee par la seconde routine
:00401251 52                      push edx			<<edx dans la pile
:00401252 6838614000              push 00406138 << "%d-%d-69" (pour _wsprintfA le serial sera sous la forme x-x-69)
:00401257 689C6A4000              push 00406A9C << buffer ou le serial va etre place
:0040125C E80F020000              call 00401470 << call a l'api _wsprintfA
:00401261 83C410                  add esp, 00000010			
:00401264 C745F0046B4000          mov [ebp-10], 00406B04 << le serial qu'on a rentre
:0040126B C745EC9C6A4000          mov [ebp-14], 00406A9C << le bon serial
:00401272 8B45EC                  mov eax, dword ptr [ebp-14]	<< met le bon serial dans eax	
:00401275 8A08                    mov cl, byte ptr [eax]		<
:00401277 884DEB                  mov byte ptr [ebp-15], cl		|
:0040127A 8B55F0                  mov edx, dword ptr [ebp-10]		|
:0040127D 3A0A                    cmp cl, byte ptr [edx]		|
:0040127F 752E                    jne 004012AF				|
:00401281 807DEB00                cmp byte ptr [ebp-15], 00		|Routine
:00401285 741F                    je 004012A6				|de
:00401287 8B45EC                  mov eax, dword ptr [ebp-14]		|verification
:0040128A 8A4801                  mov cl, byte ptr [eax+01]		|du
:0040128D 884DEA                  mov byte ptr [ebp-16], cl		|serial
:00401290 8B55F0                  mov edx, dword ptr [ebp-10]		|
:00401293 3A4A01                  cmp cl, byte ptr [edx+01]		|
:00401296 7517                    jne 004012AF				|
:00401298 8345EC02                add dword ptr [ebp-14], 00000002	|
:0040129C 8345F002                add dword ptr [ebp-10], 00000002	|
:004012A0 807DEA00                cmp byte ptr [ebp-16], 00		|
:004012A4 75CC                    jne 00401272            	        <Faux serial? => Essaye encore
:004012A6 C745E400000000          mov [ebp-1C], 00000000
:004012AD EB08                    jmp 004012B7				<Bon serial? => Bien joue

Voila le serial final est genere en 40125C, ensuite un "d 406A9C" vous permettra de voir le bon serial. Pour coder le keygen j'ai fait ca en vite fait avec Delphi, voici mon code source:

procedure TForm1.Edit1Change(Sender: TObject);
var i,ascii,result1,result2: integer;
var str1: string;

begin
 str1:='Hccc'+Edit1.Text+'KeygenMe'; //notre nom avec les 2 tables de caracteres

asm
    xor edi, edi //remet edi a 0
end;
	for i:=1 to length(str1) do //debut de la boucle
begin

ascii:=ord(str1[i]);

asm					//operation de la premiere routine
    mov eax,ascii
    add eax, 09
    imul eax,eax, 0Eh
    sar eax, 02
    add edi,eax
    mov result1, edi
end;

end;

ascii:=0;
for i:=1 to length(str1) do //seconde boucle
begin
ascii:=ord(str1[i]);

asm
   mov eax, ascii	//operation de la seconde boucle
   xor eax, 09
   add result2, eax

end;
end;
edit2.text:=inttostr(result1)+'-'+inttostr(result2)+'-69'; //serial sous la forme x-x-69

end;

Donc pour Kahel, le serial est 6284-1642-69.

Kahel - kahel@milliardaires.Com