Une base d'ASM peut beaucoup vous aider mais n'est pas nécessaire car nous allons voir tout ce qu'il vous faut savoir.
Pour commencer, nous allons nous attaquer à un crackme tout simple: Téléchargez-le ici(attention, le fichier d'origine n'étant plus disponible, je l'ai remplacé, je ne sai pas du tout si il s'agit du bon, mais celui ci est livré avec les sources)
Bon, nous lançons notre petit programme... et on voit une belle fenêtre Windows demandant un sérial. Le problème c'est que nous on le connait pas celui-là, alors comment faire ??? Réfléchissez un peu, dans notre programme il doit y être mis quelque part que quand nous cliquons sur le bouton "Check", le programme doit prendre la valeur du sérial, la comparée avec le bon sérial et si les sérials sont les mêmes retourner un message de succès, sinon un message d'erreur. On se dit qu'on a rien à perdre et on entre n'importe quoi, par exemple "12345", on click sur "Check" et hop, un joli petit message d'erreur: "Incorrect try again !!".
Bon ok, maintenant que l'on sait ce qu'il faut trouver, on démarre Windasm, on click sur "Open file to disassemble" et on choissit notre petit crackme.
AAAHHH L'HORREUR, C QUOI CES TRUCS QUI VEULENT RIEN DIRE DANS TOUS LES COINS ?????
Ben ouais, c'est ça l'assembleur... Ce sont des petites instructions qui s'enchainent l'une à la suite de l'autre pour former un programme.
Surtout ne vous décourager pas, parce que c'est très simple pour trouver notre routine qui vérifie le sérial, mais avant toute chose, je vais vous faire la présentation de votre nouveau collègue de cracking, le dénommé Windasm... ;-)
Windasm.
En tout premier lieu, aller dans "Disassembler" => "Font..." => "Select Font" et choisissez un police qui convient. Puis aller dans "Disassembler" => "Font..." => "Save default font" pour l'enregistrer.
Comme je vous l'ai dit précédemment, Windasm est un désassembleur ( ou décompilateur ) pour Windows 16 et 32 bits. Mais pourquoi faut-il désassembler un programme ?
Tout simplement parce qu'un programme qu'il soit écrit en C/C++, Visual Basic, Delphi,ect... est traduit par le compilateur approprié en code ASM, ou assembleur, le seul langage que les machines comprennent. Mais si ce n'était que ça... En faite, il faut que le code ASM soit aussi transformer en binaire, car une machine ne reconnait que ça. Donc, le but de notre désassembleur, c'est de rendre un code lisible pour nous, les humains.
Tout d'abord, ce qui apparaît à l'écran s'appelle le listing, c'est tout le code désassemblé par Windasm:
La première colonne, souvent appelée Code Data, sert à déterminer l'adresse correspondant à l'instruction. Remarquez que pour les programmes exécutable, cette ligne commence à 401000.
La seconde colonne, est le code en hexadécimal.
Et la troisième est le code traduit en ASM que nous pouvons le plus facilement comprendre mais qui doit quand même ne pas vous dire grand chose...
Ensuite, la barre d'option:
Nous allons voir ce que chacun d'eux représente respectivement 1 par 1 en partant de la gauche vers la droite.
- "Open file to disassemble" : permet d'ouvrir un fichier à désassembler.
- "Save disassembly text file et create project file" : permet d'enregistrer votre listing et de créer un fichier de projet.
- "Find text" : permet de trouver une chaîne de caractère dans le listing.
- "Copy selected lines" : permet de copier les lignes sélectionnées. Pour ce faire, cliquez avec le bouton gauche de votre souris devant la ligne choisie pour la sélectionner. Si vous voulez en sélectionner plusieurs, appuyez sur Shift en même temps.
- "Goto code start" : permet de se rendre au début du code de votre programme.
- "Goto code entry point" : permet de se rendre au point d'entré du programme.
- "Goto page" : permet de vous rendre à la page du listing voulue.
- "Goto code location" : permet de vous rendre à une adresse ( Code Data ) spécifiée.
- "Execute jump" : permet de sauter si la ligne en cours ( marquée par une ligne de couleur ) est un saut.
- "Return from last jump" : permet de retourner à la ligne où se situais le dernier saut que vous avez effectué.
- "Execute call" : permet d'aller à la ligne de code appelée.
- "Return from call" : permet de retourner à la ligne où se situait le dernier call appelé.
- "Imports" : fonctions appartenant au fichier désassemblé.
- "Exports" : fonctions appartenant à un autre fichier que celui qui est désassemblé: dll, vxd,...
- "Hex display of data objet/segments" : permet de voir le programme en hexadécimal.
- "Hex display of code data" : idem que le prédédent.
Rem je ne ferai pas la différence entre les deux car elles ne devrait pas vous servir à ce stade.
- "Dialog references" : références des boites de dialogues utilisées.
- "String data references" : références de toutes les chaines utilisées.
- "Print" : imprime les lignes sélectionnées. Si il y en a aucune, tout le listing entier est imprimer.
Méfiez-vous, un listing atteint très très rapidement les 100 pages pour un programme de 50 à 100 Ko !!!
Et voici la barre de status:
"Line:320" définit le numéro de ligne en cours.
"Pg 4 of 30" définit que nous sommes sur la page 4, et qu'il y en a un total de 30.
"Code Data @:401117" définit que nous sommes à la l'adresse 401117.
"@Offset 00001117h" définit que nous sommes à l'offset 1117, h indiquant que ce nombre est en hexadécimal.
"in File:Crackme.exe" définit le nom du programme qui est désassemblé.
Trouver le/les saut(s) conditionnel(s).
Bon, nous voilà fin près à débuter le cracking. Je suppose que vous avez quand même déjà désassemblé votre programme, sinon faites-le. Comme je vous l'ai déjà fait remarquez, il y a un endroit ou se trouve ce qu'on appelle un saut conditionnel vérifiant si le sérial est bon ou pas. Donc ils nous faut trouver ce saut.
Rappellez-vous, quand nous avions entré un mauvais sérial, un message d'erreur était apparu:
Maintenant, on sait tout ce qu'il nous faut savoir pour cracker ce programme. Nous allons nous y prendre par la manière dite du "Dead Listing", c'est-à-dire qu'on repère le saut et on le change de façon à ce que même si le serial est mauvais, nous soyons enregistré.
Pour ce faire, nous allons aller voir les "String data references".
Nous pouvons remarquez que le message d'erreur y est:"Incorrect try again!!". Donc nous double-cliquons sur celui-ci plusieurs fois en regardant l'adresse où ça nous mène pour vérifier si il n'y en a pas plusieurs. Une chance pour nous ce n'est pas le cas.
Et voilà, si le sérial n'est pas bon nous sautons ici. Celà affiche un message avec comme titre "Crackme" et comme texte "Incorrect try again!!". Mais nous pouvons voir ceci aussi:
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401595(C)
|
Ce qui signifie que le saut conditionnel se situe à l'adresse "00401595". Donc nous cliquons sur "Goto code location" et spécifions "00401595" pour nous rendre à ce saut. Mais voici à présent toute la partie du code qui nous intéresse:
:0040158D FF1500204000 Call dword ptr [00402000]
:00401593 85C0 test eax, eax
:00401595 7516 jne 004015AD
:00401597 6A40 push 00000040
* Possible StringData Ref from Data Obj ->"CrackMe"
|
:00401599 6850304000 push 00403050
* Possible StringData Ref from Data Obj ->"Correct way to go!!"
|
:0040159E 6858304000 push 00403058
:004015A3 8B4DE0 mov ecx, dword ptr [ebp-20]
* Reference To: MFC42.MFC42:NoName0077, Ord:1080h
|
:004015A6 E853050000 Call 00401AFE
:004015AB EB14 jmp 004015C1
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00401595(C)
|
:004015AD 6A40 push 00000040
* Possible StringData Ref from Data Obj ->"CrackMe"
| :004015AF 686C304000 push 0040306C
* Possible StringData Ref from Data Obj ->"Incorrect try again!!"
|
:004015B4 6874304000 push 00403074
:004015B9 8B4DE0 mov ecx, dword ptr [ebp-20]
* Reference To: MFC42.MFC42:NoName0077, Ord:1080h
|
:004015BC E83D050000 Call 00401AFE |
-> Teste si les sérials sont les mêmes
-> si les sérials sont différents, alors sauter en 004015AD et donc ne va pas allez dans la partie ou le message disant que le sérial est bon
#### D'ici à ####
#
#
#
#
#
#
# Va afficher le message disant que le sérial est bon
#
#
#
#
#
#### Ici ###
-> retourne sous le programme une fois qu'on a cliqué sur OK.
#### D'ici à ####
#
#
#
#
#
#
#
# Va afficher un message disant que le sérial
# est incorrecte et va ensuite retourner au
# programme une fois qu'on aura cliqué sur OK.
#
#
#
#
#
#
#
#### ICI ####
|
Nous avons bien remarqué qu'il faudrait soit inversé le saut, mais si vous taper le bon sérial alors vous irez vers le message d'erreur, soit désactivez ce saut afin de toujout arriver sur le message disant que le sérial est bon, et c'est la meilleur solution dans ce cas ci.
Pour ce faire, nous allons "noper" le "JNE 004015AD". Noper une instruction, veut dire qu'on va remplacer celle-ci par "NOP". Mais qu'est-ce que c'est ce "NOP" ???
Tout simplement une instruction ASM signifiant qu'il ne faut rien faire, cela peut vous paraître abérant d'avoir inventer ça, mais c'est très pratique, vous allez vite le découvrir.
Bon maintenant, il nous faut modifier notre programme.
Je vous conseil, enfin c'est une bonne habitude, de faire une copie de votre programme et de travailler sur la copie. En cas de fausse manoeuvre, on n'aura qu'à en refaire une et supprimer l'ancienne.
Modifier un fichier.
Je vous conseil, enfin c'est une bonne habitude, de faire une copie de votre programme et de travailler sur la copie. En cas de fausse manoeuvre, on n'aura qu'a en refaire une et supprimer l'ancienne.
Pour ce faire, nous avons besoin d'un éditeur hexadécimal et de l'offset à mofidier. Pour obtenir l'offset, vous double-cliquez sur la ligne dont vous voulez l'offset, et il sera indiqué dans la barre de status ( remonter à la description de Windasm si vous voulez plus d'informations ).
Nous utiliserons HView. Voci comment il se présente:
Je ne crois pas qu'il soit utile de l'expliquer de fond en comble car sont emploi est très simple. Vous pouvez choisir parmi les options qui sont indiqué tout en dessous en cliquant sur la touche correspondante ( ex: 1 = F1 ). Premièrement, déplacez-vous grâce aux flèches et "Enter" dans les répertoire. Ensuite, appuyez sur "Enter" au-dessus du programme à modifier. Là vous pouvez taper F5 pour entrer l'offet ou vous voulez vous rendre et F3 pour modifier ce qui doit être modifier. Une fois que vous avez tout fait cliquez sur F9 pour enregistrer et sur F10 pour fermer HView ce qui vous permettra de démarrer votre programme avec les changements.
Nous prenons l'offset correspondant au saut conditionnel: 1595. Et nous démarrons HView, grâce aux flèches et à "Enter" nous nous rendont dans le répertoire du crackme et sélectionnons ce programme. Ensuite, nous cliquons sur F4 et choisissons le mode "Hex" ( pour hexadécimal ). Remarquez que nous aurions pu prendre le mode "Decode" mais je préfère de loin le mode hexadécimal. Nous cliquons alors sur F5 et entrons notre offset ( 1595 ) suivis de "Enter". Nous arrivons à ceci:
Nous pouvons remarquez que tous les codes hexadécimaux se suivent l'un à la suite de l'autre, mais nous devons modifier que 85C075166A40 en 85C090906A40. Donc nous cliquons sur F3 et modifions le programme.
7516 -> JNE 004015AD
9090 -> NOP NOP
Ceci Fait vous devriez obtenir ceci:
Ensuite nous appuyons sur F10 et lançons notre programme. Vérifiez bien de lancez la copie si vous en avez fais une. Nous entrons toujours "12345"...
Woaw CA MMMMMMMAAAAAAAARRRRRRCCCCCCCHHHHHHEEEEEEE
Dans le cas ou ça n'airait pas, vérifiez que vous avez fait comme je l'ai écrit et que vous avez bien lancé le programme que vous avez modifier.
Faire des cracks.
Maintenant que vous avez modifié votre programme, il ne vous reste plus qu'à faire votre crack. Comme je n'ai pas de code source à vous filer, que j'ai encore beaucoup de choses à faire et que je n'ai pas le temps d'en faire un, je vous laisse aller sur votre moteur de recherche préféré pour en rechercher un dans votre langage préféré!
Sauts conditionnels et instructions utiles.
Nous allons voir ici les différents sauts et instructions qui pourraient vous être utile lors de déplombage de vos propre programme.
| Instruction |
Code hexadécimal |
Action |
| JA |
77 |
Saute si supérieur. |
| JAE |
83 |
Saute si supérieur ou égal |
| JB |
72 |
Saute si inférieur |
| JBE |
76 |
Saute si inférieur ou égal |
| JC |
82 |
Saute si CF = 1 |
| JCXZ |
E3 |
Saute si CF = 0 |
| JE |
74 |
Saute si égal |
| JG |
7F |
Saute si supérieur |
| JGE |
7D |
Saute si supérieur ou égal |
| JL |
7C |
Saute si inférieur |
| JLE |
7E |
Saute si inférieur ou égal |
| JMP |
EB |
Saute sans condition |
| JPE |
8A |
Saute si PF = 1, c'est-à-dire si la parité est paire |
| JPO |
8B |
Saute si OF = 1 |
| JNA |
86 |
Saute si pas supérieur |
| JNAE |
82 |
Saute si pas supérieur ou égal |
| JNB |
73 |
Saute si pas inférieur |
| JNBE |
87 |
Saute si pas inférieur ou égal |
| JNC |
?? |
Saute si CF = 0 |
| JNE |
75 |
Saute si pas égal |
| JNL |
8D |
Saute si pas inférieur |
| JNLE |
8E |
Saute si pas inférieur ou égal |
| JNG |
8C |
Saute si pas supérieur |
| JNGE |
8C |
Saute si pas supérieur ou égal |
| JNO |
71 |
Saute si OF = 0 |
| JNP |
8B |
Saute si PF = 0, c'est-à-dire si la parité est impaire |
| JNS |
89 |
Saute si SF = 0, c'est-à-dire si positif |
| JNZ |
85 |
Saute si pas zéro |
| JO |
80 |
Saute si OF = 1 |
| JP |
8A |
Saute si PF = 1, c'est-à-dire si la parité est paire |
| JS |
88 |
Saute si SF = 1, c'est-à-dire si négatif |
| JZ |
84 |
Saute si zéro |
| NOP |
90 |
Ne fais rien |
Le tableau n'est pas tout à fait complet dans le sens ou tous les sauts ne sont pas présents, mais les principaux sont là.
Debugger un programme grâce à Windams.
Contrairement au "Dead Listing" qui consiste à désassembler un fichier et en modifier certaines partie, le debbugage consiste à faire tourner un programme pas à pas. On peut ainsi par exemple, arrivé au test de votre sérial et du bon sérial, s'y arrêter un mettant ce qu'on appel un "break point" et récupérer à ce moment le bon sérial juste avant la comparaison.
Pour lancer le debugger Windasm, vous devez d'abord désassembler le fichier à débugger et ensuite aller dans le menu "Debug" => "Load Process". Ensuite, cliquez directement sur "Load", les lignes de commandes ne servent que très rarement, et vous n'en aurez pas besoin ici.
Nous gardons toujours le même programme qu'avant. Nous travaillerons ici sur la version originale, car nous ne modifierons rien dans le programme.
Donc nous devons posez un break point juste avant le teste des sérials, ce qui nous permettra de les connaître.
...
:0040158D FF1500204000 Call dword ptr [00402000] <- Donc ici !
:00401593 85C0 test eax, eax
:00401595 7516 jne 004015AD
:00401597 6A40 push 00000040
...
Nous lançons donc le debugger, "Debug" => "Load Process" => "Load".
On coche toutes les options de la fenêtre de droite, on revient dans Windasm, on clique sur "GoTo code location" et on entre notre adresse: 0040158D. Ensuite on click sur F2 pour mettre un break point. Maintenant cette ligne devrait apparaître en jaune si tout a été correctement fait.
Maintenant revenez dans la fenêtre de droite et cliquez sur "Run" ou sur F9. Au début, vous pouvez le voir dans le fenêtre de gauche tout en bas cette fois-ci que le programme commence par charger les DLL. Après plusieurs clique, le programme est lancé, entré un sérial aléatoire comme "12345" et cliquez sur "Check". Là une fenêtre s'ouvre:
Voilà le résultat que vous obtenez. Ce que nous avons entré "12345" et le bon sérial "<BrD-SoB>". Il vous suffit de le tester. Lancez le programme en dehors du debugger, entré le serial trouvé.
WOAW C'EST LE BON SERIAL...
Eh oui, pas si compliqué quand même ?!
Keygen.
D'abord qu'est-ce qu'un keygen ??
C'est un programme qui génère des clefs (serials) valides pour un programme donné, en fonction des noms, numéro de série du disque dur ...
Le but cette fois-ci est de repérer la routine qui crée le sérial en fonction d'un élément et de pouvoir créer un programme qui la reproduirais.
Ici nous allons utiliser un autre programme: Téléchargez le ici
Maintenant que vous possédez le crackme n°2 regardons de quoi il s'agit. On le lance, et on voit qu'il veut un nom et le serial qui y correspond. Bon, on rentre n'importe quoi: "HoxkH" et "12345". Pas de chance, il nous retourne un joli message d'erreur: "Wrong code". On n'en sait déjà assez, on décompile le programme, on va dans les strings data références et on trouve notre chaîne. On double-click dessus et on vérifie qu'il en existe qu'une. Woaw, qu'est qu'il y en a des chaîne ici ! Ne vous inquiétez pas, le programme est lourd parce qu'il a été écrit en Delphi qui vous pouvez le remarquez n'est pas le meilleur compilateur pour la taille et la vitesse des programmes qu'il génère... ;-)
Par chance, il n'y a qu'une occurrence de "Wrong code". et si on remonte un peu, on voit que tout le code qui test le sérial ce suit:
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004416D5(C)
|
:00441744 68D4174400 push 004417D4
:00441749 8D45F8 lea eax, dword ptr [ebp-08]
:0044174C BA05000000 mov edx, 00000005
:00441751 E89E23FCFF call 00403AF4
:00441756 8B55F8 mov edx, dword ptr [ebp-08]
:00441759 58 pop eax
:0044175A E8E523FCFF call 00403B44 <- Appel du test du sérial
:0044175F 7517 jne 00441778 <- Saute si le sérial est mauvais
:00441761 6A00 push 00000000
:00441763 668B0DD8174400 mov cx, word ptr [004417D8]
:0044176A B202 mov dl, 02
* Possible StringData Ref from Code Obj ->"Right Code"
|
:0044176C B8E4174400 mov eax, 004417E4
:00441771 E802FBFFFF call 00441278 <- affiche une message boc avec "Right code".
:00441776 EB15 jmp 0044178D
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0044175F(C)
|
:00441778 6A00 push 00000000
:0044177A 668B0DD8174400 mov cx, word ptr [004417D8]
:00441781 B201 mov dl, 01
* Possible StringData Ref from Code Obj ->"Wrong Code"
|
:00441783 B8F8174400 mov eax, 004417F8
:00441788 E8EBFAFFFF call 00441278 <- affiche une message box avec "Wrong code"
Bon maintenant on va en 00403B44 voir précisément ce qu'il y a:
* Referenced by a CALL at Addresses:
|:0040D71B , :00411A05 , :00416A25 , :00417710 , :00422296
|:00422321 , :00422F5F , :004231FC , :0042DA8B , :0042E091
|:0042E201 , :0042E375 , :00430BF1 , :00430CB5 , :00431090
|:0043114F , :004315AA , :004317CA , :00431D35 , :00431EF3
|:0043F543 , :0044175A
|
:00403B44 53 push ebx
:00403B45 56 push esi
:00403B46 57 push edi
:00403B47 89C6 mov esi, eax
:00403B49 89D7 mov edi, edx
:00403B4B 39D0 cmp eax, edx
:00403B4D 0F848F000000 je 00403BE2
:00403B53 85F6 test esi, esi
:00403B55 7468 je 00403BBF
:00403B57 85FF test edi, edi
:00403B59 746B je 00403BC6
:00403B5B 8B46FC mov eax, dword ptr [esi-04]
:00403B5E 8B57FC mov edx, dword ptr [edi-04]
:00403B61 29D0 sub eax, edx
:00403B63 7702 ja 00403B67
:00403B65 01C2 add edx, eax
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00403B63(C)
|
:00403B67 52 push edx
:00403B68 C1EA02 shr edx, 02
:00403B6B 7426 je 00403B93
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00403B89(C)
|
:00403B6D 8B0E mov ecx, dword ptr [esi]
:00403B6F 8B1F mov ebx, dword ptr [edi]
:00403B71 39D9 cmp ecx, ebx
:00403B73 7558 jne 00403BCD
:00403B75 4A dec edx
:00403B76 7415 je 00403B8D
:00403B78 8B4E04 mov ecx, dword ptr [esi+04]
:00403B7B 8B5F04 mov ebx, dword ptr [edi+04]
:00403B7E 39D9 cmp ecx, ebx
:00403B80 754B jne 00403BCD
:00403B82 83C608 add esi, 00000008
:00403B85 83C708 add edi, 00000008
:00403B88 4A dec edx
:00403B89 75E2 jne 00403B6D
:00403B8B EB06 jmp 00403B93
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00403B76(C)
|
:00403B8D 83C604 add esi, 00000004
:00403B90 83C704 add edi, 00000004
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:00403B6B(C), :00403B8B(U)
|
:00403B93 5A pop edx
:00403B94 83E203 and edx, 00000003
:00403B97 7422 je 00403BBB
:00403B99 8B0E mov ecx, dword ptr [esi]
:00403B9B 8B1F mov ebx, dword ptr [edi]
:00403B9D 38D9 cmp cl, bl
:00403B9F 7541 jne 00403BE2
:00403BA1 4A dec edx
:00403BA2 7417 je 00403BBB
:00403BA4 38FD cmp ch, bh
:00403BA6 753A jne 00403BE2
:00403BA8 4A dec edx
:00403BA9 7410 je 00403BBB
:00403BAB 81E30000FF00 and ebx, 00FF0000
:00403BB1 81E10000FF00 and ecx, 00FF0000
:00403BB7 39D9 cmp ecx, ebx
:00403BB9 7527 jne 00403BE2
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:00403B97(C), :00403BA2(C), :00403BA9(C)
|
:00403BBB 01C0 add eax, eax
:00403BBD EB23 jmp 00403BE2
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00403B55(C)
|
:00403BBF 8B57FC mov edx, dword ptr [edi-04]
:00403BC2 29D0 sub eax, edx
:00403BC4 EB1C jmp 00403BE2
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:00403B59(C)
|
:00403BC6 8B46FC mov eax, dword ptr [esi-04]
:00403BC9 29D0 sub eax, edx
:00403BCB EB15 jmp 00403BE2
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:00403B73(C), :00403B80(C)
|
:00403BCD 5A pop edx
:00403BCE 38D9 cmp cl, bl
:00403BD0 7510 jne 00403BE2
:00403BD2 38FD cmp ch, bh
:00403BD4 750C jne 00403BE2
:00403BD6 C1E910 shr ecx, 10
:00403BD9 C1EB10 shr ebx, 10
:00403BDC 38D9 cmp cl, bl
:00403BDE 7502 jne 00403BE2
:00403BE0 38FD cmp ch, bh
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:00403B4D(C), :00403B9F(C), :00403BA6(C), :00403BB9(C), :00403BBD(U)
|:00403BC4(U), :00403BCB(U), :00403BD0(C), :00403BD4(C), :00403BDE(C)
|
:00403BE2 5F pop edi
:00403BE3 5E pop esi
:00403BE4 5B pop ebx
:00403BE5 C3 ret
Et oui, long code pour le sérial, mais ce n'est pas proportionnel à la difficulté du sérial, vous aller voir.
Maintenant, soit vous vous amuser à analyser tout ce code, soit vous mettez un break point sur le call en 0044175A pour avoir un aperçu du sérial.
C'est la deuxième méthode que nous allons utilisé. Donc on debugge comme expliqué précédemment notre programme. Voici ce que vous devriez obtenir:
Et ici, on peut nettement deviner que le sérial correspondant à "HoxkH" est "HoxkHHoxkH625g72". Nous le testons... WOAW C'EST CA !!!
Bon maintenant, on sait que le sérial se composent de 2 fois le nom mais le reste, serais-ce une constante ou quelque chose qui serais calculer en fonction du nom ?!
Pour le vérifier on va tout simplement tester avec un autre sérial, par exemple "HorsLimite". Bon on recommence l'opération et le sérial obtenu est "HorsLimiteHosrLimite625g72".
Nous pouvons en conclure que le sérial est:
votre_nomvotre_nom625g72
Donc si vous voulez faire un keygen, il vous suffira de réappliquer ceci. Voilà, ça en est fini pour les keygen, je ne vais pas vous donner de code source, car il faut savoir un peut programmer pour faire un code qui va calculer notre sérial, donc je suppose que vous serez capable de tout faire... ;-)
SplashScreen.
Les NagScreen et autre SplashScreen sont des fenêtre s'ouvrant soit au démarrage soit à la fin, ou a un autre moment signalant que c'est une version d'essais ou d'autres choses aussi débiles...
C'est très simple pour les éliminer, il vous suffit de nopper son apparition.
#ToDo
Time limits.
Les time limits sont des routine comparant une date enregistrée et la date actuel puor voir si un certain délai n'est pas écoulé. Dans ce cas, soit le logiciel ne veut plus démarrer, soit il tente désespérement de s'effacer lui-même. Mais ceci encore, est largement simple à éliminer.
#ToDo
Checksum.
Un checksum est une routine situé dans un programme qui teste si la somme de tousles bytes est égal a une constante. Ce genre de protection est très facile à éliminer.
Nous n'allons pas voir d'exemples précis car on élimine ça tout à fait de la même façon que les techniques expliquées au-dessus.
Programme en Visual Basic.
Avez-vous déjà désassemblé un programme qui a été programmé en Visual Basic ??
Je vous conseil d'essayer, car vous n'aurez aucune String Data references ormis un "VB5!". Ok, mais comment on fait alors ??? Ben il existe un debugger spécialement fait puor les programmes écrit en visual basic: SmartCheck disponible sur le site de Numega ( même groupe concepteur du célèbre SoftIce ).
On pourrait faire des tutoriaux entiers rien que sur le cracking des programmes Visual Basic, donc je laisse aller voir ceux qui éxistent déjà.
Java reverse engineering.
Cracker des programmes en Java est vraimen très simple pour peu que vous connaissiez la programmation en Java. Sinon, il faudarit peut-être vous y mettre.
Ici nous avons besoin d'un décompilateur Java, JAD et c'est tout.
Le mieu c'est de ce trouver des crackme en Java. Pour ce faire, utiliser votre moteur de recherche préféré. Sinon voici le code d'un que j'ai trouvé:
public CrackMe()
{
public static void main(String args[])
{
if(args.length != 1)
{
System.out.println("Usage: java CrackMe Registration Code");
System.exit(0);
}
System.out.println("");
System.out.println("");
System.out.println("Welcome to ManKind's Java CrackMe 0.1");
System.out.println("=====================================");
System.out.println("This is an Alpha Test of ManKind's Java CrackMe, please do send your comments,suggestions, opinions, feedbacks and support words to me!");
System.out.println("");
System.out.println("");
int i = Integer.valueOf(args[0]).intValue();
if(i == 0x7f42b)
System.out.println("Congratulations, you succeeded in cracking this!");
if(i != 0x7f42b)
System.out.println("Sorry, invalid registration code. Please try again!");
System.out.println("");
System.out.println("");
System.out.println("This program is Copyright \251 1999 ManKind");
System.out.println("Service for Mankind");
System.out.println("mankind001@bigfoot.com");
System.exit(0);
}
}
Donc la valeur que nous devons entré, représenté apr la varible i, doit être égal à 7f42b en décimal. Pour ce faire, rien de plus facile, il suffit de la convertir ce qui nous donne 521259.
Je vous l'avais pas dit que c'était très facil ???
Astuces pour bien commencer à cracker.
- Lire pleins de tutoriaux fait sur de petits programmes et les comprendres
- Faut pas se prendre la tête et laisser son ésprit logique tourner seul, ca donne plus d'endurance.
- Faire de petites pause de 5 minutes minimum toutes les heures.
- Se munire d'un petit livre sur l'assembleur à moins de 10 €.
- Ne pas s'auto proclamer bon crackeur parce qu'on à cracker 1 ou 2 programmes.
- Ne pas hésiter à faire plein d'essais et alterner régulièrement le temps passé dans le désassembleur et dans l'éditeur héxadécimal.
- Désassembler un fichier d'origine et le même ficher mais cracker pour comparer et comprendre les modifications qui ont étés faites.
- ...
Source :horslimite.net
