V] CREATION D'UN KEYGENERATEUR EN VISUAL BASIC

1) comprendre le code

On a identifié la routine qui crée le bon serial (cf tutorial 4).On veut savoir ou exactement
est crée le bon sérial. On avait vu le bon serial pour la premiere fois à l'adresse 40DAFE dans
la pile, puis dans les registres

Remarque: Avant d'arriver à cet endroit, vous avez peut être vu dans les registres "MuradMeraly", "bcom".
Ce ne sont pas des serial valides, ce sont des noms pour lesquels le serial a été diffusé sur internet donc
winzip a blacklisté ces noms pour que vous ne puissiez plus vous enregistrer avec.

premiere fois

Le serial est sans doute crée par la ligne 40DAF9 CALL 40CE5E
On rentre dans le  call 40CE5E avec F7:


keygenerateur vb winzip 9.0


la création du serial se fait en deux fois:
- la partie en rouge crée la fin du sérial.
- la partie en bleu crée le début du sérial.

2) l'hexadecimal

Les ordinateurs utilisent un système de numérotation différent de nous. Au lieu d’utiliser le système
décimal (0,1,2,3,4,5,6,7,8,9), ils utilisent le système hexadécimal (0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F).
Les lettre en hexadécimal ont une correspondance en décimal (A=10, B=11, C=12, D=13, E= 15, F=16).
On peut facilement passer du décimal à l’hexadécimal ou l’inverse avec la calculatrice windows en
mode scientifique (attention elle ne vous donne que des nombres hexadecimaux positifs).
Quand on manipule des données, dans les registres on manipule aussi de l’héxadecimal.
On a vu que eax = un dword et il peut contenir une valeur de 00 00 00 00 à FF FF FF FF.
On a aussi expliqué au début que dl = 1 byte. 1 byte, cela correspond en fait à deux caractères
hexadécimal (entre 00 et FF). Chaque lettre de l'alphabet correspond à un code ascii. Ce code ascii
est ici exprimé en hexadécimal. Pour loloko, on à l=6c, o=6f, l=6c, o=6f, k=6b, o=6f

3) partie en rouge qui genere la fin du serial

Nous allons voir en détail la partie en rouge qui genere la fin du serial:

fin serial

Le code est trés simple:
Le programme récupére le nom "loloko" dans ESI. Il met ensuite le code ascii de la premiere lettre du
nom dans EDX et le multiplie par EDI (au debut EDI = 0 mais il augmente de 1 en changeant de caractere).
Le prog augmente ESI d'un pour passer à la lettre suivante. Il met la deuxième lettre du nom dans EDX 
et la multiplie par EDI (EDI=1) et ainsi de suite pour toutes les lettres du nom.
On a le resultat des multiplication dans EDX. Ce resultat est ajouté au fur et a mesure dans EBX

Pour loloko, on a donc:

1) EDX = 0*6C = 0000

2) EDX = 1*6F = 006F

3) EDX = 2*6C = 00D8

4) EDX = 3*6F = 014D

5) EDX = 4*6B = 01AC

6) EDX = 5*6F = 022B

--------------------------

TOTAL EBX = 066B

Quand la boucle est terminée, on peut voir la fin du sérial dans EBX :


fin serial winzip.

4) partie en bleu qui génére le début du sérial

boucle debut serial

 La boucle ne fait presque rien. Elle transmet deux arguments aux call 40CE38. Ces deux arguments sont
1021 et chaque lettre du nom de la premiere à la derniere. Le call 40CE38 effectue un calcul et met le 
résultat de ce calcul dans eax. Pour loloko, on obtient comme valeurs succéssives d'eax:

1) eax = 0006AD2A calculé en fonction de Arg1 = 1021 et Arg2 = 6C

2) eax = 06A1D30E calculé en fonction de Arg1 = 1021 et Arg2 = 6F

3) eax = A1D85834 calculé en fonction de Arg1 = 1021 et Arg2 = 6C

