Utilisation d'OllyDBG et du plug-in de ligne de commande

(partie de base) Vietnam

http://phuocdong.orgfree.com/mang/14.sudung.ollydbg.coban.htm
I - Introduction :

- Ollydbg ou Olly en abrégé, est un programme DEBUGGER intuitif et facile à utiliser. Adaptable pour
tous les différents niveaux de CrackEr.
- On peut dire qu'Olly comprend de nombreuses fonctionnalités qui, si elles sont utilisées individuellement,
nous devons combiner de nombreux programmes. Olly a maintenant la version 1.0
- Ce manuel d'utilisation Olly comprend trois parties :
*** Partie I : Installer et configurer Olly
*** Partie II : Présentation d'Olly
*** Partie III : UtiliserOllyOlly

II – Installer et configurer Olly

Pour pouvoir utiliser plus de fonctions d' Olly, nous devons le configurer davantage et trouver des plugins
écrits spécifiquement pour les programmes.
- Vous pouvez télécharger Olly depuis la page d'accueil http://home.t-online.de/home/Ollydbg ou depuis
http://moonbaby.envy.nu/002-tools/olly avec des plugins et des configurations prédéfinis.
- Après avoir décompressé Olly dans le dossier (par exemple OllyDbg), vous verrez qu'il y a un dossier
Plugins prédéfini , vous devez créer un autre dossier, Udd.

