Struct fs_verity::FsVerityDigest

pub struct FsVerityDigest<D = Sha256, S = [u8; 0]>where
    D: InnerHash,
    S: AsRef<[u8]> + Clone + Default,{ /* private fields */ }

Calculates an fs-verity measurement over the input data.

Implementations

impl<D> FsVerityDigest<D>where D: InnerHash,

pub fn new() -> Self

Creates a new instance of FsVerityDigest with an empty salt.

This is probably what you want.

impl<D, S> FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

pub fn new_with_salt(salt: S) -> Self

Creates a new instance of FsVerityDigest with the given salt. The salt will be mixed into every internal hash calculation.

Note that the current Linux kernel does not allow you to read back the salt used for a particular verity-protected file, which may be a problem depending on your use case.

This will panic if the salt is longer than MAX_SALT_SIZE bytes.

pub fn new_with_salt_and_block_size(salt: S, block_size: usize) -> Self

Creates a new instance of FsVerityDigest with the given salt and a custom block size.

This will panic if the salt is longer than MAX_SALT_SIZE bytes.

If you want to be compatible with the Linux kernel implementation it is not a good idea to change the block_size, as the kernel currently requires it to be equal to the system page size, which is 4096 on most architectures. Some modern 64 bit ARM systems have a 64kB page size though.

The block size must be a power of two, and it must be at least twice the size of the digests produced by the inner hash algorithm. This code will panic otherwise.

pub fn inner_hash_algorithm(&self) -> InnerHashAlgorithm

Returns the InnerHashAlgorithm value corresponding to the used inner hash algorithm.

Trait Implementations

impl<D, S> BlockSizeUser for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

NOTE: This reports the base hash function’s input block size, not the Merkle tree block size you specify when creating the FsVerityDigest!

While this may be confusing, it is probably more faithful to the purpose of the BlockInput trait. We don’t need to buffer an entire Merkle tree block in memory; data can be efficiently processed in chunks of the base hash’s input block size.

type BlockSize = <D as BlockSizeUser>::BlockSize

Equal to the inner hash algorithm’s block size.

fn block_size() -> usize

Return block size in bytes.

impl<D, S> Clone for FsVerityDigest<D, S>where D: InnerHash + Clone, S: AsRef<[u8]> + Clone + Default + Clone,

fn clone(&self) -> FsVerityDigest<D, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D, S> Default for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<D: InnerHash + 'static, S: AsRef<[u8]> + Clone + Default + 'static> DynFsVerityDigest for FsVerityDigest<D, S>

fn inner_hash_algorithm(&self) -> InnerHashAlgorithm

impl<D, S> FixedOutput for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

fn finalize_into(self, out: &mut Output<Self>)

Consume value and write result into provided array.

fn finalize_fixed(self) -> GenericArray<u8, Self::OutputSize>

Retrieve result and consume the hasher instance.

impl<D, S> FixedOutputReset for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

fn finalize_into_reset(&mut self, out: &mut Output<Self>)

Write result into provided array and reset the hasher state.

fn finalize_fixed_reset(&mut self) -> GenericArray<u8, Self::OutputSize>

Retrieve result and reset the hasher state.

impl<D, S> OutputSizeUser for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

type OutputSize = <D as OutputSizeUser>::OutputSize

Size of the output in bytes.

fn output_size() -> usize

Return output size in bytes.

impl<D, S> Reset for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

Resets to a blank state, but with the same Merkle tree block size and salt

fn reset(&mut self)

Reset state to its initial value.

impl<D, S> Update for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

fn update(&mut self, data: &[u8])

Update state using the provided data.

fn chain(self, data: impl AsRef<[u8]>) -> Selfwhere Self: Sized,

Digest input data in a chained manner.

impl<D, S> Write for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<D, S> HashMarker for FsVerityDigest<D, S>where D: InnerHash, S: AsRef<[u8]> + Clone + Default,