Struct fdh::FullDomainHash

pub struct FullDomainHash<H: Digest> { /* fields omitted */ }

Methods

impl<H: Digest + Clone> FullDomainHash<H>

pub fn with_iv(output_size: usize, iv: u32) -> Self

Create new hasher instance with the given output size and initialization vector.

The final hash will be FDH(M) = HASH(M||IV) || HASH(M||IV+1) || ... || HASH(M||IV+N) where HASH is any hash function, M is the message, || denotes concatenation, IV is the initialization vector, and N is the number of cycles requires for the output length.

If the initialization vector is large enough, it will "wrap around" from xFFxFFxFFxFF to x00x00x00x00 using modular addition.

pub fn set_suffix(&mut self, suffix: u32)

Set the suffix that is appended to the message before hashing.

This is useful when seaching for a hash output that has certain properties (for example is smaller than n in an RSA-FDH scheme.)

pub fn results_under(
    self,
    initial_iv: u32,
    max: &BigUint
) -> Result<(Vec<u8>, u32), Error>

Search for a digest value that is numerically less than the provided maximum by iterating over initial suffixes. Return the resulting digest and initialization value.

This is useful when the full-domain-hash needs to be less than some value. For example modulus n in RSA-FDH.

• initial_iv should be randomly generated.
• max should be the maximum allowed value in big endian format. For an RSA-FDH this would be the modulus n.

Example

let mut hasher = FullDomainHash::<Sha512>::new(64)?;
hasher.input(b"ATTACKATDAWN");
let iv: u32 = rng.gen();
let (digest, iv) = hasher.results_under(iv, priv_key.n())?;

Trait Implementations

impl<H: Debug + Digest> Debug for FullDomainHash<H> where
    H::OutputSize: Debug, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<H: Clone + Digest> Clone for FullDomainHash<H> where
    H::OutputSize: Clone, 

Important traits for FullDomainHash<H>

impl<H: Digest> Write for FullDomainHash<H>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H: Default + Digest> Default for FullDomainHash<H> where
    H::OutputSize: Default, 

Important traits for FullDomainHash<H>

impl<H: Digest> Write for FullDomainHash<H>

fn default() -> FullDomainHash<H>

Returns the "default value" for a type.

impl<H: Digest> Write for FullDomainHash<H>

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: &[IoVec]) -> Result<usize, Error>

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

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

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

Attempts to write an entire buffer 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 Self

Creates a "by reference" adaptor for this instance of Write.

impl<H: Digest> Input for FullDomainHash<H>

fn input<B: AsRef<[u8]>>(&mut self, data: B)

Digest input data

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

Digest input data in a chained manner.

impl<H: Digest> Reset for FullDomainHash<H>

fn reset(&mut self)

Reset the hasher, discarding all internal state.

impl<H: Digest + Clone> VariableOutput for FullDomainHash<H>

fn new(output_size: usize) -> Result<Self, InvalidOutputSize>

Create new hasher instance with the given output size.

fn output_size(&self) -> usize

Get output size of the hasher instance.

fn variable_result<F: FnOnce(&[u8])>(self, f: F)

Retrieve result via closure and consume hasher.

Closure is guaranteed to be called, length of the buffer passed to it will be equal to output_size.

You should probably use vec_result() instead.

fn vec_result(self) -> Vec<u8>

Retrieve result into vector and consume hasher.

impl<H: Digest + Clone> XofReader for FullDomainHash<H>

fn read(&mut self, buffer: &mut [u8])

Read output into the buffer. Can be called unlimited number of times.

impl<H: Digest + Clone> ExtendableOutput for FullDomainHash<H>

type Reader = Self

fn xof_result(self) -> Self::Reader

Retrieve XOF reader and consume hasher instance.

fn vec_result(self, n: usize) -> Vec<u8>

Retrieve result into vector of specified length.