Crate zerocopy

Want to help improve zerocopy? Fill out our user survey!

Fast, safe, compile error. Pick two.

Zerocopy makes zero-cost memory manipulation effortless. We write unsafe so you don’t have to.

Overview

Zerocopy provides four core marker traits, each of which can be derived (e.g., #[derive(FromZeroes)]):

• FromZeroes indicates that a sequence of zero bytes represents a valid instance of a type
• FromBytes indicates that a type may safely be converted from an arbitrary byte sequence
• AsBytes indicates that a type may safely be converted to a byte sequence
• Unaligned indicates that a type’s alignment requirement is 1

Types which implement a subset of these traits can then be converted to/from byte sequences with little to no runtime overhead.

Zerocopy also provides byte-order aware integer types that support these conversions; see the byteorder module. These types are especially useful for network parsing.

Cargo Features

• alloc
  By default, zerocopy is no_std. When the alloc feature is enabled, the alloc crate is added as a dependency, and some allocation-related functionality is added.

• byteorder (enabled by default)
  Adds the byteorder module and a dependency on the byteorder crate. The byteorder module provides byte order-aware equivalents of the multi-byte primitive numerical types. Unlike their primitive equivalents, the types in this module have no alignment requirement and support byte order conversions. This can be useful in handling file formats, network packet layouts, etc which don’t provide alignment guarantees and which may use a byte order different from that of the execution platform.

• derive
  Provides derives for the core marker traits via the zerocopy-derive crate. These derives are re-exported from zerocopy, so it is not necessary to depend on zerocopy-derive directly.

  However, you may experience better compile times if you instead directly depend on both zerocopy and zerocopy-derive in your Cargo.toml, since doing so will allow Rust to compile these crates in parallel. To do so, do not enable the derive feature, and list both dependencies in your Cargo.toml with the same leading non-zero version number; e.g:

  [dependencies]
  zerocopy = "0.X"
  zerocopy-derive = "0.X"
  

• simd
  When the simd feature is enabled, FromZeroes, FromBytes, and AsBytes impls are emitted for all stable SIMD types which exist on the target platform. Note that the layout of SIMD types is not yet stabilized, so these impls may be removed in the future if layout changes make them invalid. For more information, see the Unsafe Code Guidelines Reference page on the layout of packed SIMD vectors.

• simd-nightly
  Enables the simd feature and adds support for SIMD types which are only available on nightly. Since these types are unstable, support for any type may be removed at any point in the future.

Security Ethos

Zerocopy is expressly designed for use in security-critical contexts. We strive to ensure that that zerocopy code is sound under Rust’s current memory model, and any future memory model. We ensure this by:

• …not ‘guessing’ about Rust’s semantics.
  We annotate unsafe code with a precise rationale for its soundness that cites a relevant section of Rust’s official documentation. When Rust’s documented semantics are unclear, we work with the Rust Operational Semantics Team to clarify Rust’s documentation.
• …rigorously testing our implementation.
  We run tests using Miri, ensuring that zerocopy is sound across a wide array of supported target platforms of varying endianness and pointer width, and across both current and experimental memory models of Rust.
• …formally proving the correctness of our implementation.
  We apply formal verification tools like Kani to prove zerocopy’s correctness.

For more information, see our full soundness policy.

Relationship to Project Safe Transmute

Project Safe Transmute is an official initiative of the Rust Project to develop language-level support for safer transmutation. The Project consults with crates like zerocopy to identify aspects of safer transmutation that would benefit from compiler support, and has developed an experimental, compiler-supported analysis which determines whether, for a given type, any value of that type may be soundly transmuted into another type. Once this functionality is sufficiently mature, zerocopy intends to replace its internal transmutability analysis (implemented by our custom derives) with the compiler-supported one. This change will likely be an implementation detail that is invisible to zerocopy’s users.

Project Safe Transmute will not replace the need for most of zerocopy’s higher-level abstractions. The experimental compiler analysis is a tool for checking the soundness of unsafe code, not a tool to avoid writing unsafe code altogether. For the foreseeable future, crates like zerocopy will still be required in order to provide higher-level abstractions on top of the building block provided by Project Safe Transmute.

MSRV

See our MSRV policy.

Changelog

Zerocopy uses GitHub Releases.

Re-exports

• pub use crate::byteorder::*;

Modules

• byteorder
  Byte order-aware numeric primitives.
• macros 🔒
• post_monomorphization_compile_fail_tests 🔒
  Code that should fail to compile during the post-monomorphization compiler pass.
• sealed 🔒
• simd 🔒
• util 🔒
• wrappers 🔒

Macros

• include_value
  Includes a file and safely transmutes it to a value of an arbitrary type.
• transmute
  Safely transmutes a value of one type to a value of another type of the same size.
• transmute_mut
  Safely transmutes a mutable reference of one type to an mutable reference of another type of the same size.
• transmute_ref
  Safely transmutes a mutable or immutable reference of one type to an immutable reference of another type of the same size.

Structs

• Ref
  A typed reference derived from a byte slice.
• TrailingSliceLayout 🔒
• Unalign
  A type with no alignment requirement.

Enums

• SizeInfo 🔒

Constants

• POINTER_WIDTH_BITS 🔒
  The target pointer width, counted in bits.

Traits

• AsBytes
  Types that can be viewed as an immutable slice of initialized bytes.
• ByteSlice
  A mutable or immutable reference to a byte slice.
• ByteSliceMut
  A mutable reference to a byte slice.
• FromBytes
  Types for which any bit pattern is valid.
• FromZeroes
  Types for which a sequence of bytes all set to zero represents a valid instance of the type.
• Unaligned
  Types with no alignment requirement.

Functions

• map_prefix_tuple_zeroed 🔒
• map_suffix_tuple_zeroed 🔒
• map_zeroed 🔒

Derive Macros

• AsBytes
  Analyzes whether a type is AsBytes.
• FromBytes
  Analyzes whether a type is FromBytes.
• FromZeroes
  Analyzes whether a type is FromZeroes.
• Unaligned