ROP, JOP, SROP : recycler le code
pour gagner

Prérequis

• Compréhension des fichiers ELF (voir Segmentation Mémoire)
• Maniement de GDB

Hello ! o/

Les Code Reuse Attacks (CRA) sont la famille d'attaques qui consiste à réutiliser du code déjà chargé en mémoire pour faire ce qu'on veut, sans jamais injecter de nouveau code. Plutôt que d'écrire un shellcode, on assemble des gadgets : de petites séquences d'instructions qui se terminent par une instruction de transfert de contrôle (ret, jmp, call...) et qu'on enchaîne pour construire un payload.

C'est la réponse technique aux protections comme NX (No eXecute) et DEP (Data Execution Prevention) qui empêchent d'exécuter du code dans des zones de données. Avec les CRA, tout le code utilisé est déjà marqué exécutable par l'OS.

La galaxie des Code Reuse Attacks

Voilà la carte du territoire : chaque famille se distingue par le type de gadget utilisé et l'instruction de transfert de contrôle sur laquelle elle s'appuie.

  CODE REUSE ATTACKS
  ┌──────────────────────────────────────────────────────────────────┐
  │  Pivot : RET          Pivot : JMP/CALL         Pivot : autre     │
  │  ─────────────────    ──────────────────────    ──────────────    │
  │                                                                  │
  │  ROP                  JOP / TOP                SROP              │
  │  Return-Oriented      Jump/Trampoline-          Sigreturn-        │
  │  Programming          Oriented Programming      Oriented Prog.    │
  │                                                                  │
  │  BROP                 COP                      LOP               │
  │  Blind ROP            Call-Oriented            Loop-Oriented     │
  │  (pas d'accès         Programming              Programming       │
  │   au binaire)                                                    │
  │                       PCOP                     SOP               │
  │                       Pure COP                 String-Oriented   │
  │                       (sans gadgets ret)        Programming       │
  │                                                                  │
  │                       COOP                                       │
  │                       Counterfeit-Object                         │
  │                       Oriented Programming                       │
  │                       (C++ vtables)                              │
  └──────────────────────────────────────────────────────────────────┘

ROP - Return-Oriented Programming

ROP (Return-Oriented Programming) est la technique fondatrice des Code Reuse Attacks. L'idée : enchaîner des petits bouts de code existants, appelés gadgets, chacun se terminant par un ret. On contrôle la pile pour définir l'ordre d'exécution, et on compose un payload complet sans écrire une seule instruction.

C'est le point d'entrée obligatoire de la série - un article dédié arrive.

JOP/TOP - Jump/Trampoline-Oriented Programming

JOP (Jump-Oriented Programming) remplace les ret par des jmp indirects. Le dispatcher est un gadget central qui lit la prochaine cible dans un registre ou une structure de données. TOP (Trampoline-Oriented Programming) est une variante qui utilise des trampolines pour sauter d'un gadget à l'autre, ce qui contourne les mécanismes qui surveillent les ret (shadow stack, retpoline...).

COP - Call-Oriented Programming

Même principe que JOP mais avec des call indirects comme instruction pivot. Utile quand les gadgets terminés par ret ou jmp sont rares ou filtrés.

PCOP - Pure Call-Oriented Programming

Variante de COP qui s'interdit tout gadget ret. Vise les binaires compilés avec des protections anti-ROP très agressives qui invalident tout retour de fonction anormal.

COOP - Counterfeit-Object Oriented Programming

COOP exploite la mécanique des vtables C++. On forge de faux objets dont les vtables pointent vers des fonctions membres légitimes (les vfgadgets) pour construire un payload. Particulièrement redoutable contre les CFI (Control Flow Integrity) basiques qui autorisent les appels via vtables sans vérifier la légitimité de l'objet.

LOP - Loop-Oriented Programming

LOP tire parti de gadgets contenant des boucles (loop, rep, jne...) pour accélérer des opérations répétitives dans un payload ou pour contourner des filtres qui détectent les gadgets de type ret.

SOP - String-Oriented Programming

SOP réutilise les effets de bord des fonctions de manipulation de chaînes de la libc ( strcpy, memcpy, sprintf...) pour écrire en mémoire ou déclencher des comportements utiles, sans passer par des gadgets assembleur classiques.

SROP - SigReturn-Oriented Programming

SROP est élégant : il abuse du mécanisme de retour de signal Linux. Quand le noyau revient d'un gestionnaire de signal, il restaure le contexte CPU complet depuis la pile via un appel à sigreturn. Si on contrôle la pile, on peut y écrire un faux contexte (sigcontext) avec les valeurs de registres qu'on veut, et déclencher sigreturn pour charger ce contexte d'un coup. Un seul gadget, contrôle total de tous les registres.

BROP - Blind Return-Oriented Programming

BROP, c'est le ROP sans carte. On n'a pas accès au binaire, pas de symboles, parfois pas même un crash dump. On exploite un service réseau qui crash et redémarre (fork-based server) : en sondant des adresses une par une et en observant le comportement (crash / no-crash / output), on cartographie les gadgets disponibles puis on construit un payload ROP classique.

  BROP - sondage blind

  Attaquant                    Serveur (fork-based)
     │                              │
     │   overflow + addr_X          │
     │─────────────────────────────►│
     │                              │ crash ? no-crash ?
     │◄─────────────────────────────│
     │   (timeout = crash)          │
     │                              │
     │   overflow + addr_X+1        │
     │─────────────────────────────►│
     │                              │ ...on itère
     │◄─────────────────────────────│
     │                              │
     │   addr trouvée = gadget ?    │
     │   ─────────────────────────  │
     │   test avec registres connus │
     │─────────────────────────────►│
     │                              │
     ▼                              ▼
  carte des gadgets disponibles construite