Argon2

https://docs.rs/argon2/latest/argon2
Admin
Pure Rust implementation of the Argon2 password hashing function with support for the Argon2d,...
Tokens:39,962
Snippets:644
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Result::and_then file system example

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Uses and_then to chain metadata retrieval and modification time access.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Result::and_then chaining examples

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates chaining fallible operations that may return Err.

```rust
assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

--------------------------------

### IntoIterator Result example

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates using IntoIterator on a Result, which yields one value if Ok and none if Err.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);

let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

--------------------------------

### Chain fallible operations with and_then

Source: https://docs.rs/argon2/latest/argon2/type.Result.html?search=

Demonstrates chaining operations that may return Err. The first example uses a hypothetical sq_then_to_string function, while the second uses standard library path metadata.

```rust
assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
```

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### FromIterator Result increment example

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates using FromIterator to collect a Result of a vector after incrementing elements, checking for overflow.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

--------------------------------

### FromIterator Result subtraction example

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates using FromIterator to collect a Result of a vector after subtracting elements, checking for underflow.

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

--------------------------------

### FromIterator Result short-circuiting example

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Shows that no further elements are taken from the iterator after the first Err is encountered.

```rust
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
    shared += x;
    x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);
```

--------------------------------

### into_ok experimental method

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates the nightly-only into_ok method which extracts the Ok value without panicking.

```rust

fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### unwrap method usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates the basic usage of unwrap and its behavior when encountering an Err variant.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

--------------------------------

### unwrap basic usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html?search=u32+-%3E+bool

Demonstrates the basic usage of unwrap to extract the Ok value.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

--------------------------------

### Argon2::new

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html

Creates a new Argon2 context with the specified algorithm, version, and parameters.

```APIDOC
## Argon2::new(algorithm: Algorithm, version: Version, params: Params) -> Self

### Description
Creates a new Argon2 context instance.

### Parameters
- **algorithm** (Algorithm) - The Argon2 algorithm variant to use.
- **version** (Version) - The Argon2 version to use.
- **params** (Params) - The default set of parameters to use.
```

--------------------------------

### Result::into_ok usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html?search=

Demonstrates into_ok, a nightly-only API that extracts an Ok value without the possibility of panicking.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### Block::new

Source: https://docs.rs/argon2/latest/argon2/struct.Block.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new Block instance initialized with zeros.

```APIDOC
## pub const fn new() -> Self

### Description
Returns a Block initialized with zeros.

### Returns
- **Self** - A new Block instance.
```

--------------------------------

### ParamsBuilder::new method

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Creates a new builder instance initialized with default parameters.

```rust
pub const fn new() -> Self
```

--------------------------------

### and_then method usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates using and_then for control flow based on Result values.

```rust
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {
    x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")
}
```

--------------------------------

### and method usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Shows how the and method chains results, returning the second result if the first is Ok.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));

let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));

let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

--------------------------------

### KeyId::new

Source: https://docs.rs/argon2/latest/argon2/struct.KeyId.html?search=std%3A%3Avec

Creates a new KeyId instance from a byte slice.

```APIDOC
## pub fn new(slice: &[u8]) -> Result<Self>

### Description
Creates a new KeyId from a slice of bytes.

### Errors
Returns `Error::KeyIdTooLong` if the provided slice exceeds the maximum allowed length.
```

--------------------------------

### KeyId::new

Source: https://docs.rs/argon2/latest/argon2/struct.KeyId.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new KeyId instance from a byte slice.

```APIDOC
## pub fn new(slice: &[u8]) -> Result<Self>

### Description
Creates a new KeyId from a slice. Returns an error if the provided slice exceeds the maximum allowed length.

### Parameters
- **slice** (&[u8]) - Required - The byte slice to convert into a KeyId.

### Errors
- Returns `Error::KeyIdTooLong` if the slice is too long.
```

--------------------------------

### Password Hashing and Verification

Source: https://docs.rs/argon2/latest/argon2/index.html?search=std%3A%3Avec

Demonstrates how to hash a password into a PHC string and verify it using the Argon2 hasher.

```APIDOC
## Password Hashing

### Description
Hashes a password to a PHC string suitable for password-based authentication.

### Usage
```rust
use argon2::{
    password_hash::{PasswordHasher, PasswordVerifier, phc::PasswordHash},
    Argon2
};

let password = b"hunter42";
let argon2 = Argon2::default();

// Hash password to PHC string
let password_hash = argon2.hash_password(password)?.to_string();

