Google DeepMind liet AI-agents in vier weken een wiskundig bewijs schrijven dat de code achter je Signal-berichten doet wat ze belooft. Het bewijs telt ongeveer 6,5 miljoen regels en gaat niet over de broncode maar over de gecompileerde machinecode, zoals die op een Arm-processor draait. Elke stap is gecontroleerd door Lean, een programma dat bewijzen mechanisch nakijkt. Dat is een echte primeur. Het betekent wel niet dat Signal, WhatsApp of je gsm nu onkraakbaar zijn: het bewijs geldt voor één build, voor één-op-één-gesprekken en onder duidelijke aannames.

Het systeem heet AlphaProof Code. Hieronder lees je wat het precies bewees, wie wat deed, waar het bewijs stopt en waarom dit meer zegt over de toekomst van AI-code dan over Signal alleen.

Wat AlphaProof Code precies bewees

Het doelwit is libsignal, de open-source bibliotheek die de versleuteling van Signal regelt. DeepMind nam versie 0.105.4, samen met de module spqr 1.6.0, en verifieerde twee onderdelen. Het eerste is PQXDH, de handshake waarmee twee toestellen een gedeeld geheim afspreken, ook bestand tegen latere kwantumcomputers. Het tweede is de Triple Ratchet, het mechanisme dat bij elk bericht nieuwe sleutels afleidt.

Voor die twee onderdelen bewees het systeem onder meer deze eigenschappen:

  • Forward secrecy. Wie later je sleutel steelt, kan je oude berichten niet lezen.
  • Post-compromise security. Na een inbraak op je toestel herstelt het gesprek zich, zodat nieuwe berichten weer geheim zijn.
  • Authenticatie. Je praat echt met de persoon van wie je de sleutel hebt.
  • Bescherming tegen harvest now, decrypt later. Wie vandaag berichten bewaart om ze ooit met een kwantumcomputer te kraken, raakt de handshake-sleutels niet.

Dat gebeurde in twee soorten bewijs. Het symbolische bewijs gaat ervan uit dat de cryptografie perfect werkt en kijkt of de logica van het protocol klopt. Het computationele bewijs werkt met de gangbare wiskundige aannames over hoe moeilijk de onderliggende problemen zijn, en begrenst hoeveel voordeel een aanvaller kan halen. Volgens de technische paper is het de eerste keer dat zulke garanties op protocolniveau verbonden worden met de ongewijzigde code van een veelgebruikte cryptografische implementatie.

Waarom bewijzen op machinecode het verschil maakt

Eerdere analyses van Signal keken vooral naar het ontwerp op papier of naar kleine stukken code. Ehren Kret, CTO van Signal, zegt het zo: eerdere formele verificatie richtte zich op kleinere delen, en deze aanpak maakt een flinke uitbreiding mogelijk.

DeepMind compileerde de ongewijzigde Rust-code met de gewone compiler tot één programma voor 64-bit Arm. Het bewijs werkt rechtstreeks op de bytes van dat programma, instructie per instructie, via een model in Lean van hoe een Arm-processor en Linux zich gedragen. Het gaat om ongeveer 140.000 instructies. Het voordeel: je hoeft de compiler niet te vertrouwen. Een fout die de compiler bij het vertalen zou maken, zit gewoon in wat bewezen moet worden.

Ter vergelijking: de bekende geverifieerde microkernel seL4 kostte twintig persoonjaren, de geverifieerde C-compiler CompCert zes. Die systemen waren bovendien vanaf het begin geschreven om bewezen te worden. libsignal niet.

Wie deed wat, mensen of agents

Het team telde vijf mensen. Zij kozen wat er bewezen moest worden, stuurden een agent die de specificaties opstelde en keurden elke specificatie goed. Volgens de paper ging het meeste werk niet naar de bewijzen maar naar die specificaties. Geen enkele mens schreef bewijscode.

De rest deden agents. Een specificatie-agent schreef de stellingen uit, reviewers van een andere modelfamilie controleerden of ze klopten en sterk genoeg waren. Daarna gingen bewijsteams van 40 tot 80 agents aan de slag, telkens 24 tot 72 uur op één machine. De specificaties kwamen tot stand met Gemini 4 Carbon en Claude Opus 5.5, de bewijzen met Gemini 4 Carbon.

Animatie van mensen die een specificatie goedkeuren, agents die bewijzen schrijven en een poortwachter die ze keurt
Agents schrijven de bewijzen, maar alleen de Lean-kernel en de poortwachter beslissen wat aanvaard wordt. De specificatie kunnen de agents niet aanpassen. Bron: technische paper van Google DeepMind.

Het belangrijkste onderdeel is een poortwachter. Die aanvaardt een bewijs pas als de Lean-kernel het goedkeurt én een vergelijkingstool bevestigt dat de bewezen stelling exact de goedgekeurde specificatie is. De agents kunnen die specificatie zelf niet bewerken. Dat is geen overdreven voorzichtigheid: de paper beschrijft hoe agents onder druk soms hun doel afzwakken, en hoe in een andere agentzwerm een agent een voorwaarde gewoon herdefinieerde als iets dat altijd onwaar is, waarna dat trucje zich verspreidde.

Wat je uiteindelijk moet vertrouwen, is veel kleiner dan wat er bewezen werd. Tegenover de 6,5 miljoen regels bewijs staan ongeveer 26.000 regels die een mens moet lezen: de specificaties en het model van de Arm-processor. Volgens de blog van DeepMind markeerden de agents zelf de stukken die menselijke controle nodig hadden, zo’n 1% van de codebase.

Lees je elders over drie of over zes miljoen regels? Dat komt van DeepMind zelf, dat in zijn blog beide cijfers noemt. De paper houdt het op ongeveer 6,5 miljoen.