De plus, si vous téléchargez Olly depuis la page d'accueil, il n'y aura pas de fichier
ollydbg.ini (ce fichier contient la configuration d'Olly), mais lorsque vous exécuterez
Olly pour la première fois, le programme créera ce fichier pour vous.
- Démarrez Olly, vous choisissez Options -> Apparence -> Répertoires . Ici, vous verrez
deux chemins, Udd Path et Plugin Path , choisissez le chemin d'accès au dossier d'Olly.
Ensuite, le programme vous demande d'arrêter de bouger pour accepter la modification.
- Après le redémarrage, vous verrez sur la barre d'outils principale d'Olly apparaître un
nouvel élément Plugins .
- Lorsque vous téléchargez Olly depuis le sitehttp://moonbaby.envy.nu/002-tools/olly ,
dans ce fichier sont disponibles ollydbg.ini , quelques plugins nécessaires et
préconfigurés qui vous donnent les paramètres de couleur, la couleur d'arrière-plan
ainsi que certaines des autres options. Lorsque vous téléchargez Olly depuis la page
d'accueil, au démarrage du programme, les couleurs d'Olly ne seront pas belles. Pour
modifier la couleur que vous choisissez Options -> Apparence , dans cette fenêtre, vous
accédez à chaque élément et sélectionnez la couleur, la police et la taille du texte, la
couleur d'arrière-plan, la couleur de surbrillance ..... Ensuite, redémarrez Olly pour
modifier la taille active.
- Une fois que vous vous êtes familiarisé avec Olly, vous devriez aller à l' AIDEpour en
savoir plus et configurer Olly à votre guise. Mais si vous débutez avec Olly, je vous
recommande d'utiliser le préconfiguré que vous téléchargez à partir de
http://moonbaby.envy.nu/002-tools/olly

III – Présentation d'Olly

Olly : Olly peut être divisé en 5 fenêtres principales. Pour basculer entre ces fenêtres, nous utilisons la
touche TAB . Et la touche Shift-TAB reviendra à la fenêtre précédente.

III.1 - CPU :

- La plupart du temps nous nous concentrons là-dessus. Cette fenêtre est divisée en 4 petits
volets. On considère de gauche à droite :
** La première cellule : Affiche l'adresse du code. Lorsque nous double-cliquons dessus, la
ligne que nous double-cliquons sur " $ == > " , au-dessus ce sera " $ - x " et en dessous ce
sera " $ + x " . Ces valeurs « x » sont le nombre d'octets de l'instruction.
** Deuxième case : est le code. Lorsque nous double-cliquons dessus, cela signifie que nous y
avons mis BreakPoint . Et lorsque vous double-cliquez à nouveau, supprimez ce BreakPoint .
** Troisième cellule : code Assembleur. Il s'agit d'une case très importante lors du suivi du code.
Lorsque nous double-cliquons dessus, la case "Assembler à XXXXXXXX" apparaîtra., nous
pouvons éditer le code du programme via cette case.
** La quatrième case : affiche les informations du programme. Nous utilisons cette boîte pour
trouver des chaînes spéciales. Et lorsque l'on passe à la fenêtre "Text String reference" ,
toutes les informations de cette fenêtre sont les informations de cette cellule. Lorsque nous
double-cliquons dessus, la case « Ajouter un commentaire à XXXXXXXX » apparaîtra pour
que nous puissions noter les informations et annotations nécessaires pour une prochaine
utilisation.

III.2 - Registres [FPU, MMX, 3DNow!] :

- La deuxième fenêtre est à droite de la première.

- Afficher les registres et les drapeaux dans l'Assemblée. Cette fenêtre nous est nécessaire pour surveiller
l'évolution de la valeur des registres, des instructions mathématiques, etc.

III.3 - La troisième fenêtre

- La petite fenêtre est située juste en dessous de la première fenêtre.

- Nous informer de l'adresse réelle, de la valeur calculée, ... avant de l'afficher dans la deuxième fenêtre.
- Dans cette fenêtre, lorsque l'on fait un clic droit sur une ligne, une sous-fenêtre peut apparaître avec des
options (maximum 4 options) Modifier les données, Suivre l'adresse en Dump, Suivre la valeur en
Dump et Apparence.
Cependant, une chose doit être gardée à l'esprit, le paramètre qui apparaît dans cette fenêtre est la valeur de
la ligne de commande dans la première fenêtre lorsque nous traçons. Lors de la recherche, les paramètres
n'apparaissent pas dans cette fenêtre
*** Modifier les données : lors de la sélection de cet élément, la fenêtre Modifier dWord à XXXXX
apparaîtra avec trois valeurs : Hexadécimal, Signé et Non signé. L'avantage de cette fenêtre est que dans
certains cas, nous pouvons voir le numéro de SÉRIE réel du programme.
*** Suivre l'adresse dans Dump : Déplacez la quatrième fenêtre vers l'adresse que vous choisissez. Très
nécessaire quand il faut considérer la valeur du programme stocké à cette adresse
*** Follow value inDump: Passez la quatrième fenêtre à la valeur de l'adresse que vous choisissez.
*** Apparence : avis sur les options dans Options --> Apparence .

III.4 - Adresse, Hex dump, ASCII ou UNICODE

- La quatrième fenêtre est en dessous de la troisième fenêtre.

- Il nous faut observer le changement des valeurs calculées du programme.
- Dans certains cas, nous pouvons trouver la chaîne SERIAL ici.

III.5 - PILE

- La cinquième fenêtre est en dessous de la deuxième fenêtre et à droite de la troisième fenêtre.

- C'est la mémoire temporaire du programme.
- Les paramètres d'une fonction avant traitement seront temporairement stockés dans cette PILE. Surveiller
de près le changement des emplacements de mémoire et des valeurs de cette fenêtre aidera beaucoup dans
le processus de recherche de la chaîne SERIal réelle.

 
INSTALLER, EXÉCUTER ET ÉCRIRE UN SCRIPT EN OLLDG

Chers amis. Spécialement pour les débutants.

Comme vous pouvez le voir, lorsque nous apprenons à cracker, la plupart des logiciels sont
maintenant généralement emballés avec un certain packer. Mais nous sommes novices,
nous ne savons pas DÉBALLER. Habituellement, nous trouvons un déballeur pour
déballer. Sinon, nous devons apprendre le TUT MUP, également connu sous le nom de tut
"décompresser", puis nous entraîner à décompresser le logiciel que nous voulons cracker.
Les tutoriels MUP nous enseignent les étapes suivantes :
-Trouver OEP
-Dump le programme en mémoire à partir d'OEP vient de trouver un fichier
-Fix IAT -Puis
reconstruire PE.
(OEP, IAT, PE... qu'est-ce que c'est quand j'ai du temps libre, je vais le synthétiser pour
vous)
Habituellement, pour un type de packer, nous trouvons le même OEP pour les programmes
qui sont compressés avec ce packer. Une fois que vous savez comment trouver OEP, ce
travail est ennuyeux. Parce que ce sont juste des opérations répétées à chaque fois que
nous voulons décompresser ce type de packer. De sorte qu'à chaque fois que nous
décompressons nous devons lire le TUT MUP puis faire de même pour trouver l'OEP, les
crackers ont utilisé le langage Script d'Olly pour "écrire des opérations ennuyeuses" et les
enregistrer dans un fichier de script. Lors du déballage, il vous suffit d'exécuter le fichier et
Olly vous trouvera automatiquement l'OEP. N'êtes-vous pas en bonne santé. Salut `
L'un des crackers vietnamiens qui écrivent beaucoup de scripts est le vieux hacnho. Veuillez
vous rendre sur son site Web et trouver les scripts : http://www.hacho.nhandan.info
Le but de ce TUT est d'aider les débutants à exécuter un fichier de script et à se familiariser
avec le langage de script pour comprendre ce que les auteurs écrivent dans le fichier de
script. Ce n'est pas si difficile, les gars. On apprend doucement et  le saura.

1. INSTALLER OLLYDBGSCRIPT ET EXÉCUTER UN FICHIER SCRIPT :

Installez OllyScript en suivant ces étapes :

1. Tout d'abord, vous devez avoir déjà installé OllyDbg.(C'est naturel)
2. Installez un dossier nommé "plugins" dans le dossier contenant OllyDbg sur votre ordinateur .
3. Vous téléchargez le fichier ollyscript.dll depuis Internet et le copiez dans le dossier « plugins » créé ci-
dessus
4. Ouvrez OllDbg, allez dans le menu des options, sélectionnez Apparence/Répertoires. Une boîte de
dialogue s'ouvre
5. Dans la boîte de dialogue qui s'affiche, nous définissons « Chemin du plug-in » dans le dossier
« Plugins » créé ci-dessus.
6. Redémarrez OllyDbg. OllyScript est maintenant dans le menu Plugins.
7. Pour exécuter un script, sélectionnez « Exécuter le script… » dans le menu Plugins/OllyScript et
sélectionnez le fichier de script que vous souhaitez exécuter.

2. À PROPOS DU LANGAGE DE SCRIPT :

Pour écrire des fichiers de script, vous n'avez pas besoin d'un programme d'édition séparé, il suffit de les
modifier dans le Bloc-notes et de l'enregistrer dans un fichier avec l'extension .txt ou autre, n'hésitez pas. .
Maintenant, je vous présente ce langage de script simple comme celui-ci :
j'utilise Olly 1.10 et Plugins v0.91. Veuillez vous rendre sur le site Web d'Olly pour le télécharger.
Tout d'abord, je voudrais vous présenter son menu

a-Menus :

Vous allez dans le menu Plugins d'Olly, sélectionnez OllyScript, nous voyons les
sous - menus suivants : -Run script… : Laissez l'utilisateur choisir un fichier de script et l'exécuter.
-Abandonner : ignorer lorsque vous ne voulez pas que le script continue
-Pause : Suspendre le script pendant son exécution
-Resume : Reprendre lorsque le script est en pause
-about : À propos de ce plugin
Passons maintenant à la section principale :

b-À propos d'OllyScript Langue:

Le langage de script dans olly est linguistiquement similaire au langage ASM. Mais la différence est qu'il
n'a pas besoin d'être compilé dans un fichier .exe, mais en fait c'est un langage interprété dans Olly. Si vous
savez utiliser le langage Lisp dans AutoCAD, le script est similaire dans Olly. Pourquoi dis-je que c'est un
langage interprété, pas un langage compilé, car lorsqu'Olly exécute un script, elle rencontre n'importe
quelle commande et exécute immédiatement cette commande, sans compiler l'intégralité du fichier de
script, puis l'exécuter. Vous devriez avoir une idée sur ce problème.

i/Conventions de données :

c'est aussi la règle d'OllyScript

Voici quelques conventions de script concernant les données src (source) et dest (destination) pour les
commandes (comme la commande « MOV dest,src »):
-Constante : comme ASM est un nombre hexadécimal, mais dans le script il n'y a pas de symboles avant
ou après le nombre hexadécimal.
Exemple :
dans le script, un nombre hexadécimal est écrit 00FF, pas 0x00FF ou 00FFh
-Variable : comme Pascal, les variables sont décrites après le mot-clé VAR mais n'ont pas besoin de
déclarer le type de variable car il n'y a qu'un seul type de variable. numéro hexadécimal.
-Il n'y a qu'un seul type de registres 32 bits dans le script : EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP,
EIP. Il n'y a pas de registres 16 bits comme AX , ni de registres 8 bits comme AL. Mais vous pouvez
utiliser les instructions SHL/SHR et AND pour obtenir leurs valeurs.
- En se référant à une certaine zone mémoire, on donne l'adresse mémoire en 2 signes […. ]
Exemple :
[401000] : pointe vers un appareil à l'adresse 401000
[ecx] : pointe vers un appareil à l'adresse ecx
-Pour utiliser le drapeau dans le script, nous utilisons le point d'exclamation "!" avant le nom du drapeau
Exemple : !CF, !PF, !AF, !ZF, !SF, !DF, !OF
-chaîne d'octets (chaîne d'octets, chaque 1 octet correspond à 2 nombres hexadécimaux) pour être comprise
par le script, elle doit être mis dans 2 Le signe dièse # et la chaîne d'octets doivent être pairs, les nombres
hexadécimaux entre les deux signes # (2 nombres hexadécimaux pour 1 octet doivent toujours être pairs)
Exemple : #6A0000# (6 nombres sont des nombres pairs contenus dans 2 # signes)
-Ou mieux encore, la chaîne d'octets contenant le caractère générique est un "?".
Par exemple : #6A??00# ou #6?0000#
-La chaîne de caractères dans le Script est écrite en gardant 2 signes "...."
Par exemple, la chaîne benina est "benina"
-Pour certaines commandes, pour obtenir la valeur d'une variable, nous mettons cette variable dans {..}
Par exemple :
Var x
Mov x,"00402222"
Mov eax,{x}======== >>eax=00402222
ii/ Variables privées de script :

Devis:
$RESULT
Il s'agit de la valeur de retour de certaines fonctions comme la fonction FIND….

$VERSION

Cette variable contient la version actuelle d'OllyScript

Exemple :
cmp $VERSION, "0.8"
ja version_above_08

iii/Commentaires :
Chaque fois que je veux apprendre une nouvelle langue, la première chose que je dois apprendre est de
commenter dans cette langue. Parce que lorsque nous procédons à la rédaction de la commande, si elle
n'est pas entièrement commentée, environ une demi-heure plus tard…. Je ne sais pas ce que j'ai écrit…. Je
suis né stupide. Je vais donc vous montrer comment commenter dans le script de la manière suivante :
- Commenter pour une ligne de commande on utilise "//" avant le commentaire
- Commenter une phrase de commentaire, on met "/*" au début de la phrase et "* /" à la fin de l'annotation
de

script iv-Skeleton (Le noyau d'un script) :

Comme vous le savez lors de l'apprentissage de pascal, un programme pascal standard est le suivant :

Devis:

Programme tenchuongtrinh
Déclarer des variables, des constantes, ....
Commencer les
commandes ;
Finir.

C'est le noyau d'un programme pascal. Alors quel est le noyau du script ?. En fait, dans OllyScript il n'y a
pas de règle concernant le noyau, mais pour la règle générale quand "on s'aime d'abord", benina aimerait
proposer un noyau comme suit :

Devis:

/*=================
Nom du script
==================*/
Déclarer la variable, inclut …(Non obligatoire forcé )
Commandes de script
……………
…………..
RET // Quitte le script

En fait, les lignes de commentaire sur le nom du script ne sont pas nécessaires, mais pratiquons cette
habitude afin qu'il soit plus facile de rechercher ce que fait ce script plus tard.
Ici, nous voyons l'instruction RET à la fin du fichier. C'est la commande pour quitter le script vers Olly.
Elle est similaire à la commande Fin en Pascal uniquement.
v-Votre premier programme :
Pour éviter de vous ennuyer, je vais maintenant vous guider pour créer un fichier de script simple :
Veuillez ouvrir le
Bloc-notes et éditer un fichier .txt comme suit :

Devis:

/ * /////////////////////////////////
Chuong votre première planète
/////// // ///////////////////////////*/
MSG "benina est un bon débutant" // affiche la boîte de dialogue
RET // quitte le script

Vous pouvez maintenant enregistrer le fichier texte ci-dessus dans n'importe quel dossier. Veuillez activer
Olly, remarquez : nous devons ouvrir un certain fichier .exe dans Olly, puis exécuter le script ci-dessus.
Terminé les gars, exécutez maintenant le script ci-dessus et voyez.
Boum, il affiche une boîte de dialogue avec le message : "benina is a good newbie", hein les gars. hehe…
Ensuite, il affiche une boîte de dialogue disant « Script .  fini » ... .donc nous pouvons écrire le script ...
donc prêt à aller,
je vous présente la commande suivante:
Comme vous le savez, dans le tutoriel "Let's cracked by Olly" que j'ai écrit, il est question de la commande
de commentaire pour les routines dans Olly (pas dans le commentaire de script, ne le gâchez pas !). Il a le
bouton de raccourci ";". Lors de l'utilisation de cette commande, vous pourrez annoter une note dans la
fenêtre CPU dans la colonne des commentaires. Amis, dans le Script vous permet également de manipuler
la commande ";". La directive suivante est similaire à la commande « ; ». à Olly :

Devis:

CMT addr, text

-----------------
Ajouter un commentaire textuel à l'adresse addr
Exemple :
Cmt eip, « This is the EP »

Comme vous le savez, le registre eip contient l'instruction qui est sur le point d'être exécutée. Ainsi, lors de
l'ouverture d'un fichier dans Olly , eip contient toujours la première instruction de ce programme qui est
également l'EP du programme. Maintenant, nous réécrivons le script ci-dessus comme suit :

Devis:

/ * /////////////////////////////////
Chuong votre première planète
/////// // ///////////////////////////*/

MSG "benina is a good newbie" // show

Cmt eip, "This is the EP"
RET // quitte le script

Pouvez-vous exécuter le script ci-dessus et il fonctionne comme prévu ? Voyez-vous la ligne de

commentaire "This is the EP" sur la première ligne de commande dans la fenêtre CPU d'Olly ?.
D'ACCORD!
La raison pour laquelle je poste cette commande en premier pour vous est que dans le TUT de l'ancien
hacker, j'utilise souvent cette commande pour noter l'OEP trouvé. Maintenant, nous sommes entrés un peu
dans le script.

Remarque : lors de l'écriture d'un script, il se trompe parfois, le programme s'exécute de manière erratique,
nous voulons déboguer pour voir où le script s'exécute au mauvais endroit, nous devons appliquer la
commande MSG comme point d'arrêt dans le script. Ensuite, le programme s'arrête pour que nous
considérions… hihi. Ou vous pouvez utiliser la commande suivante comme point d'arrêt :

Devis:

PAUSE
----------
Suspend l'exécution du script. Si vous voulez que le CV continue, allez dans le menu plugins
/OllyScript/Resume
Par exemple, dans le fichier script, tapez la commande :
pause

Considérez donc le premier programme terminé.

vi-Déclarer des variables, des constantes et des

inclusions -Déclarer des variables :

Devis:

VAR varname
-----------
Déclarer la variable à utiliser dans le script
Doit déclarer avant d'utiliser la variable
Exemple :
Var x

-Déclarer des constantes : En fait dans Script il n'y a pas de déclaration de constante, nous voulons déclarer
une constante pour une variable avec la première valeur, aussi simple que cela.
Voyons d'abord la commande d'affectation de valeur dans le script, c'est comme ASM

Devis:

MOV dest,src
-----------------
Attribuer la valeur dans src à dest
Src peut être une longue chaîne hexadécimale au format suivant #<nombre hexadécimal>#, par
exemple : # 1234# (hex doit être pair)
Exemple :
mov x, 0F
mov y, "Hello world"
mov eax, ecx
mov [ecx], #00DEAD00BEEF00#
mov !CF, 1
mov !DF, ! PF
Déclarez ensuite la constante comme suit :

Devis:

Exemple :

Var x
Mov x, « le Bénin est un bon débutant »

-Comprend un fichier de script :

Devis:

Fichier #INC
----------------
Inclut un fichier de script dans un autre fichier de script
Exemple :
#INC « autrescript.txt »

Remarque : cette commande n'a pas besoin d'être au début du script, vous pouvez la placer où vous le
souhaitez. Son objectif principal est, lorsque le script en cours d'exécution rencontre cette commande,
d'exécuter toutes les commandes du fichier « autrescript.txt », puis d'exécuter les commandes après la
commande #INC (à condition que dans « autrescript.txt » pas de commande RET)

Appliquer ce que vous venez d'apprendre, vous devez écrire 2 fichiers de script comme suit :

Devis:

/*//////////////////////////////////
Fichier : Script1.txt
/////// / /////////////////////////////*/
var x
mov x,"Benina is a good newbie" //declare x

# inc "script2.txt" // exécute les commandes dans script2.txt

MSG "Script2 terminé !!"

RET // quitte le script

Devis:

------------------------------------
/*//////////// ///////////////////////
Fichier : Script2.txt
//////////////////// ////////////////*/

MSG x
// Le cycle dans le script2 n'a pas d'instruction RET
---------------------------
Laissez maintenant Olly exécuter le fichier Script1. D'accord! Vous avez déjà compris, inutile de vous
expliquer longuement. Notez juste que dans script2 il n'y a pas d'instruction RET seulement

vii-Instructions d'opération dans Olly :

Dans Olly les commandes de "manipulation manuelle" telles que F9 (run), F8 , F7... sont automatiquement
exécutées par le script. Les commandes de script suivantes sont similaires aux commandes de manipulation
d'Olly. Je ne traduis pas ces commandes, car c'est trop simple :

Devis:

AI
--
Exécute "Animate into" dans OllyDbg
Exemple :
ai

AN addr
-------
Module d'analyse qui contient l'adresse addr.
Exemple :
un eip // Identique à appuyer sur CTRL-A

AO
--
Exécute « Animate over » dans OllyDbg
Exemple :
ao
RTR
---
Exécute « Exécuter pour revenir » dans OllyDbg
Exemple :
rtr

RTU
---
Exécute « Exécuter vers le code utilisateur " dans OllyDbg
Exemple :
rtu

RUN
---
Exécute F9 dans OllyDbg
Exemple :
run

STI
---
Exécute F7 dans OllyDbg.
Exemple:
sti

STO
---
Exécutez F8 dans OllyDbg.
Exemple :
sto
ESTI
----
Exécute SHIFT-F7 dans OllyDbg.
Exemple :
ESTI

ESTO
----
exécute SHIFT-F9 dans OllyDbg.
Exemple :
Esto
TI
--
Exécute "Trace into" dans OllyDbg
Exemple :
ti

TICND cond
---------- Trace
dans les appels jusqu'à ce que cond soit vrai
Exemple :
ticnd "eip > 40100A" // s'arrêtera lorsque eip > 40100A

TO
--
Exécute "Trace over" dans OllyDbg
Exemple :
to

TOCND cond
----------
Trace les appels jusqu'à ce que cond soit vrai
Exemple :
tocnd "eip > 40100A" // s'arrêtera lorsque eip > 40100A
PAUSE
----- Suspend l'
exécution du script. Le script peut être repris à partir du menu du plugin.
Exemple :
pause

Résumé des commandes ci-dessus comme suit : (Pour nous permettre de rechercher plus facilement lors de
la lecture du code ou de l'écriture du code pour les scripts)

Devis:

AI ---------- Ctrl-F7 : Animer dans

AN---------Ctrl-A : ANAlyze module
AO---------Ctrl-F8 : Animer sur
RTR - -------Ctrl-F9 : Run To Return
RTU-------Alt-F9 : Run To User code
 RUN---------F9 : RUN
STI----- - -----F7 : PAS dans
STO----------F8 : PAS sur
ESTI---------Maj-F7 : Identique à F7, mais si lorsque le programme s'arrête sur une exception, Olly
commence à essayer de transmettre l'exception au gestionnaire spécifié dans le programme.
ESTO--------Maj-F9 : Identique à F9, mais si, lorsque le programme s'arrête sur une exception, Olly
commence à essayer de transmettre l'exception au gestionnaire spécifié dans le programme.
TI-----------Ctrl-F11 : tracer dans
TO-----------Ctrl-F12 : tracer sur
TICND------Ctrl-F11 en combinaison avec Ctrl-T : tracer dans et définir la condition
TOCND------Ctrl-F12 en combinaison avec Ctrl-T : tracer et définir la condition
PAUSE----- ---F12 ; PAUSE

HISTOIRE : Désolé d'avance, car j'ai accidentellement ouvert la "bière OllySrcipt" et j'ai ensuite dû tout
boire, mais benina était trop mauvaise, n'a pas eu le temps de boire. Je veux poser mon épée, mais j'ai
encore des problèmes avec la vie, alors je bois quelques TUT de temps en temps pour m'amuser. Et
maintenant, Benina organise simplement les commandes de script pour que vous ayez le système. Résumez
également et mettez en évidence certaines commandes importantes pour que vous ayez un concept. Benina
ne traduira pas toutes ces commandes, car c'est en fait assez facile à traduire. Si vous avez du temps libre,
traduisez-le pour moi, c'est super.

Commandes de type viii-ASM :

ces commandes de script sont toutes incluses dans le script ASM, il est donc facile d'exposer ces
commandes.

Devis:

ADD dest, src

-------------
Ajoute src à dest et stocke le résultat dans dest
Exemple :
add x, 0F
add eax, x
add [401000], 5
add y, " times" // Si y était 1000 avant cette commande alors y est "1000 fois" après

AND dest, src

-------------
ANDs src et dest et stocke le résultat dans dest
Exemple :
et x, 0F
et eax , x
et [401000], 5

DEC var
-------
Soustrait 1 de la variable
Exemple :
dec v

INC var
-------
Ajoute 1 à la variable
Exemple :
inc v

MOV dest, src

---- ---------
Déplacer src vers dest.
Src peut être une longue chaîne hexadécimale au format #<quelques nombres hexadécimaux>#, par
exemple #1234#.
N'oubliez pas que le nombre de chiffres dans la chaîne hexadécimale doit être pair, c'est-à-dire 2, 4, 6, 8,
etc.
Exemple :
mov x, 0F
mov y, "Hello world"
mov eax, ecx
mov [ecx], #00DEAD00BEEF00#
mov !CF, 1
mov !DF, !PF

OR dest, src
---------- ---
ORs src et dest et stocke le résultat dans dest
Exemple :
ou x, 0F
ou eax, x
ou [401000], 5
SHL dest, src
-------------
Décale dest vers la gauche src fois et stocke le résultat dans dest.
Exemple :
mov x, 0000010
shl x, 8 // x est maintenant 00001000

SHR dest, src

-------------
Déplace dest vers la bonne heure src et stocke le résultat dans dest.
Exemple :
mov x, 00001000
shr x, 8 // x est maintenant 0000010

SUB dest, src

-------------
Soustrait src de dest et stocke le résultat dans dest
Exemple :
sub x, 0F
sub eax , x
sub [401000], 5
XOR dest, src
-------------
XOR src et dest et stocke le résultat dans dest
Exemple :
xor x, 0F
xor eax, x
xor [401000], 5
-------------------------------------------------- - -

En bref : les commandes de tri de cette section sont :

Devis:

AJOUTER, SOUS, DEC, INC, ET, OU, XOR, SHL, SHR, MOV

ix-Instructions de saut et de comparaison :

a>Label(Label)

Tout d'abord, parlons de Label (Label) car l'instruction de saut est toujours liée à Label. Dans un langage
de programmation de haut niveau, lorsque nous voulons contrôler une instruction de saut, sauter à une
routine, nous devons déclarer cette routine à l'avance un nom d'étiquette. Ce n'est qu'alors que le
programme saura comment sauter. Dans Script, les étiquettes déclarent comme suit :

Devis:

Étiquettes
---------- Les
étiquettes sont définies en plaçant un ":" après un nom.
Exemple :
SOME_LABEL :

Ici, je voudrais également vous présenter une instruction d'étiquette de script pour le processeur de fenêtre.
Dans le TUT « Let's crack by Olly », j'ai un article sur la façon d'attribuer une étiquette à une ligne de
commande dans Olly afin que lorsque nous voulons y aller pour déboguer, nous laissions Olly sauter sur
cette étiquette. La commande d'étiquetage dans Olly est le shotcut ":" . Dans Script, il nous aide à exécuter
la commande ci-dessus comme suit :

Devis:

LBL addr, text

--------------
Insère une étiquette à l'adresse spécifiée
Exemple :
lbl eip, "NiceJump"

b>Comparer :
comme vous le savez, la commande comparer va toujours avec la commande de saut, je les trie donc dans
une catégorie.

Devis:

CMP dest, src

--------
Compare dest à src. Fonctionne comme son homologue ASM.
Exemple :
cmp y, x
cmp eip, 401000

c>Sauts (commandes de saut) :

commandes de saut dans le script :

Devis:

Étiquette JA
--------
Utilisez-la après cmp. Fonctionne comme son homologue asm.
Exemple :
ja SOME_LABEL Étiquette

JAE
--------- À
utiliser après cmp. Fonctionne comme son homologue asm.
Exemple :
jae SOME_LABEL Étiquette

JB
--------
Utilisez ceci après cmp. Fonctionne comme son homologue asm.
Exemple :
jb SOME_LABEL Étiquette

JBE
--------- À
utiliser après cmp. Fonctionne comme son homologue asm.
Exemple :
jbe SOME_LABEL

JE label
-------- À
utiliser après cmp. Fonctionne comme son homologue asm.
Exemple :
je SOME_LABEL Libellé

JMP
---------
Passer inconditionnellement à une étiquette.
Exemple :
jmp SOME_LABEL Étiquette
JNE
---------
Utilisez ceci après cmp. Fonctionne comme son homologue asm.
Exemple :
jne SOME_LABEL

===============

En bref : Les commandes de cette section :

Devis:

Fichier de script d'impression d'étiquettes;LBL;CMP;JA;JAE;JB;JBE;JE;JNE;JMP

Patch x-Command pour modifier le code :

il est similaire aux commandes Assemble (Shotcut space), Fill with NOPs, Edit Binary (Ctrl-E):

Devis:

ASM addr, command

-----------------
Assemble une commande à une certaine adresse.
Renvoie les octets assemblés dans la variable de réservation $RESULT
Exemple :
asm eip, "mov eax, ecx"

FILL addr, len, value

---------------------
Remplit len octets de mémoire à addr avec valeur
Exemple :
fill 401000, 10, 90 // NOP 10h octets

REPL addr, find, repl, len

----------------------- ---
Remplacez find par repl commençant att addr pour les octets de longueur.
Les caractères génériques sont autorisés
Exemple :
repl eip, #6a00#, #6b00#, 10
repl eip, #??00#, #??01#, 10
repl 401000, #41#, #90#, 1F

En bref : Il y a 3 commandes à patcher :

Devis:

ASM, REMPLIR, REPL

xi-Command about breakpoint :

Dans le script, donnez-nous également la commande pour définir le point d'arrêt. Remarquez que la
commande BP est la même que le point d'arrêt défini Toggle F2 et que la commande BPHWS est la même
que la commande bpm dans SI. C'est-à-dire que bp est défini à une adresse dans la zone mémoire, lorsque
le programme atteint cette zone mémoire, selon que le mod lit ou écrit dans cette zone mémoire, il
interrompt le programme.

Devis:

BC addr
-------
Efface le point d'arrêt inconditionnel à l'addr.
Exemple :
bc 401000
bc x
bc eip

BP addr
--------
Définir le point d'arrêt inconditionnel à l'adr.
Exemple :
bp 401000
bp x
bp eip

BPCND addr, cond

----------------
Définir le point d'arrêt sur l'adresse addr avec condition cond.
Exemple :
bpcnd 401000, "ECX==1"

BPL addr, expr

--------------
Définit le point d'arrêt de journalisation à l'adresse addr qui journalise l'expression expr
Exemple :
bpl 401000, "eax" // journaux la valeur de eax chaque fois que cette ligne est passée

BPLCND addr, expr, cond

-----------------------
Définit le point d'arrêt de journalisation à l'adresse addr qui enregistre l'expression expr si la condition
cond est vraie
Exemple :
bplcnd 401000, "eax", "eax > 1" // enregistre la valeur de eax chaque fois que cette ligne est passée et eax
>1

BPMC
----
Effacer le point d'arrêt de la mémoire.
Exemple :
bpmc

BPHWC addr
----------
Supprimer le point d'arrêt matériel à une adresse spécifiée
Exemple :
bphwc
401000 BPHWS addr, mode
----------------
Définir le point d'arrêt matériel. Le mode peut être "r" - lire, "w" - écrire ou "x" - exécuter.
Exemple :
bphws 401000, "x"

adresse BPRM, taille

---------------
Définir le point d'arrêt mémoire lors de la lecture.La taille est la taille de la mémoire en octets.
Exemple :
bprm 401000, FF

BPWM addr, size

---------------
Définir le point d'arrêt mémoire lors de l'écriture. La taille est la taille de la mémoire en octets.
Exemple :
bpwm 401000, FF

Résumé de la commande :

Devis:

BC, BP, BPCND, BPL, BPLCND, BPMC, BPHWC, BPHWS, BPRM, BPWM

xii-Commandes sur les boîtes de dialogue :

Commandes liées à l'affichage des boîtes de dialogue avec srcipt.

Devis:

ASK question
------------
Affiche une zone de saisie avec la question spécifiée et permet à l'utilisateur de saisir une réponse.
Définit la variable de réservation $RESULT (0 si le bouton d'annulation a été enfoncé).
Exemple :
ask "Enter new EIP"
cmp $RESULT, 0
je cancel_pressed
mov eip, $RESULT

Message MSG
-----------
Affiche une boîte de message avec le message spécifié
Exemple :
MSG "Script

paused " Message MSGYN

- ----------
Affiche une boîte de message avec le message spécifié et les boutons OUI et NON.
Définit la variable de réservation $RESULT à 1 si OUI est sélectionné et à 0 sinon.
Exemple :
MSGYN "Continuer ?"
Résumé:

Devis:

DEMANDEZ,MSG,MSGYN

xiii-Commandes de vidage :

appliquez ces commandes pour écrire un script qui vide le programme dans un fichier, sans utiliser de
logiciel de vidage professionnel. En particulier, vous devez faire attention à la commande DPE dump

Devis:

DM addr, size, file

--------------------
Vide la mémoire de la taille spécifiée de l'adresse spécifiée vers le fichier spécifié
Exemple :
dm 401000, 1F, "c:\dump.bin "

DMA addr, size, file

--------------------
Vide la mémoire de la taille spécifiée de l'adresse spécifiée vers le fichier spécifié en ajoutant à ce fichier
s'il existe
Exemple :
dma 401000, 1F , "c:\dump.bin"

nom de fichier DPE, ep

----------------
Vide l'exécutable dans le fichier avec le nom spécifié.
Le point d'entrée est réglé sur ep.
Exemple :
dpe "c:\test.exe", eip

Résumé:

Devis:

DM, DMA, DPE

xiv-Search

Commands : Ces commandes sont très importantes dans la lecture de TUT MUP, vous devez bien
comprendre ces commandes. Je voudrais traduire les commandes FINDOP pour vous

Devis:

FIND addr, what

---------------
Recherche la mémoire à partir de addr pour la valeur spécifiée.
Lorsqu'il est trouvé, définit la variable réservée $RESULT. $RESULT == 0 si rien n'a été trouvé.
La chaîne de recherche peut également utiliser le caractère générique « ? » (voir ci-dessous).

Exemple :
find eip, #6A00E8# // trouve un PUSH 0 suivi d'un appel
find eip, #6A??E8# // trouve un PUSH 0 suivi d'un appel

FINDOP addr, what

----- ------------
Recherche dans le code commençant à addr une instruction commençant par les octets spécifiés.
Lorsqu'il est trouvé, définit la variable réservée $RESULT. $RESULT == 0 si rien n'a été trouvé.
La chaîne de recherche peut également utiliser le caractère générique « ? » (voir ci-dessous).
Exemple:
findop 401000, #61# // trouver le prochain POPAD
findop 401000 , #6A??# // trouver le prochain PUSH de quelque chose

Cette commande a la signification suivante :

Rechercher une instruction qui commence par les octets spécifiés dans le paramètre what. L'adresse pour
démarrer la recherche est l'adresse addr . Une fois trouvé, il définira l'adresse de ligne de commande
résultante dans la variable $RESULT. Si $RESULT==0, cela signifie introuvable. Lors de la recherche de
chaînes, vous pouvez également utiliser le widget " ??". Voir les exemples ci-dessus.
Cette commande est très couramment utilisée dans les MUP TUT pour rechercher une certaine ligne de
commande.
Remarque : les commandes Find et FindOP sont différentes en ce sens : Find recherche quelque chose en
mémoire et FindOP recherche la ligne de commande du code.

Résumé des commandes :

Devis:

TROUVEZ, TROUVEZ

xv-Commandes liées à la fenêtre de journal :

Les commandes suivantes interfèrent avec la fenêtre de journal dans Olly (Dans Olly, vous appuyez sur le
bouton "L" de la barre de menu pour afficher la fenêtre de journal. Cette fenêtre enregistre ce que vous
voyez. quel Olly a enregistré pendant l'exécution du programme. Cette fenêtre peut également être utilisée
dans Filegen pour rechercher des fichiers de sauvegarde en série)

Devis:

#LOG
---- Active la
journalisation des commandes exécutées.
Les commandes apparaîtront dans la fenêtre du journal OllyDbg et seront préfixées par -->
Exemple :
#log

Remarque : Cette commande affichera les commandes du script qu'elle a exécuté dans la fenêtre Log

LOG src
----- --
Journaux src dans la fenêtre du journal OllyDbg.
Si src est une chaîne constante, la chaîne est enregistrée telle quelle.
Si src est une variable ou enregistrez-la avec son nom.
Exemple :
log "Hello world" // La chaîne "Hello world" est enregistrée
var x
mov x, 10
log x // La chaîne "x = 0000010" est enregistrée.

Résumé:

Devis:

#LOG, LOG

Commandes xvi-Gets :

ces commandes servent principalement à obtenir des informations à partir des données que nous
fournissons

Devis:

GN addr
-------
Obtient le nom symbolique de l'adresse spécifiée (ex l'API vers laquelle il pointe)
Définit la variable réservée $RESULT
Exemple :
gn 401000

GPA proc, lib

------------ -
Obtient l'adresse de la procédure spécifiée dans la bibliothèque spécifiée.
Lorsqu'il est trouvé, définit la variable réservée $RESULT. $RESULT == 0 si rien n'a été trouvé.
Utile pour définir des points d'arrêt sur les API.
Exemple :
gpa "MessageBoxA", "user32.dll" // Après ce $RESULT est l'adresse de MessageBoxA et vous pouvez
faire "bp $RESULT".

GMI addr, info

--------------
Obtient des informations sur un module auquel appartient l'adresse spécifiée.
"info" peut être MODULEBASE, MODULESIZE, CODEBASE ou CODESIZE (si vous voulez d'autres
informations dans les futures versions, veuillez me le dire).
Définit la variable réservée $RESULT (0 si les données ne sont pas trouvées).
Exemple :
GMI eip, CODEBASE // Après ce $RESULT est l'adresse de la base de code du module auquel eip
appartient

Résumé:

Devis:
Ces nouvelles commandes sont géniales. Je résume comme suit
GN : L'application obtient le nom de la fonction API à l'adresse spécifiée
GPA : L'application obtient l'adresse d'une certaine fonction API pour mettre le pb à cette adresse
GMI : Voir les informations sur le module qui eip (ou un adrr) pointe. Plusieurs fois, le grave besoin de
craquer n'est pas dans le fichier exe mais dans le fichier dll. Nous utilisons cette commande pour obtenir
des informations sur le module

Instructions xvii-transfert

(déplacement deexécution d'une certaine étiquette dans le fichier script du script):

Il y2 états à distinguer:
-Breakpoint (Breakpoint Olly):utilisateur forcé interruptions: forcé
-Exception (la protestation de Olly): Interruptions protesté par Olly.
Ces instructions interfèrent avec les 2 états d'interruption ci-dessus. Le but principal de ces instructions est
de dire au script, lorsqu'une interruption se produit, de laisser l'interruption continuer l'exécution (COB,
COE) ou de sauter à un certain script pour continuer l'exécution (EOB, EOE). Ainsi, lors de l'écriture d'un
script, cette commande peut être placée n'importe où avant la pause que nous avons l'intention de traiter.

Devis:

Etiquette EOB
---------
Exécution de transfert vers une étiquette au prochain point d'arrêt.
Exemple :
eob SOME_LABEL Etiquette

EOE
---------
Transférer l'exécution vers une étiquette lors de la prochaine exception.
Exemple :
eob SOME_LABEL
COB
---
Fait continuer l'exécution du script après qu'un point d'arrêt s'est produit (supprime EOB)
Exemple :
COB

COE
---
Fait continuer l'exécution du script après qu'une exception s'est produite (supprime EOE)
Exemple :
COE

Résumé:

Devis:

EOB, EOE, COB, COE

xiii- Commandes
exécutives dans Script : commandes simples et anciennes, je ne traduis pas, uniquement de nouvelles
commandes

Devis:

Fichier #INC
---------
Inclut un fichier de script dans un autre fichier de script
Exemple :
#inc "anotherscript.txt"
CMT addr, text
--------------
Insère un commentaire à l'adresse indiquée
Exemple :
cmt eip, "Ceci est le point d'entrée"
RET
---
Quitte le script.
Exemple:
ret
DBH
---
Hides débogueur
Exemple:
DHP

DBS
---
Unhides débogueur
Exemple:
Dbs

EVAL
----
Objectif: Combiner une chaîne avec une valeur calculée dans un nouveau jeu de chaîne dans la variable $
result

Évalue une expression de chaîne qui contient des variables.

Les variables déclarées dans le script courant peuvent être mises entre accolades {} pour être insérées.
Définit la variable réservée $RESULT
Exemple :
var x
mov x, 1000
eval "La valeur de x est {x}" // après ce $RESULT est "La valeur de x est 00001000"

EXEC/ENDE
------- --
Le but de ces instructions est d'interférer avec l'exécution d'Olly, comme changer une valeur de registre,
ou quitter le processus d'exécution.

Exécute les instructions entre EXEC et ENDE dans le contexte du processus cible.
Les valeurs entre accolades {} sont remplacées par leurs valeurs.
Exemple :
// Cela fait quelques mouvements
var x
var y
mov x, "eax"
mov y, "0DEADBEEF"
exec
mov {x}, {y} // mov eax, 0DEADBEEF sera exécuté
mov ecx, {x} // mov ecx, eax sera exécuté
ende
// Ceci appelle ExitProcess dans l'application déboguée
exec
push 0
call ExitProcess
ende
ret

GO addr
-------
Exécute à l'adresse spécifiée (comme G dans SoftIce)
Exemple :
go 401005

Intégration avec d'autres plugins

--- -------- ----------------------
Vous pouvez appeler OllyScript depuis votre plugin et lui faire exécuter un script.
Utilisez quelque chose comme le code source ci-dessous :
(Vous pouvez appeler OllScript depuis votre plugin et lui faire exécuter un script. Nous utilisons cette
fonction :)

HMODULE hMod = GetModuleHandle("OllyScript.dll");

if(hMod) // Vérifier que l'autre plugin est présent et chargé
{
// Récupère l'adresse de la fonction exportée
int (*pFunc)(char*) = (int (*)(char*)) GetProcAddress(hMod, "ExecuteScript" );
if(pFunc) // Vérifiez que l'autre plugin exporte la bonne fonction
pFunc("myscript.txt"); // Exécuter la fonction exportée
}

Résumé:

Devis:

#INC,CMT,RET,DBH,DBS, EXEC/ENDE,EVAL,GO, HMODULE

C'est la fin de ce TUT. Benina espère qu'à travers ce TUT, les crackers écriront beaucoup de beaux scripts.

Plugin de ligne de commande

Bienvenue, après avoir fait connaissance avec Olly pendant un certain temps, j'aimerais aujourd'hui vous
présenter un plugin tout aussi important d'Olly, qui est le Command Line Plugin . Bien qu'il existe de
nombreuses fonctionnalités limitées, ce plugin nous fournit toujours toutes les fonctionnalités qu'un
programme de débogage devrait avoir. Mais en retour, le code source de ce plugin est ouvert, il nous
permet donc d'ajouter de nouvelles commandes et il nous permet également de modifier la fonctionnalité
des commandes existantes. Cet article est traduit à partir du fichier d'aide, dans l'espoir de fournir quelques
informations, ainsi que les fonctions de base de ce plugin.

Comme nous le savons tous, pour appeler ce plugin dans Olly, nous utilisons le raccourci suivant : Alt +
F1. Actuellement, selon la documentation dont je dispose, ce plugin prend en charge les déclarations
suivantes :

1. Expressions (Expressions) :

Code:

Expression CALC : Calcule la valeur d'une expression

? expression : Identique à ci-dessus
expression (le premier caractère ne peut pas être une lettre) : comme ci-dessus
WATCH expression : Surveiller, observer une expression
Expression W : Similaire

2. Missions :

Code:

SET reg=expression : Ecrit la valeur de l'expression dans le registre général 8, 16

ou 32 bits
reg=expression : Similaire
SET memory=expression : Écrire la valeur de l'expression dans la mémoire 8, 16 ou 32
bits

3. Désassembleur :

Code:

AT expression : Gardez une trace de l'adresse dans la fenêtre du désassembleur

FOLLOW expression : Similaire
ORIG : Accéder au registre EIP actuel
* : le même, similaire

4. Vider et empiler :

Code:

Expression D : Suivre une adresse dans la fenêtre Dump.

Expression DUMP : Similaire
DA [expression] : Dump en assembleur
DB [expression] : Dump en octets (hexa)
DC [expression] : Vider en tant que texte ASCII
DD [expression] : Vider en tant qu'adresse (s'applique à la pile)
DU [expression] : Vider en tant que texte Unicode
DW [expression] : Dump in word (hexa)
Expression STK : Traçage d'une adresse dans la pile

5. Assemblage :

Code:

Une expression [,commande] : Assembler à une adresse

6. Libellés et commentaires (Commandes liées aux libellés et aux commentaires) :

Code:

L expression, label : Attribuer un label à une adresse

Expression C, commentaire : Attribuer des commentaires à une adresse

7. Commandes de point d'arrêt (commandes liées au placement de BP dans Olly) :

Code:

BP expression [,condition] : Définir le point d'arrêt INT3 à l'adresse

Libellé BPX : Définir un point d'arrêt sur toutes les fonctions d'appel.
Expression BC : Effacer la consigne BP à l'adresse
MR expression1 [,expression2] : Définir un BP comme mémoire lors de l'accès sur une
certaine plage
MW expression1 [,expression2] : Définir un BP comme mémoire en écriture sur une
certaine plage
MD : Effacer le point de consigne de la mémoire BP
Expression HR : Mettre BP 1 octet en hardware sur formulaire d'accès sur une adresse
Expression matérielle : Mettez BP 1 octet sous forme de matériel en écriture à une
adresse
Expression HE : Mettre un BP de la forme hardware en exécution sur une adresse
HD [expression] : Supprimer la consigne BP matérielle à une adresse

8. Commandes de traçage (commandes liées au code de trace dans Olly) :

Code:

STOP : Suspendre l'exécution

PAUSE : Similaire
RUN : Exécuter le programme
G [expression] : Exécutez le programme à une certaine adresse
GE [expression] : Ignorer les exceptions pour contrôler et exécuter à une certaine
adresse
 
S : Sauter à l'intérieur d'une fonction
SI : Similaire
SO : Sauter par dessus une fonction
T [expression] : trace à l'intérieur d'une fonction jusqu'à une certaine adresse
TI [expression] : similaire
TO [expression] : tracer une fonction jusqu'à une adresse
Condition TC : Trace à l'intérieur d'une fonction jusqu'à une certaine condition
Condition TOC : Trace à travers une fonction jusqu'à une certaine condition
TR : Exécuter jusqu'au Retour
TU : Exécuter jusqu'au code utilisateur

9. Fenêtres OllyDbg (Commandes liées aux fenêtres) :

Code:

LOG : Afficher la fenêtre Log      

MOD : Afficher la fenêtre de l'exécutable
MEM : Afficher la fenêtre Mémoire
CPU : Afficher la fenêtre CPU
CS : fenêtre Afficher la pile d'appels
BRK : Afficher la fenêtre Points de rupture .
OPT : fenêtre d'options d'affichage

10. Commandes diverses (Autres commandes) :

Code:

SORTIE : Fermer OllyDbg

QUITTER : Similaire
OUVRIR [nom de fichier] : ouvrir un fichier pour le débogage (fichier exécutable ou
dll)
FERMER : Fermez le programme en cours de débogage
RST : Redémarrez le programme en cours de débogage
HELP : Ouvre l'aide du plug-in de ligne de commande
AIDE OllyDbg : Ouvre la fenêtre d'aide d'Olly
HELP APIfunction : Ouvre la fenêtre d'aide de la fonction API

Les commandes utilisées dans le plug-in de ligne de commande ne sont pas sensibles à la casse, les
paramètres entre crochets sont facultatifs. Les expressions peuvent inclure des constantes, des registres et
des références de mémoire, et prennent en charge toutes les opérations arithmétiques de base et les
fonctions booléennes. Par défaut, toutes les constantes sont au format Hexa. Pour représenter les constantes
sous forme décimale, il est accompagné d'un point décimal. Par exemple :

Code:

1. 2 + 2        : Calculer la valeur de l'expression (Addition en Hexa) ;

 
2.  2.0 + 2.0 : Calculer la valeur de l'expression (Ajouter en décimal) ;
 
3. AT [EAX+10] : démonter à l'adresse qui est le contenu de Dw mem à l'adresse EAX +
0x10 ;
 
4. BP KERNEL32.GetProcAddress  : Placez un BP sur la fonction API. Notez que vous
pouvez mettre un BP dans le fichier Dll du système, mais uniquement pour les systèmes
d'exploitation NT ;
 
5. BPX GetProcAddress  : définit BP sur tous les appels API GetProcAddress ;
 
6.  BP 412010,EAX==WM_CLOSE : Placer un BP Conditionnel à l'adresse 0x412010. Le
programme s'arrêtera lorsque la valeur de EAX = WM_CLOSE ;

Auteurs:

Moonbaby

Bénin

Kienmanowar