Claude Code a découvert une vulnérabilité Linux cachée depuis 23 ans

#Introduction

La loi de Linus affirme que « si les testeurs sont assez nombreux, tous les bugs sautent aux yeux ». Pendant des décennies, la communauté open source s'est appuyée sur ce principe pour sécuriser des infrastructures fondamentales comme le noyau Linux. Mais que se passe-t-il lorsque ces yeux ne sont plus humains et qu'ils peuvent analyser du code à une échelle et une profondeur jusqu'alors jugées impossibles ?

Lors de la récente conférence sur la sécurité de l'IA [un]prompted, Nicholas Carlini, membre de la Frontier Red Team d'Anthropic, a balayé nos certitudes de longue date concernant la sécurité du code hérité (legacy). Il a démontré comment Claude Code — propulsé par le modèle très avancé Claude Opus 4.6 — a découvert et exploité de manière autonome une vulnérabilité critique, exploitable à distance, dans le noyau Linux. Celle-ci se cachait au vu et au su de tous depuis exactement 23 ans.

Il ne s'agit pas d'une simple mise à jour incrémentale des outils d'analyse statique. C'est un véritable tournant qui redéfinit notre approche de l'audit des bases de code, de l'application de correctifs défensifs et, plus globalement, de l'économie de la cybersécurité.

#Ce qui s'est passé

La méthodologie déployée par la Frontier Red Team d'Anthropic s'est révélée remarquablement simple, mais d'une efficacité redoutable. Carlini et son équipe ont essentiellement conçu un pipeline d'audit IA « en force brute » à passes multiples, fonctionnant à une échelle qu'aucune équipe humaine traditionnelle ne pourrait égaler.

Le processus d'audit de sécurité piloté par l'IA s'est articulé autour de trois phases distinctes :

• Phase 1 : Analyse sémantique profonde : Claude Code a systématiquement ingéré chaque fichier source du dépôt du noyau Linux. Au lieu de s'appuyer sur des expressions régulières prédéfinies ou sur la correspondance d'arbres syntaxiques abstraits (AST), Claude a analysé la signification sémantique du code C, traçant les machines à états complexes et les cycles de vie des pointeurs.
• Phase 2 : Vérification automatisée : Un second groupe d'agents Claude a récupéré les chemins de code signalés et a tenté de rédiger des exploits fonctionnels de preuve de concept (PoC). Cette méthode a permis d'atteindre un taux de vérification proche de 100 %, éliminant totalement la fatigue liée aux faux positifs qui gangrène habituellement les outils classiques de tests de sécurité des applications (SAST).
• Phase 3 : Génération de correctifs : Une fois la faille vérifiée, les agents ont proposé des correctifs du noyau structurellement solides pour bloquer les vecteurs d'attaque.

Le point d'orgue de cet exercice a été la découverte d'un dépassement de tampon (buffer overflow) complexe dans la pile du démon Network File System version 4 (NFSv4). Le code vulnérable avait été introduit en 2003 et avait survécu à des milliers d'audits humains, de remaniements et de campagnes de fuzzing automatisées pendant deux décennies.

Comme pour prouver qu'il ne s'agissait pas d'un coup de chance, Carlini a également révélé que Claude Opus 4.6 avait été lâché sur Ghost CMS, une plateforme extrêmement populaire comptant plus de 50 000 étoiles sur GitHub. En moins de 90 minutes, l'IA a découvert une injection SQL en aveugle (blind SQL injection) de type zero-day et a réussi à extraire une clé API administrateur.

#Pourquoi c'est important

La découverte d'une vulnérabilité vieille de 23 ans dans l'une des bases de code les plus scrutées au monde nous oblige à faire face à une réalité inconfortable : nos outils de sécurité actuels sont fondamentalement inadaptés aux bugs complexes basés sur des états.

Les marchés financiers ont immédiatement saisi la gravité de cette démonstration. À la suite de la présentation, les actions des principales entreprises de cybersécurité, y compris des géants du secteur comme CrowdStrike et Palo Alto Networks, ont accusé une forte baisse. Les investisseurs doivent désormais composer avec un avenir où la barrière technique et financière pour découvrir des exploits zero-day chute presque à zéro.

Historiquement, débusquer une vulnérabilité comme le dépassement de tampon dans NFSv4 nécessitait des mois de recherche acharnée par des ingénieurs humains hautement spécialisés, dotés d'une expertise pointue des rouages internes du noyau et des protocoles réseau. En automatisant ce processus, Claude Code a radicalement modifié l'asymétrie entre les attaquants et les défenseurs. Si une IA est capable de cartographier et d'exploiter intégralement un bug de 23 ans le temps d'un week-end, le concept même de logiciel « éprouvé » nécessite une réévaluation fondamentale.

