🚀 Vérification formelle de Signal par IA : limites
Découvrez comment la IA et la vérification formelle de Signal avec Lean testent des protocoles cryptographiques—et quelles limites freinent la cybersécurité.

Comment l'IA a vérifié une partie du code cryptographique de Signal
La sécurité d'une messagerie chiffrée ne tient pas seulement à la beauté d'un protocole sur le papier. Elle dépend aussi de la façon dont ce protocole est traduit en code, compilé, puis exécuté sur des appareils réels. Et c'est précisément dans cet écart entre la théorie et le logiciel que se cachent parfois des failles difficiles à attraper avec des tests « classiques ».
Google DeepMind dit avoir franchi une étape avec AlphaProof Code, un système d'agents d'intelligence artificielle, pour vérifier formellement des propriétés de sécurité du code cryptographique central de Signal. Le travail aurait mobilisé des spécialistes et produit plusieurs millions de lignes de preuves en Lean, un langage dont le vérificateur contrôle les démonstrations de manière mécanique. D'après l'équipe, le projet a pris quatre semaines.
Cette avancée mérite d'être suivie, mais sans tomber dans les raccourcis. Une preuve formelle n'implique pas que toute l'application Signal est infaillible. Elle ne veut pas non plus dire que toutes les exigences de sécurité ont été choisies sans discussion. Ce que la preuve apporte, c'est une garantie très ciblée : dans un périmètre précis et sous des hypothèses explicites, le code étudié satisfait des propriétés données. Voici ce qui a été vérifié, comment les agents ont contribué, et ce que les entreprises peuvent en retenir de façon raisonnable.
Ce qui a été vérifié dans le code de Signal
La plupart des analyses formelles de protocoles cryptographiques portent sur leur conception : elles décrivent les échanges entre participants et démontrent des propriétés dans un modèle mathématique. C'est déjà compliqué. Sauf que, dans le monde réel, une implémentation ajoute des éléments qu'on retrouve rarement dans le modèle : structures de données, gestion des états, erreurs, dépendances, détails de compilation.
Dans ce cas, Google DeepMind affirme être allé jusqu'à vérifier des propriétés du code cryptographique de Signal « jusqu'aux instructions machine ». L'idée n'était pas de rester sur une description abstraite du protocole, mais de vérifier que l'implémentation étudiée réalise bien les garanties définies au départ.
Parmi les propriétés examinées figurent des protections qui doivent tenir même dans des situations difficiles, notamment avant et après une compromission temporaire d'un appareil. Ce genre de scénario compte concrètement : la sécurité d'une conversation ne consiste pas uniquement à empêcher qu'un message soit intercepté pendant son transport. Il faut aussi comprendre ce qu'un attaquant peut apprendre quand un appareil est compromis à un moment donné, et ce qui reste protégé après.
Pourquoi l'écart entre protocole et code est important
On peut avoir un protocole parfaitement conçu et, malgré tout, une implémentation qui dérape. Un détail de gestion d'état, une condition mal vérifiée, ou un décalage entre le modèle et le programme peuvent faire tomber une propriété qui, théoriquement, « passe ». Les tests et les audits classiques restent utiles, mais ils ne prouvent pas automatiquement que toutes les exécutions possibles respectent une règle donnée.
La vérification formelle vise justement à relier une spécification mathématique au comportement réel d'un programme. Ici, le périmètre annoncé concerne le cœur cryptographique étudié, pas l'ensemble de l'application, ses serveurs, ses appareils, ni son environnement d'exécution.
Cette nuance change la lecture de l'annonce : on parle bien d'une vérification profonde d'une portion critique d'un protocole largement déployé, pas d'une certification globale de Signal. Les garanties obtenues sont solides dans le cadre défini ; elles ne s'étendent pas automatiquement aux composants qui n'ont pas été inclus dans la preuve.
Ce que cette preuve garantit - et ce qu'elle ne garantit pas
La vérification formelle donne une garantie plus précise qu'un simple résultat de test : pour un programme et une spécification donnés, elle établit qu'une propriété est satisfaite dans le cadre des hypothèses retenues. Les tests couvrent un ensemble d'exécutions ; une preuve peut couvrir toutes les exécutions représentées par le modèle formel. C'est particulièrement utile quand un échec sur un cas rare aurait des conséquences sérieuses.
Mais une preuve ne répond pas à tout. Elle ne prouve pas que la spécification correspond exactement aux besoins réels, ni que les hypothèses sur l'environnement restent vraies dans la durée. Elle ne garantit pas non plus que les appareils des utilisateurs ne contiennent pas de logiciels malveillants, ni que la sécurité globale du système restera intacte en dehors du périmètre formalisé. Et elle ne remplace pas l'analyse des mises à jour, de la chaîne d'approvisionnement ou des risques humains.
En pratique, la qualité d'une preuve dépend de deux choses : la validité mécanique de la démonstration et la pertinence du problème posé. Lean vérifie avec rigueur qu'un code satisfait un théorème. Il ne peut pas, tout seul, décider si ce théorème traduit la bonne garantie pour les utilisateurs. Cette responsabilité revient à ceux qui définissent les exigences et évaluent les menaces.
Le test des bogues réintroduits
Pour évaluer si AlphaProof Code pouvait distinguer une implémentation correcte d'une version défectueuse, les chercheurs auraient réintroduit deux bogues réels - corrigés auparavant - dans une version isolée du code de Signal. D'après l'équipe, dans les deux cas le système a produit une preuve vérifiée mécaniquement montrant que la version modifiée ne respectait plus la propriété de sécurité visée.
Ce test intéresse parce qu'il s'appuie sur des défauts concrets plutôt que sur un exemple « fait pour réussir ». Il suggère que la méthode peut détecter certaines violations dans le périmètre considéré. En revanche, deux bogues ne suffisent pas à établir un taux de détection global. On ne peut pas en déduire que toutes les familles d'erreurs seront repérées, ni qu'il n'y aura jamais de faux négatifs.
La formulation la plus juste, donc, est la suivante : le travail renforce la confiance dans des propriétés ciblées du code vérifié, avec un contrôle formel des preuves et une validation humaine sur les spécifications et les zones signalées. Un bon niveau d'assurance, mais circonscrit.
Ce que les entreprises peuvent en tirer
Pour une entreprise, le point n'est pas de « mettre de l'IA partout ». La question est plutôt : où le coût d'une défaillance est-il assez élevé pour que des garanties plus fortes justifient un investissement important ? La cryptographie d'une messagerie, le firmware d'un dispositif médical ou certains composants d'infrastructure entrent souvent dans cette catégorie.
La vérification formelle a longtemps été freinée par le travail manuel. Si des agents peuvent aider à transformer du code réel en théorèmes Lean, ils peuvent réduire une partie de l'effort. Ils ne remplacent pas les ingénieurs en sécurité, mais ils peuvent leur laisser plus de temps pour définir les propriétés et inspecter les zones risquées, plutôt que de refaire sans fin la partie « production de preuves ».
Un déploiement à réserver aux composants critiques
Dans une organisation française ou européenne, une démarche pragmatique peut commencer par quelques composants dont la défaillance aurait un impact disproportionné : authentification, gestion des clés, contrôle d'accès, ou firmware d'un équipement sensible. L'objectif n'est pas de formaliser toute une application avant la mise en production - ce qui serait souvent trop coûteux et ralentirait les équipes sans bénéfice clairement proportionné.
Un parcours réaliste ressemble plutôt à ceci :
- Définir le risque métier : quelles données, quels utilisateurs, quels services seraient exposés en cas de défaillance ?
- Choisir un périmètre réduit : isoler un composant dont le comportement peut être spécifié et dont les interfaces sont maîtrisées.
- Écrire les propriétés avant les preuves : décider quelles garanties doivent tenir, et quelles hypothèses seront nécessaires.
- Comparer le coût au risque : intégrer la compétence experte, la maintenance des preuves et l'évolution du code.
- Garder les contrôles existants : audits, tests, revue de code et suivi des incidents restent complémentaires.
L'usage d'agents IA amène aussi des questions de gouvernance. Qui reçoit quoi : quelles données sont transmises aux modèles, comment les artefacts de preuve sont stockés, qui valide les spécifications ? Dans des secteurs soumis au RGPD ou à des exigences de résilience, la traçabilité des décisions et des versions compte autant que la démonstration elle-même.
Le vrai indicateur : une preuve qui suit le logiciel
Une preuve « faite une fois » peut perdre vite de sa valeur si le code change sans réévaluation. Pour un usage en production, il faut prévoir comment les modifications seront gérées : mise à jour de la spécification, régénération ou adaptation des preuves, revue des dépendances, et contrôle dans le processus de livraison.
Le critère de réussite n'est donc pas le nombre de lignes générées par l'IA. C'est la capacité à maintenir, à un coût acceptable, un lien vérifiable entre les exigences de sécurité et le logiciel réellement déployé. Là , l'automatisation peut vraiment changer l'équation : elle rend envisageable une assurance plus poussée sur des composants qui auraient été trop chers à prouver entièrement à la main.
Google DeepMind présente cette approche comme une base possible pour étendre la vérification à d'autres systèmes critiques. La perspective paraît crédible à une condition : rester sélectif. Tous les logiciels n'ont pas le même niveau de risque, et toutes les équipes ne disposent pas des spécifications ou des compétences nécessaires.
Conclusion
Le travail autour de Signal montre comment des agents IA peuvent aider à rendre la vérification formelle plus abordable à grande échelle. La combinaison fonctionne parce qu'elle sépare les rôles : les humains définissent et valident les exigences, les agents produisent une grande partie des preuves, et Lean vérifie mécaniquement leur validité.
La leçon n'est pas que l'IA garantit désormais un logiciel sans faille. Plutôt : elle peut réduire le coût d'une assurance rigoureuse sur des composants ciblés, là où une erreur aurait un impact majeur. Pour les équipes, la bonne approche reste simple : partir du risque, expliciter les propriétés attendues, puis s'assurer que les preuves pourront suivre l'évolution du logiciel dans le temps.
Comment les agents IA et Lean ont produit les preuves
AlphaProof Code s'appuie sur une organisation en plusieurs rôles, plutôt que sur un schéma unique du type « un modèle qui vérifie tout ». L'équipe indique d'abord avoir travaillé avec plusieurs modèles pour transformer les objectifs de sécurité de Signal en spécifications mathématiques. Là encore, des spécialistes humains ont revu ces spécifications, parce que leur pertinence conditionne tout le reste.
Ensuite, des agents s'appuyant sur Gemini Carbon ont généré les preuves en Lean. Google DeepMind mentionne plus de six millions de lignes de code Lean produites. Il ne faut pas comprendre cela comme « six millions de lignes de code applicatif vérifiées une par une par des humains ». Ce volume correspond au matériau formel utilisé pour établir les propriétés et faire le lien entre le code étudié et les spécifications.
Lean est au centre du processus. Les agents peuvent proposer des démonstrations, mais le vérificateur de Lean décide si les preuves sont valides. Une réponse « convaincante » n'a pas de valeur si elle n'est pas acceptée mécaniquement par le système. Cette séparation entre génération et contrôle limite le risque qu'une erreur de raisonnement produite par l'IA soit prise pour une preuve.
Le rĂ´le des humains n'a pas disparu
Les chercheurs ont défini les propriétés à démontrer et revu les spécifications. Les agents ont pris en charge une grande partie de la production, puis ont signalé des zones qui nécessitaient une revue plus approfondie par des experts. L'équipe avance que cette revue ciblée a porté sur environ 1 % du corpus, avec pour effet de concentrer l'attention sur les cas les plus délicats.
Il faut donc éviter deux malentendus. Non, on n'est pas dans une démonstration entièrement automatisée sans intervention humaine. Et non, ce n'est pas juste un assistant qui suggère quelques morceaux de code. Le vrai changement, c'est la capacité à répartir une formalisation lourde entre des spécialistes humains, des agents générateurs et un vérificateur mécanique.
Le projet aurait duré quatre semaines. La comparaison avec des travaux où des équipes d'experts peuvent passer des années donne une idée du potentiel de productivité - sans pour autant garantir que tout logiciel pourra être formalisé et prouvé dans ce délai. Tout dépend du périmètre, de la qualité des spécifications, de la maturité des outils et de la disponibilité d'experts capables de valider les hypothèses.