The Ultimate Tutorial sur Get Right 3.xx

By Nody

Intro.  

Logiciel : HeadLight Get Right 3.xx (la 3.3 est utilisée pour ce tutorial)

Source : Beaucoup de mag. récents dans le répertoire 'tools'

Outils : W32Dasm, Soft-Ice et un éditeur hexa (RegMonitor si possible)

Commentaires :

Get Right est un logiciel sympa pour télécharger des fichiers et il permet en autres de récupérer des téléchargements perturbés par les éternelles déconnexions de Windows.

Le Crack.

D'abord armez-vous de patience, ce tut. est très long.

"Préliminaires"

Get Right possède pas mal de signes distinctifs montrant qu'il est un shareware :

    - limité dans le temps

    - plein de "Buy GetRight"

    - certaines limitations comme le nombre de serveurs, etc .....

C'est d'ailleurs par celle-ci que nous allons commencer :

(Commencez par désassembler getright.exe, on en aura besoin plus tard)

Démarrez GR (GetRight), puis Edit/Configuration puis cliquez sur l'onglet Login. Ajoutez un nom de serveur et cliquez sur Add. Réessayez ..... ah une petite MessageBoxA qui se pointe "Sorry, you must be a registered GetRight user etc ....".

Sous W32Dasm, cherchez dans les Strings Data Réf. ce message. Comme il y en a plusieurs, je vous donne la soluce : c'est en 0040BF57 et ça donne :

:0040BF5C  push edi

Ce qu'il y a de magic, c'est qu'un saut conditionnel en 40BF52 nous permet de passer au-dessus de ce message. La condition de ce saut est "saute si eax <> 0". Et un juste avant il y a un call, hmmm...étrange, quelque chose me dit que ce call dit si on est des utilisateurs enregistrés ou non ...

1ère Etape  (crack brutal pour débutants)

Dans cette 1ère étape, on va cracker GR de manière (très) brutale.

Voici le début du call :

:0043C801  push edi

Précédement, on a vu que eax devait être différent de 0. Or ici, on a un xor eax, eax en 0043C7F9 (ie eax = 0) donc eax est remis à 0. Transformer un coup le je (en 0043C7F7) par un jmp (74 à remplacer par EB en héxa.).

Mouais, ça marche pas (on verra pourquoi plus tard). Essayez autre chose : remplacez le xor eax, eax par nop nop (héxa : 33C0 par 9090) de telle manière que eax ne soit pas ré-initialisé. Ouais, ça marche !! Ah merde, une MessageBoxA nous dit  "GR : divide by zero error." et ça plante. C'est marrant ça, un programme comme GR qui possède ses propres messages d'erreur "divide by zero" !! On est plutôt habitué à la boîte de dialogue Windows... Ne vous inquiétez pas, ce ne sont pas de vrais messages d'erreur, ils sont uniquement destinés à stopper le jeune cracker, apeuré par ces messages à 2F. D'ailleurs, ces messages, on les retrouve dans les String Datas Réf. comme par exemple celui-là :

:00410023  push esi

Tiens c'est marrant qu'il appelle la routine de vérification du RegCode (0043C7D5), avant un message d'erreur...

Pour cracker (brutalement) GR, il suffit de :

    1) Modifier la routine de  vérif' pour que eax soit différent de 0

    2) Changer les je en jmp pour ne pas voir les messages "divide by zero error"

C'est à dire :

1) on l'a déjà fait ici.

2) Vous devez alors repérer chaque "GR : divide by zero error " dans le code ASM avec W32Dasm. Pour cela, prenez la routine de vérif' (0043C7D5) et repérez chaque adresse qui l'appelle, allez à ces adresses, vérifiez qu'il y a une String Data Réf. "GR : divide by zero error" et changez le je en jmp !

Routine de vérif' :

Ouaou ! Il y a quand même 25 adresses à vérifier, bon courage !!!

Pour ceux qui veulent un crack d'un niveau supérieur et/ou ceux qui ont la flemme de vérifier 25 adresses et de virer 10 je en jmp, voici la :

2ème étape  (crack un p'tit mieux pour les moins débutants)

Vous aurez absolument besoin de Soft Ice dans cette partie.

On va faire une simple analyse du code assembleur de la routine de vérif' et créer notre propre clé d'enregistrement (et même un générateur de clés).

Tout d'abord, quitter entièrement GR (ie virez le même de la barre des tâches) puis démarrez Reg Monitor (sur le site de Frog's Print) et enfin redémarrez GR. Une fois fait, arrêtez le "Capture Events" de Reg Monitor et analysez les appels faits à la Base de Registre par GR. Une très intéressante : HKEY_CURRENT_USER/Software/Headlight/GetRight/Config/RegsitrationCode et juste devant celle-ci on a le texte NOT FOUND => commencer par créer cette clé et affectez lui la valeur que vous voulez (123456).

Bon, on va changer de registre (petit jeu de mots merdique, excusez-moi ...)

Appel de la routine de vérif' :

:0040FFFB  lea ecx, dword ptr [ebp-10]

:0040FFFE    call 0043C7D5

(1)  D'après Soft Ice, après ce call, on retrouve notre RegCode (123456) dans ecx. D'ailleurs, en 0040FFFB, on fait pointer ecx sur notre RegCode, et cela juste avant d'appeler la routine de vérification.

D'ailleurs, accrochez vous bien, la voici dans presque son intégrité :

