DeepMind's AlphaProof Code formally verifies Signal's compiled cryptographic code in four weeks
- Google DeepMind's AlphaProof Code guided AI agents to formally verify the compiled code of the Signal protocol, producing over 6 million lines of Lean in four weeks, a task the team says historically takes expert teams years.
- DeepMind claims this is the first time AI has formally verified a widely deployed cryptographic protocol at implementation depth, and the first formal verification of such an implementation by any method, with or without AI.
- Human experts wrote and reviewed every formal specification; agents powered by Gemini Carbon generated the proofs and flagged about 1% of the codebase for human review, with Lean machine-checking the rest.
- To test soundness, researchers reintroduced two previously fixed bugs into an isolated copy of Signal's code, and the system produced machine-checked proofs that both buggy versions were insecure.
- Signal CTO Ehren Kret called translating live code into valid Lean theorems a major breakthrough; the work covers Signal's core cryptographic code, not the Signal app itself.
Hacker News 의견들
Pleased to see Signal looks good to our robot mindlords. A codebase that size holding up in a strict formal sense is genuinely impressive.
The crypto might be secure. I wouldn't be so sure about the rest of the code.
They verified the Signal protocol, not the Signal app. That distinction matters a lot.
I'm not versed in formal proofing at all. How does this get around the halting problem?
Lean has nothing to do with the halting problem. Think of it as a language where proofs are code, and the compiler enforces the constraints.
The halting problem only stops you from proving things about every program. Proving one specific program terminates is often easy.
Wonder how many dollars got spent on this one.
Please do Telegram next so we can settle the 'they invented their own crypto' argument for good.
They didn't invent their own crypto. They took the OTP protocol and cut it in all the wrong ways, then reinvented TLS with device IDs sitting outside the encrypted packet.
I figured software was about to get much buggier now that everyone offloads to AI. Tools like this give me some hope the opposite happens.
It'll be great when every CI run costs $10,000 so the AI can confirm you didn't break its giant proof.
Opposite happened at my company. Six months of fully agentic coding and our incident rate went down, mostly because the extra dev capacity went into tests and automated review.
The agent proves the implementation against the spec but never challenges the spec, right? How is that different from a normal coding agent iterating until Lean compiles?
How do we know the Lean model of the processor matches a real processor? Or that the spec matches what the Rust code actually does?
Why can't the AI decide what to prove? Is that the fundamental limit?
Deciding what to prove is a value judgment, not a reasoning step. At some point a human has to make the wish.
In a few years, running unverified software will look as mad as plaintext HTTP does now.
The scope of what we can verify is still tiny. 'This program won't crash' works. 'This GUI app talking to SQL does what's expected' is nowhere close.
Google has been the cleanest of the big players on this. Having humans review only the 1% that matters is a smart design.