Skip to content

Add a few intrinsics contracts - #37

Merged
celinval merged 18 commits into
model-checking:mainfrom
celinval:verify-intrinsics
Dec 7, 2024
Merged

celinval merged 18 commits into
model-checking:mainfrom
celinval:verify-intrinsics

Conversation

@celinval

@celinval celinval commented Jul 16, 2024 •

Copy link
Copy Markdown

Here are a few limitations:

  1. Harness forwrite_bytes was disabled due to:
  2. The harnesses explicitly disable cases where a pointer is dangling.
  3. Actual intrinsics are very hard to verify with Kani. The cases we can verify are those that have wrappers around the actual intrinsic.

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

@celinval
celinval force-pushed the verify-intrinsics branch from c6f96e3 to ee88552 Compare July 17, 2024 19:53
celinval added 4 commits July 22, 2024 20:29
- This is not working due to a Kani limitation
The intrinsics `copy` and `copy_nonoverlapping` are untyped copies,
so they don't respect the validity requirements of `T`.
@rahulku

rahulku commented Sep 13, 2024

Copy link
Copy Markdown

is this waiting for something?

@celinval

Copy link
Copy Markdown
Author

Yes, I need to update the branch and tests.

# Conflicts:
#	library/core/src/intrinsics.rs
@celinval

celinval commented Oct 1, 2024

Copy link
Copy Markdown
Author

FYI, this is blocked until we merge the PointerGenerator into Kani: model-checking/kani#3538

@celinval
celinval marked this pull request as ready for review October 16, 2024 23:41
@celinval
celinval requested a review from a team as a code owner October 16, 2024 23:41
@celinval

celinval commented Nov 4, 2024

Copy link
Copy Markdown
Author

Just an update. I haven't been able to figure out yet why the copy_nonoverlapping harness is failing yet. The error is:

Checking harness intrinsics::verify::check_copy_nonoverlapping...

VERIFICATION RESULT:
 ** 1 of 856 failed (3 unreachable)
Failed Checks: Only a single top-level call to function _RNCNCINvNtCsf4mLL5B4Lhf_4core10intrinsics19copy_nonoverlappinghEs0_0s_0B8_ when checking contract _RNCNCINvNtCsf4mLL5B4Lhf_4core10intrinsics19copy_nonoverlappinghEs0_0s_0B8_
2024-11-02T01:43:52.2508870Z  File: "/Users/runner/work/verify-rust-std/verify-rust-std/head/library/core/src/intrinsics.rs", line 3311, in _RNCNCINvNtCsf4mLL5B4Lhf_4core10intrinsics19copy_nonoverlappinghEs0_0s_0B8_

VERIFICATION:- FAILED

which doesn't make sense to me. The harness structure is exactly the same as copy, and so is the function implementation. 🤷‍♀️

@qinheping
qinheping self-requested a review November 6, 2024 18:03
@celinval
celinval requested a review from feliperodri November 6, 2024 18:03
Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved

@qinheping qinheping left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

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

LGTM, thank you!

Comment thread library/core/src/intrinsics.rs Resolved
@tautschnig

Copy link
Copy Markdown
Member

Just an update. I haven't been able to figure out yet why the copy_nonoverlapping harness is failing yet. The error is:

Checking harness intrinsics::verify::check_copy_nonoverlapping...

VERIFICATION RESULT:
 ** 1 of 856 failed (3 unreachable)
Failed Checks: Only a single top-level call to function _RNCNCINvNtCsf4mLL5B4Lhf_4core10intrinsics19copy_nonoverlappinghEs0_0s_0B8_ when checking contract _RNCNCINvNtCsf4mLL5B4Lhf_4core10intrinsics19copy_nonoverlappinghEs0_0s_0B8_
2024-11-02T01:43:52.2508870Z  File: "/Users/runner/work/verify-rust-std/verify-rust-std/head/library/core/src/intrinsics.rs", line 3311, in _RNCNCINvNtCsf4mLL5B4Lhf_4core10intrinsics19copy_nonoverlappinghEs0_0s_0B8_

VERIFICATION:- FAILED

which doesn't make sense to me. The harness structure is exactly the same as copy, and so is the function implementation. 🤷‍♀️

I have seen the very same problem on #120, and I haven't yet managed to understand why.

@tautschnig

Copy link
Copy Markdown
Member

Here are a few problems that I bumped into: [...]

Before merning, would you mind adding to the PR description also what actually does work?

Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved
Comment thread library/core/src/intrinsics.rs Resolved
@celinval

Copy link
Copy Markdown
Author

@tautschnig can you please see my answer to your comments? Is it OK if I move ahead and merge these changes?

@celinval

Copy link
Copy Markdown
Author

I need to solve the new conflicts. After that, I'll merge this PR

Since intrinsics file has been deleted, we will have to reapply the
patch.

Conflicts:
 - library/core/src/intrinsics.rs
Co-authored-by: Michael Tautschnig <mt@debian.org>
@celinval

celinval commented Dec 6, 2024

Copy link
Copy Markdown
Author

I updated this PR to account to the fact that the intrinsics.rs file was moved to intrinsics/mod.rs. I have also disabled the write_bytes harness because of model-checking/kani#90.

@tautschnig can you please take a look and see if this is good to go?

@celinval celinval assigned tautschnig and unassigned celinval Dec 6, 2024
@celinval
celinval enabled auto-merge (squash) December 6, 2024 23:45
@celinval
celinval merged commit d92a7ea into model-checking:main Dec 7, 2024
v3risec pushed a commit to v3risec/verify-rust-std that referenced this pull request Nov 19, 2026
)

Towards model-checking#16. Solves [Challenge 2: Verify the memory safety of core
intrinsics using raw
pointers](https://model-checking.github.io/verify-rust-std/challenges/0002-intrinsics-memory.html):
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 model-checking#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 model-checking#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

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

model-checking#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.

model-checking#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:

- **Adversarial inputs.** Copy-family harnesses here generate
byte-granular pointer offsets across several element types, so
misaligned and overlapping inputs are produced by the solver rather than
avoided; model-checking#643's are `u8`-only (alignment trivially 1) with a single
fixed overlap shift, so its alignment precondition is never
non-trivially exercised.
- **Part 2 depth.** Both PRs touch all five usage sites; this PR proves
each more deeply: 10 byte-level `zeroed` harnesses (model-checking#643 has 2,
integer-only), `copy_from_slice` at symbolic lengths 0..=32 across 5
element types (model-checking#643: one `u8` harness at fixed length 4), and a
`mem::swap` proof that `stub_verified`s the intrinsic contract so its
`requires` become explicit call-site obligations (model-checking#643 asserts value
exchange only).
- **Part 3 coverage.** This PR contracts and verifies the exposing
functions — `ptr::swap` (overlap-permitted path), `ptr::write_bytes`,
`mem::align_of_val_raw` — as the challenge asks; in model-checking#643 this part is
essentially absent (plain fixed-size harnesses without contracts,
`align_of_val_raw` not covered).

By submitting this pull request, I confirm that my contribution is made
under the terms of the Apache 2.0 and MIT licenses.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants