NewsMacroGoogle DeepMind AI-Generated Proofs Catch Two Reintroduced Bugs in Signal's Encryption Library

Google DeepMind AI-Generated Proofs Catch Two Reintroduced Bugs in Signal's Encryption Library

Author: Blockonomi·

Key Takeaways

  • •The proofs detected both known libsignal bugs after researchers deliberately reintroduced them.
  • •AI agents generated about 6.5 million lines of machine-checked proof code for the verification effort.
  • •The verified target was limited to an AArch64 Linux program using specified libsignal and SPQR versions.
  • •The analysis did not directly verify key generation, group messaging, Signal phone apps, multi-device state or quantum resistance.
  • •A GitHub update verified ten more routines and reduced reliance on modeled contracts from 37 hooks to 27.
Google DeepMind AI-Generated Proofs Catch Two Reintroduced Bugs in Signal's Encryption Library

Google DeepMind researchers put their AI-written security proofs to the test by planting two previously fixed bugs back into Signal's encryption library — and the machine-checked proofs flagged both tampered builds as violations of the expected security rules.

The test forms one part of a larger verification effort in which AI agents produced roughly 6.5 million lines of machine-checked proof code tied to a compiled build of libsignal, the library underlying the Signal protocol. The findings were released on Nov. 10 in the AlphaProof Code report, and the researchers also posted their evidence online so that others can check it independently. Because the proofs are machine-checked, they can be replayed and inspected rather than accepted on faith.

The project was guided by five people over four weeks. The humans steered the work, selected the reference models and reviewed the specifications — documents that set out precisely what the AI agents were required to prove — while the step-by-step validation of the resulting proofs was left to the machine checker.

How the Bug Test Worked

The two bugs had already been fixed in libsignal. The team added them back and ran the modified build against its symbolic security theorem. Both altered versions failed to satisfy the theorem, demonstrating that the specifications can reject known defects rather than approve whatever code is placed in front of them.

The proofs cover one specific target: an AArch64 (64-bit ARM) Linux program using libsignal-protocol v0.105.4 and SPQR v1.6.0, run inside a small command-line tool. In other words, the verified target is a narrowly pinned configuration rather than Signal's full deployment. The theorems span three actions — starting a session, sending a message and receiving one — and link the program to the security properties of PQXDH (Post-Quantum Extended Diffie-Hellman) and Triple Ratchet one-to-one messaging.

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

The work relies on 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 hidden — 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 account for quantum attackers, and it leaves out multi-device state. Its guarantees also stop being useful once workloads grow sufficiently large.

The symbolic proof does show that handshake secrecy holds under certain later breaks of Diffie-Hellman. Even so, the results depend on trust in the checking kernel of Lean, the proof assistant in which the proofs are written, as well as the reviewed specifications, the AArch64 Linux model and contracts covering selected routines. Those contracts — known as hooks — replace the running of certain routines with assumed descriptions of how they behave. Fewer hooks means less of the overall 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 that the theorems match the trusted statements, then replays the proofs in a fresh Lean kernel.

A Nov. 11 update, merged on GitHub, verified ten additional library routines, cutting 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.

Source: Blockonomi