// Verify password against PHC string
let parsed_hash = PasswordHash::new(&password_hash)?;
assert!(Argon2::default().verify_password(password, &parsed_hash).is_ok());
```
```

--------------------------------

### Argon2::new constructor

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html?search=

Creates a new Argon2 context with the specified algorithm, version, and parameters.

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

--------------------------------

### Password Hashing and Verification

Source: https://docs.rs/argon2/latest/argon2/index.html?search=

Demonstrates how to hash a password into a PHC string and verify it using the Argon2id algorithm.

```APIDOC
## Password Hashing and Verification

### Description
Hashes a password to a PHC string suitable for authentication and verifies a password against a previously generated hash.

### Usage
```rust
use argon2::{
    password_hash::{PasswordHasher, PasswordVerifier, phc::PasswordHash},
    Argon2
};

let password = b"hunter42";
let argon2 = Argon2::default();

// Hash password to PHC string
let password_hash = argon2.hash_password(password)?.to_string();

// Verify password against PHC string
let parsed_hash = PasswordHash::new(&password_hash)?;
assert!(Argon2::default().verify_password(password, &parsed_hash).is_ok());
```
```

--------------------------------

### Block constants and initialization

Source: https://docs.rs/argon2/latest/argon2/struct.Block.html

Constants and constructor for the Block struct.

```rust
pub const SIZE: usize = 1024
```

```rust
pub const fn new() -> Self
```

--------------------------------

### Hash and Verify Password with Argon2

Source: https://docs.rs/argon2/latest/argon2/index.html?search=

Demonstrates hashing a password to a PHC string using default parameters and verifying it. Requires the getrandom feature to be enabled.

```rust
// NOTE: example requires `getrandom` feature is enabled

use argon2::{
    password_hash::{PasswordHasher, PasswordVerifier, phc::PasswordHash},
    Argon2
};

let password = b"hunter42"; // Bad password; don't actually use!

// Argon2 with default params (Argon2id v19), generating a random salt
let argon2 = Argon2::default();

// Hash password to PHC string ($argon2id$v=19$...)
let password_hash = argon2.hash_password(password)?.to_string();

// Verify password against PHC string.
//
// NOTE: hash params from `parsed_hash` are used instead of what is configured in the
// `Argon2` instance.
let parsed_hash = PasswordHash::new(&password_hash)?;
assert!(Argon2::default().verify_password(password, &parsed_hash).is_ok());
```

--------------------------------

### Key Derivation

Source: https://docs.rs/argon2/latest/argon2/index.html?search=

Demonstrates how to transform a password into cryptographic key material.

```APIDOC
## Key Derivation

### Description
Transforms a password into cryptographic keys of a specified size using the Argon2 algorithm.

### Usage
```rust
use argon2::Argon2;

let password = b"hunter42";
let salt = b"example salt";

let mut output_key_material = [0u8; 32];
Argon2::default().hash_password_into(password, salt, &mut output_key_material)?;
```
```

--------------------------------

### ParamsBuilder::context method

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Creates a new Argon2 context using the specified algorithm and version.

```rust
pub fn context( &self, algorithm: Algorithm, version: Version, ) -> Result<Argon2<'_>>
```

--------------------------------

### Params::new

Source: https://docs.rs/argon2/latest/argon2/struct.Params.html?search=u32+-%3E+bool

Creates a new instance of Argon2 parameters with validation for memory, time, and parallelism costs.

```APIDOC
## fn new(m_cost: u32, t_cost: u32, p_cost: u32, output_len: Option<usize>) -> Result<Self>

### Description
Creates new Argon2 parameters. Validates that costs and output length are within the allowed bounds defined by the library constants.

### Parameters
- **m_cost** (u32) - Required - Memory size in 1 KiB blocks. Must be between 8*p_cost and (2^32)-1.
- **t_cost** (u32) - Required - Number of iterations. Must be between 1 and (2^32)-1.
- **p_cost** (u32) - Required - Degree of parallelism. Must be between 1 and (2^24)-1.
- **output_len** (Option<usize>) - Optional - Size of the KDF output in bytes. Defaults to 32 if not provided.
```

--------------------------------

### Argon2::params

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html?search=u32+-%3E+bool

Retrieves the default configured parameters.

```APIDOC
## fn params(&self) -> &Params

### Description
Returns the default configured parameters for the Argon2 context.
```

--------------------------------

### Params getter methods

