|
introduction
Quand on parle de Keygens, beaucoup pensent à des heures
et des heures à comprendre des routines.
Dans de nombreux cas, comme les logiciels calculant le bon serial, il peut être très simple de créer
un Keygen à partir d'un simple rippage ASM de la routine.
Voici donc quelques méthodes "artisanales" et trucs qui permettront à tout débutant
de pouvoir keygenner beaucoup de logiciels sans rien n'y comprendre ou le minimum.
Il faut quand même savoir cracker et connaitre l'ASM un minimum.
Ceci démystifie beaucoup le travail de Keygenning mais cela ne porte que sur certaines catégories
de logiciels.
N'espérez donc pas rentrer chez CoRE, DAMN, ECL, TMG, UCF ou autres groupes spécialisés dans
le Keygen, avec cette simple connaissance.
D'ailleurs, le Rippage ASM appliqué au Keygenning est tellement implicite à comprendre qu'il est
miraculeux si vous trouvez un tut dessus...
Exception faite maintenant :)
Dernière chose : l'outil principalement mentionné est Softice. Toutefois, vous pouvez reporter ces
techniques sur des debuggers en mousse (1) comme Ollydebug.
principe
On va récupérer la routine ASM calculant le
serial du programme, l'implanter dans notre Keygen et refaire les branchements avec les informations utiles à
son calcul. ( nom à de la personne, constantes, tables, clés, etc )
Très simple à comprendre. ( Même pour Steevy du Loft... quoique... )
Tout est TRES détaillé pour que ceux qui n'ont jamais keygenné, puissent comprendre.
Pour mener à bien cette mission, "l'aventure" se déroulera en 7 phases :
- Customisation de Softice pour le rendre plus simple.
- Localisation de la routine.
- Moyen de désenregistrement pour repasser en "non enregistré".
- Délimitation de la routine.
- Techniques de Rippage pour extraire la routine.
- Rebranchements des "flux" d'informations et identification.
- Tests de fonctionnement sur le Keygen.
customisation
Il est parfois très fastidieux de taper " d eax"
ou "d ebx", etc ou "? eax" ou "? ebx"... sous Softice.
Aussi afin d'avoir plus de souplesse, voici un truc de Presage visant à transformer la frappe de la commande
par un raccourci clavier.
|
Raccourcis clavier sur Softice
A mettre dans la configuration de Softice ( Winice.dat ou à l'installation ).
| CF1="^d eax;" |
; ----> Ctrl + F1 = renvoit à l'adresse
contenue dans EAX |
| CF2="^d ebx;" |
; ----> Ctrl + F2 = renvoit à l'adresse
contenue dans EBX |
| CF3="^d ecx;" |
; ----> Ctrl + F3 = renvoit à l'adresse
contenue dans ECX |
| CF4="^d edx;" |
; ----> Ctrl + F4 = renvoit à l'adresse
contenue dans EDX |
| CF5="^d esi;" |
; ----> Ctrl + F5 = renvoit à l'adresse
contenue dans ESI |
| CF6="^d edi;" |
; ----> Ctrl + F6 = renvoit à l'adresse
contenue dans EDI |
| CF7="^d ebp;" |
; ----> Ctrl + F7 = renvoit à l'adresse
contenue dans EBP |
| CF8="^d esp;" |
; ----> Ctrl + F8 = renvoit à l'adresse
contenue dans ESP |
| AF1="^? eax;" |
; ----> Alt + F1 = renvoit la valeur contenue
dans EAX |
| AF2="^? ebx;" |
; ----> Alt + F2 = renvoit la valeur contenue
dans EBX |
| AF3="^? ecx;" |
; ----> Alt + F3 = renvoit la valeur contenue
dans ECX |
| AF4="^? edx;" |
; ----> Alt + F4 = renvoit la valeur contenue
dans EDX |
| AF5="^? esi;" |
; ----> Alt + F5 = renvoit la valeur contenue
dans ESI |
| AF6="^? edi;" |
; ----> Alt + F6 = renvoit la valeur contenue
dans EDI |
| AF7="^? ebp;" |
; ----> Alt + F7 = renvoit la valeur contenue
dans EBP |
| AF8="^? esp;" |
; ----> Alt + F8 = renvoit la valeur contenue
dans ESP |
Afin de rendre la chose plus visible, vous pouvez mettre un ruban de papier avec les registres au-dessus des touches
de fonction. ( Quand je parlais de méthodes artisanales...)
|
eax
|
ebx
|
ecx
|
edx
|
esi
|
edi
|
ebp
|
esp
|
|
F1
|
F2
|
F3
|
F4
|
F5
|
F6
|
F7
|
F8
|
Désormais, vous n'aurez qu'à utiliser les touches
de fonctions + Contrôle pour pointer vers l'adresse ou + ALT pour avoir la valeur du registre.
|
La dernière chose est de vous munir de feuilles de
papier et d'un stylo pour noter les adresses, les flags, etc...
localisation
C'est du cracking standard, mais n'hésitez pas à
(re)lire le Millenium Tutorial de The Analyst pour compléter vos connaissances.
Debugger
- BPX GetDlgItemTextA, GetWindowTextA,
Hmemcpy ( pour W98 ), ...
- BPX lstrcat, lstrcpy, lstrlen, wsprintfa, ... ( API de traitement
sur chaines de caractéres )
- s 0 l ffffffff "nom" + BPR adresse_debut_nom adresse_fin_nom rw ( recherche du nom dans la mémoire )
- s 0 l ffffffff "serial" + BPR adresse_debut_serial adresse_fin_serial rw ( recherche du serial dans la mémoire )
- BPX MessageBoxA, ShowWindow, CreateWindowExA, MessageBeep, ...
- BPM sur des flags définissant l'état "registered / unregistered".
- trouver des API judicieux. |
Désassembleur
- regarder dans les environs des
"Registered to", "Registered", ...pour trouver des call + test ou des flags.
C'est un classique que l'auteur "plombe"
la recherche de la routine dans les boites d'enregistrement mais pas quand il affiche le status Registered/Unregistered
dans le "About" ou dans un caption. |
Dans les deux cas
- des successions de certaines
instructions peuvent attirer l'oeil :
ADD, SUB, MUL, DIV, IMUL, IDIV, AND, OR, XOR, ... ( instructions de calcul )
CMPSB, SCASB, MOVZX, REP, ... (
instructions de manipulations sur String )
ROL, ROR, SHR, ... ( instructions
de rotations )
Naturellement, ce genre d'instructions n'est pas
réservé qu'à la routine du serial mais parfois on tombe dessus :) |
A priori, si vous êtes déjà apte à
trouver des serials valides pour un logiciel ou à le cracker, c'est que vous avez survolé ou repéré
la routine.
désenregistrement
Une fois que vous avez à peu prés localiser
la routine et vérifiez que le serial que vous avez trouvé, était le bon, il faut vous créer
un moyen de repasser en Shareware non enregistré très rapidement.
En effet, il va falloir tester la routine et aussi votre Keygen quand il sera terminé... ( Vous aurez à
repasser en Shareware non enregistré plus d'une fois. )
Le programme peut être plus ou moins vicieux à cacher les informations d'enregistrement...
|
Clé de registre
Utilisez Regedit de Windows et regardez dans :
- HKEY_CURRENT_USER\Software\
- HKEY_LOCAL_MACHINE\Software\
Le logiciel peut avoir défini des fichiers
avec des clés registres.
Si vous ne trouvez pas, cliquez sur "rechercher"
et entrez votre nom ou votre bon serial, sinon utilisez Regmon.
Une fois trouvée, sélectionnez le
Répertoire de la clé et cliquez sur :
- Registre\Exporter un fichier du Registre
Vous aurez un fichier *.reg contenant des informations.
Exemple :
REGEDIT4
[HKEY_CURRENT_USER\Software\SCATLAWS\3DYAMS]
"USER"="PRESAGE - FFF"
"CODE"="640547464541"
"HIGHSCORE"="0"
"NOM"=""
"NOM1"="JO1"
"NOM2"="JO2"
"NOM3"="JO3"
"NOM4"="JO4"
"NOM5"="JO5"
"LANGUE"="francais.lan"
Editez ce fichier et modifier le en ne conservant
que les infos d'enregistrement comme ci-dessous:
[HKEY_CURRENT_USER\Software\SCATLAWS\3DYAMS]
"USER"=""
"CODE"=""
Si vous cliquez sur ce fichier *.reg, les informations
seront effacées. ( = plus enregistré. )
NB : Il est aussi fort possible que la clé ne soit pas défini avec un nom aussi explicite
que "USER" ou "CODE"...
Ne choisissez de détruire les fichiers registres du logiciel, qu'en dernière alternative.
|
Fichier
Vous pouvez trouver les informations dans des fichiers.
- Fichier *.INI dans le répertoire
du logiciel ou dans le répertoire Windows
- Fichier dans le répertoire du logiciel.
- Fichier caché sur le disque.
Voici quelques trucs pour trouver ces fichiers quand cela n'est pas explicite :
- Ultrasearch, qui scanne tous
les fichiers d'un répertoire pour trouver une String ( nom, serial, ... ) en Unicode ou Standard. ( trouvable sur Protools)
- Outils de Monitoring comme Filemon
et Regmon.
- Via le debugger sur des API comme
ReadFile, WriteFile, SetFilePointer (
le logiciel peut tenter de charger le fichier pas très loin de notre routine )
Une fois trouvé, faites un raccourci de
ce fichier sur le Bureau, pour pouvoir le modifier rapidement. |
Cas désespéré
Si vous ne trouvez rien...
- soit vous placez un breakpoint
sur le début de la routine et vous changez en mémoire les infos. ( nom, serial ou flag d'enregistrement, ... )
- soit vous patchez le logiciel pour avoir la fenêtre d'enregistrement du logiciel même en status "enregistré". |
délimitation
Resumé de l'épisode précédent
:
* la routine a été trouvée.
* on a un moyen de repasser en "non enregistré".
Maintenant, il faut délimiter la routine pour avoir quelquechose de la forme :
prend le nom
...................
...................
...................
serial fini d'être calculé
Pour cela, on va mettre la routine dans un "étau" :)
|
* Délimiter
On cherche donc à créer un interval de travail entre une adresse de DEBUT et une adresse de FIN.
On va chercher ensuite à resserer cet interval le plus possible ( étau ) afin d'avoir la routine
la plus simple à ripper.
- passez toute la routine en TRACE
OVER mais en regardant les push et les registres qui sont modifiés après le(s) call(s)
A noter que, quand vous cherchez à obtenir un serial calculé par le logiciel, c'est ce que vous faites
déjà !
Essayez d'avoir quelquechose comme :
| Principe |
Exemple 1 |
Exemple 2 |
Exemple 3 |
prend le nom
...................
...................
...................
test serial bon |
push eax <-- offset nom
...
call *** <-- contrôle serial
test eax, eax
je Mauvais_Serial |
push eax <-- offset nom
...
call *** <-- ?
...
call *** <-- ?
...
call *** <-- ?
cmp eax, 01
jne Mauvais_Serial |
push eax <-- offset nom
...
call *** <-- contrôle serial
cmp eax, ebx
jne Mauvais_Serial |
NB : Dans le cas de l' Exemple 2, il y a fort à parier que le dernier call soit celui qui soit
le plus intéressant.
Une fois, la chose faite, notez l'adresse de DEBUT et l'adresse de FIN.
Vous avez votre premier intervalle d'étude !
|
|
* Début
d'identification pour raccourcir le Rippage
Souvent, la routine fait des pré-test inutiles à ripper :
- combien de caractéres il y a dans le nom ? Si c'est moins de 5 = Nom invalide.
- il y a un "-" dans le serial bidon ?
- tous les caractéres du nom sont compris entre "A" et "z" ?
....
On a aussi des modifications basiques sur le nom avant le vrai calcul :
- copier le nom ailleurs dans la mémoire.
- passe tous les caractéres en majuscules ( ou en minuscules --> Easy CD-DA Extractor )
- coupe le nom sur les 3ers caractéres ( ou les 4ers, etc... )
....
Tous ces tests, modifications sont à prendre en considération pour réaliser le Keygen mais
inutiles à ripper, car vous pouvez le programmer plus simplement !
A la fin de la routine, on a souvent :
- transformer la valeur d'un registre ( eax, ebx, ... ) en chaine ASCII affichable.
- mettre des "-" entre des chiffres du serial.
....
Cela aussi est inutile de le récupérer en ASM, car on peut le programmer simplement en ASM.
Au niveau du debbuger :
- rentrez dans le call d'enregistrement
et on reprocéde à un TRACE OVER.
- si on tombe sur des calls, on regarde ce qu'ils prennent dans leurs PUSH et on regarde les registres modifiés
après le call.
- on tente d'identifier ce qu'à fait le call.
Au final, on doit avoir un schéma comme
celui-ci :
| Principe |
Exemple |
prend le nom
...................
...................
...................
serial apparait
au complet en
mémoire ou dans
un registre |
mov eax, offset nom
call met_le_nom_en_majuscule
....
calcul
....
call transforme ASCII_caractére_en_sa_valeur_numérique
....
call ? <-- on voit pas ce qu'il fait
....
calcul
...
mov eax, offset bon_serial |
Pas besoin de tracer dans un call si celui semble transformer
les caractéres du nom en majuscule !
Si jamais un call ne fait pas ce que l'on croit, on n'aura qu'à y revenir plus tard.
A la fin, votre interval de travail doit être réduit.
Vous remarquerez que jusqu'à présent, on a cherché à comprendre la routine qu'au travers
de ses call éventuels !
Pas de travail de compréhension sur les calculs, etc !
|
techniques de rippage
Resumé de l'épisode précédent
:
* la routine a été trouvée.
* on a un moyen de repasser en "non enregistré".
* on a réussi à la délimiter au maximum.
* on a commencé à identifier l'action de certains calls dans le calcul.
Le Rippage ASM est l'art de récupérer le code du logiciel pour le coller autre part... ( que cela
soit dans un tut mais aussi dans un Keygen. )
Pour reprendre une dénomination bien connue, on peut dire qu'il y a comme dans le Cracking : le "Dead
Rip" ( avec désassembleur ) et le "Live Rip" ( avec débugger ou outil ) :)
Voici plusieurs techniques :
"Live Rip" : Utilisation de Screendump avec Softice
Icedump est un formidable outil qui vous donne accès à une multitude de fonctionnalités nouvelles
dont Screendump, qui fait une pseudo-capture d'écran de Softice.
Il existe plusieurs formats de sortie de ces captures :
0 - Mode Raw ( pas intéressant
)
1 - Mode Texte ( très intéressant
)
2 - Mode HTML ( saisissant de similitude avec l'aspect de l'interface de Softice, mais à
réserver pour des tuts. )
3 - Mode Latex ( pas intéressant )
4 - Mode PostScript ( qui peut être reconverti en PDF mais pas intéressant )
Pour changer de mode, tapez sous Softice /screendump
Par défaut, c'est le mode 1 ( texte ) qui
est actif.
- placez vous sur le début
de la routine.
- /screendump path ( ex: /screendump c:/rip1.txt )
Vous aurez un fichier texte à la racine
avec votre Rip ASM.
Screendump vous donnera une capture texte de la
fenêtre ( code, data... ) et donc il se peut que vous ayez à vous replacer plus loin pour refaire
un Screendump pour avoir la routine au complet.
L'avantage de cette méthode est que si le programme est packé ( sauf AsProtect et autres packers
méchants ), vous aurez votre rippage sans unpacker le programme ! |
"Live Rip" : Utilisation du History Buffer de Softice
( merci à The Analyst )
Pour remplacer le Screendump d'Icedump, on peut logger la routine via l'Historique.
- cls ( efface le Buffer History de Softice )
- u adresse_debut l nombre_instruc_à_ripper
( ex: u 4010d3 l 100 logue les
100 instructions à partir de 4010d3 )
- taper Entrée pour reprendre
la main.
- passer sur le loader de Softice
et sauver l'Historique ( Files > Save SoftICE History As ... ) |
" Dead Rip" : Utilisation de W32Dasm
Tout le monde connait.
Pour récupérer une portion de code :
- click devant l'instruction de
départ.
- maintenir la touche "Contrôle" appuyée et reclick sur l'instruction de fin.
- "Contrôle" + C pour copier la portion de code.
- "Contrôle" + V pour coller la portion de code dans Notepad ou ailleurs. |
" Dead Rip" : Utilisation d' IDA
Il suffit de sélectionner et de faire un copié-collé. |
" Dead Rip" : TMG Ripper Studio de Chafe
Jamais utilisée mais son utilisation est très simple. ( trouvable sur Protools )
- préciser les adresses
de début et de fin ( notre interval ).
- fixer les variables ( dword, word, etc ) et leurs valeurs.
Cet outil désassemble la routine et génére une source assemblable avec MASM. |
" Dead Rip" : Table Extractor de Thigo et Table
Ripper de Smoke
Attention, ces outils servent à ripper des datas ( constantes très longues, tables, ... ) et non
du code.
L'avantage par rapport à IDA qui vous donne aussi cette possibilité, c'est que l'outil formate le
Rippage pour être collé dans une source ASM, Delphi, VC+, VB. |
Maintenant, que votre Rippage ASM est dans un fichier Texte,
il faut le nettoyer.
Le problème est de pouvoir effacer les colonnes d'adresses et d'opcodes !
ATTENTION !!! ( A faire avant d'effacer par colonne )
Exception faite d'IDA qui donne un désassemblage exploitable pour être assemblé directement,
les autres techniques vous donneront un Rippage que vous devrez retravailler !
---> Problèmes de Labels
Le désassemblage donne les adresses mémoires qui sont définies à la compilation du
Shareware à la suite des jmp.
Pour la compilation ou l'assemblage, on doit les changer par des labels pour être reconnu par MASM ou autre.
| JMP 04030D |
--> |
JMP Saut1 |
| .................. |
--> |
................... |
| |
|
Saut1: |
---> Problèmes de valeur HEXA
W32Dasm et Softice donne les valeurs numériques en Hexadécimale.
Le problème est que le Rippage ne porte pas de mention Hexadécimal derrière les valeurs numériques.
| MOV EAX, 00000022 |
--> |
MOV EAX, 00000022h |
| PUSH 0000000E |
--> |
PUSH 0000000Eh |
| .................. |
--> |
................... |
| MOV EAX, FFFFFFFF |
--> |
MOV EAX, 0FFFFFFFFh |
|
Sélection et effacement par colonne
Word
- Maintenir "Alt" appuyé
+ sélection avec Click Gauche
VIM pour Windows ( Freeware )
Pas vraiment l'outil le plus simple pour cela :)
- "Contrôle" +
V pour sélectionner par colonne
- "Shift" + V pour sélectionner par ligne
UltraEdit
- vous regarderez ! ( merci à
Nag-Scrim ) |
rebranchements et identification
Resumé de l'épisode précédent
:
* la routine a été trouvée.
* on a un moyen de repasser en "non enregistré".
* on a réussi à la délimiter au maximum.
* on a commencé à identifier l'action de certains calls dans le calcul.
* on a rippé les instructions ASM et enlever les adresses/opcodes.
Maintenant, vous pouvez copié-collé votre rippage ASM dans votre source ASM de Keygen.
Le travail est à moitié fini !
Il faut maintenant transplanter proprement !
Le Rippage ASM est comme une transplantation cardiaque : si vous ne refaites pas les connexions nerveuses et sanguines,
la greffe ne marchera pas.
Ici, on doit :
- rebrancher la routine avec ses variables, ses constantes, ...
- identifier l'action des calls et les variables locales ( [EBP - nombre ] , [ESP - nombre ]... )
Dans un premier temps, tout ce travail se fait au debugger.
|
Prenons un exemple de routine simple après notre travail
:
| Debut : |
|
|
| mov |
edx, dword ptr [ebp-10] |
<-- nom ( Lise_Grim ) |
| push |
edx |
|
| call |
00400120 |
<-- met les caractéres du nom en majuscule
( LISE_GRIM ) |
| movsx |
eax, byte ptr [edx+03] |
|
| mov |
ebx, dword ptr [ebp-8] |
<-- récupére une valeur dans
la pile |
| xchg |
ebx, eax |
|
| mov |
byte ptr [edx+03], eax |
|
| mov |
byte ptr [edx+04], ebx |
|
| push |
0040340D |
<-- String1 : LIS1EGRIM |
| push |
0040850D |
<-- String2 : 35A5841 |
| call |
00401355 |
<-- ? |
| mov |
eax, [ebp-10] |
<-- Serial : LIS1EGRIM35A5841 |
Identifié :
[ebp-10] = offset Nom
call 00400120 = call UperCase
Non identifié :
[ebp-8] = ?
call 00401355 = ?
Avec le debugger, vous tracez la routine dans le Shareware et vous identifiez :
d ebp-8 --> [ebp-8] = 031h
call 00401355 = colle String2 à la fin de String1 = call lstrcat
on transforme la routine :
| .DATA |
|
|
| KEY |
db "35A5841",0 |
|
| ......... |
................................. |
|
| ......... |
................................. |
|
| .CODE |
|
|
| ......... |
................................. |
|
| ......... |
................................. |
|
| Debut : |
|
|
| mov |
edx, offset NOM |
<-- NOM ( Lise_Grim ) |
| push |
edx |
|
| call |
UpperCase |
<-- met les caractéres du nom en majuscule
( LISE_GRIM ) |
| movsx |
eax, byte ptr [edx+03] |
|
| mov |
ebx, 031h |
<-- récupére une valeur |
| xchg |
ebx, eax |
|
| mov |
byte ptr [edx+03], eax |
|
| mov |
byte ptr [edx+04], ebx |
|
| push |
offset NOM |
<-- offset NOM ( LIS1EGRIM ) |
| push |
offset KEY |
<-- String2 : 35A5841 |
| call |
lstrcat |
<-- colle les Strings |
| mov |
eax, offset NOM |
<-- Serial : LIS1EGRIM35A5841 |
Voilà, la routine est rippée et fonctionnelle
!
Remarquez que je ne cherche pas à savoir ce qu'elle fait.
L'exemple donné est ultrasimple mais parfois, vous pouvez vous retrouver avec une multitude de variables
type :
[ ebp - nombre ]
Ex : [ebp - 0Ch], [ebp - 10 ],
etc
Dans le cas le plus simple, il vous suffira d'identifier chacune de ses variables avec le debugger pour leur donner
une valeur, un offset, ...
Après si ces variables sont appellés plusieurs fois, vous n'aurez qu'à faire des "remplacer"
avec Wordpad ou Word. ( ou VIM :) ... Pour les masos uniquement. )
Ex :
[ebp - 0Ch] = 035h ---> remplacer
"dword ptr [ebp-0Ch]" par "035h".
[ebp - 10h] = offset Buffer_Temporaire --> remplacer "dword ptr [ebp - 10h]" par "offset Buffer_Temporaire"
|
Problème de longueur de constantes, de table
Des constantes ou des tables peuvent avoir une taille assez importante pour être un frein à la récupération
manuelle.
IDA
- utilisez IDA et pointez sur la
Table, Constante.
- click droit et sélectionnez "Array" et précisez votre formatage.
Table Extractor de Thigo
- fais la même chose mais
vous pouvez vous servir sélectionner à partir de la RVA. |
Problème de call
Parfois identifier l'action d'un call est simple, parfois non.
Voici quelques trucs pour savoir ce que fait un call :
- rentrer dedans avec le debugger.
( Il se peut que vous ayiez à
ripper son code.)
- désassembler avec IDA.
( IDA possêde un identifieur
FLIRT qui permet de reconnaitre une fonction Visual C++, Delphi, etc dans le désassemblage. Si le nom n'est
pas clair, lancez une recherche avec Internet dessus. )
Dans tous les cas, vous pouvez essayer de ripper
son contenu mais faites attention, ce call peut être une fonction cryptographique ( Hash, ... ) et donc plus
ou moins longue.
A noter que vous pouvez trouver des sources ASM sur Internet pour des HASH type SHA, MD5, ... |
Problème de variables
Il arrive que l'identification des variables soit bonne mais que le résultat soit faux.
Voici un truc pour coller le maximum au Shareware au niveau des variables.
Méthode "Artisanale" par Presage :)
- identifier les variables ( comme avant )
- noter les adresses mémoire
de chaque variable.
- agencer les variables comme dans la mémoire.
Exemple bidon :
On a les variables [ebp + 1Ch], [ebp + 21h], à définir.
ebp + 1Ch = 023h
ebp + 1Ch pointe sur l'adresse
mémoire 67F7B0 donc "ebp + 1Ch" = BUF_67F7B0 = 023h
Je trace jusqu'à arriver sur l'instruction qui utilise [ebp + 22h] :
ebp + 22h = 0Ah
ebp + 22h pointe sur l'adresse
mémoire 67F7B6 donc"ebp + 22h" = BUF_67F7B6 = 0Ah
Je définis ensuite :
BUF_67F7B0 db 23h,0,0,0,0,0 <-- de 67F7B0 à 67F7B6, il y a 6 bytes donc
"23h" + 5 zéros.
BUF_67F7B6 db 0Ah,0,0,0,0,0
Naturellement cela s'applique à tout et aussi aux différents buffers ( nom, stockage temporaire,
... ) si leurs adresses mémoire se situent à côté ou entre.
C'est très pratique... Si on entre un nom trop long et que cela écrase une valeur utilisée
par la routine, notre Keygen fera la même chose et donnera le même serial. |
Voilà, c'est à 99% terminé ! Simple non
?
tests
Resumé de l'épisode précédent
:
* la routine a été trouvée.
* on a un moyen de repasser en "non enregistré".
* on a réussi à la délimiter au maximum.
* on a commencé à identifier l'action de certains calls dans le calcul.
* on a rippé les instructions ASM et enlever les adresses/opcodes.
* on a identifié et rebranché les variables, calls, ...
C'est maintenant que notre moyen de désenregistrement va servir.
Il est impératif dans un Keygenning par rippage ASM de bien tester le Keygen produit !
Une constante qui est une variable, une variable mal définie, un Rippage mal fait, ... et c'est un Keygen
faux.
Test à faire
0 - Un nom bidon
- Donner un autre nom que le votre
et voyiez si le résultat est bon ! (
En effet, ce n'est pas rare que le Keygen donne le bon serial avec votre nom mais qu'il se plante avec un autre
! )
1 - Donner des limites de caractéres
à rentrer pour le nom.
Pour la limite inférieure
( nombre minimum de lettres de votre nom ), générallement, un pré-test dans le Shareware la
donne.
Pour la limite supérieure, c'est moins fréquent et bon nombre de Keygen se plante au-delà
d'un certain nombre de caractéres...
Si vous avez suivi la méthode pour éviter les problèmes de rebranchement de variables [ebp
- nombre ], le Keygen doit suivre le comportement du Shareware même en Overflow :)
Toutefois, limitez vos Keygens a 30 lettres... Vous avez fait "l'exploit" de faire un Keygen, alors autant
qu'il soit parfait.
2 - Tester visuellement la génération
Si votre Keygen est "direct"
( = le serial s'affiche à la frappe du nom ), vous pouvez le faire rapidement.
Commencer à taper 1 caractére puis plusieurs, jusqu'à la limite supérieure.
A moins qu'il y ait un serial même sans nom, vous devriez avoir l'affichage suivant :
- Pas assez de caractéres pour le nom
- Serial
- Trop de lettres pour le nom
- Le Beep de Windows indiquant que la limite de récupération
3 - Tester avec un nom "exotique"
Ne vous limitez pas aux chiffres
et caractéres de l'alphabet !
A moins que la routine du Shareware ne le précise, testez donc avec des caractéres comme :
²&éé"'(-è_ç_à)=%µ*ù!:;,§/.?><
4 - Tester sur un autre PC ( sur conditions
)
Normallement, vous n'avez pas à le faire SAUF si ce que vous avez rippé, utilise des fonctions récupérant
des informations spécifiques au PC.
A noter que pour le nom du disque dur et le nom que vous avez donné en installant Windows, vous pouvez changer
ces informations manuellement. |
conclusion
Resumé FINAL :
* la routine a été trouvée.
* on a un moyen de repasser en "non enregistré".
* on a réussi à la délimiter au maximum.
* on a commencé à identifier l'action de certains calls dans le calcul.
* on a rippé les instructions ASM et enlever les adresses/opcodes.
* on a identifié et rebranché les variables, calls, ...
* on a testé son Keygen.
Certes si vous regardez ce tut, cela semble long et compliqué mais gardez plutôt en tête le
résumé ci-dessus !
C'est facile à comprendre ET à refaire.
En aucun cas, vous n'avez vu d'analyse de calculs ou d'opérations ! Et pour cause, il n'y a pas besoin !
Laissez les explications de routine pour des tuts sur des crackmes !
Tout est détaillé pour éviter que votre élan ne soit stopper par une broutille. ( sélection
par colonne, comment ripper, ... )
Le Keygenning est un peu le réapprentissage du Cracking dans une voie parallèle.
Dans le Cracking Standard, vous cherchez la routine de la protection ; dans le Keygenning, vous cherchez à
exploiter cette protection.
De toute manière, commencer le Keygenning, c'est comme commencer le Cracking : quand vous ne réussissez
pas sur un logiciel, vous passez au suivant.
A force d'expériences et de lectures, vous pourrez keygenner beaucoup plus de logiciels... comme en Cracking
Standard.
Le Cracking francophone peut s'enorgueillir d'avoir dans ses rangs beaucoup des meilleurs Keygenneurs qui officient
actuellement et peut-être même le meilleur au niveau mondial, alors il ne vous reste plus qu'à
travailler pour les rejoindre :)
Bon courage.
remerciements
Merci à The Analyst, DeeDee, aux membres des groupes
FFF et Know[l]edge et à tous ceux qui ont crée outils, tuts et Keygenmes ( Christal & GdT, Thigo,
Syntax, Roy|Fleur, Kahel... ) pour faire progresser le Keygenning francophone.
(1) "Debugger en carton pâte" et "Debugger en mousse"
sont des marques déposées par BOFH.
BOFH : "Parce qu'il y en marre des debuggers en mousse."
|