Initiation au cracking

Il faut avoir un minimum de connaissances en assembleur, connaitre le plus de fonctions possibles, posséder des programmes tels que Win32DASM, SoftICE (dommage qu'il plante votre PC assez souvent), Turbo debugger (pratique des fois) et un éditeur hexadécimal pour effectuer les modifications. Vous n'aurez pas d'exemples pratiques pour aujourd'hui, avalez donc déjà la théorie, il faut passer par là.
Bon, par quoi je vais commencer ? d'abord, cracker un programme n'est pas réservé aux Yaankees du net ou de la programmation, certes, il vaut mieux savoir bien programmer. Aussi, si vous voulez cracker du Visual Basic, arrêtez vous ici car c'est un langage qui compilé hyper-mal les programmes et donc, le code fait sans arrêt appel à ces *ù*^$¨%$ de DLL (vbrunxxx, vbxxxxx, ....), et en plus, la majorité des programmes faits en VB sont merdiques, et l'auteur ne sait pas progarmmer (ou pas beaucoup), on ne pourras rien faire de ce langage.
Il va donc falloir décompiler le programme, c'est à dire, le remettre sous sa forme de code source, mais il y a un problème, si on a écrit et compilé son programe avec turbo pascal, on ne verra pas la source en turbo pascal, mais en assembleur, car le programme est déjà compilé et donc, chaque instruction en hexadécimal correspond à une instruction en assembleur, par exemple, dans un programme que vous regardez avec votre éditeur hexadécimal, vous pouvez apperçevoir le nombre 90, il correspond à l'instruction NOP en assembleur, donc, le debugger ne fait que traduire toutes ces valeurs en instructions assembleur. Voici quelques instructions assembleurs :
Jne : cette instruction sert à aller à un emplacement quand la valeur est fausse, son code hexadécimal est 75.
Je : cette instruction sert à aller à un emplacement quand la valeur est correcte, son code hexadécimal est 74.
Jmp : cette instruction est à aller à un emplacement dans tous les cas, son code hexadécimal est EB.
donc, dans le code, quand vous verrez :
75xxx  Jne xxx, vous vous direz : "Quand la valeur sera fausse, le programme ira sur xxx, j'ai donc qu'à remplacer Jne par Je"
C'est bon, vous pourrez faire ça, mais le programme calculera peut être ici des déplacements de variables en mémoire, et pas forcément le calcul d'un password. Essayez toujours, après, avec votre éditeur hexadécimal, recherchez la valeur 75xxx, et remplacez par 74, car nous avons vu plus haut que 74 correspond à Je.
Bon, c'est en fait assez compliqué à expliquer sans exemple, et j'ai pas trop le temps d'en faire un, alors, je vais mettre un très bon exemple, que j'ai demandé à un ami, le voici :

Code.exe : Programme très simple permettant d'apprendre à cracker.
A la base, quand on tape 1, le programme écrit "Bon code" et pour tout le reste, il écrit "Mauvais code".

Amusons nous avec un debugger, dans cet exemple, j'utilise Turbo Debugger pour DOS.
Je repère, assez rapidement dans le programme une comparaison :

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01   <-- ici, comparaison
  cs:0065 751E                 jne    0085  <----------------- ici, saut si faux
  cs:0067 BF5401            mov    di,0154
  cs:006A 1E                   push   ds

Je me rappelle :
Jne : cette instruction sert à aller à un emplacement quand la valeur est fausse, son code hexadécimal est 75
Je : cette instruction sert à aller à un emplacement quand la valeur est correcte, son code hexadécimal est 74.
Jmp : cette instruction est à aller à un emplacement dans tous les cas, son code hexadécimal est EB.

Il faut donc remplacer 75 (Jne) par 74(Je), ce qui donnera :

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01
  cs:0065 741E                 je    0085
  cs:0067 BF5401            mov    di,0154
  cs:006A 1E                   push   ds

avec un éditeur hexadécimal, on cherchera donc :
80 3E 52 00 01 75 1E BF 54 01  et on remplace par
-- -- -- -- -- 74 -- -- -- --

Maintenant, quand on tape 2, le programme ‚crira Bon code et quand on tape 1, le programme écrit : Mauvais code.
Approfondissons un peu, le programme doit écrire "Bon code", que l'on tape 1 ou n'importe quel autre nombre.

Je vais vous montrer une erreur à éviter mais qui nous en apprend :

"Si on remplace jne 0085 par jmp 0085, comme ça, il saute tout de suite sur 0085"

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01
  cs:0065 EB1E                jmp    0085   <------------ ici
  cs:0067 BF5401            mov    di,0154
  cs:006A 1E                   push   ds

avec un éditeur hexadécimal, on cherchera donc :
80 3E 52 00 01 74 1E BF 54 01  et on remplace par
-- -- -- -- -- EB -- -- -- --

mais maintenant, tout est mauvais, quoi que l'on tape, eh ben, on réfléchit :
"Si le code est faux (Jne), il va à l'emplacement 0085, ça veux dire que si il est juste, il ne lit pas cette instruction et continue à lire la suite du programme"
On dira alors au programme de sauter à l'instruction juste après : 0067

  cs:005B 9A91028560     call   6085:0291
  cs:0060 803E520001     cmp    byte ptr [0052],01
  cs:0065 EB00                 jmp    0067
  cs:0067 BF5401             mov    di,0154
  cs:006A 1E                    push   ds

avec un éditeur hexadécimal, on cherchera donc :
80 3E 52 00 01 EB 1E BF 54 01  et on remplace par
-- -- -- -- -- -- 00 -- -- --

Eh voilà le travail, maintenant, le programme écrit "Bon code", quoi
qu'il arrive. Amusez vous bien.

The yAcC.

Merci The yAcC pour ton exemple, t'es sympa, il permet de bien apprendre le crack, on fabrique le programme et on le cracke, ce qui permet de tout voir étape par étape.