#Implications techniques

Pour bien comprendre en quoi il s'agit d'un bond technologique majeur, il faut se pencher sur les raisons pour lesquelles les outils traditionnels ont échoué à trouver ce bug pendant 23 ans.

Les fuzzers traditionnels (comme syzkaller) sont incroyables pour détecter les corruptions de mémoire, mais ils s'appuient fortement sur des mutations guidées par la couverture de code. Il est bien connu qu'ils peinent à atteindre des chemins d'exécution qui exigent des interactions complexes en plusieurs étapes avec une machine à états. Pour déclencher le bug NFSv4, un client devait envoyer une séquence très spécifique de requêtes composées malformées qui satisfaisaient à un ensemble strict de conditions préalables avant que le dépassement de tampon ne puisse être atteint. Un fuzzer standard resterait presque inévitablement bloqué sur la génération de sommes de contrôle valides ou sur le respect des exigences d'état strictes du protocole.

Claude Code, en revanche, n'a pas eu besoin de deviner la machine à états : il l'a tout simplement lue et comprise.

Voici un exemple conceptuel simplifié du type d'angle mort sémantique que Claude a été capable d'exploiter :

/* Conceptual example of the semantic bug pattern */
int process_nfs4_compound(struct nfsd4_compoundargs *argp, void *buf) {
    int op_count = argp->opcnt;
    char local_buffer[256];
    
    // Traditional SAST sees a bounds check here and marks it safe
    if (op_count > MAX_OPS) {
        return -EINVAL;
    }

    // However, an obscure protocol downgrade state allows 
    // op_count to be manipulated AFTER the initial check
    trigger_legacy_fallback(argp); 

    // Semantic understanding reveals that argp->opcnt is now unbound,
    // leading to a stack overflow during the memory copy
    memcpy(local_buffer, buf, argp->opcnt * sizeof(struct nfsd4_op));
    
    return 0;
}

Alors que les outils d'analyse statique repèrent la vérification initiale des limites et supposent que la variable est sûre, Claude Opus 4.6 a été capable de tracer le cycle de vie de la variable à travers de multiples appels de fonctions. Il a compris que trigger_legacy_fallback() modifiait l'état de manière à invalider le contrôle de sécurité précédent. Cela exige un niveau de raisonnement contextuel jusqu'ici réservé aux chercheurs humains chevronnés en cybersécurité.

#Perspectives

Nous entrons dans l'ère de l'IA à double usage en matière de sécurité.

Côté défense, cette technologie offre une promesse alléchante : la capacité d'éradiquer systématiquement des décennies de dette technique. Les entreprises peuvent déployer des clusters internes d'agents IA pour auditer l'ensemble de leur chaîne d'approvisionnement logicielle, en identifiant et en corrigeant les vulnérabilités avant qu'elles ne puissent être exploitées dans la nature. Le rêve d'un logiciel « sécurisé par défaut » est soudainement à portée de main.

Cependant, les implications offensives sont indéniables. Carlini a noté qu'Anthropic avait récemment chargé une équipe de 16 agents Opus d'écrire avec succès un compilateur C fonctionnel en Rust, et ce, en partant de zéro. Lorsque ce niveau de compétence architecturale et de programmation est orienté vers la sécurité offensive, le paysage des menaces évolue de manière exponentielle. Les acteurs malveillants auront bientôt accès à des pipelines de recherche de vulnérabilités automatisés et hautement performants, fonctionnant 24 heures sur 24.

Pour s'adapter, l'industrie doit aller au-delà de l'application réactive de correctifs. Nous assisterons probablement à un élan massif vers les langages à mémoire sécurisée — ce qui valide les efforts en cours pour intégrer Rust dans le noyau Linux — et au déploiement de systèmes de défense autonomes pilotés par l'IA, capables d'opérer à la même vitesse et à la même échelle que les attaquants IA.

#Conclusion

La découverte par Claude Code d'un bug vieux de 23 ans dans le noyau Linux est un signal d'alarme sans équivoque pour la communauté de l'ingénierie logicielle. Elle prouve que nos bases de code héritées regorgent encore de vulnérabilités critiques, n'attendant que d'être découvertes par quiconque — ou n'importe quoi — doté d'assez de temps et de capacités de raisonnement.

Le bug spécifique du noyau est désormais corrigé, mais la méthodologie utilisée pour le débusquer est désormais publique. À mesure que les modèles d'IA continuent de gagner en longueur de contexte et en puissance de raisonnement, l'industrie de la cybersécurité doit évoluer rapidement. La course entre les défenseurs automatisés et les attaquants automatisés a officiellement commencé, et il n'y a pas de retour en arrière possible.