Claude has proven security properties for more than 100 real-world open-source software libraries, a step the researchers say shows formal verification can now work at a scale that was out of reach until recently. The effort, carried out with the verification firm Theorem, produced proofs for 239 entry points across 123 libraries that tested code crashes on no input up to 64 MB. While writing those proofs, Claude also turned up bugs that had escaped detection for years, despite trillions of test runs.

The work targets a problem that has grown harder to ignore. Even heavily tested software contains bugs, and language models are getting better at finding them. The Linux kernel, one of the most scrutinized pieces of software in existence and running on billions of devices, recently had more than 1,000 vulnerabilities disclosed. Standard defenses are not enough on their own. Developers need a way to show that code is free of certain classes of bugs, not just to hunt for them.

Formal verification offers that kind of proof, but it has been expensive. Developers translate code into a mathematical model and try to prove it always follows a set of security rules. Each failed proof points to a possible bug, and fixing it moves the work forward. The catch is effort. Proofs can run many times longer than the code they check, and they demand a rare skill set. Building the seL4 operating system kernel took two person-years, the researchers noted, but verifying it took 20. That cost has kept the method mostly in mission-critical work such as Airbus avionics code.

For this project, Claude took fuzz tests written by developers and converted them into formal specifications. A fuzz test feeds a program huge numbers of semi-random inputs to look for crashes. The problem is that fuzzing can run forever and still miss paths through the code. Claude’s proofs were built on the compiled RISC-V instructions, the low-level commands that software is translated into, and they cover a single-threaded static binary with a fixed memory budget running on Linux. The full set of proofs runs to about 180 million lines of Rocq, the proof-checking system used. A typical proof is around 600,000 lines and covers binaries with a median length of 18,000 RISC-V instructions.

The process did more than confirm code was safe. When Claude could not complete a proof, it often found a real bug, patched it, and then proved the corrected version. The researchers said this approach can be risky because a model might simply change a program until the proof becomes easy, so they penalized patches and audited the changes for shortcuts. The fixes it made turned up problems fuzzers would be unlikely to find. In one library, Claude found a counter underflow in a decompressor that caused an out-of-bounds write, but only with inputs around 20 MB that had one rare layout. Another out-of-bounds read required a 64 MB input and more than 2 GB of memory. In a third case, Claude rediscovered CVE-2026-56132 in libexpat, which needed deeply nested input. It also flagged a logic problem that never crashes a program: a feature meant to restrict which files an application can load was not always enforced.

The team also tested the method on other code. Claude wrote a formal specification of RFC 1950, the document defining the zlib compression format, and then proved that the zlib implementation in the Linux kernel matched it at the x86 binary level. The researchers repeated the exercise on about half a dozen other widely used libraries and found minor, unexploitable bugs in corner cases. In a separate experiment, Claude built a large subset of Python as an interpreter in Rust. Running more than 1.7 million randomly generated programs, the team found identical behavior to CPython in 99.95 percent of tests. In another project, the team verified a widely used PDF reader and found as many security bugs in one week as are typically reported in a year. In one case, a logic bug had been present for more than a decade.

The researchers are clear about what the proofs do not show. A proof checker can confirm that a program meets a specification, but it cannot confirm the specification matches the real world. Most people run these libraries on x86 or ARM processors and link them to glibc, while the proofs assume RISC-V and musl libc. Verification also does not catch every memory safety bug, since AddressSanitizer misses some, and the proofs do not cover callers that misuse a library. The team said its own statement is that “formally verified” does not mean “bug-free.”

Cost remains the main barrier. The proofs can take hundreds of millions of tokens to produce. The team says costs are falling. On 36 small verification tasks drawn from OSS-Fuzz code, the newer Opus 5.5 model proved half of them using about 40 percent fewer tokens than Opus 5. Reusing proofs also helps. When agents worked in a shared workspace, they needed 17 percent fewer tokens than when they worked alone, and some agents succeeded where solo attempts had failed.

Theorem is offering to run the same pipeline on other open-source projects, and the research team is publishing a subset of its proofs, along with the RISC-V and operating system semantics, so outside researchers can check the work. It is also releasing a Claude skill to help developers begin verifying their own code.

Este artículo fue escrito con la asistencia de IA.
News Factory APP - noticias agénticas para impulsar tu SEO y AEO.