DEV Community

Mohammad Taha Azizi Ahad
Mohammad Taha Azizi Ahad

Posted on

AI Just Proved Signal's Encryption Correct — Here's What That Proof Actually Covers

AI Just Proved Signal's Encryption Correct — Here's What That Proof Actually Covers

On November 10, Google DeepMind announced something I did not expect to see this year: AI agents produced a machine-checked mathematical proof about the core of the Signal protocol. Not a test suite. Not a fuzzing run. A formal proof, written in Lean, about the compiled code that encrypts messages for billions of people.

I build a messenger myself, a small one with a post-quantum handshake I designed from scratch, so I read the announcement the way a builder reads it: what exactly was proved, what was left out, and whether this changes anything for the rest of us who write crypto code without a research lab behind us.

What happened

DeepMind's team took libsignal, the open-source library that implements the Signal protocol, and fed it to a new framework called AlphaProof Code. The engine behind it is Gemini Carbon. The target was specific: the post-quantum PQXDH handshake and the Triple Ratchet, the two pieces that protect a one-to-one conversation from the first key exchange through every message that follows.

The proof came out at roughly 6.5 million lines of Lean. That number sounds absurd until you learn that humans only had to read about 26,000 lines of it: around 18,000 lines of specification theorems and 8,000 lines of machine semantics. The rest was machine-generated and machine-checked. Nobody sat down and read 6.5 million lines by hand, and nobody needed to. That is the whole point of a machine-checked proof.

The work took four weeks. For comparison, the paper names two benchmarks from the history of formal verification: the seL4 microkernel took about twenty person-years, and the verified C compiler CompCert took six. Four weeks for a proof at this depth is the headline, and it is a real one.

The four properties

The proof establishes four properties for one-to-one sessions:

  • Forward secrecy. If today's keys leak, yesterday's messages stay unreadable.
  • Authentication. The person you think you are talking to is the person on the other end of the handshake.
  • Post-compromise security. If an attacker briefly gets into a device, the conversation heals itself and later messages become safe again.
  • Handshake secrecy. The handshake itself does not leak the session key.

Signal's CTO, Ehren Kret, said the work gives the team "even greater confidence" in the code's privacy guarantees. WIRED reported that the analysis found no new vulnerabilities in the code it examined, which is worth noting: a proof effort that finds nothing is still a result, because it rules out a whole class of bugs in the parts it covers.

What the proof does not cover

This is where the announcement gets interesting, and where most of the coverage I have seen gets it wrong. The proof is narrow on purpose, and DeepMind's own researchers say so.

First, it covers one-to-one sessions only. Group chats are outside it. The Signal app as a whole is outside it. The operating system and the phone underneath are outside it.

Second, key generation is not verified. The proof assumes the keys it starts from are good. If your random number generator is broken, no proof about the handshake saves you.

Third, and this matters most for anyone following post-quantum work: the paper states plainly that no post-quantum guarantee is established for SPQR's healing property. SPQR, the Sparse Post Quantum Ratchet, is the piece that keeps re-injecting ML-KEM-768 into the conversation so it keeps healing in a post-quantum sense. The proof covers the Triple Ratchet's classical healing, but the post-quantum part of that healing is not proved. That is an honest gap, and DeepMind did not hide it.

Fourth, the symbolic part of the argument assumes perfect cryptography. It proves the protocol logic is correct if the underlying primitives behave as specified. A separate computational argument bounds what an attacker can do inside the researchers' model. Neither is a promise that no one can ever read a message.

So the correct sentence is not "AI proved Signal secure." The correct sentence is: "AI proved that libsignal's post-quantum handshake and Triple Ratchet, in one-to-one sessions, satisfy four named properties at the level of compiled machine code, under stated assumptions." Less exciting. Much more useful.

Why the compiled-code part matters

Most formal verification in cryptography works on a model of the protocol, written in a specification language. The gap between the model and the shipped code is where real bugs live. DeepMind's team verified the compiled AArch64 machine code of the actual Rust crates: libsignal v0.105.4 and SPQR v1.6.0, wrapped in a small command-line harness and built with stock Rust.

That is the part I keep coming back to. A proof about a model tells you the design is sound. A proof about the compiled code tells you the thing people actually run behaves the way the design says. The distance between those two statements is most of the history of cryptographic bugs.

It also was not fully automatic. Humans wrote the formal specification, decided what "secure" should mean, reviewed the definitions, and kept final approval. The agents did the grinding work of producing millions of lines of proof. That division of labor is probably the shape of this for the next few years: humans decide what correctness means, machines do the exhaustive part.

What this means for the rest of us

Here is the part that matters if you are not at DeepMind. libsignal is not only Signal's library. Variants of the protocol run in WhatsApp, Messenger, and Google Messages, so a proof about this code reaches further than one app. And the technique is now public: the specifications and proofs are published, and the framework behind them, Gemini Carbon, became generally available the same day.

For someone building a messenger, the lesson is not "wait for AI to prove your code." The lesson is narrower and more practical. Formal verification used to be a thing only a team with years and a budget could attempt. Four weeks changes the arithmetic. It does not make verification cheap, and it does not remove the human work of writing a correct specification, which is arguably the hard part. But it moves verification from "impossible for a small team" to "expensive but conceivable," and that is a real shift.

My own project is a good reality check here. I built a post-quantum messenger with a hybrid ML-KEM-768 and ECDH handshake, epoch-based group keys, and rotation, and I test it the ordinary way: unit tests, known-answer tests against the NIST vectors, fuzzing, and careful code review. I have no formal proof of any of it, and I do not pretend otherwise. The honest position for a small builder is that testing finds bugs and a proof rules out classes of bugs, and those are different things. What DeepMind did shows that the second option is getting closer to reachable, not that it is already here for everyone.

The part to watch next

DeepMind's researchers say there is "a long distance to go" before this scales to all software, and they are right. The open questions are the interesting ones: can this extend to group chats, where most real conversations happen? Can it cover key generation and the device layer? Can the post-quantum healing property of SPQR be proved, rather than just the classical part? And can the cost come down far enough that a team of five, or one person, can run this on their own protocol?

If even two of those get answered in the next year, the standard for what "we verified our crypto" means will move, and it will move fast. Until then, the right way to read this announcement is as a proof of concept in the literal sense: a concept, proved, about a real library, with its limits stated in the open. That is already more than most security announcements give you.


Sources: Google DeepMind, "Formal Verification of Signal's Protocol with Gemini" (10 November 2026); the AlphaProof Code technical paper; Signal's Double Ratchet specification, Revision 4 (4 November 2026), Section 6; WIRED's coverage of the announcement.

Top comments (0)