Aller au contenu
Encyclopédie informatique Édition 2026

L'assembleur

Partie 6 sur 6

Niveau de lecture :

13Lire ce que produit un compilateur

La meilleure façon d’apprendre à lire l’assembleur est de regarder ce que fait un compilateur. Prenons deux fonctions en C (voir le langage C) :

int carre(int x) { return x * x; }

int somme(int n) {
    int s = 0;
    for (int i = 1; i <= n; i++) s += i;
    return s;
}

Compilées par GCC avec une optimisation modérée pour x86-64 (commande gcc -O1 -S -masm=intel), elles donnent, en omettant les lignes de décoration :

carre:
    imul  edi, edi        ; edi = edi * edi   (le paramètre x est arrivé dans edi)
    mov   eax, edi        ; le résultat doit être dans eax pour être rendu
    ret                   ; retour à l'appelant

somme:
    test  edi, edi        ; n est-il nul ou négatif ? (met à jour les indicateurs)
    jle   .vide           ; si oui, sauter vers le cas « boucle vide »
    add   edi, 1          ; edi = n + 1 : borne de fin de la boucle
    mov   eax, 1          ; eax = i, le compteur, commence à 1
    mov   edx, 0          ; edx = s, le total, commence à 0
.boucle:
    add   edx, eax        ; s = s + i
    add   eax, 1          ; i = i + 1
    cmp   eax, edi        ; i a-t-il atteint n + 1 ?
    jne   .boucle         ; sinon, recommencer
.fin:
    mov   eax, edx        ; le total devient le résultat
    ret
.vide:
    mov   edx, 0          ; cas n <= 0 : total nul
    jmp   .fin            ; aller rendre le résultat

On reconnaît tout ce que cet article a présenté : un paramètre arrivé dans EDI selon la convention, des registres utilisés comme variables, une comparaison suivie d’un saut conditionnel, un résultat rendu dans EAX, une instruction RET qui dépile l’adresse de retour. À noter que le compilateur a transformé la boucle « de 1 à n » en une boucle « jusqu’à n + 1 avec comparaison d’égalité », plus économe, et qu’il a inversé le test d’entrée pour traiter à part le cas où n est nul ou négatif. Ces astuces sont typiques : lire le code produit apprend ce que le compilateur sait faire, et pourquoi il vaut mieux lui laisser le travail.

14Assembleur et sécurité

L’assembleur est le niveau auquel se jouent beaucoup de questions de sécurité, parce que c’est celui où la mémoire n’a plus de sens autre que les octets qu’elle contient.

14.1Les failles de mémoire

La pile contient côte à côte les variables locales des fonctions et les adresses de retour (partie 10). Si un programme écrit dans un tableau local plus de données qu’il n’en peut contenir, les octets en trop écrasent ce qui se trouve à côté, parfois l’adresse de retour. Au moment du RET, le processeur saute alors à une adresse choisie par celui qui a fourni les données, et non à celle de l’appelant. C’est le principe du débordement de tampon (buffer overflow), la famille de failles qui a permis, depuis les années 1980, une grande partie des prises de contrôle de programmes (voir les vulnérabilités). Les langages qui gèrent eux-mêmes la mémoire (Python, Java, Rust dans son mode sûr) rendent cette faille beaucoup plus difficile ; le C et le C++, qui laissent le programmeur libre, y restent exposés.

14.2Les défenses modernes

Plusieurs protections se sont empilées, et leur raison d’être se comprend avec ce qui précède :

  • le canari de pile (stack canary) : le compilateur place une valeur secrète entre les variables locales et l’adresse de retour et la vérifie avant de rendre la main ; un débordement la modifie et déclenche l’arrêt du programme ;
  • la pile non exécutable (souvent appelée NX ou DEP) : les zones de données sont marquées comme non exécutables, de sorte que du texte envoyé dans un tampon ne peut pas être lancé comme du code ;
  • l’ASLR (Address Space Layout Randomization, répartition aléatoire de l’espace d’adressage) : le système place le code, la pile et les bibliothèques à des adresses différentes à chaque lancement, ce qui empêche de prévoir où sauter ;
  • les piles fantômes matérielles (par exemple la technologie CET d’Intel) : le processeur garde une seconde copie des adresses de retour, dans un espace protégé, et vérifie qu’elles concordent.

Aucune n’est absolue, et leur combinaison a rendu l’exploitation beaucoup plus coûteuse. La meilleure défense reste d’éviter la faille : langage sûr pour la mémoire, vérification des tailles, analyses automatiques, mises à jour (voir les vulnérabilités).

14.3Lire du code qu’on n’a pas écrit

L’analyste qui reçoit un fichier suspect ne dispose pas du code source : il dispose des octets. Il utilise un désassembleur pour les relire en instructions, un débogueur pour les suivre pas à pas dans un environnement isolé, et l’on parle d’analyse de logiciel malveillant (voir les logiciels malveillants). La connaissance de l’assembleur lui permet de repérer ce que fait un programme : appels au système d’exploitation, accès au réseau, chiffrement. La rétro-ingénierie est encadrée par la loi : en France comme dans l’Union européenne, la décompilation d’un logiciel n’est permise que dans des cas limités (notamment pour assurer l’interopérabilité), et l’analyse de logiciels malveillants s’inscrit dans un cadre professionnel et contractuel.

14.4Quand le temps d’exécution trahit des secrets