Source: https://docs.rs/argon2/latest/argon2/struct.Params.html

Methods to retrieve the configured parameters and calculated values.

```rust
pub const fn m_cost(&self) -> u32
pub const fn t_cost(&self) -> u32
pub const fn p_cost(&self) -> u32
pub fn keyid(&self) -> &[u8] ⓘ
pub fn data(&self) -> &[u8] ⓘ
pub const fn output_len(&self) -> Option<usize>
pub const fn block_count(&self) -> usize
```

--------------------------------

### ParamsBuilder::DEFAULT constant

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

The default parameters recommended for use.

```rust
pub const DEFAULT: ParamsBuilder
```

--------------------------------

### expect

Source: https://docs.rs/argon2/latest/argon2/type.Result.html?search=

Returns the contained Ok value, consuming the self value, or panics if Err.

```APIDOC
## pub fn expect(self, msg: &str) -> T

### Description
Returns the contained `Ok` value, consuming the `self` value. Panics if the value is an `Err`, with a panic message including the passed message, and the content of the `Err`.
```

--------------------------------

### KeyId::new

Source: https://docs.rs/argon2/latest/argon2/struct.KeyId.html

Creates a new KeyId instance from a byte slice. Returns an error if the slice exceeds the maximum allowed length.

```APIDOC
## pub fn new(slice: &[u8]) -> Result<Self>

### Description
Creates a new KeyId from a slice. 

### Errors
Returns `Error::KeyIdTooLong` in the event the provided slice is too long.
```

--------------------------------

### Argon2::params method

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html?search=

Retrieves the default configured parameters.

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

--------------------------------

### expect method

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Returns the contained Ok value or panics with a provided message.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

--------------------------------

### Params constructor

Source: https://docs.rs/argon2/latest/argon2/struct.Params.html

Creates a new instance of Params with specified costs and output length.

```rust
pub const fn new( m_cost: u32, t_cost: u32, p_cost: u32, output_len: Option<usize>, ) -> Result<Self>
```

--------------------------------

### Result::or usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Returns the provided result if the current one is Err, otherwise returns the Ok value.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));

let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));
```

--------------------------------

### ParamsBuilder Methods

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Methods available for configuring and building Argon2 parameters.

```APIDOC
## new()

### Description
Creates a new builder with the default parameters.

## m_cost(m_cost: u32)

### Description
Sets memory size, expressed in kibibytes, between 8*p_cost and (2^32)-1.

## t_cost(t_cost: u32)

### Description
Sets number of iterations, between 1 and (2^32)-1.

## p_cost(p_cost: u32)

### Description
Sets degree of parallelism, between 1 and (2^24)-1.

## keyid(keyid: KeyId)

### Description
Sets key identifier.

## data(data: AssociatedData)

### Description
Sets associated data.

## output_len(len: usize)

### Description
Sets length of the output (in bytes).

## build()

### Description
Returns the finished Params object after performing validation checks.

## context(algorithm: Algorithm, version: Version)

### Description
Creates a new Argon2 context using the provided algorithm and version.
```

--------------------------------

### ParamsBuilder::m_cost method

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Sets the memory size in kibibytes.

```rust
pub fn m_cost(&mut self, m_cost: u32) -> &mut Self
```

--------------------------------

### ParamsBuilder::keyid method

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Sets the key identifier.

```rust
pub fn keyid(&mut self, keyid: KeyId) -> &mut Self
```

--------------------------------

### Hash and Verify Password with Pepper

Source: https://docs.rs/argon2/latest/argon2/index.html?search=

Shows how to use a secret pepper in addition to a salt for password hashing and verification. Requires the getrandom feature to be enabled.

```rust
// NOTE: example requires `getrandom` feature is enabled

use argon2::{
    password_hash::{PasswordHasher, PasswordVerifier, phc::PasswordHash},
    Algorithm, Argon2, Params, Version
};

let password = b"hunter42"; // Bad password; don't actually use!

// Argon2 with default params (Argon2id v19) and pepper
let argon2 = Argon2::new_with_secret(
    b"secret pepper",
    Algorithm::default(),
    Version::default(),
    Params::default()
)?;

// Hash password to PHC string ($argon2id$v=19$...), generating a random salt
let password_hash = argon2.hash_password(password)?.to_string();

