Bonjour ! Un jour je me suis dit que si j'avais eu un tuto plus clair sur comment cracker du .NET plus tôt, j'aurais certainement gagné beaucoup plus de temps. Tous les autres tutos actuels étants en anglais/vieux/peu compréhensibles, j'ai décidé d'essayer de faire un tuto au plus clair. Il a la vocation de montrer différentes voies de crackage, différents outils utiles, des manières usuelles de faire (même si vous ne comptez pas trouver de serial ou faire de keygen, jetez un coup d'oeil à ces parties puisque cela présente également des outils/manières de faire).
Ce tutoriel n'est théoriquement pas dûr et est de la rigolade comparé à du crackage de programmes qui n'ont pas été faits en .NET (donc votre cerveau n'a pas besoin de mobiliser des capacités surhumaines, et ça ne demande pas de grosses compétences).
Pour ce tutoriel, il n'est pas nécessaire d'avoir de grandes connaissances. Il peut être utile de connaître des bases de C# ou de Basic, mais pas strictement nécessaire; par contre savoir se débrouiller un peu tout seul peut rester un +.
Merci de me dire s'il y a un soucis/incompréhension ou si je suis allé trop vite, je veux ce tutoriel le plus accessible et le plus clair possible.
Je montrerai comment :
1) faire un crack (2 manières)
2) trouver le serial
3) faire un keygen (préférable pour ce logiciel)
Outils nécessaires :
- .Net Framework 3.5 ou 4
- Protection ID : hxxp://pid.gamecopyworld.com/
- Reflector : hxxp://www.reflector.net/download/latest/
- M*ar%é*e!s : hxxp://www.mediafire.com/?3692uyclkdisizm ou hxxp://www.navilog.com/include/scripts/ ... gement.php
Pour un crack :
- Reflexil : hxxp://sourceforge.net/projects/reflexi ... urce=files
Pour le serial :
- Microsoft Visual Studio 2010
Pour un keygen :
- Microsoft Visual Studio 2010 est l'idéal, sinon Visual Studio C# 2010 Express ou Microsoft Visual Basic 2010 express (selon votre langage de programmation préféré entre le C# et le Basic)
Petite présentation des outils:
- Reflector est un decompiler : il permet d'observer d'une certaine manière le code source d'un programme/une DLL écrit en .NET et donc de chercher/analyser les protections. Reflector permet de voir le code source d'origine notamment en C# et en Basic (des bases en C# ou en Basic seront utiles mais pas forcément nécessaires pour des petits programmes tels que celui-là). Il est possible de changer la vision du langage en haut à droite, moi j'analyserai en C# mais vous pourrez le faire en Basic.
- Reflexil est un add-on à Reflector et permet de modifier le programme décompilé.
- Protection ID est un programme qui permet de détecter les protections des programmes (s'ils ont été "cryptés", et par quoi) et le langage d'origine de programmation (et pleins d'autres choses).
Alors tout d'abord, commençons par inspecter le programme M*ar%é*e!s : on ouvre Protection ID et on scanne le fichier (bouton Scan en bas à gauche -> Single File) et on voit :
Chic ! Ce programme n'a pas de protection (=n'a pas été packé, c'est à dire que le programme n'a pas été compressé/crypté par un packer... et donc est plus simple à analyser directement), et a été fait en .NET ce qui veut dire qu'on peut décompiler le programme avec Reflector : on va pouvoir voir d'une certaine manière le code source du programme et donc chercher la protection. En plus, Protection ID semble avoir trouvé quelque chose qui correspond à une protection dans le programme du type serial (-> serialNumber)
Alors là, plusieurs méthodes s'offrent à nous pour trouver la partie de code qui s'occupe de vérifier la licence.
1) On utilise le système de recherche de Reflector (Tools -> Search ou F3) pour chercher quelque chose qui s'apparent au module de protection (ici, le bouton est appelé Licence, donc on peut chercher des mots tels que serial, Verification, Licence... Finalement avec Licence, on arrive sur "FLicence".
2) On navigue dans le programme et on cherche des trucs qui ressemblent à une fonction qui demande le serial. Ici, il n'y a pas besoin d'ouvrir trop de zones puisqu'on voit rapidement le beau "FLicence".
Donc une fois qu'on a trouvé FLicence, on le déplie. Et en fouillant un peu au hasard des fonctions on tombe sur celle avec les messages d'erreur de vérification du sérial (quand on rentre un mauvais sérial on obtient le message "Pas de correspondance..." qu'on retrouve ici) :
De plus on observe un if(match), ce qui correspond à "si cela correspond au vrai serial" qui amène, si le serial correspond, à "Bravo !" puis décoince le mode Trial du logiciel (FPrincipale.VERSION_DEMO = false;) ou si le serial ne correspond pas à "Pas de correspondance entre le numéro utilisateur et le code".
Alors maintenant qu'on a trouvé la classe où était la vérification (FLicence) et même la fonction de vérification (, on va passer à l'embranchement sur crack ou keygen :
-------------------------------------------
1) Faire un crack
--------
a) Patcher la vérification à l'entrée du serial (pour ce logiciel non fonctionnel, mais ça peut toujours servir pour d'autres
, ne sautez pas si vous voulez mieux connaitre !)Tout d'abord il est nécessaire d'installer l'add-in Reflexil (il faut décompresser les .dll de Reflexil, aller dans Tools de Reflector -> Add-Ins -> Add -> ajouter Reflexil.Reflector.dll. Ensuite il faut lancer la fenêtre Reflexil : Tools -> Reflexil
Plusieurs méthodes s'offrent à nous. La première consiste à chercher les instructions (les commandes) qui disent "si oui on fait ça, sinon on fait ça". Donc, en ouvrant Reflexil on obtient le code en (C)IL/MSIL (Common Intermediate Language (MSIL)) qui correspond à la partie de code de la fonction que vous avez ouvert. Donc nous allons étudier rapidement (je n'aime pas tellement ce langage, je ne vais pas approfondir ou faire un cours, surtout que ce n'est pas un langage indispensable). Tout d'abord, il faut savoir que les instructions traduites en ce langage sont dans le même ordre que celles en C# vues, vous pouvez donc essayer de vous repérer avec les appels de fonction/les messages.
Nous obtenons ce code en mettant le langage en IL en haut à droite, qui correspond à celui de Reflexil (mais plus clair à analyser via Reflector que via Reflexil, donc tant qu'on ne modifie rien on reste dans Reflector) : http://pastebin.com/Zz0Yq3jP
Déjà, on cherche la comparaison, donc le match et on voit que c'est :
- Code: Tout sélectionner
L_000c: call bool M*ar%é*e!s.FLicence::match(string)
Donc, normalement le renvoi au bon message/activation se décide juste après, et on voit bien juste après un système de comparaison (avec true/false)
- Code: Tout sélectionner
L_0016: brtrue.s L_004f
On constate bien dans la description de brtrue.s que si la valeur est =1 (true), on saute jusqu'au message d'erreur de vérification du sérial. (ça saute jusqu'à 4f qui correspond en hexadécimal à 79, donc aux lignes dans Reflexil qui vont avec "Pas de correspondance"). Il faut donc inverser ce système (on ne va pas se casser la tête).
On va dans Reflexil, on fait donc un clic droit sur brtrue.s, on fait Edit et on trouve facilement que l'inverse c'est brfalse.s, on change donc brtrue.s en brfalse.s, puis on clique sur Update :
Ensuite, on fait un clic droit sur M*ar%é*e!s.exe et on clique sur Reflexil -> Save as... et on sauvegarde dans le dossier de M*ar%é*e!s, puis on lance l'application en mode admin sur 7, et quand on rentre une licence au hasard, magie ça donne Bravo et quand vous fermez le "A Propos" et que vous réouvrez , la licence est enregistrée.
Malheureusement on remarque assez vite que la licence est stockée clairement avec les autres préférences dans un fichier qui se situe dans ce dossier (.dta si je me souviens bien) et vérifiée à chaque démarrage : le mode du logiciel se remet en démo à chaque démarrage et il est nécessaire à chaque fois de rentrer une licence bidon (ça fait perdre 5 secondes à chaque lancement, ça peut se garder mais on peut faire plus propre).
C'est pourquoi il est mieux de faire un serial (peut-être même plus simple parfois) ou un keygen (mais légèrement moins simple et plus long).
Pour pallier à ça vous pouvez aussi modifier d'autres choses : forcer la valeur de la variable booléenne (en gros qui ne peut qu'être vraie ou fausse) VERSION_DEMO à FALSE (ou 0, c'est pareil) (dans ce cas l'application n'est plus en démo) ou supprimer les limitations de la démo ainsi que les messages "non enregistré" dans le a propos et même changer la manière de vérification.
Et vous trouverez pleins d'autres méthodes surement, il suffit d'avoir un peu d'imagination et de creuser, prenez des initiatives et fouillez avec Google. Nous allons voir la méthode suivante qui ici est une méthode de patching fonctionnelle (pas besoin de serial/keygen !) :
--------
b) Patcher l'initialisation de la config du logiciel (fonctionnel ici, peut être aussi très utile comme technique)
En écriture//
Tout d'abord nous avons vu précédemment que le logiciel est mis en version démo avec FPrincipale.VERSION_DEMO = false;. Nous avons vu que l'activation permet de le passer en true et donc d'enlever les limitations de demo; et que la licence est stockée et revérifiée à chaque début avec une autre procédure, d'où le fait qu'il soit nécessaire de réeffectuer la manipulation d'activation à chaque lancement.
Alors pourquoi ne pas simplement trouver la procédure qui vérifie la licence à l'initialisation ?
Pour cela on fait un clic droit sur VERSION_DEMO et on clique sur "Analyze".
On cherche à savoir quelles procédures définissent ce booléen, nous cliquons donc sur 'Assigned by' ('Used by' sert à savoir quelles procédures récupèrent la valeur de ce booléen, vous pouvez donc choisir de patcher toutes les fonctions de 'Used by' ou de patcher les procédures qui définissent VERSION_DEMO).
Nous reconnaissons la procédure btnOK_Click qui correspond au bouton d'entrée de licence, puis deux autres fonctions : .cctor et .ctor. Ce sont des fonctions qui se lancent tout au début de l'initialisation d'une classe quand elle est appelée (pour faire simple). Ils s'initialisent tous les deux avec la fenêtre principale (FPrincipale). Regardons .cctor (clic droit, go to member).
qui amène à
Magie ! Au démarrage, VERSION_DEMO est mis à "true", ce qui active le fait que le logiciel soit en démonstration [si vous voulez aller plus loin, vous pourrez voir que dans .ctor il est passé à ="false" avec if ((VERSION_DEMO && (this.varGlobales.strCodeUtilisateur != "")) && FLicence.match(this.varGlobales.strCodeUtilisateur))].
Il suffit donc de patcher ça !
Sachant que le code IL est structuré de la même manière et dans le même ordre que la transcription en C# ou VB.NET que vous lisez, comme VERSION_DEMO = true; est la première instruction C# c'est donc la première instruction IL.
Nous pouvons voir un appel en IL à VERSION_DEMO avec stsfld et en lisant la description de stsfld (clic droit, edit dessus) : Replaces the value of a static field with a value from the evaluation stack. Cela prend donc la valeur en haut de la pile, et comme il n'y a qu'une instruction au-dessus : ldc.i4.1 avec description : Pushes the integer value of 1 onto the evaluation stack as an int32.. (rappel : 0=FALSE / 1=TRUE).
Nous avons donc ldc.id4.1 qui mets "1" (donc TRUE) en haut de la pile et stsfld qui prend la valeur en haut de la pile (donc TRUE) et la définit VERSION_DEMO avec. Il faut donc remplacer ldc.id4.1 pour que la valeur en haut de la pile soit 0 et donc false. En toute logique si ldc.id4.1 met 1, ldc.id4.0 met 0. Cette manière de définir un booléen est très courant dans toutes les applications retenez au moins ça
On fait donc Edit sur ldc.id4.1 et on met à la place ldc.id4.0 puis on clique sur Update. On sauvegarde de la même manière que pour le a).
On ouvre le fichier patché et oh magie "Version intégrale" ! On a donc réussi à mettre le logiciel en version intégrale en ne faisant que patcher, sans trouver un serial ou faire un keygen !
Juste pour conclure la section patch : c'est rare qu'il soit impossible de patcher un logiciel, il y a toujours une méthode. Pleins de voies s'offrent à vous !
-------------------------------------------
2) Trouver le serial
Tout d'abord il est nécessaire de mettre Reflector en add-in à Visual Studio 2010 : initialisez Visual Studio jusqu'à atteindre l'écran de création de projets, ensuite ouvrez Reflector, allez dans Tools -> Visual Studio and Windows Explorer integration et cocher votre Visual Studio puis validez.
Ensuite relancez Visual Studio (n'oubliez pas de le lancer en mode administrateur, c'est plus simple pour la suite) : vous avez un nouvel onglet ".NET Reflector". Vous cliquez donc dessus -> Choose assembly to debug -> bouton browse et sélectionnez votre fichier M*ar%é*e!s.exe et validez. Ensuite .NET Reflector -> Explore decompiled assembly -> vous développez tout et double-cliquez sur "FLicence" : tout le code décompilé de FLicence est chargé dans Visual Studio.
Maintenant il est nécessaire de mettre un "breakpoint" sur la fin de la routine de création de sérial, c'est à dire au moment où le serial est retourné. Un breakpoint est une sorte de pause du programme à la ligne où il a été mis, et permet d'analyser ce que le programme a en mémoire à ce moment-là.
On sait que la routine est code(string numeroUtilisateur), on voit que le serial est renvoyé à la ligne
- Code: Tout sélectionner
return str;
Nous mettons donc un breakpoint sur cette ligne : on la sélectionne, on fait clic droit -> Point d'arrêt -> Insérer un point d'arrêt :
Il est maintenant nécessaire de lancer le programme. On ouvre donc normalement M*ar%é*e!s.exe, puis une fois ouvert on retourne dans notre fenêtre de Visual Studio -> Déboguer -> Attacher un processus
Nous avons donc le processus lié à Visual Studio et le breakpoint mis sur le retour de la fonction de création du serial. Maintenant il ne nous reste plus qu'à activer cette fonction en rentrant un mauvais serial dans le programme que nous avons lancé. Nous allons donc dans A Propos -> Licence et on rentre un serial bidon puis on valide.
Et là, bam magie, le programme s'arrête, Visual Studio se met en avant et montre les variables au moment du breakpoint, c'est à dire qu'on voit le numeroUtilisateur et le str qui correspond au serial ! Vous avez donc récupéré votre serial !
Et comme vous pourrez voir
-------------------------------------------
3) Faire un keygen
Il n'est pas forcément nécessaire de connaître le C# ou le Basic, mais ça reste un + pour cette partie aussi.
Nous allons utiliser le langage C# dans Reflector et Visual C# 2010 Express, mais vous pourrez faire la même manipulation avec du VB avec Visual Basic 2010 Express.
Donc vous ouvrez Visual C# et vous créez un nouveau projet Windows Form. Vous insérez un bouton et une zone de texte avec l'utilitaire. Le bouton devrai s'appeler button1 et la zone de texte textBox1. Ensuite double-cliquez sur le bouton pour paramétrer ce qu'il faut faire quand on clique dessus. On obtient le code suivant : http://pastebin.com/1UBryaTt
Maintenant il faut découvrir la routine de création du serial : on voit en fouillant encore, que c'est la fonction "code(String)". On rajoute donc cette fonction à la classe dans la zone de code obtenue en double-cliquant sur le bouton dans Visual C# : http://pastebin.com/jqc79nHQ
Cependant, on remarque qu'il est nécessaire d'avoir une fonction numeroUtilisateur() (qui correspond à votre numéro d'ordinateur affiché dans Licence du logiciel). On rajoute donc aussi cette fonction : http://pastebin.com/F2Y0CCrz
Ensuite Visual C# dit qu'il manque aussi des informations sur GetVolumeInformation, on clique donc sur ce nom dans Reflector et on copie encore les infos dans notre code : http://pastebin.com/9He20vz6
Visual C# ensuite nous dit qu'il ne connait pas Dllimport : c'est normal il n'a pas été appelé, on rajoute donc le module qui lui correspond, soit tout en haut du code
- Code: Tout sélectionner
using System.Runtime.InteropServices;
Maintenant il faut lier la routine de création (code(string numeroUtilisateur)) au clic sur le bouton pour pouvoir afficher le serial dans la zone de texte. Il faut d'abord dire que le serial obtenu à la fin de l'exécution de code(...) sera un string (je définirai ça vaguement comme étant une chaine de caractères). Ce que je vais mettre en // est un commentaire de la ligne :
- Code: Tout sélectionner
string numuti; //on définit "numuti" comme étant une chaine de caractères (vous l'appelez comme vous le voulez)
numuti = numeroUtilisateur(); //on dit que "numuti" est le résultat de l'exécution de la fonction numeroUtilisateur(), soit le numéro donné par le logiciel pour identifier votre ordinateur
textBox1.Text = code(numuti); //on met dans la textBox1 le texte correspondant à l'exécution de la fonction code depuis la valeur de votre numéro d'ordinateur, qui est numuti
On met tout ça dans la fonction private void button1_Click(object sender, EventArgs e) créée automatiquement par Visual C# pour être exécutée lorsque le bouton est cliqué : http://pastebin.com/chK4q0sB (ceci est le code final).
On clique sur Déboguer->Démarrer le débogage et on constate que le programme marche bien.
Vous pouvez ensuite cliquer sur "Enregistrer tout" pour enregistrer le code source, puis Déboguer->Générer la solution pour créer le .exe que vous trouverez dans le dossier bin de votre projet (là où vous avez "enregistré tout"). Vous pouvez également paramétrer la couleur de la fenêtre, le nom des objets......
Et voilà vous avez un keygen fonctionnel (testez sur une version toute neuve de M*ar%é*e!s et vous verrez - vous pourrez aussi constater avec bloc-notes que le sérial entré est mis à la fin du fichier .dta dans le dossier de M*ar%é*e!s).
PS: N'oubliez pas que fouiller reste le principal : il faut toujours essayer, chercher, creuser...
De plus la méthode de vérification du sérial ne sera pas toujours de cette manière, il est possible qu'on parte du sérial que vous avez rentré, qu'on fasse des opérations dessus et qu'ensuite on vérifie après les opérations. Dans ce cas il est nécessaire d'avoir quelques connaissances de programmation pour arriver à coder un keygen qui arrive à créer un serial qui vérifie à la fin des opérations la comparaison. Le patching est généralement plus fréquent à bas niveau (plus simple et pas forcément moins bien).
Vous pourrez également rencontrer des codes obfusqués (une certaine forme de cryptage pour mieux éviter qu'on cracke le programme) ou des appels à des DLL de vérification de sérial qui n'ont pas été codées en .NET pour éviter aussi qu'on cracke aussi facilement, mais on ne traitera pas ce sujet maintenant.
Si le code est obfusqué, je vous renvoie aux outils de deobfuscation : de4dot.
Si il y a un renvoi à une DLL (vous pouvez voir les renvois à des DLL dans par exemple M*ar%é*e!s.exe -> References) qui n'a pas été faite en .NET, il faudra faire du cracking basique avec le bon vieux OllyDBG et un cerveau.
Vous pouvez également rechercher des messages qui apparaissent en utilisant la fonction loupe puis en cliquant sur le 3eme bouton (bouton pour rechercher dans les string) [très utile]
Si vous désirez aller plus profondément sur le cracking (RE, reverse engineering), notamment sur les applications non codées en .NET, de multiples tutos sont disponibles mais nécessitent un peu plus d'apprentissage et de cerveau (vous allez baver de l'ASM clairement). Ils sont évidemment plus dûrs que ce tuto-là puisque les applications non codées en .NET ne sont pas décompilables directement (enfin hxxp://www.hex-rays.com/products/decompiler/index.shtml c'est plus compliqué que ça mais théoriquement impossible). Les sites de tutos les plus connus :
* hxxp://deamonftp.free.fr/deamoncrack/
* hxxp://kibaaaa.free.fr/Jobs/APPcrack/Co ... acking.htm
------- Bonus 1 : utiliser la fonction recherche de Reflector -------
Comme certains (comme moi au début) croient que la fonction rechercher est peu puissante, mais c'est qu'il y a différentes options !
Imaginons que l'on veuille savoir où se trouve "heure d'hiver" de la fenêtre Annuaires. Il y a quelques années j'aurais appuyé sur l'icône de la loupe, j'aurais tapé "heure d'hiver" dans le champ, mais rien ne serait apparu et j'aurais dit "mais c'est de la merde ce système de recherche".
Mais non il faut appuyer sur le 3eme bouton, puis attendre un peu (quelques secondes voire minutes) :
------- Bonus 2 : utiliser le "replace all with code" -------
[Pour ceux qui connaissent un minimum de C#/VB] [exemple sur un autre logiciel]
Imaginons qu'une procédure retourne dans une boîte par exemple le nom de la personne enregistrée, mais que vous avez patchée donc qu'il n'y en a pas. Exemple :
On aimerait que cette fonction affiche "mArTi" : clic droit, replace all with code
Le seul problème de cette fonction est qu'on ne peut pas appeler de fonctions situées dans d'autres classes
On va donc se contenter de faire une petite fonction qui retourne tout le temps mArTi.
On sauvegarde et zou ! Ca retourne bien mArTi
(Il est possible qu'il y ait des erreurs avec des appels dans les methods stubs/fields stubs, dans ce cas-là supprimer toutes les méthodes/champs qui embêtent le compilo)
------- Bonus 3 : retirer l'avertissement au début -------
Sachant qu'il est au début, il vaut mieux voir directement le début du programme (et puis ça permet d'introduire une autre fonctionnalité de Reflector
).Clic droit sur M/a*r-é%e/s puis Go to Entry Point
On voit que la fonction d'initialisation exécute Application.Run(new FPrincipale());, soit FPrincipale. On clique sur FPrincipale de cette ligne et on tombe sur le .ctor de FPrincipale. On cherche donc une référence à l'avertissement : new FAvertissement(this).ShowDialog();
On regarde donc avec Reflexil tout ce qui a référence a ça, on sélectionne, clic droit et delete :
On sauvegarde, on lance et hop y'a plus l'avertissement de démarrage. Si cela n'a pas marché c'est que vous avez supprimé une/des instruction en trop ou en moins, réessayez !
--Indic n°1--
Avec un nag au chargement, regardez l'entry point et changez-le vers la fenêtre principale.
Martinooooo. 
, mais ton approche est intéressante ! 
J'ai rectifié ça 