4) eax = D85B72B4 calculé en fonction de Arg1 = 1021 et Arg2 = 6F

5) eax = 5B733718 calculé en fonction de Arg1 = 1021 et Arg2 = 6B

6) eax = 7332C3FD calculé en fonction de Arg1 = 1021 et Arg2 = 6F

On prend ensuite la dernière valeur de eax (7332C3FD), et on lui ajoute 63 (toujours de l'hexadécimal).
Quand la boucle est terminée, on peut voir le debut du sérial dans EAX :

winzip 9.0 crack.


Oui tout ça c'est cool, sauf qu'on a pas compris grand chose --> c'est le call 40CE38 qui fait les calculs
pour la fin du serial  --> on rentre dedans pour essayer de comprendre --> la ça devient un peu plus
compliqué:

detail du call

la boucle effectue l'opération xor (opération de cryptage que l'on peut réaliser avec la calculatrice
windows) sur ESI et ECX et conserve le résultat dans ESI. Ensuite le prog effectue un test sur SI.
Les 'instructions TEST SI, SI, puis  JNS 40CE54 signifient qu'on va travailler sur SI en nombres signés.
JNS est un saut conditionnel qui signifie saute si SI est non signé (c'est à dire positif).
ESI est codé sur 4 octects, si ESI = 0001A021, alors on a SI= A021(seulement 2 octects).
Si A021 est un nombre positif, alors on saute en 40CE56.
Pour ceux qui ne le sauraient pas, les nombres Hexadecimaux peuvent être négatifs si on travaille sur
des  nombres signés. Quand on prend un nombre codé sur 2 octets, on a des nombres positifs de 0000
à 7FFF, et des nombres négatifs de 8000 à FFFF (en décimal, cela fait de 0 à 32767, et de -32768 à -1)
Ainsi, même sans le convertir en décimal on sait que A021 est un nombre négatif.
Quand le nombre est positif, on saute et on multiplie par 2 eax et ecx.
Quand le nombre est négatif, on ne saute pas: on multiplie par 2 eax, on réalise l'opération
xor eax, 1021, et on multiplie par 2 ecx. On répéte cette boucle 8 fois.

Voici les calculs avec eax=00000000 et ecx=6C00 au départ :

.1) si=6C00 (jump), eax=0, ecx=D800

2) si=D800 (no jump), eax=1021, ecx=1B00

3) si=A021 (no jump), eax=3063, ecx=36000

4) si=5063 (jump), eax=60C6, ecx=6C000

5) si=A0C6 (no jump), eax=D1AD, ecx=D8000

6) si=51AD (jump), eax=1A35A, ecx=1B0000

7) si=A35A (no jump), eax=35695, ecx=360000

8) si=5695 (jump), eax=6AD2A, ecx=6C0000


On trouve donc à la fin eax=6AD2A et on recommence le calcul avec cette valeur d'eax, et ecx=6F00
(la lettre suivante) et ainsi de suite jusqu'a la dernière lettre de notre nom. --> la j'ai illustré les calculs
seuelement pour la premiere lettre.

5) réunion des deux bouts de serial

Pour résumer, on a la fin du serial dans BX, le debut dans AX
La premiere instruction copie BX dans ECX
Ensuite c'est le call 004B85A1 qui se charge de reunir les deux parties
Pour cela, on lui transmet le debut du serial (ECX), la fin (EAX), deux autres parametres,
et l'adresse ou il doit stocker le résultat (0012F0EC)
Une fois le call executé, on le serial "C460066B" a l'adresse 12F0EC

final

6) créer un keygenerateur en visual basic.

J'ai choisi visual basic car c'est le language que je maitrise le mieux. Vous pouvez executer ce
code dans l'environement de developpement visual basic ou dans l'editeur visual basic d'Excel.

 

