pegase 0.2.0

Cli to generate secret config files from yaml recipe
Documentation
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))
            );
        }
    }
}