// Verify password against PHC string.
//
// NOTE: hash params from `parsed_hash` are used instead of what is configured in the
// `Argon2` instance.
let parsed_hash = PasswordHash::new(&password_hash)?;
let argon2 = Argon2::new_with_secret(
    b"secret pepper",
    Algorithm::default(),
    Version::default(),
    Params::default(),
)
.unwrap();
let res = argon2.verify_password(password, &parsed_hash);
assert!(res.is_ok());
```

--------------------------------

### expect_err method usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates expect_err, which panics if the result is an Ok variant.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

--------------------------------

### Result::is_ok_and

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Returns true if the result is Ok and the value inside matches a predicate.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

--------------------------------

### ParamsBuilder::data method

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Sets the associated data.

```rust
pub fn data(&mut self, data: AssociatedData) -> &mut Self
```

--------------------------------

### From trait implementation

Source: https://docs.rs/argon2/latest/argon2/enum.Algorithm.html

Returns the argument unchanged.

```rust
fn from(t: T) -> T
```

--------------------------------

### CloneToUninit trait implementation

Source: https://docs.rs/argon2/latest/argon2/enum.Algorithm.html

Performs copy-assignment from self to dest. This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### ParamsBuilder::output_len method

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Sets the length of the output in bytes.

```rust
pub fn output_len(&mut self, len: usize) -> &mut Self
```

--------------------------------

### Argon2::hash_password_into

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html

Hashes a password into the provided output buffer (requires 'alloc' feature).

```APIDOC
## Argon2::hash_password_into(&self, pwd: &[u8], salt: &[u8], out: &mut [u8]) -> Result<()>

### Description
Hashes a password and associated parameters into the provided output buffer. This method is only available when the 'alloc' feature is enabled.

### Parameters
- **pwd** (&[u8]) - The password to hash.
- **salt** (&[u8]) - The salt to use.
- **out** (&mut [u8]) - The output buffer for the hash.

### Errors
- Returns `Error::PwdTooLong`, `Error::SaltTooShort`, `Error::SaltTooLong`, `Error::OutputTooShort`, or `Error::OutputTooLong` based on input validation.
```

--------------------------------

### KeyId::is_empty

Source: https://docs.rs/argon2/latest/argon2/struct.KeyId.html

Checks if the KeyId is empty.

```APIDOC
## pub const fn is_empty(&self) -> bool

### Description
Is this value empty?
```

--------------------------------

### Argon2::hash_password_with_salt

Source: https://docs.rs/argon2/latest/argon2/struct.PasswordHash.html?search=std%3A%3Avec

Computes a password hash from the given password and salt using the Argon2 configuration.

```APIDOC
## fn hash_password_with_salt(&self, password: &[u8], salt: &[u8]) -> Result<PasswordHash>

### Description
Compute the hash from the given password and salt, potentially using configuration stored in the Argon2 instance for the parameters, or otherwise the recommended defaults.

### Parameters
- **password** (&[u8]) - Required - The password to hash.
- **salt** (&[u8]) - Required - The salt to use for hashing.

### Returns
- **Result<PasswordHash>** - Returns the computed PasswordHash on success.
```

--------------------------------

### Algorithm::new

Source: https://docs.rs/argon2/latest/argon2/enum.Algorithm.html

Parses an Algorithm variant from a provided string identifier.

```APIDOC
## pub fn new(id: impl AsRef<str>) -> Result<Self>

### Description
Parses an `Algorithm` from the provided string identifier.

### Errors
Returns `Error::AlgorithmInvalid` if `id` is not a valid Argon2 algorithm identifier.
```

--------------------------------

### derive_key

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Derives a key from a password and salt.

```APIDOC
## derive_key

### Description
Writes uniformly random data suitable as key material into the entire length of the output buffer, derived from the provided password and salt.

### Parameters
- **password** (&[u8]) - The password input.
- **salt** (&[u8]) - The salt input.
- **out** (&mut [u8]) - The buffer to write the derived key into.
```

--------------------------------

### into_err experimental method

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Demonstrates the nightly-only into_err method which extracts the Err value without panicking.

```rust

fn only_bad_news() -> Result<!, String> {
    Err("Oops, it failed".into())
}

let error: String = only_bad_news().into_err();
println!("{error}");
```

--------------------------------

### Argon2::hash_password_into

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html?search=u32+-%3E+bool

Hashes a password and associated parameters into a provided output buffer.

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

### Description
Hashes a password and salt into the provided output buffer. Requires the 'alloc' feature.

### Errors
- **Error::PwdTooLong** - If pwd is longer than MAX_PWD_LEN.
- **Error::SaltTooShort** - If salt is shorter than MIN_SALT_LEN.
- **Error::SaltLong** - If salt is longer than MAX_SALT_LEN.
- **Error::OutputTooShort** - If out is too short.
- **Error::OutputTooLong** - If out is too long.
```

