Google DeepMind releases AlphaProof Code, formally verifying a Signal protocol implementation at the machine code level
On November 10, 2026, Google DeepMind released AlphaProof Code, a human-AI collaborative formal verification framework, and applied it to libsignal, the reference implementation of the Signal protocol. Without modifying the libsignal code, the team used rustc to compile an AArch64 Linux executable, modeled the instructions and runtime environment in Lean, and proved that the compiled machine code satisfies security properties such as forward secrecy. A team of 5 people spent 4 weeks, and an AI agent based on Gemini Carbon generated approximately 6.5 million lines of Lean proof code; the specifications, proofs, and verification scripts have been published on GitHub at google-deepmind/code-verification.
Why read this
AI score 68
The original text explains the human-AI collaborative verification workflow and the scope of the proof at the libsignal machine code level, and also lists the assumptions and limitations not covered.
Topics
Body · AI translation
On November 10, 2026, Google DeepMind announced "AlphaProof Code," a framework in which human experts and AI agents collaborate to formally verify software. The research team applied this mechanism to libsignal, the reference implementation of the Signal protocol used for end-to-end encrypted communication. They report that, under assumptions concerning cryptographic processing and the execution environment, they proved that the compiled machine code satisfies key security properties.
Introducing AlphaProof Code: a breakthrough in verifying complex software at depth - Google DeepMind
In formal verification, one first describes the properties that software must satisfy as a specification. Then one mathematically proves that the program satisfies that specification when assumptions about the execution environment, inputs, and so on hold. Conventional verification of cryptographic protocols has often dealt with abstract designs or implementations rewritten to be easier to verify, and verifying the code actually used required enormous effort. The research team positions this result as the first achievement of proving protocol-level security for a widely used cryptographic protocol implementation without modifying it.
Humans approve the specification, AI generates the proof, Lean checks it
In AlphaProof Code, human experts decide which properties of the program to prove and what assumptions to make about inputs, the execution environment, and so on. Following that policy, AI agents describe the claims and assumptions to be proved in the language of the Lean theorem prover and draft the specification. Experts review and revise the draft and approve the specification.
After approval, a coordinating AI agent divides the work of proving that the program satisfies the specification and assigns it to the responsible agents. Each responsible agent generates Lean proof code, and an integration agent combines them.
The Lean kernel checks the logical correctness of the generated proofs. In addition, a checking AI agent runs comparison tools and checks not only the claims being proved but also the definitions that those claims directly or indirectly reference against the approved specification. This prevents acceptance of proofs in which AI has altered the specification without authorization. However, even if the correctness of the proof and its consistency with the specification can be confirmed, humans must judge whether that specification expresses the properties they actually want to verify.
Flow of formal verification with AlphaProof Code. At the upper left, humans and AI create a Lean specification, and humans approve it. At the lower left, the compiled machine code is handled by an execution model on Lean. The group of AI agents on the right proves that the code satisfies the specification. The checker performs Lean checking and comparison against the approved specification, and accepts proofs that pass both (from Google DeepMind's announcement blog).
Proving forward secrecy and more in the libsignal implementation
According to the technical paper, the research team incorporated the libsignal code without modification into a command-line program for verification and used the Rust compiler rustc to create an executable for AArch64 Linux. They loaded this executable into Lean and, based on models defining AArch64 instructions and the behavior of the Linux execution environment in Lean, AI agents generated proofs. Because they directly verified the compiled code this time, they did not need to assume that the compiler works correctly.
A team of five people worked on this proof effort for four weeks, and AI agents generated approximately 6.5 million lines of Lean proof code. According to the announcement, Gemini Carbon was used as the model for the AI agents that generate proofs.
The verification target is one-to-one communication, including PQXDH, in which both communicating parties share a secret value that serves as the basis for cryptographic keys, and the Triple Ratchet, which updates the cryptographic key for each subsequent message. For this program, the research team proved that even if current keys and so on are leaked, past messages cannot be decrypted (forward secrecy). In addition, they proved that, under conditions such as an attacker not intervening in key exchange after a compromise, the security of communication can be restored through key updates.
The research team further intentionally reproduced two previously fixed libsignal bugs in the verification code. In this verification, they checked whether code containing the bugs would still satisfy the current specification. In both cases, they proved that the program reproducing the bug does not satisfy the security properties defined in the specification, and the proof was checked in Lean.
However, the verification target this time is limited to the command-line program that the research team created by incorporating libsignal. Also, in this proof, they assumed that some cryptographic processing and file output processing, among others, work as specified, and did not verify those implementations themselves. When assuming an attacker using a quantum computer, they did not prove that the security of communication can be restored after a compromise[1].
Specifications, proofs, and verification tools released on GitHub
Google DeepMind has released the artifacts of this formal verification at google-deepmind/code-verification on GitHub. It includes the specifications and proofs written in Lean, definitions representing AArch64 instructions and the execution environment, verification scripts, and so on. It also provides build and checking procedures so that third parties can re-check the proofs in Lean.
As future applications, they cite firmware for medical devices and software for power grids, among others. However, they say that further research is needed to apply the method widely.
AI Trends