DeepMind's AlphaProof Code formally verifies Signal's core encryption down to machine code
Google DeepMind has released AlphaProof Code, an AI agent framework for formal verification, and used it to mathematically prove key security properties of libsignal, the core library of the Signal protocol, at the level of compiled machine code.
Google DeepMind announced on 10 November 2026 that it has used a new agentic framework called AlphaProof Code to mathematically prove key security properties of the actual code underlying the Signal protocol, the technology that protects conversations in apps such as Signal and Google Messages. A five-person research team completed the proof work in four weeks, with AI agents generating about 6.5 million lines of machine-checked Lean proof, according to the technical paper. The verification covers libsignal version 0.105.4 with SPQR version 1.6.0, for one-to-one sessions only, and extends to the compiled AArch64 machine code rather than stopping at the protocol design. The result is not a certificate that Signal is unbreakable: group messaging, key generation, sealed sender, server-side code and side-channel attacks sit outside the proof.
What DeepMind announced
Google DeepMind announced on 10 November 2026 that its researchers guided AI agents to mathematically prove key security properties of the actual code underlying the Signal protocol. The work used AlphaProof Code, a multi-LLM agentic framework for formal verification that combines human expertise with AI agents. DeepMind says the work marks the first time AI has been used to formally verify a widely deployed cryptographic protocol at this depth, and the first time the implementation of such a protocol has been formally verified by any method.
Formal verification means mathematically proving that code runs correctly without flaws, and DeepMind describes it as the highest standard of security assurance — but one that is difficult and often labor-intensive. The verification process took just four weeks, a task that historically takes expert teams years, according to DeepMind.
What was actually verified
The researchers wrapped the unmodified libsignal v0.105.4 and SPQR v1.6.0 crates in a small command-line harness and compiled them with the stock Rust compiler into a statically linked AArch64 Linux executable. The verified target was one-to-one session code covering the PQXDH handshake — the post-quantum key agreement that starts a conversation — and the Triple Ratchet, which keeps rotating keys as messages flow. About 560 KB of code, roughly 140,000 AArch64 instructions, was verified.
The researchers report two independent arguments: ten symbolic theorems under idealized cryptographic assumptions, and a computational proof bounding an attacker's advantage through cryptographic assumptions and statistical terms. The properties include forward secrecy, which protects earlier messages after current state is stolen; authentication; post-compromise security, which concerns recovery after a compromise; and handshake secrecy. Agents powered by Gemini Carbon generated the proof code — about 6.5 million lines of machine-checked Lean, according to the technical paper — while humans selected the properties, reviewed the specifications and retained final approval. DeepMind has open-sourced its formal verification artifacts for community use.
How the team checked the system could catch real bugs
To confirm that AlphaProof Code can tell correct code from buggy code, the team reintroduced two real, previously fixed bugs into an isolated version of Signal's code — known as weak state and small subgroup. In both cases, the system produced a machine-checked proof that the buggy version was insecure, according to DeepMind.
The agents also audited the proof and highlighted areas that needed a second look by a human — just one percent of the codebase, according to DeepMind. Because Lean automatically checks the rest, the experts could focus their review where human judgment matters most. Signal chief technology officer Ehren Kret said the work 'gives us even greater confidence in our code's privacy guarantees.'
The limits — what the proof does not cover
The guarantees stop well short of certifying Signal's complete applications. They concern the researchers' libsignal-cli build running as a fresh process; key generation was not verified, group messaging was left for future work, and side channels and multi-device state fall outside the scenario. Low-level cryptographic primitives and selected output and library routines are represented by trusted contracts, so the result also depends on those contracts, the approved specifications, Lean's kernel and assumptions about the primitives.
The technical paper also states that neither argument proves the post-quantum healing that SPQR is designed to add: the computational theorem covers classical attackers, while the symbolic ratchet theorems let the attacker choose SPQR keys. The researchers' stated next steps are to strengthen the theorems, reduce the trusted base, and expand coverage to group messaging, sealed sender and server-side protocols.
Editorial disclosure
This article was researched with AI assistance and reviewed by the publisher before publication. Report factual errors through our contact page.
Frequently asked questions
What is AlphaProof Code?
AlphaProof Code is a multi-LLM agentic framework from Google DeepMind for formal verification — mathematically proving that code meets specified security properties. Human experts decide what to prove and review the specifications; AI agents generate the machine-checked proofs.
What exactly was verified in the Signal work?
The compiled libsignal v0.105.4 with SPQR v1.6.0 code, for one-to-one sessions only, covering the PQXDH handshake and the Triple Ratchet, down to AArch64 machine code. Properties proved include forward secrecy, authentication, post-compromise security and handshake secrecy.
Does this prove Signal is unbreakable?
No. The proof does not cover group messaging, key generation, sealed sender, server-side code, side channels or the full Signal app, and it rests on trusted specifications and assumptions about the underlying cryptographic primitives.