Struct RistrettoHash 

pub struct RistrettoHash<H> { /* private fields */ }

RistrettoHash represents a hash function for multi-sets.

A multi-set is a collection of objects, where any given object may appear multiple times. This hash function will accept the objects in different orders, and with different groupings, but always return the same result for the same multi-set.

This allows incrementally calculating such a multi-set hash without keeping the entire set in memory.

This struct is parameterized by a hash function with 512 bits of output. For example, SHA-512.

This is called RistrettoHash, because this function internally uses the Ristretto group to implement its commutative hashing.

Examples

In the usual case, you add in different byte slices, with multiplicity For example, to hash the set {cat, cat, dog, dog}, you could do:

use digest::Digest;
use sha2::Sha512;

let mut hash = RistrettoHash::<Sha512>::default();
hash.add(b"cat", 2);
hash.add(b"dog", 2);

This is equivalent to hashing the same number of objects, with a different grouping and order:

use digest::Digest;

let mut hash = RistrettoHash::<Sha512>::default();
hash.add(b"dog", 1);
hash.add(b"cat", 1);
hash.add(b"cat", 1);
hash.add(b"dog", 1);

You can also hash objects in multiple pieces using the update method:

use digest::Digest;

let mut hash = RistrettoHash::<Sha512>::default();
hash.update(b"d");
hash.update(b"og");
hash.end_update(2);
hash.add(b"cat", 2);

If you use update, you must call end_update before adding another object, or calling finalize to get the output of the hash function.

Implementations

impl<H: Digest<OutputSize = U64> + Default> RistrettoHash<H>

pub fn add(&mut self, data: impl AsRef<[u8]>, multiplicity: u64)

This function adds a complete object to the hash.

This function takes a multiplicity, which is equivalent to calling the function multiple times, but is much more efficient.

pub fn end_update(&mut self, multiplicity: u64)

This function should be called to mark the end of an object provided with update.

This must always be called after calls to update, otherwise panics will happen when finalizing or adding new objects.

If called without any prior calls to update, this function is equivalent to calling add with an empty slice.

Trait Implementations

impl<H: Clone> Clone for RistrettoHash<H>

fn clone(&self) -> RistrettoHash<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: Default> Default for RistrettoHash<H>

fn default() -> RistrettoHash<H>

Returns the “default value” for a type.

impl<H: Reset> FixedOutput for RistrettoHash<H>

type OutputSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

Output size for fixed output digest

fn finalize_into(self, out: &mut GenericArray<u8, Self::OutputSize>)

Write result into provided array and consume the hasher instance.

fn finalize_into_reset(&mut self, out: &mut GenericArray<u8, Self::OutputSize>)

Write result into provided array and reset the hasher instance.

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

where Self: Sized,

Retrieve result and consume the hasher instance.

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

Retrieve result and reset the hasher instance.

impl<H: Reset> Reset for RistrettoHash<H>

fn reset(&mut self)

Reset hasher instance to its initial state and return current state.

impl<H: Update> Update for RistrettoHash<H>

fn update(&mut self, data: impl AsRef<[u8]>)

update hashes in part of an object.

This method is used to hash an object in multiple different parts. These updates must be finished by calling end_update to mark the end of the object, and its multiplicity.

Failing to call end_update before adding a new object with add or finalizing the hash will panic.

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

where Self: Sized,

Digest input data in a chained manner.