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: 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, Input, 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.input(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(&BigUint) -> 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, Input, 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.input(b"ATTACKATDAWN");

let (digest, iv) = hasher.results_in_domain(0, |check_digest| check_digest.is_odd()).unwrap();

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.