Struct Argon2 

pub struct Argon2<'key> {
    pub(crate) algorithm: Algorithm,
    pub(crate) version: Version,
    pub(crate) params: Params,
    pub(crate) secret: Option<&'key [u8]>,
    pub(crate) cpu_feat_avx2: InitToken,
}

Argon2 context.

This is the primary type of this crate’s API, and contains the following:

• Argon2 Algorithm variant to be used
• Argon2 Version to be used
• Default set of Params to be used
• (Optional) Secret key a.k.a. “pepper” to be used

Fields

algorithm: Algorithm

Algorithm to use

version: Version

Version number

params: Params

Algorithm parameters

secret: Option<&'key [u8]>

Key array

cpu_feat_avx2: InitToken

Implementations

impl<'key> Argon2<'key>

pub fn new(algorithm: Algorithm, version: Version, params: Params) -> Self

Create a new Argon2 context.

pub fn new_with_secret( secret: &'key [u8], algorithm: Algorithm, version: Version, params: Params, ) -> Result<Self>

Create a new Argon2 context.

pub fn hash_password_into( &self, pwd: &[u8], salt: &[u8], out: &mut [u8], ) -> Result<()>

Hash a password and associated parameters into the provided output buffer.

pub fn hash_password_into_with_memory( &self, pwd: &[u8], salt: &[u8], out: &mut [u8], memory_blocks: impl AsMut<[Block]>, ) -> Result<()>

Hash a password and associated parameters into the provided output buffer.

This method takes an explicit memory_blocks parameter which allows the caller to provide the backing storage for the algorithm’s state:

• Users with the alloc feature enabled can use Argon2::hash_password_into to have it allocated for them.
• no_std users on “heapless” targets can use an array of the Block type to stack allocate this buffer.

pub fn fill_memory( &self, pwd: &[u8], salt: &[u8], memory_blocks: impl AsMut<[Block]>, ) -> Result<()>

Use a password and associated parameters only to fill the given memory blocks.

This method omits the calculation of a hash and can be used when only the filled memory is required. It is not necessary to call this method before calling any of the hashing functions.

pub(crate) fn fill_blocks( &self, memory_blocks: &mut [Block], initial_hash: Output<Blake2b512>, ) -> Result<()>

pub(crate) fn compress(&self, rhs: &Block, lhs: &Block) -> Block

pub const fn params(&self) -> &Params

Get default configured Params.

pub(crate) fn finalize( &self, memory_blocks: &[Block], out: &mut [u8], ) -> Result<()>

pub(crate) fn update_address_block( &self, address_block: &mut Block, input_block: &mut Block, zero_block: &Block, )

pub(crate) fn initial_hash( &self, pwd: &[u8], salt: &[u8], out: &[u8], ) -> Output<Blake2b512>

Hashes all the inputs into blockhash[PREHASH_DIGEST_LEN].

pub(crate) const fn verify_inputs(pwd: &[u8], salt: &[u8]) -> Result<()>

Trait Implementations

impl<'key> Clone for Argon2<'key>

fn clone(&self) -> Argon2<'key>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Argon2<'_>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Argon2<'_>

fn default() -> Self

Returns the “default value” for a type.

impl<'key> From<&Params> for Argon2<'key>

fn from(params: &Params) -> Self

Converts to this type from the input type.

impl<'key> From<Params> for Argon2<'key>

fn from(params: Params) -> Self

Converts to this type from the input type.

impl PasswordHasher for Argon2<'_>

Available on crate features alloc and password-hash only.

type Params = Params

Algorithm-specific parameters.

fn hash_password<'a>( &self, password: &[u8], salt: impl Into<Salt<'a>>, ) -> Result<PasswordHash<'a>>

Simple API for computing a PasswordHash from a password and salt value.

fn hash_password_customized<'a>( &self, password: &[u8], alg_id: Option<Ident<'a>>, version: Option<Decimal>, params: Params, salt: impl Into<Salt<'a>>, ) -> Result<PasswordHash<'a>>

Compute a PasswordHash from the provided password using an explicit set of customized algorithm parameters as opposed to the defaults.