Struct Blake3 

pub struct Blake3 { /* private fields */ }

BLAKE3 hash function.

Implements the Hasher trait.

One-shot API

use crypto::{Hasher, blake3::Blake3};

let hash = Blake3::hash(b"hello world");

Incremental API

use crypto::{Hasher, blake3::Blake3};

let mut hasher = Blake3::new();
hasher.update(b"hello ");
hasher.update(b"world");
let hash = hasher.sum();

XOF (Extendable-Output Function) API

use crypto::{Hasher, blake3::Blake3};

let mut out = [0u8; 64];
let mut hasher = Blake3::new();
hasher.update(b"hello world");
hasher.finalize_xof().squeeze(&mut out);

Keyed hashing

use crypto::{Hasher, blake3::Blake3};

let key = b"whats the Elvish word for friend";
let mut hasher = Blake3::new_keyed(key);
hasher.update(b"hello world");
let hash = hasher.sum();

The keyed_hash one-shot is also available:

use crypto::blake3::Blake3;

let key = b"whats the Elvish word for friend";
let hash = Blake3::keyed_hash(key, b"hello world");

Derive-key mode

use crypto::blake3::Blake3;

let key = Blake3::derive_key("my app context", b"key material");
let mut hasher = Blake3::new_keyed(&key);
hasher.update(b"hello world");
let hash = hasher.sum();

Implementations

impl Blake3

pub fn new_keyed(key: &[u8; 32]) -> Self

pub fn new_derive_key(context: &str) -> Self

pub fn derive_key(context: &str, key_material: &[u8]) -> [u8; 32]

pub fn keyed_hash(key: &[u8; 32], input: &[u8]) -> Hash

pub fn finalize_xof(self) -> Blake3XofReader

Trait Implementations

impl Clone for Blake3

fn clone(&self) -> Blake3

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Drop for Blake3

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Hasher for Blake3

const BLOCK_SIZE: usize = 64

The internal block size of the hash function

const OUTPUT_SIZE: usize = 32

The output size of the hash function

fn new() -> Self

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

fn sum(self) -> Hash

fn hash(data: &[u8]) -> Hash

impl Zeroize for Blake3

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.