use garde::Validate;
use serde::{Deserialize, Serialize};
use crate::{
generators::{GenerateSecret, GenerationError, Secret},
internal::{garde::all_unique, secrets::pass::generate_pass},
};
#[derive(Debug, Serialize, Deserialize, Clone, Validate, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PassSize {
Length(#[garde(range(min = 1))] usize),
AtLeastBits(#[garde(range(min = 1))] usize),
}
impl Default for PassSize {
fn default() -> Self {
Self::Length(40)
}
}
#[derive(Debug, Serialize, Deserialize, Default, Clone, Validate, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PassCharset {
Num,
Hex,
#[default]
AlNum,
Rfc3986,
AlNumSpec,
Custom(#[garde(length(min = 2), custom(all_unique))] String),
}
impl PassCharset {
pub fn charset(&self) -> &[u8] {
match self {
PassCharset::Num => b"0123456789",
PassCharset::Hex => b"0123456789ABCDEF",
PassCharset::AlNum => b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
PassCharset::Rfc3986 => b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~",
PassCharset::AlNumSpec => {
b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
}
PassCharset::Custom(value) => value.as_bytes(),
}
}
}
#[derive(Debug, Serialize, Deserialize, Default, Clone, Validate, PartialEq)]
#[serde(deny_unknown_fields)]
pub struct PassSecretGeneratorConfig {
#[serde(flatten)]
#[garde(dive)]
pub size: Option<PassSize>,
#[garde(dive)]
pub charset: Option<PassCharset>,
}
#[derive(Debug, Serialize, Deserialize, Clone, Default, Validate, PartialEq)]
#[serde(transparent)]
pub struct PassSecretGenerator {
#[garde(dive)]
pub config: PassSecretGeneratorConfig,
}
impl GenerateSecret for PassSecretGenerator {
fn generate(&self) -> Result<Secret, GenerationError> {
let config = self.config.clone();
config.validate()?;
let pass_charset = config.charset.unwrap_or_default();
let charset = pass_charset.charset();
let char_len = match config.size.unwrap_or_default() {
PassSize::Length(length) => length,
PassSize::AtLeastBits(bits) => {
(bits as f64 * f64::log(2.0, charset.len() as f64)).ceil() as usize
}
};
Ok(Secret::String(generate_pass(char_len, charset)?))
}
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use super::{PassCharset, PassSecretGenerator, PassSecretGeneratorConfig, PassSize};
use crate::generators::{GenerateSecret, GenerationError, Secret};
#[test]
fn check_length() {
for length in [1, 2, 10, 50, 200, 12345] {
for charset in [
PassCharset::AlNum,
PassCharset::AlNumSpec,
PassCharset::Hex,
PassCharset::Num,
PassCharset::Rfc3986,
PassCharset::Custom("pasword".to_string()),
] {
let generator = PassSecretGenerator {
config: PassSecretGeneratorConfig {
size: Some(PassSize::Length(length)),
charset: Some(charset),
},
};
let secret = generator.generate().unwrap();
if let Secret::String(sym_secret) = secret {
assert_eq!(sym_secret.len(), length);
} else {
panic!("expected sym, got {secret:?}")
}
}
}
}
#[test]
fn check_bits_hex() {
for (bits, length) in [(1, 1), (2, 1), (10, 3), (50, 13), (256, 64), (12345, 3087)] {
let generator = PassSecretGenerator {
config: PassSecretGeneratorConfig {
size: Some(PassSize::AtLeastBits(bits)),
charset: Some(PassCharset::Hex),
},
};
let secret = generator.generate().unwrap();
if let Secret::String(sym_secret) = secret {
assert_eq!(sym_secret.len(), length);
} else {
panic!("expected sym, got {secret:?}")
}
}
}
#[test]
fn check_bits_alnum() {
for (bits, length) in [(1, 1), (2, 1), (10, 2), (50, 9), (256, 43), (12345, 2074)] {
let generator = PassSecretGenerator {
config: PassSecretGeneratorConfig {
size: Some(PassSize::AtLeastBits(bits)),
charset: Some(PassCharset::AlNum),
},
};
let secret = generator.generate().unwrap();
if let Secret::String(sym_secret) = secret {
assert_eq!(sym_secret.len(), length);
} else {
panic!("expected sym, got {secret:?}")
}
}
}
#[test]
fn check_charset() {
for charset in [
PassCharset::AlNum,
PassCharset::AlNumSpec,
PassCharset::Hex,
PassCharset::Num,
PassCharset::Rfc3986,
PassCharset::Custom("pasword".to_string()),
] {
let generator = PassSecretGenerator {
config: PassSecretGeneratorConfig {
size: Some(PassSize::Length(10_000)),
charset: Some(charset.clone()),
},
};
let secret = generator.generate().unwrap();
println!("{secret:?}");
if let Secret::String(sym_secret) = secret {
let allowed_chars = charset.charset();
let unique_chars: HashSet<_> = HashSet::from_iter(sym_secret.as_bytes());
assert!(
sym_secret
.as_bytes()
.iter()
.all(|c| allowed_chars.contains(c))
);
assert_eq!(unique_chars.len(), allowed_chars.len())
} else {
panic!("expected sym, got {secret:?}")
}
}
}
#[test]
fn check_invalid() {
for (config, err) in [
(
PassSecretGeneratorConfig {
size: Some(PassSize::Length(0)),
charset: None,
},
vec![("size[0]".to_string(), "lower than 1".to_string())],
),
(
PassSecretGeneratorConfig {
size: Some(PassSize::AtLeastBits(0)),
charset: None,
},
vec![("size[0]".to_string(), "lower than 1".to_string())],
),
(
PassSecretGeneratorConfig {
size: None,
charset: Some(PassCharset::Custom("".to_string())),
},
vec![(
"charset[0]".to_string(),
"length is lower than 2".to_string(),
)],
),
(
PassSecretGeneratorConfig {
size: None,
charset: Some(PassCharset::Custom("a".to_string())),
},
vec![(
"charset[0]".to_string(),
"length is lower than 2".to_string(),
)],
),
(
PassSecretGeneratorConfig {
size: None,
charset: Some(PassCharset::Custom("abcad".to_string())),
},
vec![(
"charset[0]".to_string(),
"must not contain duplicate characters".to_string(),
)],
),
] {
assert_eq!(
PassSecretGenerator { config }.generate(),
Result::Err(GenerationError::InvalidConfig(err))
);
}
}
}