Skip to content

Challenge 2: memory safety of raw-pointer intrinsics - #649

Open
stefanzetzsche wants to merge 4 commits into
model-checking:mainfrom
stefanzetzsche:intrinsics-challenge-2
Open

stefanzetzsche wants to merge 4 commits into
model-checking:mainfrom
stefanzetzsche:intrinsics-challenge-2

Conversation

@stefanzetzsche

@stefanzetzsche stefanzetzsche commented Aug 20, 2026 •

Copy link
Copy Markdown

Towards #16. Solves Challenge 2: Verify the memory safety of core intrinsics using raw pointers: safety contracts and Kani harnesses for the raw-pointer intrinsics (Part 1), proofs that the std library's uses of them are safe (Part 2), and contracts on the raw-pointer functions exposing them (Part 3). All 146 harnesses added by this PR pass in a single kani verify-std invocation at the pinned Kani commit.

Changes

File Change
intrinsics/mod.rs Contracts + proof_for_contract harnesses for 20 intrinsics, via thin wrappers (Kani cannot attach contracts to body-less #[rustc_intrinsic]s, model-checking/kani#3325; same pattern as the in-tree transmute_unchecked_wrapper); also fixes the pre-existing check_copy_untyped spec helper, which compared src[0]'s initialization state against dst[elem]'s instead of src[elem]'s
mem/mod.rs Usage proofs for swap and align_of_val; contract + harnesses for align_of_val_raw (Part 3)
mem/maybe_uninit.rs Usage proof for zeroed (reaches write_bytes), byte-level ensures
fmt/num.rs Contract + harnesses for u64::_fmt, the successor of the challenge-listed parse_u64_into (Part 2)
ptr/mod.rs Contracts + harnesses for ptr::swap and ptr::write_bytes (Part 3)
slice/mod.rs Contract + harnesses for copy_from_slice (Parts 2/3)

Part 1: the intrinsics

All 21 listed intrinsics are contracted and verified: 20 by this PR, and the 21st, typed_swap, already carries a verified in-tree contract with passing harnesses (added by #37, before this challenge was tackled), so re-verifying it here would only duplicate upstream code. This PR still exercises that existing contract as part of the mem::swap usage proof (Part 2). One finding for the committee: parse_u64_into no longer exists anywhere in the tree (see Part 2). The five volatile intrinsics (volatile_copy_memory, volatile_copy_nonoverlapping_memory, volatile_set_memory, unaligned_volatile_load, unaligned_volatile_store) are verified directly: as for volatile_load/volatile_store, each contract sits on a thin *_model wrapper that calls the real intrinsic, which Kani supports since model-checking/kani#4672 and model-checking/kani#4673.

Contracts state exactly the documented # Safety conditions. Where the documented condition is per-case, so is the contract: size_of_val/align_of_val get a Sized wrapper with no precondition (documented "always safe", proven with dangling pointers) and a slice wrapper requiring only that the total size fits isize. All remaining intrinsics are Kani-modeled; each harness pins the model with a concrete assertion (e.g. vtable_size returns exactly size_of::<T>(), store harnesses read the value back).

Intrinsics Approach
copy, copy_nonoverlapping, write_bytes, volatile/unaligned family Readable/writable-range + alignment + (where documented) non-overlap requires; untyped-copy ensures; byte-granular pointer offsets so misaligned inputs are generated, not avoided
vtable_size, vtable_align, size_of_val, align_of_val Metadata-only models; generic ensures (size fits isize, alignment is a power of two); per-type fidelity asserts in harnesses; the layout queries cover all three documented cases (Sized, slice tail, trait-object tail via real compiler-produced vtables)
ptr_offset_from, ptr_offset_from_unsigned, arith_offset Same-allocation / ordering requires; arith_offset checked for every base in [1, 2^52) and every offset whose result lands in [0, 2^52), which is every address CBMC can represent with CI's --object-bits 12
compare_bytes Whole-range readability requires (docs stress chunked reads); checked instances bounded to 64 bytes (unwind(65)), because Kani lowers the intrinsic to CBMC's built-in memcmp loop, which cannot take a loop invariant; the bound lives in the harness, not the contract
read_via_copy, write_via_move Read/write validity; write_via_move ensures dereferenceability post-state (the moved value cannot be re-read for generic T)

For the trait-object case, Kani has no "is a vtable" predicate, so (as for vtable_size/vtable_align) dereferenceability of the three metadata words is the stated approximation of the documented condition; the harnesses supply real compiler-produced vtables, so the precondition is discharged non-vacuously.

Initialization: ub_checks::can_dereference checks that bytes are initialized only when Kani runs with -Z uninit-checks, and CI doesn't pass that flag. So in CI, the requires and ensures clauses that use it don't rule out uninitialized reads, and check_copy_untyped doesn't compare initialization state. In @feliperodri's run with the flag, 91 of the 394 intrinsics::verify harnesses stop on constructs Kani's uninit checking doesn't support yet (model-checking/kani#5151, model-checking/kani#5166), and none reports an uninitialized read. How solutions should treat this is open in #733.

Part 2: std usage sites

Usage site Proof
mem::swap proof_for_contract(swap) + stub_verified(typed_swap_nonoverlapping), so the intrinsic's requires become explicit call-site obligations
<[T]>::copy_from_slice Contract on the function; symbolic lengths 0..=32 across 5 element types, element equality asserted per type
mem::align_of_val 8 harnesses (Sized + slice tails); the precondition holds structurally for &T
MaybeUninit::zeroed 10 harnesses: the reached write_bytes is safe and all backing bytes are 0
fmt::parse_u64_into Does not exist in the tree (finding above); its successor u64::_fmt is contracted and verified instead — the documented buffer-size safety condition as requires, digits-only/length ensures, plus a bounded value-fidelity harness. The contract lives on a #[cfg(kani)] wrapper because _fmt is macro-generated for every integer type; annotating it directly would touch them all

Part 3: raw-pointer functions

Contracts + harnesses for ptr::swap (overlap-permitted path exercised), ptr::write_bytes, and mem::align_of_val_raw (including dangling-pointer harnesses for the documented always-safe Sized case). copy_from_slice doubles as its own Part 3 item.

Wherever a harness restricts inputs with kani::assume, a kani::cover check confirms some input satisfies the restriction, so no proof passes vacuously; value-level properties that cannot be generic ensures clauses (no PartialEq bound) are asserted per concrete type.

Relation to other work on this challenge

#37 (merged) contributed the typed_swap contract this PR builds on and exercises via the mem::swap usage proof.

#618 is an open partial solution covering 15 Part 1 intrinsics. This PR was developed independently and additionally covers the five volatile intrinsics, Part 2, and Part 3. Its review thread shaped two of this PR's contracts (per-case preconditions instead of a blanket can_dereference), and its author's now-merged Kani fixes (model-checking/kani#4672, model-checking/kani#4673) are what let this PR verify the five volatile intrinsics directly.

#643 is another open full-table attempt, developed independently on the same wrapper pattern; this PR adopts its correct fix to the pre-existing check_copy_untyped spec helper (src_data was never offset by the chosen element), with all affected harnesses re-verified. Beyond that, this PR goes further on three fronts:

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 and MIT licenses.

@stefanzetzsche
stefanzetzsche requested a review from a team as a code owner August 20, 2026 14:51
@feliperodri feliperodri added the Challenge Used to tag a challenge label Aug 20, 2026

@feliperodri feliperodri left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Approving — leading solution for Challenge 2

Thanks @stefanzetzsche. After reviewing all three open Challenge 2 submissions, this is the only complete one and we're prioritizing it in the review process.

Coverage against the challenge criteria:

  • All 21 listed intrinsics carry a safety contract verified by #[kani::proof_for_contract] (on thin forwarding wrappers, since Kani can't attach contracts to body-less intrinsics — kani#3325).
  • All 5 usage sites (copy_from_slice, the parse_u64_into successor u64::_fmt, swap, align_of_val, zeroed) proven safe.
  • All 5 std wrappers (ptr::swap, ptr::write_bytes, mem::align_of_val_raw, <[T]>::copy_from_slice, u64 fmt) annotated + verified.

Soundness: clean on our vacuity checks — no cfg(kani) body swaps of real std code, no trivial/decorative contracts (every contract has a matching proof_for_contract; none rely on the autoharness allowlist), no assume-the-conclusion. Inputs are symbolic kani::any() (byte-granular pointer offsets, so misaligned/overlapping/aliasing pointers are solver-generated, not avoided). Additive only — no runtime std logic changed; the 37 deletions are dead/commented spec helpers, including a genuine fix to the check_copy_untyped oracle.

The author-disclosed approximations are reasonable and worth noting for the record:

  1. The 5 volatile/unaligned-volatile intrinsics are verified against equivalent non-volatile *_model bodies (the real intrinsic isn't invoked; rests on the LLVM volatile flag being a no-op for CBMC's abstract memory). Please swap these to the real intrinsics once the Kani pin moves past kani#4672/rust-lang#4673.
  2. compare_bytes proof bounded to 8 bytes (the contract itself is general).
  3. arith_offset verified over a [2^32, 2^45] address window (CBMC mismodels near-NULL/wrap edges).

CI is green across all Kani jobs (all 4 verify partitions + autoharness + metrics).

@feliperodri

Copy link
Copy Markdown
Member

@tautschnig @dkcumming @rafaelsamenezes could you give this challenge solution a review?

@feliperodri feliperodri added the Accepted Solution Tag used to mark the solution accepted for a given challenge label Sep 13, 2026
@feliperodri

Copy link
Copy Markdown
Member

@stefanzetzsche could you resolve the conflicts against main?

@feliperodri

Copy link
Copy Markdown
Member

@stefanzetzsche, this has merge conflicts with main after the recent subtree syncs. Could you rebase it? It's approved, so once it's conflict-free and CI is green it can go to the merge queue.

Comment thread library/core/src/intrinsics/mod.rs Resolved
@feliperodri

feliperodri commented Nov 10, 2026 •

Copy link
Copy Markdown
Member

@stefanzetzsche, now that model-checking/kani#4672 and github.com/model-checking/kani/pull/4673 are merged (both are in this PR's Kani pin and in main's), all three approximations noted in my approval can be removed or tightened. I tried each one locally on this PR merged with current main (Kani c5e65fd). It merges cleanly.

1. Verify the real volatile intrinsics. Kani now supports volatile_copy_nonoverlapping_memory, volatile_copy_memory, volatile_set_memory, unaligned_volatile_load and unaligned_volatile_store. The five *_model functions can call them directly, as volatile_load_model and volatile_store_model already do, instead of their non-volatile equivalents. With that change all 15 volatile harnesses pass, the slowest in 14 s, the same as today. To check that this isn't vacuous, I made the copy and set calls touch one element past the end, and the unaligned load read one byte past it. All 9 affected harnesses then fail, so Kani checks the memory accesses inside the real intrinsics. This removes the assumption that the volatile flag makes no difference to CBMC, and every intrinsic in the challenge is then verified directly.

2. Raise the compare_bytes bound. The bound itself has to stay: Kani turns the intrinsic into CBMC's built-in memcmp loop, which can't take a loop invariant. But 8 bytes is far below what's affordable:

MAX_BYTES time
16 0.8 s
32 1.7 s
64 13.4 s

I'd suggest MAX_BYTES = 64 with #[kani::unwind(65)].

3. Widen the arith_offset window to the real limit. The failures outside the current window have nothing to do with addresses near NULL; a result of 0 verifies fine. The limit is CBMC's pointer encoding: CI runs it with --object-bits 12, which leaves 52 bits for an address. Constraining the base and the result to that range, instead of [2^32, 2^45] and |offset| <= 2^20, verifies all 4 harnesses in under 0.3 s each:

kani::assume(base_addr >= 1 && base_addr < (1usize << 52));
let offset: isize = kani::any();
let r = base_addr as i128 + (offset as i128) * (crate::mem::size_of::<$ty>() as i128);
kani::assume(r >= 0 && r < (1i128 << 52));

That covers every base below 2^52 and every offset that lands in that range. With no limits, with any non-null base, or with offsets up to ±2^40, the ensures fails, because the result then leaves the 52 bits CBMC can represent. Results that wrap around past usize::MAX stay out of reach with 12 object bits, so the comment could say that instead of "CBMC mismodels near-NULL/wrap edges".

None of this changes the approval. The three changes make the solution as strong as Kani currently allows, so it would be good to have them in before we merge.

… and arith_offset

Addresses feliperodri's comment of 10 Nov:
model-checking#649 (comment)

- The five volatile/unaligned-volatile `*_model` wrappers now call the
  real intrinsics instead of their non-volatile equivalents. Kani supports
  them since model-checking/kani#4672 and rust-lang#4673.
- compare_bytes: MAX_BYTES 8 -> 64, unwind 9 -> 65.
- arith_offset: the harness now covers every base in [1, 2^52) and every
  offset whose result lands in [0, 2^52), instead of a base in
  [2^32, 2^45] and |offset| <= 2^20. The comment now names the real
  limit: CBMC's address encoding leaves 52 bits with --object-bits 12.

All 146 harnesses of this PR pass with the PR's Kani pin (cd355b0b) and
on the PR merged with current main (Kani c5e65fd). As a negative check,
making each of the five intrinsic calls touch one element past its range
makes all 15 affected harnesses fail.
…hecks

Addresses feliperodri's review comment of 13 Nov:
model-checking#649 (comment)

Without -Z uninit-checks, Kani compiles `is_initialized` to `true`, so
`ub_checks::can_dereference` does not exclude uninitialized memory, and
CI does not pass that flag. Comments that implied otherwise now say
initialization is checked only with -Z uninit-checks:

- `check_copy_untyped` doc, and the `copy_nonoverlapping` contract comment
  that refers to it;
- the `volatile_load` harness ("uninit would make `can_dereference`
  unsatisfiable, hence vacuous");
- the `compare_bytes` contract and harness ("whole-range clause otherwise
  unsatisfiable");
- the same claim in the `align_of_val_raw` slice harness (mem/mod.rs) and
  the `ptr::write_bytes` ensures (ptr/mod.rs).

Comments only; no contract, harness or code changes.

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

Accepted Solution Tag used to mark the solution accepted for a given challenge Challenge Used to tag a challenge

Projects

None yet

Development

Successfully merging this pull request may close these issues.

3 participants