Aller au contenu
Gridpak

[‘Claude écarte les risques de plantage dans 123 bibliothèques open source’]

Hermes Integration

Claude écarte les plantages dans 123 bibliothèques open source (Anthropic)
Le visuel publié par Anthropic avec cette annonce, consulté le 24 octobre 2026.

Anthropic a publié le 22 octobre 2026 un article de recherche décrivant un travail mené avec Theorem, dans lequel Claude a rédigé des preuves formelles établissant que 239 points d’entrée de fuzz tests, répartis sur 123 bibliothèques open source, ne peuvent jamais planter. Les preuves portent sur des binaires RISC-V compilés plutôt que sur le code source, et un vérificateur nommé Rocq a validé chacune d’elles.

Le haut de la page de recherche d'Anthropic sur la vérification formelle de logiciels, avec son titre et sa date de publication du 22 octobre 2026
La page publiée par Anthropic, consultée le 24 octobre 2026.

Ce qui a réellement été publié

L’article est signé Frontier Red Team et livre des artefacts, pas seulement des affirmations : les sémantiques du processus RISC-V et Linux construites pour le projet, les preuves de Claude pour les fuzz tests qui n’ont nécessité aucun correctif, et les spécifications des fuzz tests qu’il n’a pas pu prouver. Anthropic précise que toute preuve susceptible d’exposer un bug non corrigé reste non publiée.

La méthode compte plus que le chiffre. Chaque bibliothèque du programme OSS-Fuzz de Google embarque un fuzz test, une fonction qui plante quand son entrée casse quelque chose, instrumentée avec AddressSanitizer. Anthropic a compilé ces programmes en RISC-V, transformé chaque fuzz test en une spécification affirmant que le programme ne plante jamais pour aucune entrée inférieure à 64 Mo, puis fait rédiger la preuve par Claude. Le noyau Rocq vérifie ensuite la preuve, si bien que quasiment aucun de ces codes n’a besoin d’un lecteur humain.

Mesure Chiffre publié par Anthropic
Bibliothèques open source 123
Points d’entrée de fuzz tests prouvés 239
Code de preuve généré environ 180 millions de lignes de Rocq
Preuve unique typique environ 600 000 lignes
Binaire médian sous preuve 18 000 instructions RISC-V
Plus grande entrée couverte 64 Mo

Ce que vous pouvez vérifier dès aujourd’hui

  • Un sous-ensemble des preuves, publié pour que chacun puisse les revérifier ou les réutiliser, ainsi que les sémantiques RISC-V et Linux dont elles dépendent.
  • Les spécifications des fuzz tests que Claude n’a pas pu prouver, qui marquent l’endroit où la méthode s’est arrêtée.
  • Theorem propose d’appliquer le même pipeline à d’autres projets open source et publie un skill Claude pour démarrer sur votre propre code.

Claude a aussi corrigé ce qu’il a trouvé, et la liste de bugs est ce qu’un ingénieur sécurité lit en premier. Un sous-dépassement de compteur a produit une écriture hors limites, mais uniquement sur des entrées d’environ 20 Mo avec une disposition mémoire rare. Une autre bibliothèque présentait une lecture hors limites nécessitant une entrée de 64 Mo et plus de 2 Go de mémoire. Claude a également redécouvert la CVE-2026-56132 dans libexpat, et trouvé un bug qui ne plante jamais du tout : une restriction de chargement de fichier qui n’est pas toujours appliquée.

Deux expériences annexes suivent. Claude a rédigé une spécification formelle de la RFC 1950 et prouvé que l’implémentation zlib du noyau Linux la respecte, cette fois sur des binaires x86, puis a répété l’opération sur une demi-douzaine de bibliothèques. Il a aussi construit un interpréteur Python en Rust et prouvé sa conformité aux sémantiques de CPython avec Verus : sur 1,7 million de programmes aléatoires, 99,95 % se sont comportés de façon identique.

Vérifié formellement ne veut pas dire exempt de bugs.

Sur quoi repose l’affirmation

Cette phrase est d’Anthropic elle-même, et elle porte le poids des réserves. Une preuve ne vaut que par son modèle de la machine, et le modèle ici est étroit : un binaire statique mono-thread, lié à musl, avec un budget mémoire fixe, sur un processeur RISC-V sous Linux. Ces bibliothèques sont surtout déployées sur x86 ou ARM, liées dynamiquement à glibc, au sein d’applications multithreadées.

Hypothèse dans la preuve À quoi ressemble généralement le déploiement
Processeur RISC-V x86 ou ARM
Binaire statique mono-thread threads, liaison dynamique
musl libc glibc
Entrées inférieures à 64 Mo aucune limite
Erreurs détectables par AddressSanitizer bugs qui échappent à ce qu’ASan détecte

