UAL-FR Assembly Language

_ _ _ _ _ _
| | | |_ __ __| | ___ _ __ ___| |_ __ _ _ __ __| (_)_ __ __ _
||||'_\/_`|/_\'__/__|__/_`|'_\/_`||'_\/_`|
||_|||||(_|| __/| \__\||(_|||||(_||||||(_||
\___/|_| |_|\__,_|\___|_| |___/\__\__,_|_| |_|\__,_|_|_| |_|\__, |
|___/
_ _ _
/ \ ___ ___ ___ _ __ ___ | |__ | |_ _
/_\/__/__|/_\'_`_\|'_\|||||
/ ___ \\__ \__ \ __/ | | | | | |_) | | |_| |
/_/ \_\___/___/\___|_| |_| |_|_.__/|_|\__, |
|___/
_
| | __ _ _ __ __ _ _ _ __ _ __ _ ___
|| /_`|'_\/_`||||/_`|/_`|/_\
| |__| (_| | | | | (_| | |_| | (_| | (_| | __/
|_____\__,_|_| |_|\__, |\__,_|\__,_|\__, |\___|
|___/ |___/

Comprendre le langage d’assemblage
(Rétro-ingénierie pour Débutants)
Pourquoi deux titres? Lire ici: on page xiii.
Dennis Yurichev
<[email protected]>
cba
©2013-2020, Dennis Yurichev.
Ce travail est sous licence Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0).
Pour voir une copie de cette licence, rendez vous sur
https://creativecommons.org/licenses/by-sa/4.0/.
Version du texte (14 août 2020).
La dernière version (et l’édition en russe) de ce texte est accessible sur beginners.re.
A la recherche de traducteurs !
Vous souhaitez peut-être m’aider en traduisant ce projet dans d’autres langues, autres que l’anglais et le
russe. Il vous sut de m’envoyer les portions de texte que vous avez traduites (peu importe leur longueur)
et je les intégrerai à mon code source LaTeX.
Lire ici.
Les statistiques par langage sont disponible ici: https://beginners.re/.
La vitesse de traduction n’est pas importante, puisqu’il s’agit d’un projet open-source après tout. Votre
nom sera mentionné en tant que contributeur au projet. Les traductions en coréen, chinois et persan sont
réservées par mes éditeurs.
Les versions anglaise et russe ont été réalisées par moi-même. Toutefois, mon anglais est toujours horrible
et je vous serais très reconnaissant pour toute éventuelle remarque sur la grammaire, etc... Même mon
russe est imparfait, donc je vous serais également reconnaissant pour toute remarque sur la traduction
en russe !
N’hésitez donc pas à me contacter : <[email protected]> / <[email protected]>.
i

Contenus abrégés
1 Pattern de code 1
2 Fondamentaux importants 449
3 Exemples un peu plus avancés 471
4 Java 664
5 Trouver des choses importantes/intéressantes dans le code 698
6 Spécique aux OS 733
7 Outils 789
8 Études de cas 793
9 Exemples de Reverse Engineering de format de chier propriétaire 920
10 Dynamic binary instrumentation 984
11 Autres sujets 992
12 Livres/blogs qui valent le détour 1011
13 Communautés 1014
Épilogue 1016
Appendice 1018
Acronymes utilisés 1046
Glossaire 1051
Index 1053
ii

Table des matières
1 Pattern de code 1
1.1 La méthode ..................................................... 1
1.2 Quelques bases ................................................... 2
1.2.1 Une courte introduction sur le CPU .................................. 2
1.2.2 Systèmes de numération ........................................ 3
1.2.3 Conversion d’une base à une autre .................................. 3
1.3 Fonction vide .................................................... 5
1.3.1 x86 ...................................................... 6
1.3.2 ARM ...................................................... 6
1.3.3 MIPS ...................................................... 6
1.3.4 Fonctions vides en pratique ....................................... 6
1.4 Valeur de retour .................................................. 7
1.4.1 x86 ...................................................... 7
1.4.2 ARM ...................................................... 8
1.4.3 MIPS ...................................................... 8
1.4.4 En pratique ................................................. 8
1.5 Hello, world! ..................................................... 8
1.5.1 x86 ...................................................... 9
1.5.2 x86-64 .................................................... 14
1.5.3 ARM ...................................................... 18
1.5.4 MIPS ...................................................... 24
1.5.5 Conclusion .................................................. 28
1.5.6 Exercices ................................................... 28
1.6 Fonction prologue et épilogue ......................................... 29
1.6.1 Récursivité ................................................. 29
1.7 Une fonction vide: redux ............................................. 29
1.8 Renvoyer des valeurs: redux .......................................... 29
1.9 Pile ........................................................... 30
1.9.1 Pourquoi la pile grandit en descendant ? .............................. 30
1.9.2 Quel est le rôle de la pile? ....................................... 31
1.9.3 Une disposition typique de la pile .................................. 37
1.9.4 Bruit dans la pile .............................................. 37
1.9.5 Exercices ................................................... 41
1.10 Fonction presque vide .............................................. 41
1.11 printf() avec plusieurs arguments ...................................... 42
1.11.1 x86 ..................................................... 42
1.11.2 ARM ..................................................... 53
1.11.3 MIPS ..................................................... 58
1.11.4 Conclusion ................................................. 64
1.11.5 À propos .................................................. 65
1.12 scanf() ........................................................ 66
1.12.1 Exemple simple .............................................. 66
1.12.2 Erreur courante .............................................. 75
1.12.3 Variables globales ............................................ 76
1.12.4 scanf() ................................................... 85
1.12.5 Exercice .................................................. 96
1.13 Intéressant à noter: variables globales vs. locales ............................ 96
1.14 Accéder aux arguments passés ........................................ 97
1.14.1 x86 ..................................................... 97
1.14.2 x64 ..................................................... 99
1.14.3 ARM .....................................................102
1.14.4 MIPS .....................................................105
1.15 Plus loin sur le renvoi des résultats .....................................106
iii

1.15.1 Tentative d’utilisation du résultat d’une fonction renvoyant void ..............106
1.15.2 Que se passe-t-il si on n’utilise pas le résultat de la fonction? ................107
1.15.3 Renvoyer une structure ........................................108
1.16 Pointeurs ......................................................109
1.16.1 Renvoyer des valeurs ..........................................109
1.16.2 Échanger les valeurs en entrée ...................................119
1.17 Opérateur GOTO .................................................120
1.17.1 Code mort .................................................123
1.17.2 Exercice ..................................................124
1.18 Sauts conditionnels ...............................................124
1.18.1 Exemple simple .............................................124
1.18.2 Calcul de valeur absolue ........................................141
1.18.3 Opérateur conditionnel ternaire ...................................143
1.18.4 Trouver les valeurs minimale et maximale ............................146
1.18.5 Conclusion .................................................151
1.18.6 Exercice ..................................................152
1.19 Déplombage de logiciel .............................................152
1.20 Blague de l’arrêt impossible (Windows 7) .................................154
1.21 switch()/case/default ..............................................154
1.21.1 Petit nombre de cas ...........................................154
1.21.2 De nombreux cas ............................................168
1.21.3 Lorsqu’il y a quelques déclarations case dans un bloc .....................180
1.21.4 Fall-through ................................................184
1.21.5 Exercices ..................................................185
1.22 Boucles .......................................................185
1.22.1 Exemple simple ..............................................185
1.22.2 Routine de copie de blocs de mémoire ...............................196
1.22.3 Vérication de condition ........................................199
1.22.4 Conclusion .................................................200
1.22.5 Exercices ..................................................201
1.23 Plus d’information sur les chaînes ......................................202
1.23.1 strlen() ...................................................202
1.23.2 Limites de chaînes ............................................213
1.24 Remplacement de certaines instructions arithmétiques par d’autres ................213
1.24.1 Multiplication ...............................................213
1.24.2 Division ...................................................218
1.24.3 Exercice ..................................................219
1.25 Unité à virgule ottante .............................................219
1.25.1 IEEE 754 ..................................................219
1.25.2 x86 .....................................................219
1.25.3 ARM, MIPS, x86/x64 SIMD .......................................220
1.25.4 C/C++ ...................................................220
1.25.5 Exemple simple ..............................................220
1.25.6 Passage de nombres en virgule ottante par les arguments .................230
1.25.7 Exemple de comparaison .......................................232
1.25.8 Quelques constantes ..........................................266
1.25.9 Copie ....................................................266
1.25.10 Pile, calculateurs et notation polonaise inverse ........................266
1.25.11 80 bits? ..................................................266
1.25.12 x64 .....................................................266
1.25.13 Exercices .................................................266
1.26 Tableaux ......................................................266
1.26.1 Exemple simple ..............................................267
1.26.2 Débordement de tampon .......................................274
1.26.3 Méthodes de protection contre les débordements de tampon ................282
1.26.4 Encore un mot sur les tableaux ...................................285
1.26.5 Tableau de pointeurs sur des chaînes ................................286
1.26.6 Tableaux multidimensionnels .....................................293
1.26.7 Ensemble de chaînes comme un tableau à deux dimensions ................300
1.26.8 Conclusion .................................................304
1.26.9 Exercices ..................................................304
1.27 Exemple: un bogue dans Angband ......................................304
1.28 Manipulation de bits spéciques .......................................306
1.28.1 Test d’un bit spécique .........................................307
iv