:0043CCDB  leave

:0043CCDC  ret

Commentaires de la routine :

(Ses commentaires sont réalisés à partir d'observation sous Soft-Ice)

commentaire 1    retour au code

En [eax-08] est placé la taille de notre RegCode. Si vous avez entré 123456, [eax-08] = 6.

Nous avons juste après un cmp dword ptr [eax-08], 0C => il compare la longueur de notre RegCode à 12 et saute si égale. Remplacez le 123456 par 123456789012. Regardez ce qu'il se passe sous SI et c'est bon, on passe la condition !!

A partir de maintenant, je désigne le code de cette façon :

[1] [2] [3] ..... [12] ie [1] = le 1er chiffre, etc ... jusqu'au douzième.

On continue .....

commentaire 2   retour au code

0043C845 : eax = [9] et esi = [6].

0043C84A :  eax := eax + esi ie eax := [9] + [6].

0043C84C : ecx := 10 (car 2 lignes au-dessus, on a push 0A et Ah = 10d)

0043C84E : idiv ecx

Rappel de l'instruction IDIV (division signée) :

    IDIV reg  <=>   EAX / reg et on place dans EAX le quotient et dans EDX le reste

On a donc comme division :

    ( [9] + [6] ) / 10  

et en 0043C850, on a un cmp edx, 9 c'est à dire  on compare le reste de la division à 9 et il faut que celui-ci l'égale !!

   ( [9] + [6] ) / 10 = quotient + 9   <=>     [9] + [6] = 9 car [9] et [6] sont inférieurs à 10.

On a donc les 2 premiers éléments de notre RegCode : le neuvième plus le sixième doivent égaler 9  (je vous laisse choisir).

On continue ....

commentaire 3 retour au code

Le code est similaire au commentaire 2 avec :

eax := [7] et ecx := [2] et il faut que le reste soit égale à 3 (on divise tjrs par 10).

Donc il suffit de prendre [7] + [2] = 3 ou 13.

commentaire 4 retour au code

Le code est similaire au commentaire 2 avec :

eax := [12] et ecx := [3] et il faut que le reste soit égale à 8 (on divise tjrs par 10).

Donc il suffit de prendre [12] + [3] = 8 ou 18.

commentaire 5 retour au code

Le code est similaire au commentaire 2 avec :

eax := [5] et ecx := [4] et il faut que le reste soit égale à 0 (on divise tjrs par 10 et on cette fois un test edx, edx qui est à peu près égale à un cmp edx, 0).

Donc il suffit de prendre [5] + [4] = 10 car 10/10 = quotient (=1) + 0.

commentaire 6 retour au code

Le code est similaire au commentaire 2 avec :

eax := [11] et ecx := [8] et il faut que le reste soit égale à 5 (on divise tjrs par 10).

Donc il suffit de prendre [11] + [8] = 5 ou 15.

commentaire 7 retour au code

Le code est similaire au commentaire 2 avec :

eax := [10] et ecx := [1] et il faut que le reste soit égale à 2 (on divise tjrs par 10).

Donc il suffit de prendre [10] + [1] = 2 ou 12.

commentaire 8 retour au code

Dans la routine appelée en 0043CCC8, il y a une dernière vérification, qui vérifie si le code n'est pas un code frauduleusement acquis (c'est GR qui le dit) car ces petits vicieux ont placés comme String Data Réf. des n° de code bidons.

On a donc tout ce qu'il faut pour écrire un petit générateur de n° de série.

Voici qques numéros valides :

113731228135

121732127137

213646253005  , etc ....

Voilà une source Pascal :

==début==

program getright3;

uses crt;

var
un,deu,tro,qua,cin,six,sep,hui,neu,dix,onz,dou:real;

begin
clrscr;
textcolor(green);
writeln('Key Generator for Get Right 3.xx by Nody');
textcolor(white);
writeln;writeln;
randomize;
un:=0;deu:=0;tro:=0;qua:=0;cin:=0;six:=0;sep:=0;hui:=0;neu:=0;dix:=0;onz:=0;dou:=0;

while un+dix <> 2 do
begin
  un:=int(random*9+0);
  dix:=int(random*9+0)
end;

while six+neu <> 9 do
begin
  six:=int(random*9+0);
  neu:=int(random*9+0)
end;

while deu+sep <> 3 do
begin
  deu:=int(random*9+0);
  sep:=int(random*9+0)
end;

while tro+dou <> 8 do
begin
  tro:=int(random*9+0);
  dou:=int(random*9+0)
end;

while qua+cin <> 10 do
begin
  qua:=int(random*9+0);
  cin:=int(random*9+0)
end;

while onz+hui <> 5 do
begin
  onz:=int(random*9+0);
  hui:=int(random*9+0)
end;


write(un:1:0,deu:1:0,tro:1:0,qua:1:0,cin:1:0,six:1:0,sep:1:0,hui:1:0,neu:1:0,dix:1:0,onz:1:0,dou:1:0)


end.

==fin==

Et voilà, Get Right 3.xx version version d'essai n'est plus. Faîtes en bonne usage mais d'oublier que ce que vous êtes en train de lire est une AIDE pour les crackers débutants !! Si vous vous en servez à un autre usage, allez sur un moteur de recherche, cherchez un patch pour Get Right 3.xx, mettez-y votre nom et soyez heureux mais vous n'êtes pas cracker alors mais simple copieur.

nodless@usa.net