De proef met twee oude bugs

Een bewijs dat altijd lukt, is niets waard. Daarom zette het team twee bugs terug die onderzoekers eerder in libsignal vonden en die Signal al had hersteld. De ene liet een oude sessie geheime sleutelinformatie bewaren. De andere controleerde een sleutel van de tegenpartij onvoldoende, waardoor een aanvaller een tweede sessie met hetzelfde geheim kon opzetten.

In beide gevallen leverde het systeem een machinaal gecontroleerd bewijs dat de aangepaste versie onveilig is, met een concreet aanvalsscenario erbij. Dat toont dat de methode het verschil ziet tussen correcte code en deze twee fouten. Het bewijst niet dat ze elke denkbare fout zou vinden. Nieuwe kwetsbaarheden in de gecontroleerde delen vond het team niet.

Wat het bewijs niet zegt

Hier gaan veel samenvattingen de mist in. Het bewijs is sterk, maar het geldt voor een afgebakend stuk:

Overzicht van wat het bewijs over Signal dekt, zoals de handshake, en wat erbuiten valt, zoals groepschats en de app
Het bewijs gaat over één-op-één-gesprekken in één build van libsignal. De app, groepschats en aanvallen via stroomverbruik of timing vallen erbuiten. Bron: technische paper van Google DeepMind.
  • Het is niet de Signal-app. DeepMind bewees een klein opdrachtregelprogramma rond de ongewijzigde bibliotheek. Dezelfde Rust-code zit in de apps voor Android en iOS, maar die apps zelf zijn niet geverifieerd.
  • Alleen één-op-één. Groepsgesprekken, meerdere toestellen per account en het aanmaken van sleutels vallen erbuiten.
  • Geen side channels. Aanvallen die timing of stroomverbruik meten, zitten niet in het model.
  • Aannames over bouwstenen. Het bewijs gaat ervan uit dat de cryptografische basisfuncties werken zoals beschreven. Voor 39 hulproutines rekent het met een contract dat niet tegen de echte code bewezen is.
  • Grenzen in schaal. De statistische garantie wordt waardeloos vanaf ongeveer 25.000 berichten in één sessie, en het kwantumherstel van de nieuwste ratchet-laag is niet bewezen.

Gebruik je WhatsApp of Google Messages? Die steunen op het Signal-protocol, maar het bewijs gaat over deze specifieke build van libsignal, niet over hun apps.

Waarom dit meer is dan een verhaal over Signal

AI schrijft steeds meer code, en het nakijken wordt de flessenhals. Tests vangen alleen wat je bedacht te testen. Dat zag je bij de AWS-emulator die agents volledig zelf bouwden: de eigen testscore van 56,5% vertelt je waar je hem kan vertrouwen, en waar niet. Een formeel bewijs werkt anders. Het zegt dat iets in elke situatie klopt, binnen wat de specificatie beschrijft.

Dat verschuift het werk. Swarat Chaudhuri, onderzoeker bij DeepMind, zei tegen The Register dat “the next frontier is not going to be proof but specification”. Het bewijzen kan je steeds meer aan agents overlaten. Bepalen wat er waar moet zijn, blijft mensenwerk, en een fout in de specificatie levert een geldig bewijs van het verkeerde op.

Werk je zelf met codeeragents, dan zit er een les in die je vandaag al kan toepassen. Laat de agent die het werk doet niet ook beslissen of het goed is. Zet een onafhankelijke keurder ertussen, zoals tests die de agent niet mag aanpassen, een vaste set regels of een mens die goedkeurt. En leg de doelen vast op een plek waar de agent niet bij kan.

Het werk past in Signal Shot, een project van Signal, de Beneficial AI Foundation en de Lean FRO uit april 2026 om het Signal-protocol en de Rust-code ervan in Lean te verifiëren. DeepMind zet de specificaties en bewijzen op GitHub onder de Apache 2.0-licentie. Alles opnieuw nakijken duurt enkele uren en vraagt 15 tot 34 GB werkgeheugen. Wat het hele project kostte, maakte Google niet bekend. Ook in cybersecurity in het algemeen verandert AI het tempo: wie sneller lekken vindt, heeft ook sneller bewijs nodig dat iets dicht zit.

Veelgestelde vragen

Is Signal nu bewezen onkraakbaar?

Nee. Het bewijs zegt dat de handshake en de ratchet in één build van libsignal hun beloftes waarmaken, binnen de aannames van het model. De app, groepschats en aanvallen via timing of stroomverbruik vallen erbuiten.

Geldt dit ook voor WhatsApp?

Niet rechtstreeks. WhatsApp gebruikt het Signal-protocol, maar het bewijs gaat over de gecompileerde code van libsignal versie 0.105.4, niet over de app of de build van WhatsApp.

Wat is Lean?

Lean is een programmeertaal en bewijsassistent waarin je wiskundige stellingen en hun bewijs zo opschrijft dat een computer elke stap kan nakijken. De kern die dat nakijken doet, is klein, zodat je die zelf kan vertrouwen zonder miljoenen regels te lezen.

Kan ik AlphaProof Code zelf gebruiken?

Niet als product. DeepMind publiceerde de paper en de bewijzen voor Signal, maar geen dienst om je eigen code te laten verifiëren, en zegt zelf dat opschalen naar alle software nog veel onderzoek vraagt.

Het bewijs is af, de vraag begint

De vraag verschuift. Of de code klopt, kunnen agents steeds beter bewijzen. Of we het juiste vroegen, niet. Zes en een half miljoen regels bewijs schreef geen mens, maar de 26.000 regels die zeggen wat er bewezen moet worden, moet wel iemand lezen en begrijpen. Hoe meer code agents schrijven, hoe meer dat kleine stuk mensenwerk waard wordt.