Fuzzing Assisté par IA : Découverte de Vulnérabilités

Figure 1 — Pipeline de fuzzing assisté par IA : boucle de rétroaction ML avec génération de corpus LLM, mutation intelligente et triage automatisé

3 Génération de Corpus et Harnesses par LLM

La génération de corpus par LLM transforme l'étape la plus chronophage du fuzzing en un processus quasi-automatique. Traditionnellement, constituer un bon corpus de seeds nécessitait des jours de collecte manuelle d'échantillons représentatifs, de minimisation et de validation. Les LLM permettent de générer en quelques minutes des centaines de fichiers de test diversifiés, couvrant à la fois les cas normaux, les edge cases et les entrées pathologiques que les corpus manuels omettent systématiquement.

Comprendre les formats complexes : PDF, XML, protobuf

Les LLM comme GPT-4 et Claude ont été entraînés sur d'immenses corpus documentaires incluant les spécifications techniques des formats de fichiers. Ils peuvent donc comprendre la structure syntaxique et sémantique de formats complexes comme PDF (avec ses objets indirects, ses streams compressés et ses cross-reference tables), XML (avec ses DTD, namespaces et schémas XSD), ou protobuf (avec ses champs typés et ses messages imbriqués). En demandant au LLM de « générer un fichier PDF minimal avec une page contenant un formulaire XFA et un JavaScript embarqué », on obtient un seed qui cible directement les parsers les plus complexes et les plus vulnérables.

Génération de seed corpus diversifiés et edge-case

La stratégie de génération optimale combine plusieurs types de prompts. Les prompts structurels demandent au LLM de générer des fichiers explorant différentes combinaisons de features du format (ex: « un JSON avec 50 niveaux d'imbrication, des clés Unicode, et des valeurs numériques aux limites de IEEE 754 »). Les prompts adversariaux ciblent explicitement les cas problématiques : « génère un XML avec des entités récursives, des namespaces conflictuels et des attributs dupliqués ». Les prompts de fuzzing historique s'appuient sur les bugs connus : « génère un fichier PNG similaire à celui qui a causé CVE-2023-XXXX dans libpng ». L'ensemble forme un corpus multi-dimensionnel de 500 à 2000 seeds qui surpasse systématiquement les corpus collectés manuellement.

Auto-génération de harnesses de fuzzing

La création automatique de fuzz targets (harnesses) par LLM est l'une des avancées les plus impactantes. Le processus fonctionne en plusieurs étapes : le LLM analyse le code source de la bibliothèque cible, identifie les fonctions d'entrée (parsers, décodeurs, handlers de protocole), comprend les préconditions (allocation mémoire, initialisation de contexte) et génère un wrapper C/C++ qui connecte la fonction LLVMFuzzerTestOneInput au code cible. Le projet OSS-Fuzz-Gen de Google a démontré que les harnesses générés par LLM compilent avec succès dans 92% des cas et atteignent en moyenne 78% de la couverture des harnesses écrits manuellement par des experts.

Mise en pratique et recommandations

import openai

# Prompt pour génération de harness via LLM
HARNESS_PROMPT = """
Analyse le code source suivant et génère un harness de fuzzing
compatible avec LibFuzzer (LLVMFuzzerTestOneInput).

Code source de la bibliothèque cible:
{source_code}

Exigences:
1. Inclure tous les headers nécessaires
2. Initialiser correctement le contexte
3. Appeler la fonction de parsing principale
4. Gérer la libération mémoire (pas de leaks)
5. Retourner 0 systématiquement
6. Ajouter des sanitizers hints si pertinent
"""

def generate_harness(source_code, target_function):
    """Génère un harness via LLM et le valide."""
    response = openai.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "system",
             "content": "Expert C/C++ fuzzing engineer"},
            {"role": "user",
             "content": HARNESS_PROMPT.format(
                 source_code=source_code)}
        ],
        temperature=0.2
    )
    harness_code = response.choices[0].message.content
    return harness_code

