Google DeepMind AI Proofs Catch Two Old Bugs Planted Back in Signal’s Code

1 hour ago 1

TLDR

  • Google DeepMind’s AI agents wrote about 6.5 million lines of machine-checked proof code for Signal’s encryption library.
  • Researchers put two old, fixed bugs back into the code, and the proofs showed both builds broke security rules.
  • Five people guided the work over four weeks, with humans setting what the AI had to prove.
  • Key generation, group messaging and the phone apps are outside the verified scope.
  • A Nov. 11 update cut trusted assumptions in the project from 37 to 27.

Google DeepMind researchers tested their AI-written security proofs by putting two old bugs back into Signal’s encryption library. The proofs showed that both modified versions broke the expected security rules.

The test is one part of a larger project. AI agents wrote about 6.5 million lines of machine-checked proof code tied to a compiled build of libsignal, the code behind the Signal protocol.

The findings come from the AlphaProof Code report, released on Nov. 10. The researchers also posted their evidence online so others can check it.

Five people worked on the project over four weeks. Humans guided the work, picked reference models and reviewed the specifications. These specifications set out exactly what the AI agents had to prove.

How the Bug Test Worked

The two bugs had already been fixed in libsignal. The team added them back and ran the modified code against its symbolic security theorem.

Both modified builds failed to meet that theorem. This shows the specifications can reject known errors rather than approve any code put in front of them.

The proofs cover one specific target. It was an AArch64 Linux program using libsignal-protocol v0.105.4 and SPQR v1.6.0, run inside a small command-line tool.

The theorems cover three actions: starting a session, sending a message and receiving one. They link the program to security properties of PQXDH and Triple Ratchet one-to-one messaging.

Those properties include forward secrecy, authentication and post-compromise security. In plain terms, they deal with whether old messages stay secret after keys are stolen, whether senders are who they claim to be, and whether a session can become secure again after a breach.

The work uses two proof models. The symbolic model assumes idealized cryptography, while the computational model limits how well classical attackers can succeed under stated assumptions.

Google AI agents audit Signal’s code and one major flaw stays hiddenhttps://t.co/bMeneq2zhg

— CryptoSlate (@CryptoSlate) November 17, 2026

What the Proofs Leave Out

Several areas fall outside the verified scope. Key generation, group messaging and the Signal phone apps are not directly proven.

The computational proof does not cover quantum attackers, and it leaves out multi-device state. Its guarantees also stop being useful once workloads grow large enough.

The symbolic proof does show handshake secrecy holds under certain later breaks of Diffie-Hellman. Still, the results depend on trust in Lean’s checking kernel, the reviewed specifications, the AArch64 Linux model and contracts for selected routines.

Those contracts, called hooks, replace running certain routines with assumed descriptions of how they behave. Fewer hooks means less of the result rests on assumptions.

The project’s code repository includes public steps to rebuild the pinned program and check its proofs. A Linux-only comparator confirms the theorems match trusted statements, then replays the proofs in a fresh Lean kernel.

A Nov. 11 update, merged on GitHub, verified ten more library routines. That cut the number of trusted hooks from 37 to 27.

The update kept libsignal v0.105.4 but changed the pinned program. The newer build checks the actual machine code for those ten routines instead of relying on modeled contracts.

The post Google DeepMind AI Proofs Catch Two Old Bugs Planted Back in Signal’s Code appeared first on Blockonomi.

Read Entire Article