Google's AI Just Proved Signal's Encryption Is Secure — by Checking Every Line of Code

sheen6869

2 days ago

7 min read

By Shakeel Ahmed — AI Growth Lab | November 11, 2026

Originally published on AI Growth Lab: https://aigrowthlabshakeel.blogspot.com/

On November 10, 2026, Google DeepMind announced that its AlphaProof Code system formally verified key security properties of the Signal protocol's cryptographic code. AI agents powered by Gemini Carbon generated more than six million lines of machine-checked proof in the Lean proof language, and the full verification took four weeks. The work covers Signal's post-quantum handshake and its Triple Ratchet, proven down to the compiled machine code that actually runs on devices.

This is not another story about an AI finding a bug. It is the opposite. Instead of hunting for mistakes, DeepMind's system produced a mathematical proof that the code does what it claims to do. If you use Signal, Google Messages, or any app built on the Signal protocol, this is the strongest assurance that code has ever received. This article explains what formal verification is, how AlphaProof Code works, what exactly was proven, and the honest limits you should know about.

WHAT FORMAL VERIFICATION ACTUALLY MEANS

Most security testing works like this: run the code, throw attacks at it, and see what breaks. If nothing breaks, you ship it and hope. Formal verification works the other way around. You write a mathematical statement of what the code must do, and then you prove, step by step, that the code always does it. No test cases. No sampling. A proof that a machine can check from start to finish.

Google DeepMind puts it plainly in its announcement: "Formal verification, mathematically proving code runs correctly without flaws, is the highest standard of security assurance; however, it is difficult and often labor-intensive." That difficulty is why almost no widely used software has ever been verified this way. DeepMind's own blog notes that the verification took four weeks, "a task that historically takes expert teams years." For scale, one famous earlier project, the verification of the seL4 microkernel, a far smaller piece of software, took about 20 person-years of expert work.

That is the gap AlphaProof Code is trying to close. If AI agents can do the slow, grinding work of writing proofs, then the highest standard of security stops being a luxury for tiny programs and starts becoming realistic for the software billions of people rely on.

HOW ALPHAPROOF CODE DID IT

AlphaProof Code is not one model. It is a team of AI agents that splits the work the way a research team would, with humans keeping the decisions that matter most.

First, human experts worked with several AI models to turn Signal's security goals into formal mathematical specifications. Humans reviewed every specification. This is the crucial part: the proof is only as good as the statement of what must be true, and people, not models, decided that.

Second, teams of prover agents running on Gemini Carbon wrote the proofs in Lean, a programming language that doubles as a strict proof checker. The agents produced more than six million lines of Lean proof, about 6.5 million lines according to the technical paper, resting on roughly 26,000 lines of trusted specifications and machine-code rules.

Third, the agents audited their own proof and flagged the parts that needed a second look by a human. That was just one percent of the codebase. Because the Lean kernel automatically checks everything else, human experts could focus their review where judgment actually matters.

And here is the detail that separates this from ordinary AI code review: the verification went all the way down to the compiled machine code. DeepMind compiled the unmodified libsignal code, version 0.105.4, with the standard Rust compiler into AArch64 machine code, about 140,000 instructions, and proved the properties against that compiled code. Most protocol proofs stop at the design on paper. This one checked the code that really runs, closing the gap between design and implementation where real-world vulnerabilities usually hide.

WHAT WAS PROVEN

The verification covers one-to-one Signal sessions, and it proves four core properties of the code.

1. Forward secrecy: if someone steals your phone or your keys today, they cannot go back and read your old messages.

2. Authentication: you are really talking to the person you think you are talking to, not an impostor in the middle.

3. Post-compromise security: if an attacker briefly compromises a device, future messages become safe again once keys rotate. The system heals itself.

4. Handshake secrecy: the first key exchange between two phones, including the post-quantum PQXDH handshake, keeps its secrets from eavesdroppers.

These properties were proven for the PQXDH handshake, the post-quantum key agreement that starts a conversation, and the Triple Ratchet, the mechanism that keeps rotating keys as messages flow. DeepMind states: "Our work marks the first time AI has been used to formally verify a widely deployed cryptographic protocol at this depth. It is also the first time the implementation of a widely deployed protocol like this has been formally verified by any method, with or without AI."

WHY SIGNAL WAS THE TEST CASE

Signal was the obvious target, and the hardest one. Its protocol protects billions of private conversations, not only in the Signal app but also in Google Messages, and variants of it run in WhatsApp and Messenger. It is the app journalists, activists, doctors, and ordinary people trust when a conversation must stay private.

That trust rests on code that has been audited many times, but until now it had never been formally verified at the level of the actual implementation. Signal's chief technology officer, Ehren Kret, welcomed the result, saying that "having the core Signal protocol rigorously verified with automated theorem proving gives us even greater confidence that our code delivers on its privacy guarantees."

