use std::collections::BTreeMap;
use garde::{Report, Validate};
use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::{
generators::{
GenerateSecret, GenerationError, Secret,
pass::{PassCharset, PassSecretGenerator, PassSecretGeneratorConfig, PassSize},
},
internal::secrets::{
argon2::{
DEFAULT_M_COST, DEFAULT_P_COST, DEFAULT_T_COST, MAX_M_COST, MAX_P_COST, MAX_T_COST,
MIN_P_COST, MIN_T_COST, generate_argon2,
},
pbkdf2::{DEFAULT_ROUNDS, MAX_ROUNDS, MIN_ROUNDS, generate_pbkdf2},
yescrypt::{
DEFAULT_N, DEFAULT_P, DEFAULT_R, MAX_N, MAX_P, MAX_R, MIN_N, MIN_P, MIN_R,
generate_yescrypt,
},
},
};
#[derive(Debug, Serialize, Deserialize, Clone, Validate, PartialEq)]
pub struct Argon2Params {
#[garde(range(min = self.p_cost * 8, max = MAX_M_COST))]
pub m_cost: u32,
#[garde(range(min = MIN_T_COST, max = MAX_T_COST))]
pub t_cost: u32,
#[garde(range(min = MIN_P_COST, max = MAX_P_COST))]
pub p_cost: u32,
}
impl Default for Argon2Params {
fn default() -> Self {
Self {
m_cost: DEFAULT_M_COST,
t_cost: DEFAULT_T_COST,
p_cost: DEFAULT_P_COST,
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Validate, PartialEq)]
pub struct Pbkdf2Params {
#[garde(range(min = MIN_ROUNDS, max = MAX_ROUNDS))]
pub rounds: u32,
}
impl Default for Pbkdf2Params {
fn default() -> Self {
Self {
rounds: DEFAULT_ROUNDS,
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Validate, PartialEq)]
pub struct YescryptParams {
#[garde(range(min = MIN_N, max = MAX_N))]
pub n_cost: u64,
#[garde(range(min = MIN_R, max = MAX_R))]
pub r_cost: u32,
#[garde(range(min = MIN_P, max = MAX_P))]
pub p_cost: u32,
}
impl Default for YescryptParams {
fn default() -> Self {
Self {
n_cost: DEFAULT_N,
r_cost: DEFAULT_R,
p_cost: DEFAULT_P,
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Validate, PartialEq)]
#[serde(rename_all = "snake_case")]
#[serde(tag = "kind")]
pub enum HashKind {
Argon2 {
#[garde(dive)]
params: Option<Argon2Params>,
},
Pbkdf2 {
#[garde(dive)]
params: Option<Pbkdf2Params>,
},
#[serde(alias = "linux_passwd")]
Yescrypt {
#[garde(dive)]
params: Option<YescryptParams>,
},
}
impl Default for HashKind {
fn default() -> Self {
HashKind::Argon2 {
params: Default::default(),
}
}
}
#[derive(Debug, Serialize, Deserialize, Default, Clone, Validate, PartialEq)]
#[serde(try_from = "HashSecretGeneratorConfigDeserializeWith")]
pub struct HashSecretGeneratorConfig {
#[garde(dive)]
pub kind: Option<HashKind>,
#[garde(dive)]
pub pass_config: Option<PassSecretGeneratorConfig>,
}
#[derive(Deserialize, Default, Clone, Debug, Validate)]
struct HashSecretGeneratorConfigDeserializeWith {
#[serde(flatten)]
#[garde(dive)]
pub kind: Option<HashKind>,
#[serde(flatten)]
#[garde(dive)]
pub size: Option<PassSize>,
#[garde(dive)]
pub charset: Option<PassCharset>,
#[serde(flatten)]
#[garde(skip)]
other: BTreeMap<String, serde_value::Value>,
}
#[derive(Debug, Error)]
pub enum ParsingError {
#[error("Unknown field: {0}")]
UnknownField(String),
#[error("Missing field: {0}")]
MissingField(String),
#[error("Value error: {0}")]
ValueError(#[from] Report),
}
impl TryFrom<HashSecretGeneratorConfigDeserializeWith> for HashSecretGeneratorConfig {
type Error = ParsingError;
fn try_from(
value: HashSecretGeneratorConfigDeserializeWith,
) -> Result<HashSecretGeneratorConfig, ParsingError> {
let mut other_keys = value.other.clone();
match &value.kind {
Some(HashKind::Argon2 { params: Some(_) }) => {
other_keys.remove("params");
other_keys.remove("kind");
}
Some(HashKind::Pbkdf2 { params: Some(_) }) => {
other_keys.remove("params");
other_keys.remove("kind");
}
Some(HashKind::Yescrypt { params: Some(_) }) => {
other_keys.remove("params");
other_keys.remove("kind");
}
Some(_) => {
other_keys.remove("kind");
}
None => (),
}
match value.size {
Some(PassSize::Length(_)) => {
other_keys.remove("length");
}
Some(PassSize::AtLeastBits(_)) => {
other_keys.remove("at_least_bits");
}
None => (),
}
if value.charset.is_some() {
other_keys.remove("charset");
}
if other_keys.contains_key("kind") {
return Err(ParsingError::MissingField(
"missing field inside param".to_string(),
));
}
if let Some((key, _)) = other_keys.first_key_value() {
return Err(ParsingError::UnknownField(format!("{:?}", key)));
}
value.validate()?;
Ok(HashSecretGeneratorConfig {
kind: value.kind,
pass_config: Some(PassSecretGeneratorConfig {
charset: value.charset,
size: value.size,
}),
})
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Default, Validate, PartialEq)]
#[serde(transparent)]
pub struct HashSecretGenerator {
#[garde(dive)]
pub config: HashSecretGeneratorConfig,
}
impl GenerateSecret for HashSecretGenerator {
fn generate(&self) -> Result<Secret, GenerationError> {
let config = self.config.clone();
config.validate()?;
let Secret::String(plain) = PassSecretGenerator {
config: config.pass_config.unwrap_or_default(),
}
.generate()?
else {
unreachable!()
};
let hash = match config.kind.unwrap_or_default() {
HashKind::Argon2 { params } => {
let params = params.unwrap_or_default();
generate_argon2(
plain.as_bytes(),
params.m_cost,
params.t_cost,
params.p_cost,
)?
}
HashKind::Pbkdf2 { params } => {
let params = params.unwrap_or_default();
generate_pbkdf2(plain.as_bytes(), params.rounds)?
}
HashKind::Yescrypt { params } => {
let params = params.unwrap_or_default();
generate_yescrypt(
plain.as_bytes(),
params.n_cost,
params.r_cost,
params.p_cost,
)?
}
};
Ok(Secret::Hash { plain, hash })
}
}
#[cfg(test)]
mod test {
use std::collections::HashSet;
use argon2::Argon2;
use password_hash::PasswordVerifier;
use pbkdf2::Pbkdf2;
use yescrypt::Yescrypt;
use crate::generators::{
GenerateSecret, Secret,
pass::{PassCharset, PassSecretGeneratorConfig, PassSize},
};
use super::{
Argon2Params, HashKind, HashSecretGenerator, HashSecretGeneratorConfig, Pbkdf2Params,
YescryptParams,
};
#[test]
fn check_argon2() {
let m_cost = 10 * 1024;
let t_cost = 3;
let p_cost = 2;
let size = 10_000;
let charset = PassCharset::Hex;
let generator = HashSecretGenerator {
config: HashSecretGeneratorConfig {
kind: Some(HashKind::Argon2 {
params: Some(Argon2Params {
m_cost,
t_cost,
p_cost,
}),
}),
pass_config: Some(PassSecretGeneratorConfig {
size: Some(PassSize::Length(10_000)),
charset: Some(charset.clone()),
}),
},
};
let secret = generator.generate().unwrap();
if let Secret::Hash { plain, hash } = secret {
let allowed_chars = charset.charset();
let unique_chars: HashSet<_> = HashSet::from_iter(plain.as_bytes());
assert!(plain.as_bytes().iter().all(|c| allowed_chars.contains(c)));
assert_eq!(unique_chars.len(), allowed_chars.len());
assert_eq!(plain.len(), size);
let parsed_hash = argon2::PasswordHash::new(&hash).unwrap();
assert_eq!(parsed_hash.algorithm.as_str(), "argon2id");
assert_eq!(parsed_hash.params.get_decimal("m").unwrap(), m_cost);
assert_eq!(parsed_hash.params.get_decimal("t").unwrap(), t_cost);
assert_eq!(parsed_hash.params.get_decimal("p").unwrap(), p_cost);
assert!(
Argon2::default()
.verify_password(plain.as_bytes(), &parsed_hash)
.is_ok()
);
} else {
panic!("expected hash, got {secret:?}")
}
}
#[test]
fn check_pbkdf2() {
let rounds = 100_000;
let size = 10_000;
let charset = PassCharset::Hex;
let generator = HashSecretGenerator {
config: HashSecretGeneratorConfig {
kind: Some(HashKind::Pbkdf2 {
params: Some(Pbkdf2Params { rounds }),
}),
pass_config: Some(PassSecretGeneratorConfig {
size: Some(PassSize::Length(10_000)),
charset: Some(charset.clone()),
}),
},
};
let secret = generator.generate().unwrap();
if let Secret::Hash { plain, hash } = secret {
let allowed_chars = charset.charset();
let unique_chars: HashSet<_> = HashSet::from_iter(plain.as_bytes());
assert!(plain.as_bytes().iter().all(|c| allowed_chars.contains(c)));
assert_eq!(unique_chars.len(), allowed_chars.len());
assert_eq!(plain.len(), size);
let parsed_hash = pbkdf2::mcf::PasswordHash::new(&hash).unwrap();
assert!(hash.starts_with(&format!("$pbkdf2-sha256${rounds}$")));
assert!(
Pbkdf2::default()
.verify_password(plain.as_bytes(), &parsed_hash)
.is_ok()
);
} else {
panic!("expected hash, got {secret:?}")
}
}
#[test]
fn check_yescrypt() {
let n = 2048;
let r = 16;
let p = 2;
let size = 10_000;
let charset = PassCharset::Hex;
let generator = HashSecretGenerator {
config: HashSecretGeneratorConfig {
kind: Some(HashKind::Yescrypt {
params: Some(YescryptParams {
n_cost: n,
r_cost: r,
p_cost: p,
}),
}),
pass_config: Some(PassSecretGeneratorConfig {
size: Some(PassSize::Length(10_000)),
charset: Some(charset.clone()),
}),
},
};
let secret = generator.generate().unwrap();
if let Secret::Hash { plain, hash } = secret {
let allowed_chars = charset.charset();
let unique_chars: HashSet<_> = HashSet::from_iter(plain.as_bytes());
assert!(plain.as_bytes().iter().all(|c| allowed_chars.contains(c)));
assert_eq!(unique_chars.len(), allowed_chars.len());
assert_eq!(plain.len(), size);
let parsed_hash = yescrypt::PasswordHash::new(&hash).unwrap();
assert!(hash.starts_with("$y$j8D..$"));
assert!(
Yescrypt::default()
.verify_password(plain.as_bytes(), &parsed_hash)
.is_ok()
);
} else {
panic!("expected hash, got {secret:?}")
}
}
}