La couverture a elle aussi ses limites. Anthropic indique ne pas avoir vérifié chaque point d’entrée de chaque bibliothèque, que le code mort échappe à la preuve et qu’un appelant peut encore corrompre la mémoire en utilisant mal une fonction vérifiée.

Vient ensuite la base de confiance. Le noyau Rocq vérifie la preuve, mais il suppose que les sémantiques RISC-V et Linux sont correctes, que le théorème dit bien ce que les auteurs voulaient dire, et que le compilateur, le système d’exploitation et le matériel sous Rocq se comportent comme prévu. Ces composants sont publiés pour que d’autres les attaquent, et c’est la partie la plus solide de la publication.

Ce qui n’est pas publié

Aucune facture de tokens, aucun coût en dollars, aucun décompte des points d’entrée tentés face aux points d’entrée prouvés, aucun nombre exact de bugs au-delà de « des centaines », et aucune liste des bibliothèques qui n’ont pas obtenu de preuve.

La méthode a un piège qu’Anthropic signale elle-même : un modèle à qui l’on demande de prouver qu’un programme est sûr peut réécrire le programme en un programme qui ne peut pas planter. Anthropic a pénalisé les patches, accordé un crédit supplémentaire pour la preuve des entrées qu’un patch modifie, et audité les patches ensuite.

Le coût doit être reconstruit à partir des prix publiés. L’article indique que des preuves individuelles peuvent consommer des centaines de millions de tokens. Aux tarifs Opus 5.5 que nous avons relevés sur la grille tarifaire d’Anthropic le 8 octobre 2026, 4 $ par million de tokens en entrée et 20 $ par million de tokens en sortie, une preuve à 100 millions de tokens en sortie revient à 2 000 $ avant toute nouvelle tentative. C’est notre calcul, pas un chiffre divulgué. La tendance compte davantage : sur 36 petites tâches, Opus 5.5 en a prouvé la moitié avec environ 40 % de tokens en moins qu’Opus 5, et les agents partageant un espace de travail de preuve en ont eu besoin de 17 % de moins que les agents travaillant seuls.

Ce que cela change pour les développeurs qui livrent du code IA

Le goulot d’étranglement quand on livre du code écrit par une IA, c’est la revue, et la revue est une attention qui ne passe pas à l’échelle. Cette publication attaque ce goulot en un point : une preuve vérifiée par machine remplace l’attention humaine sur le code qu’elle couvre, sans que personne n’ait à lire 600 000 lignes.

Elle paie d’abord pour les composants qui ingèrent des octets non fiables : parseurs, décompresseurs, décodeurs d’images, là où les bugs ci-dessus sont apparus. La frontière est tout aussi concrète : sur x86 avec glibc et des threads, les preuves actuelles décrivent une machine que vous n’utilisez pas. La garantie se transpose aux binaires statiques et aux dépendances épinglées, pas à un service web classique.

Pour une petite équipe, le point d’entrée n’est pas d’écrire des preuves. Theorem publie un skill Claude qui guide un développeur dans le pipeline et propose de l’exécuter sur d’autres projets, ce qui transforme un résultat de recherche en quelque chose qui a un prix.

L’avis de Neural Minute

Nous avons couvert l’autre moitié de cette histoire le 10 octobre, quand OpenAI a publié 372 résultats mathématiques dont 42 % des preuves principales étaient vérifiées par machine en Lean. OpenAI vendait des résultats, et les preuves étaient les justificatifs. Anthropic vend un workflow appliqué à du code déjà livré, et les preuves sont le produit.

Cela change ce qu’il faut demander. En mathématiques, la spécification, c’est les mathématiques, donc une preuve vérifiée clôt la question. Ici, la spécification est un test de fuzzing réécrit en propriété, et tout ce que la preuve ne peut pas dire vit dans cette réécriture : quels points d’entrée, quelle taille d’entrée, quelle machine. Si les hypothèses correspondent à votre déploiement, une preuve vaut mieux qu’une année de fuzzing supplémentaire ; sinon, c’est un indice fort sur une base de code, pas une garantie sur la vôtre.

Ce que je voudrais avant de recommander cela à quiconque paie pour : le ratio entre points d’entrée tentés et points d’entrée prouvés, un coût par dépendance vérifiée, et la liste des bibliothèques où la preuve a échoué. Les spécifications publiées pour les preuves échouées sont un substitut partiel, et meilleur qu’une page marketing, parce qu’elles montrent la limite de la méthode.

Le chiffre que je surveillerais n’est pas 180 millions mais les 17 % : c’est la réutilisation qui fait baisser le coût vers quelque chose qu’un projet normal peut payer, comme Mathlib a grandi jusqu’à près de 300 000 théorèmes. Si cela tient, la question dans un an sera quelles dépendances valent la peine d’être prouvées une fois pour toutes.

Sources