DEV Community

Mohammad Taha Azizi Ahad
Mohammad Taha Azizi Ahad

Posted on

AI Just Proved Signal's Encryption With Math. Here's What That Actually Means

AI Just Proved Signal's Encryption With Math. Here's What That Actually Means

On November 10, Google DeepMind published something I have been waiting years to see: a mathematical proof that the code behind Signal's encryption actually does what it promises. Not a code review. Not an audit. A proof, checked by a machine, covering the compiled code that runs on real phones.

The project is called AlphaProof Code. A team of five researchers spent four weeks with it, and AI agents working under human supervision generated more than six million lines of Lean proof covering libsignal, the reference implementation of the Signal protocol. That is the same protocol that protects chats in Signal, WhatsApp, and Google Messages. The work covers two things that matter most in a messenger: the PQXDH handshake that sets up a conversation, and the Triple Ratchet that rotates the key for every message.

Four weeks. Work like this used to take expert teams years.

Why this is different from every audit you have read about

Most of the security assurance in our industry stops at the design level. Cryptographers write a protocol on paper, prove the paper version is sound, and then somebody else writes the code. The gap between those two things is where real vulnerabilities live. A ratchet that is perfect in a paper can still leak a key if the implementation reuses a nonce, skips a step on an error path, or mishandles a state transition that the paper never had to think about.

DeepMind's team did not verify the paper version. They verified the compiled code, down to the exact instructions running on ARM devices. They proved four properties of that code: messages stay secret, the other side is who they claim to be, past messages stay secret even if a key leaks later, and the conversation recovers its security after a compromise. That last one, post-compromise security, is the property most messengers get wrong in practice, and it is the one users notice least until it fails.

This is also the first time, by DeepMind's own account, that the implementation of a widely deployed protocol like this has been formally verified by any method at all, with or without AI.

The detail that convinced me

A proof that finds no bugs always raises the same question: would it have found a bug if one was there? DeepMind answered that directly. They took two real bugs that had been found and fixed in older versions of Signal, reintroduced them into an isolated copy of the code, and ran the system against it. In both cases, AlphaProof Code produced a machine-checked proof that the buggy version was insecure.

That is the right test. A verification tool that cannot fail is a rubber stamp. This one failed exactly when it was supposed to.

The human side of the process matters too. Researchers and models wrote the formal specifications together, and human experts reviewed every single one. The agents then flagged about one percent of the codebase for a second human look, and Lean checked the rest automatically. The point is not that AI replaced the experts. The point is that the experts could finally spend their time on the one percent where judgment actually matters, instead of grinding through the other ninety-nine.

What it does not prove

I am writing this as someone building a messenger, so I want to be precise about the limits, because they are easy to overstate away.

First, the proof covers one-to-one sessions only. Group messaging is listed as future work. Second, it applies to libsignal version 0.105.4, compiled for ARM Linux inside a test harness, not to the full Signal app on your phone. The app, the servers, the key servers, the UI that shows you a safety number: none of that is covered. Third, the low-level cryptographic building blocks are assumed secure, not proven. If the math under ML-KEM or the curve code had a flaw, this proof would not catch it. And fourth, a proof is only as good as its specification. If the humans wrote down the wrong security goal, the machine will happily prove the wrong thing.

There is also a subtlety people will miss: WhatsApp and Google Messages run their own versions of the protocol. This result is about libsignal. It does not automatically carry over to every app that borrows Signal's ideas.

None of that diminishes the result. It just tells you what the result is. A proof about the core ratchet and handshake of the reference implementation is exactly the part that has been out of reach for years, and it is now in reach.

What changes for people building messengers

I build a messenger myself. My own project uses a post-quantum ratchet built on ML-KEM-768 with ML-DSA-65 signatures, and I have written before about how much of the work is not the cryptography on paper but the state machine around it: what happens when a message arrives out of order, when a key is replaced, when a session is restored from a backup. That is the work where bugs hide, and it is also the work that formal verification has historically been too slow and too expensive to touch.

If a four-week project with five people can now do what used to take years, the economics of that work change completely. Verification stops being something only a Signal or a Google can afford for one protocol, and starts being something a small team can plan for. The artifacts are open source, the technical paper is public, and the method is not tied to Signal. DeepMind names medical device firmware and power grid software as the next targets, and they are right to aim there, but the more immediate effect is on messaging itself: the next generation of protocols, including post-quantum ones, can be verified at implementation depth from the start instead of audited years after shipping.

There is a second effect that matters just as much. As AI-written code becomes normal, AI-written attacks will get faster too. A defense that takes years to build and four weeks to verify is a defense that can keep up. A defense that takes years to verify is not. Pairing verification with automated patching, which DeepMind mentions alongside a tool called CodeMender, points at a future where the loop from finding a flaw to proving the fix is measured in weeks, not release cycles.

The honest summary

Signal's core cryptography now has something almost no widely used software can claim: a machine-checked proof that the compiled code delivers forward secrecy, authentication, post-compromise security, and handshake secrecy for one-to-one chats. No new flaws were found in the current code. The proof is public, the method is repeatable, and the control experiment shows the tool can actually catch real bugs.

It does not prove the whole app is safe. It does not cover groups. It does not replace audits, and it does not mean every messenger using Signal's ideas inherits the result. But it moves the strongest form of assurance we have from the realm of multi-year research projects into something a small team can run in a month.

For anyone building secure messaging, that is the news. The bar for what "verified" means just moved, and it moved in our direction.


Sources: Google DeepMind, "Formal Verification of Signal's Protocol with Gemini" (November 10, 2026); DeepMind's AlphaProof Code announcement and open-sourced verification artifacts.

Top comments (0)