Une dernière raison de s’intéresser au niveau machine : deux programmes qui donnent le même résultat ne se comportent pas pareil. Un calcul qui dure plus ou moins longtemps selon une valeur secrète (par exemple selon la clé de chiffrement), ou qui laisse des traces dans la mémoire rapide du processeur, peut permettre à un observateur de déduire la valeur. Les bibliothèques de chiffrement sont donc écrites, ou vérifiées, pour s’exécuter en un temps indépendant des données secrètes ; certaines parties critiques sont même écrites en assembleur pour que le compilateur ne réintroduise pas de différences. De la même façon, les failles dites d’exécution spéculative (des erreurs de conception de processeurs découvertes en 2018) ont montré que même un programme correct peut laisser fuiter des informations par la façon dont le processeur anticipe ses sauts.

15Ce qui a changé, et les erreurs à éviter

  • Les idées tiennent : registres, instructions à code opération et opérandes, modes d’adressage, indicateurs, sauts, pile, procédures. Elles s’appliquent à tous les processeurs, au prix d’un changement de vocabulaire.
  • Le processeur choisi n’est plus celui des machines actuelles : les ordinateurs sont en 64 bits (x86-64) et les téléphones en ARM. Les registres ont des noms plus longs et sont plus nombreux, et les appels de fonctions passent par des conventions.
  • Erreurs courantes corrigées ici : les adresses en octets (octet de poids faible en premier) ; la taille d’une instruction x86 (1 à 15 octets, pas 1 à 8) ; l’adressage direct et indirect copient le contenu d’une case, pas son adresse ; AND n’« additionne » pas ; la taille d’un JMP (2 octets, pas 1 bit) et le calcul de son déplacement ; JLE signifie inférieur ou égal ; CMP positionne tous les indicateurs ; la division par 2n se fait par décalage et non par rotation ; la segmentation donne une adresse de 20 bits et non de 32 bits.
  • La segmentation a disparu en pratique au profit d’un espace plat et de la mémoire virtuelle.
  • Les outils ont changé : NASM et GAS ont largement remplacé MASM et les directives ASSUME ; les débogueurs et Compiler Explorer facilitent l’apprentissage.
  • La sécurité a pris une place centrale, avec les canaris de pile, la mémoire non exécutable, l’ASLR et les piles fantômes, ainsi que l’analyse de logiciels malveillants.
Sécurité de l’information

Le coin cyber

Cet article explique comment les programmes s’exécutent et pourquoi certaines erreurs de mémoire sont dangereuses. Il ne contient aucun code d’exploitation, aucune méthode pour contourner les protections, ni aucun programme malveillant ; les exemples sont des programmes inoffensifs.

C.1Pourquoi une faille de mémoire est grave

Dans un programme en langage machine, rien ne distingue une donnée d’une adresse : ce sont des octets. Si un programme laisse un utilisateur écrire plus de données qu’il n’a prévu de place, l’utilisateur peut modifier ce qui contrôle le déroulement du programme (adresses de retour, pointeurs). Le défaut vient donc du code qui ne vérifie pas les tailles, et non d’une mauvaise manipulation de l’utilisateur. Le plus ancien exemple célèbre est un ver informatique de 1988 qui s’est propagé en exploitant un débordement de ce type dans un service d’Unix ; depuis, des familles entières de logiciels malveillants s’appuient sur des failles analogues.

C.2Lire pour défendre

L’analyse de code machine est un métier de la défense : analystes de logiciels malveillants, équipes de réponse aux incidents, chercheurs en vulnérabilités qui signalent une faille aux éditeurs avant sa publication (« divulgation coordonnée »). Cette pratique suppose un cadre : autorisation écrite pour toute analyse de logiciel qui n’est pas le sien, laboratoire isolé du réseau, et respect de la loi sur l’accès frauduleux aux systèmes.

C.3Idée reçue

« Le code compilé est illisible, donc mon secret est en sécurité dedans. » Faux. Un programme compilé se désassemble en quelques secondes, et un analyste patient en comprend la logique. Une clé, un mot de passe ou un algorithme « caché » dans un exécutable finit par être retrouvé. Les secrets doivent être gardés hors du code (coffre à secrets, variables d’environnement, matériel dédié), et la sécurité d’un système ne doit pas reposer sur le fait que son fonctionnement soit inconnu.

C.4Bonnes pratiques

Développeur

  • Préférer un langage qui contrôle les tailles et les accès à la mémoire quand c’est possible ; en C et C++, vérifier toute taille issue de l’extérieur et activer les protections du compilateur.
  • Garder activés le canari de pile, la mémoire non exécutable et l’ASLR ; compiler avec les options d’analyse et de renforcement.
  • Ne jamais enfouir de secret dans un programme distribué.

Organisation

  • Appliquer rapidement les correctifs, sur les systèmes comme sur les programmes tiers.
  • Réaliser l’analyse de fichiers suspects dans un environnement isolé, par des personnes formées et autorisées.
  • Organiser la réception des signalements de failles (adresse de contact, politique de divulgation).

Référentiels : CWE-787 (écriture hors limites) et CWE-121 (débordement de tampon sur la pile) · Intel, Software Developer’s Manual · System V ABI pour x86-64 · ANSSI, règles de développement sécurisé · Code de la propriété intellectuelle, article L122-6-1 (exceptions aux droits sur les logiciels).

Références

  1. Intel, Intel 64 and IA-32 Architectures Software Developer’s Manual.
  2. M. Matz, J. Hubička, A. Jaeger, M. Mitchell, System V Application Binary Interface, AMD64 Architecture Processor Supplement.
  3. Microsoft, x64 calling convention, documentation.
  4. Documentation de NASM, The Netwide Assembler.
  5. MITRE, CWE-121 : Stack-based Buffer Overflow.
  6. E. H. Spafford, The Internet Worm Program : An Analysis, Purdue Technical Report, 1988.
  7. P. Kocher et coll., Spectre Attacks : Exploiting Speculative Execution, 2018.

Voir aussi

Citer cet article

« L'assembleur », Encyclopédie informatique, révision du 4 novembre 2026.