← Back to Blog

Picking Open-Source Dependencies When Some Come With Proofs: How to Read Theorem's Proofs Repository Without Fooling Yourself

· 7 min read One long shelf of identical plain blank boxes against a deep navy wall, with two of them glowing warm amber from within.

Most small businesses never write a parser. They use other people's: a JSON library in the website back end, a TLS library behind every HTTPS call, a compression library inside backups, an image decoder in the photo upload form. Choosing among them has always meant judging popularity, maintenance and security history.

There is now one more signal for some of them. Theorem's OSS Verify program publishes machine-checked proofs about open-source libraries in a public repository, oss-verify-proofs. As of November 19, 2026, its README says "90 entry points in 32 libraries have proofs," including parts of OpenSSL, mbedTLS, libpcap, bzip2, coturn, pupnp, json-c and cJSON.

That's a real and useful signal. It's also easy to overread. We took one library, cJSON, read its proof page end to end, and re-ran the proof check on our own server. Here is how to read the repository the way a careful buyer should.

The maintainer's side of the same program is in our measured test of Theorem's tools and the defense small-business guide.

The one-paragraph version

A proof in this repository is about one entry point (a fuzz target) of a library, compiled into specific binaries for RISC-V 64, at one commit of the library. It shows that on every input within stated limits, those binaries never crash, trip a sanitizer or (for some statements) hang. It doesn't show the library gives correct answers, and it doesn't cover code that entry point never reaches, other versions, or the build in your product.

How to read a project page: cJSON as the example

Each library has a page at projects/<name>/README.md. Here's what cJSON's page says, and what each part means for you.

"Built from cJSON 1.7.18 (commit acc76239)." The proof is about that version. If you run 1.7.19, which was current when we checked, the proof is evidence about closely related code, not a proof about yours. We rebuilt v1.7.19 with Theorem's own tool and got a 72,888-byte plain binary. The proved one is 72,792 bytes. Different source, different bytes, different object.

"15 statements: 3 proved, 0 known false, 0 suspected false, 0 blocked by the model, 12 open." A statement is one precise claim. "Proved" means a machine-checked proof exists. "Open" means nobody has proved or refuted it yet. Three of fifteen is not a failure. It means the work is in progress, and you should read which three.

The three proved statements are asan_agrees, ubsan_agrees and asan_ubsan_agrees. An agreement statement says that on every covered input, "neither build reaches an error," and the plain and sanitizer builds behave identically. The sanitizers are AddressSanitizer (memory errors) and UndefinedBehaviorSanitizer (undefined behavior such as signed overflow). So the proofs rule out every error those sanitizers detect, on every input within the memory budget. But the repository says plainly that an agreement statement "does not rule out a run that never ends; only a halts statement does." For cJSON, the halts statements are among the twelve still open. So: proved memory-safe and free of undefined behavior on that entry point, not yet proved to always finish.

"Checks beyond 'does not crash': none." cJSON's fuzz target parses, prints and minifies, and "every output is freed unexamined." The proof shows the parser can't crash or corrupt memory. It says nothing about whether it parses correctly. That is the norm for fuzz targets imported from OSS-Fuzz, and it's the most important line on any project page. Look for it.

"1 of OSS-Fuzz's 1 fuzz target has statements" and "Not included: api-driver (held from this release)." Coverage is per entry point. A library whose other APIs have no fuzz target has no proof about them.

What every proof leaves out

The repository README has a section titled "What a proof does not say." Paraphrasing it only lightly:

  • It doesn't say the library is correct. Wrong results and memory leaks are not excluded.
  • It's about the code one entry point reaches, not the whole library.
  • It's about static RISC-V 64 binaries built with clang 20.1.8 against musl. It's not about the source code, or the x86-64 builds OSS-Fuzz runs.
  • It's true in LPS, Theorem's formal model of a Linux process, which the README calls "best effort and not complete."

The program docs add a few more:

  • Single-threaded programs only. The model has one thread.
  • No uninitialized-memory checks. There's no MemorySanitizer build.
  • No leak detection.
  • Inputs under 64 MiB.

What you have to trust

The README lists the trusted base:

  • the Rocq proof assistant's kernel and a short list of allowed axioms;
  • LPS at a pinned commit;
  • the tools that turn an ELF binary into a memory image for Rocq;
  • and Theorem's oft check wrapper, which confirms each proof has the right theorem type and refuses any assumption not on the allowed list.

You don't have to trust Theorem's AI, which wrote the proofs, or the people who reviewed them, because the checker re-verifies everything. That's the point of a machine-checked proof.

We re-checked one ourselves