# Exemple de harness généré pour libxml2
GENERATED_HARNESS = '''
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <stdint.h>
#include <stddef.h>

int LLVMFuzzerTestOneInput(const uint8_t *data,
                           size_t size) {
    xmlDocPtr doc = xmlReadMemory(
        (const char *)data, size,
        "noname.xml", NULL,
        XML_PARSE_NONET | XML_PARSE_RECOVER
    );
    if (doc != NULL) {
        xmlFreeDoc(doc);
    }
    xmlCleanupParser();
    return 0;
}
'''

FuzzIntrospector + LLM pour couverture maximale

Google FuzzIntrospector est un outil d'analyse statique qui cartographie les fonctions d'une bibliothèque, calcule leur complexité cyclomatique, identifie la couverture actuelle du fuzzing et repère les « trous de couverture » critiques. En combinant FuzzIntrospector avec un LLM, le processus devient entièrement automatisé : FuzzIntrospector identifie les fonctions non couvertes les plus intéressantes (haute complexité, manipulation de mémoire, parsing d'entrées utilisateur), puis le LLM génère des harnesses spécifiques pour ces fonctions. Cette approche a permis d'augmenter la couverture moyenne des projets OSS-Fuzz de 30% en ciblant précisément les zones mortes identifiées par l'analyse statique.

• ▹Workflow automatisé : FuzzIntrospector analyse le projet → identifie les fonctions non fuzzées → le LLM génère un harness → compilation et test automatiques → intégration dans la campagne de fuzzing
• ▹Correction automatique : si le harness ne compile pas, le LLM analyse l'erreur de compilation, comprend le problème (header manquant, type incorrect, API mal utilisée) et régénère une version corrigée
• ▹Résultats OSS-Fuzz-Gen : en 2025-2026, le projet a généré automatiquement plus de 800 nouveaux harnesses pour des projets open source, découvrant 370+ bugs supplémentaires qui auraient été manqués par les harnesses existants
• ▹Limites actuelles : les harnesses LLM sont moins efficaces pour les API nécessitant une séquence complexe d'appels (state machines) ou une configuration d'environnement spécifique (fichiers de config, réseau, bases de données)

4 Mutation Intelligente et Apprentissage par Renforcement

Au coeur du fuzzing se trouve le moteur de mutation : l'algorithme qui décide comment transformer les entrées pour explorer de nouveaux chemins d'exécution. Les mutations classiques (bit flip, byte swap, arithmetic, dictionary-based) sont efficaces mais aveugles. L'intégration du machine learning dans le processus de mutation transforme cette exploration aléatoire en une recherche guidée, augmentant drastiquement l'efficacité du fuzzing en termes de couverture et de découverte de bugs par unité de temps de calcul.

Stratégies de mutation classiques vs ML-guided

Les fuzzers classiques comme AFL utilisent un ensemble fixe de stratégies de mutation : deterministic (walking bit flips, walking byte flips, simple arithmetics, known interesting integers) suivi d'un stage havoc (mutations aléatoires combinées). La sélection des stratégies est statique ou basée sur des heuristiques simples. Les fuzzers ML-guided remplacent cette logique par un modèle de décision appris. Un réseau de neurones observe l'état courant (seed sélectionné, bitmap de couverture, historique des mutations récentes) et prédit la combinaison de mutations la plus susceptible de produire une nouvelle couverture. L'apprentissage est continu : chaque cycle de fuzzing fournit de nouvelles données d'entraînement. Pour approfondir, consultez AI Act Aout 2025 : Premieres Sanctions Activees.

Neural network-based mutation scheduling

Le neural mutation scheduling utilise un réseau de neurones (typiquement un transformer léger ou un LSTM) pour prédire la probabilité qu'une mutation donnée produise une nouvelle couverture. Le modèle prend en entrée un vecteur de features incluant : la position dans le fichier, la valeur courante de l'octet, le contexte environnant (fenêtre de 16-64 octets), les branches couvertes par ce seed, et l'historique des mutations tentées. La sortie est une distribution de probabilités sur les actions possibles : quel type de mutation appliquer, à quelle position, avec quelle intensité. Les travaux de recherche (NeuFuzz, MTFuzz, PreFuzz) montrent des gains de 25 à 50% de couverture supplémentaire sur des benchmarks standardisés comme le LAVA-M et le Magma.

Reinforcement Learning pour la sélection de seeds

Le problème de seed scheduling (choisir quel input de la file d'attente fuzzer en priorité) se modélise naturellement comme un problème de multi-armed bandit ou de MDP (Markov Decision Process). L'agent RL doit équilibrer l'exploration (essayer des seeds peu testés) et l'exploitation (approfondir les seeds prometteurs). Des approches comme EcoFuzz (Thompson Sampling), RLFUZZ (Deep Q-Network) et PFUZZ (Proximal Policy Optimization) ont démontré des améliorations significatives. EcoFuzz, par exemple, réduit l'énergie gaspillée sur des seeds improductifs de 70% tout en maintenant la même couverture finale, ce qui signifie qu'il atteint le même résultat avec 3 fois moins de CPU-hours.

Mise en pratique et recommandations

import numpy as np
from collections import defaultdict

class RLSeedScheduler:
    """Seed scheduler basé sur Thompson Sampling."""

    def __init__(self):
        # Paramètres Beta pour chaque seed
        self.alpha = defaultdict(lambda: 1.0)
        self.beta = defaultdict(lambda: 1.0)
        self.total_coverage = 0

    def select_seed(self, seed_queue):
        """Sélectionne le seed avec le plus haut
        score Thompson Sampling."""
        scores = {}
        for seed_id in seed_queue:
            # Échantillonnage Beta(alpha, beta)
            scores[seed_id] = np.random.beta(
                self.alpha[seed_id],
                self.beta[seed_id]
            )
        return max(scores, key=scores.get)

    def update(self, seed_id, new_coverage):
        """Met à jour les paramètres après exécution."""
        if new_coverage > 0:
            self.alpha[seed_id] += new_coverage
            self.total_coverage += new_coverage
        else:
            self.beta[seed_id] += 1.0

GAN-based fuzzing : génération d'inputs réalistes

Les Generative Adversarial Networks (GANs) ouvrent une approche complémentaire au fuzzing. Le générateur apprend à produire des inputs qui ressemblent à des données valides (passent les checks syntaxiques) tout en explorant les frontières du comportement attendu. Le discriminateur évalue si l'input est « suffisamment réaliste » pour passer les validations initiales. Cette approche est particulièrement efficace pour les protocoles réseau et les formats binaires complexes où la validité syntaxique est une condition préalable à l'exploration des fonctionnalités profondes. Les travaux sur GANFuzz et SeqFuzzer montrent une amélioration de 30 à 50% de la couverture sur des cibles comme les implémentations TLS, HTTP/2 et MQTT par rapport au fuzzing classique.

• ▹Résultats quantifiés (benchmarks académiques) : les approches ML-guided montrent +30 à 50% de couverture edge supplémentaire, +2 à 5x de crashs uniques découverts, et -40 à 70% de CPU-hours gaspillés sur des mutations improductives
• ▹Overhead acceptable : le coût d'inférence du modèle ML (1-10 microsecondes par décision) est négligeable par rapport au coût d'exécution d'un test case (100 microsecondes à 10 millisecondes), l'overhead total reste sous 5%
• ▹Limitation principale : les modèles ML nécessitent une phase de warm-up (1-4 heures) pour accumuler suffisamment de données d'entraînement, pendant laquelle le fuzzing classique reste plus performant
• ▹Approche hybride recommandée : commencer en mode classique (AFL++ standard), basculer vers le ML-guided après 2-4 heures quand le plateau de couverture est atteint, pour maximiser le gain marginal

5 Outils et Frameworks de Fuzzing IA

L'écosystème d'outils de fuzzing assisté par IA s'est considérablement enrichi entre 2024 et 2026. Des fuzzers historiques comme AFL++ ont intégré des interfaces pour les mutateurs ML, tandis que de nouveaux frameworks comme ChatFuzz exploitent nativement les LLM. Chaque outil a ses forces et ses cas d'usage optimaux. Comprendre ce paysage est essentiel pour choisir la bonne combinaison d'outils selon le contexte (type de cible, budget CPU, niveau d'expertise).

AFL++ avec plugins ML (custom mutators)

AFL++ est le fuzzer greybox de référence en 2026, fork amélioré de l'AFL original. Sa fonctionnalité de custom mutators permet d'intégrer n'importe quel moteur de mutation externe, y compris des modèles ML. L'API est simple : un module partagé (.so) exporte des fonctions afl_custom_fuzz() et afl_custom_post_process() qui reçoivent le buffer d'entrée et retournent un buffer muté. Plusieurs projets de recherche ont publié des custom mutators ML pour AFL++, notamment Neuzz (gradient-guided), MOPT (mutation optimization via Particle Swarm) et des mutateurs basés sur des autoencoders. AFL++ intègre aussi nativement CmpLog (input-to-state correspondence) et RedQueen (magic byte inference), qui ne sont pas du ML à proprement parler mais résolvent les mêmes problèmes de manière heuristique.

Google OSS-Fuzz + AI-assisted triage

OSS-Fuzz est la plateforme de fuzzing continu de Google qui teste en permanence plus de 1 200 projets open source. En 2025-2026, Google a intégré plusieurs composants IA dans OSS-Fuzz : OSS-Fuzz-Gen pour la génération automatique de harnesses par LLM, ClusterFuzz pour le triage ML-assisted des crashs (déduplication par clustering, classification de sévérité), et des modèles de prédiction de couverture pour orienter les campagnes de fuzzing. La plateforme exécute 15 milliards de test cases par semaine et a découvert plus de 40 000 bugs dont des milliers de vulnérabilités de sécurité critiques. L'ajout des composants IA a augmenté le taux de découverte de nouveaux bugs de 28% en 2025.

ChatFuzz et LLM-based fuzzers

ChatFuzz représente une nouvelle catégorie de fuzzers qui utilisent les LLM comme moteur principal de génération. Le principe : décrire la cible en langage naturel (« fuzz le parser JSON de cette bibliothèque, en ciblant les cas d'imbrication profonde et les caractères Unicode ») et laisser le LLM générer et itérer les test cases. ChatFuzz utilise un dialogue multi-tours avec le LLM : il soumet le crash log ou le rapport de couverture au LLM, qui analyse le résultat et propose de nouvelles mutations ciblées. Cette approche est particulièrement efficace pour les cibles de haut niveau (APIs REST, parsers de configuration, interfaces web) où la compréhension sémantique du LLM apporte un avantage décisif par rapport aux mutations binaires.

Mise en pratique et recommandations

Microsoft RESTler pour fuzzing d'API

RESTler de Microsoft est le premier fuzzer de REST APIs stateful. Il analyse automatiquement la spécification OpenAPI/Swagger d'une API, infère les dépendances entre les requêtes (ex: créer un utilisateur avant de modifier son profil) et génère des séquences de requêtes qui explorent l'espace d'états de l'API. En 2025, Microsoft a enrichi RESTler avec des capacités IA : les LLM génèrent des valeurs de paramètres sémantiquement pertinentes (au lieu de chaînes aléatoires), et un modèle ML prédit quelles séquences de requêtes sont les plus susceptibles de déclencher des bugs de logique métier. RESTler a découvert des centaines de bugs dans les services Azure, GitHub et Office 365, dont des vulnérabilités de contournement d'autorisation (BOLA/IDOR) que les fuzzers classiques ne peuvent pas détecter.