Struct fdh::FullDomainHash

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

Implementations

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

pub fn with_iv(output_size: usize, iv: u8) -> 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 xFF to x00 using modular addition.

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

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

Example

use sha2::Sha512;
use fdh::{FullDomainHash, Update, VariableOutput};
use num_bigint::BigUint;

// Get a full domain hash that is a mere 8 bytes (64 bits) long.
let mut hasher = FullDomainHash::<Sha512>::new(8).unwrap();
hasher.update(b"ATTACKATDAWN");
let min = BigUint::from(10u64);
let max = BigUint::from(5_000_000_000_000_000_000u64); // about half of u64 max.

let (digest, iv) = hasher.results_between(0, &min, &max).unwrap();

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

Get a digest value that is less than the specified maximum value.

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

pub fn results_gt(
    self,
    initial_iv: u8,
    min: &BigUint
) -> Result<(Vec<u8>, u8), Error>

Get a digest value that is more than the specified maximum value.

pub fn results_in_domain<C: Fn(&[u8]) -> bool>(
    self,
    initial_iv: u8,
    value_in_domain: C
) -> Result<(Vec<u8>, u8), Error>

Get a digest value that is within the domain specified by the passed closure.

Example

use sha2::Sha512;
use fdh::{FullDomainHash, Update, VariableOutput};
use num_bigint::BigUint;
use num_integer::Integer;

// Get a full domain hash that is odd
let mut hasher = FullDomainHash::<Sha512>::new(64).unwrap();
hasher.update(b"ATTACKATDAWN");

let (digest, iv) = hasher.results_in_domain(0, |digest| BigUint::from_bytes_be(digest).is_odd()).unwrap();

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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: Default + Digest> Default for FullDomainHash<H> where
    H::OutputSize: Default, 

fn default() -> FullDomainHash<H>

Returns the "default value" for a type.

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

type Reader = Self

Reader

fn finalize_xof(self) -> Self::Reader

Retrieve XOF reader and consume hasher instance.

fn finalize_xof_reset(&mut self) -> Self::Reader

Retrieve XOF reader and reset hasher instance state.

pub fn finalize_boxed(self, n: usize) -> Box<[u8], Global>

Retrieve result into a boxed slice of the specified size and consume the hasher.

pub fn finalize_boxed_reset(&mut self, n: usize) -> Box<[u8], Global>

Retrieve result into a boxed slice of the specified size and reset the hasher's state.

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

fn reset(&mut self)

Reset the hasher, discarding all internal state.

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

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

Digest input data

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

Digest input data in a chained manner.

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

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 finalize_variable(mut self: Self, f: impl FnOnce(&[u8]))

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.

fn finalize_variable_reset(&mut self, f: impl FnOnce(&[u8]))

Retrieve result via closure and reset the hasher state.

pub fn finalize_boxed(self) -> Box<[u8], Global>

Retrieve result into a boxed slice and consume hasher.

pub fn finalize_boxed_reset(&mut self) -> Box<[u8], Global>

Retrieve result into a boxed slice and reset hasher state.

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.

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

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

pub 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.

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

Attempts to write an entire buffer into this writer.

pub 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.

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

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

pub fn by_ref(&mut self) -> &mut Self

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

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

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

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

pub fn read_boxed(&mut self, n: usize) -> Box<[u8], Global>

Read output into a boxed slice of the specified size.