Rust-proof your code with our new Testing Handbook chapter

We’ve added a new chapter to our Testing Handbook: a comprehensive guide to security testing Rust programs. This chapter covers the tools and techniques we use at Trail of Bits to validate the security of Rust programs and systems.
What’s in the chapter
The chapter starts with a security overview of what Rust’s guarantees do and don’t cover, including underappreciated issues like unwind safety, nondeterminism, and arithmetic errors. This leads into an overview of dynamic analysis, which covers a range of boosters for unit tests, how to use Miri to detect undefined behavior, property testing with proptest
, coverage measurement, and mutation testing. The static analysis section then covers Clippy in depth, including a list of our favorite lints.
Beyond tooling, the chapter also covers what we’ve learned from auditing Rust codebases directly. Our gotchas and footguns checklist is a great reference for manual code reviews, and will help you find subtle issues like a & b == c
having different operator precedence than in C. The memory zeroization section offers three solutions to the tricky problem of guaranteeing that secrets are erased from memory.
Finally, the specialized testing sections cover tools like Kani (a model checker), and the supply chain section covers the full toolchain for vetting dependencies.
Still oxidizing
We’ve also released rust-review, a Claude Code plugin for automated Rust security reviews. Co-built with Aptos Labs, it targets over a dozen bug classes, from memory safety and concurrency hazards to FFI pitfalls and async cancellation issues. It’s a fast way to catch security issues in a Rust codebase before they make it to audit.
Our goal is to keep the handbook current as the Rust ecosystem evolves. If your favorite tool or gotcha isn’t covered, submit a PR. And if you need help securing your Rust systems, contact us.

Facts Only

* A new chapter on security testing Rust programs was added to the Testing Handbook.
* The chapter covers tools and techniques used by Trail of Bits for validating Rust program security.
* The content includes a security overview of Rust's guarantees, covering topics like unwind safety, nondeterminism, and arithmetic errors.
* Dynamic analysis topics include unit test boosters, using Miri to detect undefined behavior, property testing with proptest, coverage measurement, and mutation testing.
* The static analysis section covers Clippy in depth, including a list of favored lints.
* The chapter details findings from auditing Rust codebases, such as issues related to operator precedence.
* A memory zeroization section provides three solutions for erasing secrets from memory.
* Specialized testing sections cover tools like Kani (a model checker).
* A supply chain section covers the toolchain for vetting dependencies.
* A separate tool, rust-review, is released as a Claude Code plugin for automated Rust security reviews targeting bug classes like memory safety and concurrency hazards.

Executive Summary

A new chapter has been added to the Testing Handbook, providing a comprehensive guide to security testing Rust programs, detailing tools and techniques used by Trail of Bits. The chapter begins with a security overview of Rust's guarantees, addressing topics like unwind safety, nondeterminism, and arithmetic errors. It then covers dynamic analysis methods, including unit test boosters, using Miri for undefined behavior detection, property testing with proptest, coverage measurement, and mutation testing. The static analysis section focuses on Clippy, featuring a list of preferred lints. Furthermore, the chapter includes practical knowledge from auditing Rust codebases, such as a gotchas and footguns checklist regarding subtle issues like operator precedence errors, a memory zeroization section offering solutions for erasing secrets from memory, specialized testing with tools like Kani (a model checker), and supply chain vetting toolchains for dependencies. Additionally, a separate release, rust-review, is available as a Claude Code plugin for automated security reviews targeting memory safety, concurrency hazards, FFI pitfalls, and async cancellation issues.

Full Take

The presentation of this material establishes a pattern of building comprehensive, multi-layered defense against software vulnerabilities by addressing theoretical guarantees alongside practical tooling and manual code review pitfalls. The structure moves logically from the high-level guarantees of the language to dynamic testing, static analysis (Clippy), memory management solutions, specialized formal verification (Kani), and supply chain auditing. This mirrors an approach where foundational theory is immediately bridged to actionable implementation, which builds cognitive sovereignty by showing that security assurance requires both abstract understanding and concrete execution. The inclusion of practical "gotchas" from direct code auditing suggests an awareness that automated tooling is insufficient; human intuition remains critical for catching subtle errors like operator precedence differences across languages. The accompanying release of rust-review indicates a pattern of augmenting static tools with LLM-assisted automation to increase the velocity of security feedback. A potential implication is the expectation that developers must simultaneously master idiomatic Rust safety principles and learn the specific adversarial surface areas identified through tooling, suggesting that security mastery resides in bridging the gap between compiler guarantees and real-world system complexity.

Sentinel — Human

Confidence

The text reads like an authentic technical announcement from an expert source detailing complex software development security practices.

Signals Detected

Moderate sentence length variance; uses domain-specific terminology effectively.

Clear, purposeful structure linking the handbook update to supplementary tooling releases.

Information flow is logical (overview -> dynamic -> static -> practical application); no verbatim template matching detected.

Specific, highly technical details (Miri, Clippy lints, operator precedence differences) suggest deep domain knowledge, not simple generation.

Human Indicators

Use of specific, nested concepts common in deep technical/security circles (unwind safety, Miri, Clippy, FFI pitfalls).

The tone balances instruction ('guide,' 'checklist') with insider knowledge ('gotchas and footguns').