--------------------------------

### RECOMMENDED_SALT_LEN constant definition

Source: https://docs.rs/argon2/latest/argon2/constant.RECOMMENDED_SALT_LEN.html

The constant is defined as 16 bytes, which is the recommended length for password hashing salts.

```rust
pub const RECOMMENDED_SALT_LEN: usize = 16;
```

--------------------------------

### Result::unwrap_or usage

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Returns the contained Ok value or a provided default value.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

--------------------------------

### Argon2::new_with_secret

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html

Creates a new Argon2 context with an optional secret key (pepper).

```APIDOC
## Argon2::new_with_secret(secret: &[u8], algorithm: Algorithm, version: Version, params: Params) -> Result<Self>

### Description
Creates a new Argon2 context with an associated secret key.

### Parameters
- **secret** (&[u8]) - The secret key (pepper) to be used.
- **algorithm** (Algorithm) - The Argon2 algorithm variant to use.
- **version** (Version) - The Argon2 version to use.
- **params** (Params) - The default set of parameters to use.

### Errors
- Returns `Error::SecretTooLong` if the secret is too long.
```

--------------------------------

### Result::is_ok

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Returns true if the result is Ok.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

--------------------------------

### Result::ok conversion

Source: https://docs.rs/argon2/latest/argon2/type.Result.html

Converts a Result into an Option, discarding the error.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### KeyId::from_b64

Source: https://docs.rs/argon2/latest/argon2/struct.KeyId.html

Decodes a KeyId from a base64 encoded string.

```APIDOC
## pub fn from_b64(s: &str) -> Result<Self>

### Description
Decode KeyId from a B64 string.

### Errors
Returns `Error::B64Encoding` if the providing string couldn’t be decoded as B64.
```

--------------------------------

### Params constants

Source: https://docs.rs/argon2/latest/argon2/struct.Params.html

Constants defining the default, minimum, and maximum values for Argon2 parameters.

```rust
pub const DEFAULT_M_COST: u32
pub const MIN_M_COST: u32
pub const MAX_M_COST: u32 = u32::MAX
pub const DEFAULT_T_COST: u32 = 2
pub const MIN_T_COST: u32 = 1
pub const MAX_T_COST: u32 = u32::MAX
pub const DEFAULT_P_COST: u32 = 1
pub const MIN_P_COST: u32 = 1
pub const MAX_P_COST: u32 = 0xFFFFFF
pub const MAX_KEYID_LEN: usize = 8
pub const MAX_DATA_LEN: usize = 32
pub const DEFAULT_OUTPUT_LEN: usize = 32
pub const MIN_OUTPUT_LEN: usize = 4
pub const MAX_OUTPUT_LEN: usize = 0xFFFFFFFF
pub const DEFAULT: Self
```

--------------------------------

### verify_password

Source: https://docs.rs/argon2/latest/argon2/struct.Argon2.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Verifies a password against a provided hash.

```APIDOC
## verify_password

### Description
Compute this password hashing function against the provided password using the parameters from the provided password hash and see if the computed output matches.

### Parameters
- **password** (&[u8]) - The password to verify.
- **hash** (&str) - The hash string to verify against.
```

--------------------------------

### ParamsBuilder::build method

Source: https://docs.rs/argon2/latest/argon2/struct.ParamsBuilder.html

Constructs the final Params object, performing validation checks.

```rust
pub const fn build(&self) -> Result<Params>
```

--------------------------------

### fn verify_password

Source: https://docs.rs/argon2/latest/argon2/trait.PasswordVerifier.html?search=

Computes the password hashing function against a provided password using parameters from the hash to verify if they match.

```APIDOC
## fn verify_password(&self, password: &[u8], hash: &H) -> Result<(), Error>

### Description
Computes the password hashing function against the provided password using the parameters from the provided password hash and checks if the computed output matches the expected hash.

### Parameters
- **password** (&[u8]) - The password to verify.
- **hash** (&H) - The password hash to verify against.

### Errors
- **Error::Algorithm**: Returned if the algorithm requested by the hash H is unsupported.
- **Error::PasswordInvalid**: Returned if the computed hash for the supplied password does not match the expected hash.
- **Other**: May return other algorithm-specific errors.
```
Tokens:
Raw