D'abord un petit lexique des instructions VB qu'on va utliser:
- Inputbox : permet de recuperer le texte entré au clavier
- Len(texte) : indique le nombre de caracteres d'une chaine de texte
- Mid(nom, i, 1) : recupere le i eme caractere du nom
- Asc : donne la valeur ASCII d'un caractere
- Hex : affiche la valeur en hexadecimal
- Right (valeur,4) : garde 4 caracteres de valeur en commencant par la droite
- Msgbox : affiche un texte ou une valeur dans une boite de message

voila le code en visual basic pour générer la fin du sérial:

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

Sub partie1()
nom = InputBox("entrez votre nom")
For i = 1 To Len(nom)
edi = i - 1
edx = Asc(Mid(nom, i, 1))
edx = edx * edi
MsgBox ("edx = " & Hex(edx))
ebx = ebx + edx
Next
MsgBox ("fin serial = " & Right("0000" + Hex(ebx), 4))
End Sub

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

Grace à Inputbox, on recupere notre nom dans la variable nom. Avec For Next, on cree une boucle
qui s'execute pour toutes les lettre de notre nom. On recupere le code Ascii du  premier caractere du nom
avec Asc (Mid(nom, i, 1) et on le met dans la variable edx. On multiplie edx par edi (compteur). On
ajoute edx à ebx. On continue cette boucle pour toutes les lettres du nom. A la fin, on a le serial
dans ebx. On s'aide de Right pour afficher le résultat dans la message box --> cela permet d'avoir
comme résultat de fin serial 066B et pas seulement fin serial=66B)

(si vous utiliser un navigateur compatible VB Script, vous pouvez essayer le code en cliquant sur le boutton)

.

Voici maintenant le code en VB pour générer le début du sérial:

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

Sub partie2boucle1_OnClick()
nom = InputBox("entrez votre nom")
For i = 1 To Len(nom)
ecx = "&h" + Hex(Asc(Mid(nom, i, 1))) + "00"
For edx = 1 To 8
esi = Hex(ecx Xor eax)
esi = Right(esi, 4)
If esi < "8000" Then
eax = eax * 2
If eax > 2147483647 Then eax = eax - 4294967296
If eax < -2147483648 Then eax = eax + 4294967296
ecx = ecx * 2
MsgBox ("eax = " & Hex(eax))
Else
eax = eax * 2
If eax > 2147483647 Then eax = eax - 4294967296
If eax < -2147483648 Then eax = eax + 4294967296
eax = eax Xor &H1021
ecx = ecx * 2
MsgBox ("eax = " & Hex(eax))
End If
Next
Next
MsgBox ("eax final = " & Hex(eax + &H63))
MsgBox ("debut serial = " & Right(Hex(eax + &H63), 4))
End Sub

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

L'instruction if esi < "8000" sert à savoir si le nombre est positif (cf plus haut pour les nombres négatifs)
On voit &H1021. VB comprend que le nombre est le nombre est hexadecimal quand on rajoute &H devant.
Ici, &H1021 est donc le nombre 1021 en hexadécimal. Ensuite, aprés chaque multiplication par 2 de eax,
on a un une verification de la valeur de eax. Cela vient du fait que pour un registre les nombres possibles
vont de 00 00 00 00 à FF FF FF FF avec des nombres positifs et négatifs. Le nombre maximum est
2 147 483 647, le nombre minimun est - 2 147 483 648 avec des valeurs signées. Pour vb qui effectue
ces opérations en décimal il n'y a pas de limite. VB peut donc trouver un chiffre inférieur ou superieur aux
limites de l'hexadecimal. Quand on cherche ensuite à convertir ce chiffre en hexadécimal avec Hex() cela 
crée une erreur. Pour éviter cette erreur, on fait ce que font les registres en cas de dépassement, on ajoute
ou on retire 4 294 967 296 en fonction du signe. Vous pouvez essayer le prog en cliquant sur le boutton DEBUT SERIAL




cours precedent                                                                                                                              cours suivant