The choice also answers a challenge. In April 2026, the Beneficial AI Foundation challenged the field to formally verify the Signal protocol and the Signal app using Lean. DeepMind's team of nine researchers took up the core of that challenge, and the proof is now public: DeepMind has open-sourced its verification artifacts for community use.

THE BUG TEST THAT PROVES THE PROOF WORKS

A proof system is only useful if it can tell good code from bad code. DeepMind tested that directly. The team took two real Signal bugs that had already been fixed, known as the weak state and small subgroup flaws, and put them back into an isolated copy of the code. In both cases, AlphaProof Code produced a machine-checked proof that the buggy version was insecure. The system caught what it was supposed to catch.

Just as important is what it did not find. The analysis found no new vulnerabilities in the parts of the code it examined. That is a strong result, but read it carefully: no new flaws in the parts examined, not a guarantee that no flaw exists anywhere.

This is the difference between AlphaProof Code and the AI bug-hunting tools you have read about before. We covered the other side of this story in October, when AI found a bug hiding in PHP code since 2012: https://aigrowthlabshakeel.blogspot.com/2026/10/ai-found-the-bug-php2shell.html. Bug hunting asks, can you find what is wrong. Formal verification asks, can you prove what is right. The second question is much harder, and much more valuable when the answer is yes.

WHAT IT DOES NOT PROVE

Honest reporting means stating the limits in plain language. This proof is real, and it is also bounded.

First, the proof assumes the underlying cryptography is perfect. The low-level crypto building blocks were treated as trusted contracts, not proven from scratch. If a primitive itself were broken, the proof would not catch it.

Second, the work covers one-to-one sessions only. Group messaging, sealed sender, and server-side code were not covered. Key generation was not verified, and the post-quantum healing that Signal's SPQR system is designed to add was not proved.

Third, the proof targets one compiled platform, AArch64 Linux, and one build of the library running as a fresh process. It is not a certificate for the whole Signal app on your phone, and it does not cover side-channel attacks or what happens on a compromised device.

Fourth, this is a research result, not a product. There is no app update to install and nothing you need to do. DeepMind has not said whether it plans to sell formal verification as a service, and its researchers say there is still a long distance to go before this scales to all software.

None of this weakens the achievement. It defines it. A proof is only meaningful when you know exactly what it covers, and DeepMind's technical paper is unusually open about those boundaries.

WHAT IT MEANS FOR THE SOFTWARE YOU USE

The near-term effect is simple: Signal users get stronger assurance with no action needed. Nothing changes on your phone, and there is no patch to install. The deeper effect is about the future of software security.

If AI agents can verify production cryptography in four weeks, the same approach can reach the code that runs hospitals, power grids, and banks. DeepMind says verifying Signal's core cryptography lays the groundwork to secure other vital systems, from medical device firmware to power grid software. When security fails in those places, the damage is physical, not just digital. A cyberattack shut every Boston Scientific factory for eight days, and patients felt it: https://dev.to/shakeelahmed/a-cyber-attack-shut-every-boston-scientific-factory-for-8-days-and-patients-felt-it-4ikg

The other shift is who does the work. Formal verification used to need a room full of rare specialists for years. AlphaProof Code still needs human experts, but only for the specification and the one percent of the work that needs judgment. The agents did the millions of lines. That changes the economics of trust.

DeepMind has been probing encryption from both sides. Just days ago, its AI found cracks in RSA encryption, and we explained what that means for the keys protecting the internet: https://dev.to/shakeelahmed/deepminds-ai-found-cracks-in-rsa-encryption-should-you-worry-4ooa. Finding cracks and proving strength are two halves of the same job, and AI is now doing both.

What to watch next: whether independent researchers reproduce the proofs from the open-sourced artifacts, whether the work extends to group messaging and the full Signal app, and which critical system gets verified second. The first widely deployed protocol has its proof. The question now is how fast the second one follows.

Sources

Google DeepMind — Formal Verification of Signal's Protocol with Gemini, November 10, 2026: https://deepmind.google/blog/introducing-alphaproof-code/

The Register — Google DeepMind melds humans and AI agents to vet Signal's secure messaging techniques, November 10, 2026: https://www.theregister.com/ai-and-ml/2026/11/10/google-deepmind-melds-humans-and-ai-agents-to-vet-signals-secure-messaging-techniques/5308625

SXF Brief — AI News Nov 11, 2026: AlphaProof Code, November 11, 2026: https://sxf.si/brief/

Google DeepMind — AlphaProof Code verification artifacts and technical paper: https://github.com/google-deepmind/code-verification

Google's AI Just Proved Signal's Encryption Is Secure — by Checking Every Line of Code

Recent Posts

Comments