← Back to Blog

A Free Machine-Checked Proof for Your Open-Source Parser: What It's Worth to a Defense Small Business, and How Not to Overclaim It

· 7 min read A blank sheet of paper on a dark navy desk with a small warm amber wax seal and a thin ribbon, crossed by a diagonal beam of light.

Defense customers increasingly ask small vendors for evidence, not adjectives. "Secure by design" and "rigorously tested" are adjectives. A machine-checked proof that a specific compiled parser cannot crash on any input under 64 MiB is evidence. Proofs like that used to take specialists years: Anthropic puts the seL4 kernel proof at 20 person-years.

Theorem's OSS Verify program now produces that kind of proof for free, for qualifying open-source projects. If your company maintains an open-source library that parses untrusted input, such as a message format, a sensor protocol, a codec or a configuration language, that is worth understanding. This article covers what you get, what it costs, where it fits in a defense system, and the exact claims you can and can't make afterwards.

It builds on our measured test of Theorem's tools, where three of four plausible-looking fuzz targets turned out to test nothing.

Who this is for

It fits a small business that:

  • maintains (not just uses) an open-source library under an OSI-approved license, in a public repository;
  • writes it in C, C++ or Rust (Theorem's builder also handles Python and Go, but those enrollments are paused, and Go gets no proofs yet);
  • has code on a trust boundary. Theorem's program page says it reviews projects partly on "how much of it sits on a security boundary or underneath other software (parsers, compression, cryptography, image and font decoders, protocol implementations)";
  • and can name a core maintainer. Only core maintainers can enroll, and Theorem checks the contact address.

C projects whose binaries hold under 1 MB of code are the most likely to get a quick response, per the README.

If your code is proprietary, you can't get a proof from this program. You can still use its method, which is in the kit from the companion article.

What you actually receive

From Theorem's program page and the proofs repository:

  • A proof about your binary. For each fuzz target, a Rocq proof that no input up to 64 MiB makes it crash, fail a fuzz-test check or trip AddressSanitizer. The proof is "about the compiled fuzz test, not its source code."
  • Checked by a machine. "You don't need to trust it; you only need to trust Rocq." Anyone can re-run the check. We did it ourselves on a published proof, as the buyer's guide describes.
  • The bugs found on the way, privately. "It's impossible to prove something that isn't true," so a bug blocking the proof gets reported to your contact address, with a patch when Theorem has one. There is "no disclosure deadline," and Theorem says it doesn't publish findings.
  • A public record, if you want one. The publish setting controls when the proofs go public: as they progress, after fixes are public (the default), or never.

What it costs you

The program is free, but the work isn't:

  • Engineering time to write real fuzz targets. This is most of the cost. Theorem's skill has a coding agent interview you about what "correct" means: which inputs an attacker controls, which outcomes are expected, which properties must always hold. Then it writes targets that crash only when a property breaks, proves each check is reachable, and requires a deliberate breakage for each check. In our test, cutting that corner left three targets that tested nothing and still passed.
  • A build machine. Linux x86-64, Docker with buildx, git, uv, and about 10 GB of disk. Our first full check of an enrolled project took 256 seconds including the toolchain download, and later checks about a minute.
  • A build port. Proofs are about static RISC-V 64 binaries built with clang 20.1.8 against musl, so your build may need porting even if it already runs in OSS-Fuzz.
  • Days of waiting. Proofs "can take multiple days to produce," and Theorem doesn't promise to take every project.
  • Triage time. Findings and patches are AI-generated, and Theorem says it doesn't promise a person reviews them before sending. Budget engineer time to verify each one.

Read the Dockerfile before you run the check tool. It builds with network access, and the README says to use it only on a project you trust.

Where it fits in a defense system

A proof about one parser is not a secure system. It is one strong component, and it's most valuable where a system's architecture already isolates components.

In our seL4 learning path, the worked design for a hardened sensor feeder has a small beast_parser component. It's the only code that reads raw frames from an untrusted radio front end, and the verified seL4 kernel ensures it can only write to one validated-frames buffer. The kernel's proof keeps a compromised parser contained. A parser proof would make it much less likely the parser gets compromised in the first place. The two proofs cover different failures, and a program office reviewing a design can see both.

The same logic applies wherever untrusted bytes enter a system: a message decoder on a tactical radio, a file-format reader in a ground station, a configuration parser in a mission computer. If that decoder is an open-source library you maintain, it's a candidate.

What you can and can't claim afterwards

This is where small firms get in trouble. The proofs repository lists exactly what a proof does not say:

  • "It does not say that the library is correct. Errors that the sanitizers cannot detect are not excluded: for example, a wrong result or a memory leak."
  • "It is about the code that one entry point reaches, not about the whole library."
  • "It is about these binaries: static riscv64 programs, built with clang 20.1.8 against musl. It is not about the source code, and not about the x86-64 builds of OSS-Fuzz."
  • "It is true in LPS," Theorem's formal model of a Linux process, and "where LPS differs from Linux, the proof may not apply." The README calls LPS "best effort and not complete."

Two more limits matter for fielded systems. The model covers single-threaded programs only. And there's no MemorySanitizer, so reads of uninitialized memory aren't checked.

The biggest one for defense work: your fielded binary isn't the proved binary. Your product probably runs on Arm or x86, built with a different compiler, flags and C library. The proof is strong evidence about your code's behavior, because the same source produced both. It isn't a certificate for the artifact you ship. Say so.

Wording that holds up

Good: "Our open-source libexample decoder has machine-checked Rocq proofs, published by Theorem's OSS Verify program, that its decode_frame fuzz target cannot crash or trigger an AddressSanitizer or UndefinedBehaviorSanitizer error on any input under 64 MiB, for the RISC-V 64 builds named in the proof. Our fielded builds use the same source; the proof does not cover them directly."

Bad: "Formally verified." "Proven secure." "Mathematically guaranteed bug-free." Each overstates a proof about one entry point of one build, under one model, for one class of errors.

Put the proof repository link and the commit in the capability statement, so a reviewer can check it the same way we did.

Practical notes

  • Licensing. Contributions to Theorem's repository are Apache-2.0. The skill notes that a project under GPL-2.0-only must license its new fuzz-target files as MIT or Apache-2.0, because GPL-2.0-only code can't link with Apache-2.0 code. Sort this out before your engineers write anything.
  • The contact address is public. The docs advise using "an address that you are glad to publish, such as a security alias." Use one.
  • Encrypt reports if you need to. Set pgp and reports go encrypted to the primary contact only.
  • Pause or leave any time by pull request.
  • Contracts and controlled data. Open-source code is public by definition, but your fuzz targets, seed inputs and comments are public too once you open the pull request. Keep controlled program details out of them.

Is it worth it?

For a small defense firm that maintains an open-source parser, yes, if you do the fuzz targets properly. The engineering cost is mostly work you should do anyway: decide what correct means, write it down as checks, and prove each check can fire. The proof adds independently checkable evidence at no license cost. Our companion test showed the trap: rush the fuzz targets and you get a proof that the code doesn't crash and nothing more, with an impressive-sounding name attached.

Fact-check notes and sources

  • Program terms (free, eligibility criteria, what you receive, days to produce, no disclosure deadline, publish options, pause and leave): Theorem, OSS Verify.
  • Who can enroll, requirements, capacity note, network warning, AI-generated findings: oss-verify README. Licensing and GPL-2.0-only rule: add-project skill, step 3.8. Public contact address advice and pgp: project.yaml reference. Single thread, no MemorySanitizer, 64 MiB: what-gets-proven.md.
  • What a proof does not say, the build toolchain, LPS caveat: oss-verify-proofs README.
  • Our timings: our server, November 19, 2026, as described in the companion article.
  • libexample and decode_frame are placeholders in the wording example, not real projects.

Related reading

This post is informational, not legal, contracting or export-control advice. Confirm claims language with your contracts officer and counsel. Mentions of Theorem, OSS Verify, Rocq, Google, OSS-Fuzz and seL4 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