The README gives the commands to re-run a proof. We did it for cJSON on November 19, 2026:

  • Fetch: ./oft fetch cjson downloaded the four published binaries in 3 seconds and checked each against its SHA-256. We first had to install the repository's pinned Python packages for our own Python version. A build for the wrong version silently drops PyYAML's fast loader, and the tool then fails.
  • Check: the documented docker run ... ./oft check cjson/cjson_read_fuzzer --parts statements,proofs, in Theorem's pinned checker image, with no network, limited to 8 cores. The README warns that one check can need up to 20 GiB of memory on 16 cores.
  • Progress when we published: the 15 statements compiled first. After 37 minutes, 1,258 Rocq files had compiled at about 6 GB of memory, with the final, largest theorems still running. Theorem doesn't publish expected check times, so plan for an hour or more per entry point on modest hardware.

You probably won't re-check proofs for every dependency. But knowing that you can, with public tools and pinned images, is what separates this from a vendor badge.

How to use this when choosing a dependency

  1. Treat it as a tiebreaker, not a gate. Most good libraries have no proofs yet, because the program is new. Absence of a proof isn't evidence of a problem. A project might not be enrolled, might have chosen publish: never, or might be waiting in the queue.
  2. Match the entry point to your use. If you only call the parse function, a proof about the parse fuzz target is relevant. A proof about a bignum fuzz target in a crypto library tells you about bignum code, not about TLS handshakes.
  3. Match the version. Note the commit the proof was built from. Upgrading past it is usually wise for other reasons, but then you're relying on "similar code was proved," not on a proof.
  4. Read "checks beyond does not crash." If it says "none," the proof is about memory safety and undefined behavior, not correctness.
  5. Check the statement type. "Agrees" rules out sanitizer-detected errors. "Halts" also rules out hangs. Both are good. They aren't the same.
  6. Keep patching. A proof covers one commit. Security fixes still land in later versions, and you still need them.
  7. Remember dependencies of dependencies. Theorem's FAQ says bugs found in a project's dependencies "are reported to the maintainers of those dependencies, not to the maintainer of the project." A proof about library A's fuzz target covers the code of B that A's target reaches, in that build. It says nothing about the rest of B.

What it means for a small business

For a business that only consumes libraries, the practical value today is small but real. When you or your developer choose between two libraries that do the same job, a published proof on the entry point you'll use is a meaningful point in its favor. It's also a sign the maintainers took the time to answer Theorem's question of what "correct" means. For anyone writing a security questionnaire or vendor review, "do any of your parsing dependencies carry published proofs, for which entry points and versions?" is now a fair question with checkable answers.

For a business that maintains a library, the defense small-business guide covers what enrolling costs and how to describe the result.

Fact-check notes and sources

  • Proof counts, statement meanings, what a proof does not say, the trust list, re-check commands: oss-verify-proofs README, read November 19, 2026 (repository head 2db17da).
  • The cJSON page (version 1.7.18, commit acc76239, 15 statements with 3 proved and 12 open, "checks beyond does not crash: none", outputs freed unexamined, the held api-driver): projects/cjson.
  • Single thread, no MemorySanitizer, no leaks, 64 MiB: what-gets-proven.md. Dependency bug reporting, publish options: Theorem, OSS Verify FAQ.
  • Our rebuild and re-check: our server, November 19, 2026. The re-check was still running at publication, so this article reports progress, not a result. The 72,888-byte figure is our v1.7.19 plain build from oss-verify check. The 72,792-byte figure is the published 1.7.18 binary fetched with ./oft fetch cjson and checked against its SHA-256.

Related reading

This post is informational, not security-consulting or procurement advice. Mentions of Theorem, OSS Verify, Rocq, Google, OSS-Fuzz, cJSON, OpenSSL, mbedTLS, libpcap, bzip2, coturn, pupnp and json-c are nominative fair use. No affiliation is implied.

← Back to Blog

Accessibility Options

Text Size
High Contrast
Reduce Motion
Reading Guide
Link Highlighting
Accessibility Statement

J.A. Watte is committed to ensuring digital accessibility for people with disabilities. This site conforms to WCAG 2.1 and 2.2 Level AA guidelines.

Measures Taken

  • Semantic HTML with proper heading hierarchy
  • ARIA labels and roles for interactive components
  • Color contrast ratios meeting WCAG AA (4.5:1)
  • Full keyboard navigation support
  • Skip navigation link
  • Visible focus indicators (3:1 contrast)
  • 44px minimum touch/click targets
  • Dark/light theme with system preference detection
  • Responsive design for all devices
  • Reduced motion support (CSS + toggle)
  • Text size customization (14px–20px)
  • Print stylesheet

Feedback

Contact: jwatte.com/contact

Full Accessibility Statement • Privacy Policy

Last updated: April 2026