Implement secure password generation (#8)

crates/storage/tests/password_generation.rs

@@ -0,0 +1,380 @@
+#![forbid(unsafe_code)]
+
+mod support;
+
+use std::{collections::BTreeMap, num::NonZeroUsize};
+
+use ironstorage::{
+    command::{GenerateRequest, GeneratedPresentation},
+    crypto::{KeyInfo, KeyStore, SecretProvider, SecretProviderError},
+    generate::{
+        GenerateError, GeneratedChannel, GeneratorConfig, MAX_PASSWORD_LENGTH, PasswordGenerator,
+    },
+    repository::{EntryPath, Repository, SecretBytes},
+    write::{EntryCommit, EntryCommitError, EntryCommitter, OverwriteDecision, WriteError},
+};
+use rand_chacha::{
+    ChaCha20Rng,
+    rand_core::{CryptoRng, Error as RandError, RngCore, SeedableRng},
+};
+use support::compatibility::{FixtureSet, TestResult};
+
+struct FixtureSecrets(BTreeMap<String, Vec<u8>>);
+
+impl FixtureSecrets {
+    fn all(fixture: &FixtureSet) -> Self {
+        Self(
+            fixture
+                .generated
+                .keys
+                .iter()
+                .map(|key| {
+                    (
+                        key.primary_fingerprint.clone(),
+                        key.passphrase.as_bytes().to_vec(),
+                    )
+                })
+                .collect(),
+        )
+    }
+}
+
+impl SecretProvider for FixtureSecrets {
+    fn secret_for(&mut self, key: &KeyInfo) -> Result<SecretBytes, SecretProviderError> {
+        self.0
+            .get(key.fingerprint().as_str())
+            .cloned()
+            .map(SecretBytes::new)
+            .ok_or(SecretProviderError::Unavailable)
+    }
+}
+
+#[derive(Default)]
+struct Committer {
+    changes: Vec<EntryCommit>,
+    fail: bool,
+}
+
+struct FailingRng;
+
+impl RngCore for FailingRng {
+    fn next_u32(&mut self) -> u32 {
+        0
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        0
+    }
+
+    fn fill_bytes(&mut self, _destination: &mut [u8]) {
+        panic!("fallible generator must use try_fill_bytes")
+    }
+
+    fn try_fill_bytes(&mut self, _destination: &mut [u8]) -> Result<(), RandError> {
+        Err(RandError::new("simulated unavailable randomness"))
+    }
+}
+
+impl CryptoRng for FailingRng {}
+
+impl EntryCommitter for Committer {
+    fn commit(&mut self, change: &EntryCommit) -> Result<(), EntryCommitError> {
+        self.changes.push(change.clone());
+        if self.fail {
+            Err(EntryCommitError::new("simulated"))
+        } else {
+            Ok(())
+        }
+    }
+}
+
+#[test]
+fn deterministic_generation_uses_only_requested_characters_and_length() -> TestResult {
+    let fixture = FixtureSet::load()?;
+    let store = fixture.materialize_store("basic")?;
+    let repository = Repository::open(store.path())?;
+    let keys = KeyStore::load(fixture.path("keys"))?;
+    let service = PasswordGenerator::new(&repository, &keys, GeneratorConfig::new(12, "abc123")?);
+    let mut rng = ChaCha20Rng::from_seed([0x81; 32]);
+    let mut provider = FixtureSecrets::all(&fixture);
+    let mut committer = Committer::default();
+
+    let outcome = service.generate_with_rng(
+        &request(
+            "generated/custom",
+            Some(64),
+            false,
+            false,
+            false,
+            GeneratedPresentation::Terminal,
+        ),
+        OverwriteDecision::Allow,
+        None,
+        &mut provider,
+        &mut committer,
+        &mut rng,
+    )?;
+    assert_eq!(outcome.password().expose().len(), 64);
+    assert!(
+        outcome
+            .password()
+            .expose()
+            .iter()
+            .all(|byte| b"abc123".contains(byte))
+    );
+    assert_eq!(outcome.channel(), GeneratedChannel::Terminal);
+    assert!(!format!("{outcome:?}").contains(std::str::from_utf8(outcome.password().expose())?));
+    assert_eq!(
+        committer.changes[0].message(),
+        "Add generated password for generated/custom."
+    );
+    Ok(())
+}
+
+#[test]
+fn default_no_symbols_and_presentation_actions_are_typed() -> TestResult {
+    let fixture = FixtureSet::load()?;
+    let store = fixture.materialize_store("basic")?;
+    let repository = Repository::open(store.path())?;
+    let keys = KeyStore::load(fixture.path("keys"))?;
+    let service = PasswordGenerator::new(&repository, &keys, GeneratorConfig::pass_defaults());
+    let mut provider = FixtureSecrets::all(&fixture);
+    let mut committer = Committer::default();
+    let mut rng = ChaCha20Rng::from_seed([0x82; 32]);
+
+    for (path, presentation, channel) in [
+        (
+            "generated/clip",
+            GeneratedPresentation::Clipboard,
+            GeneratedChannel::Clipboard,
+        ),
+        (
+            "generated/qr",
+            GeneratedPresentation::QrCode,
+            GeneratedChannel::QrCode,
+        ),
+    ] {
+        let outcome = service.generate_with_rng(
+            &request(path, None, true, false, false, presentation),
+            OverwriteDecision::Allow,
+            None,
+            &mut provider,
+            &mut committer,
+            &mut rng,
+        )?;
+        assert_eq!(outcome.password().expose().len(), 25);
+        assert!(
+            outcome
+                .password()
+                .expose()
+                .iter()
+                .all(u8::is_ascii_alphanumeric)
+        );
+        assert_eq!(outcome.channel(), channel);
+    }
+    Ok(())
+}
+
+#[test]
+fn in_place_replaces_only_first_line_and_preserves_suffix_bytes() -> TestResult {
+    let fixture = FixtureSet::load()?;
+    let store = fixture.materialize_store("basic")?;
+    let repository = Repository::open(store.path())?;
+    let keys = KeyStore::load(fixture.path("keys"))?;
+    let service = PasswordGenerator::new(&repository, &keys, GeneratorConfig::new(8, "XYZ")?);
+    let mut provider = FixtureSecrets::all(&fixture);
+    let mut committer = Committer::default();
+    let mut rng = ChaCha20Rng::from_seed([0x83; 32]);
+    let original = fixture.read("expected/basic/email/personal.txt")?;
+    let suffix = &original[original
+        .iter()
+        .position(|byte| *byte == b'\n')
+        .expect("newline")..];
+
+    let outcome = service.generate_with_rng(
+        &request(
+            "email/personal",
+            Some(8),
+            false,
+            false,
+            true,
+            GeneratedPresentation::Terminal,
+        ),
+        OverwriteDecision::Decline,
+        None,
+        &mut provider,
+        &mut committer,
+        &mut rng,
+    )?;
+    let plaintext = keys.decrypt(
+        &repository.read_entry(&EntryPath::parse("email/personal")?)?,
+        &mut provider,
+    )?;
+    assert_eq!(&plaintext.expose()[8..], suffix);
+    assert_eq!(&plaintext.expose()[..8], outcome.password().expose());
+    Ok(())
+}
+
+#[test]
+fn validates_lengths_character_sets_and_incompatible_flags() -> TestResult {
+    assert!(matches!(
+        GeneratorConfig::new(0, "abc"),
+        Err(GenerateError::InvalidLength)
+    ));
+    assert!(matches!(
+        GeneratorConfig::new(MAX_PASSWORD_LENGTH + 1, "abc"),
+        Err(GenerateError::InvalidLength)
+    ));
+    assert!(matches!(
+        GeneratorConfig::new(10, ""),
+        Err(GenerateError::EmptyCharacterSet)
+    ));
+    assert!(matches!(
+        GeneratorConfig::new(10, "aab"),
+        Err(GenerateError::InvalidCharacterSet)
+    ));
+    assert!(matches!(
+        GeneratorConfig::new(10, "a\nb"),
+        Err(GenerateError::InvalidCharacterSet)
+    ));
+
+    let fixture = FixtureSet::load()?;
+    let store = fixture.materialize_store("basic")?;
+    let repository = Repository::open(store.path())?;
+    let keys = KeyStore::load(fixture.path("keys"))?;
+    let service = PasswordGenerator::new(&repository, &keys, GeneratorConfig::pass_defaults());
+    let mut provider = FixtureSecrets::all(&fixture);
+    let mut rng = ChaCha20Rng::from_seed([0x84; 32]);
+    assert!(matches!(
+        service.generate_with_rng(
+            &request(
+                "entry",
+                Some(8),
+                false,
+                true,
+                true,
+                GeneratedPresentation::Terminal
+            ),
+            OverwriteDecision::Allow,
+            None,
+            &mut provider,
+            &mut Committer::default(),
+            &mut rng,
+        ),
+        Err(GenerateError::IncompatibleFlags)
+    ));
+    assert!(matches!(
+        service.generate_with_rng(
+            &request(
+                "randomness-failure",
+                Some(8),
+                false,
+                false,
+                false,
+                GeneratedPresentation::Terminal,
+            ),
+            OverwriteDecision::Allow,
+            None,
+            &mut provider,
+            &mut Committer::default(),
+            &mut FailingRng,
+        ),
+        Err(GenerateError::RandomnessUnavailable)
+    ));
+    assert!(!store.path().join("randomness-failure.gpg").exists());
+    Ok(())
+}
+
+#[test]
+fn decline_missing_in_place_and_commit_failure_leave_entries_unchanged() -> TestResult {
+    let fixture = FixtureSet::load()?;
+    let store = fixture.materialize_store("basic")?;
+    let repository = Repository::open(store.path())?;
+    let keys = KeyStore::load(fixture.path("keys"))?;
+    let service = PasswordGenerator::new(&repository, &keys, GeneratorConfig::pass_defaults());
+    let path = EntryPath::parse("email/personal")?;
+    let original = repository.read_entry(&path)?;
+    let mut provider = FixtureSecrets::all(&fixture);
+    let mut rng = ChaCha20Rng::from_seed([0x85; 32]);
+
+    assert!(matches!(
+        service.generate_with_rng(
+            &request(
+                "email/personal",
+                Some(8),
+                false,
+                false,
+                false,
+                GeneratedPresentation::Terminal
+            ),
+            OverwriteDecision::Decline,
+            None,
+            &mut provider,
+            &mut Committer::default(),
+            &mut rng,
+        ),
+        Err(GenerateError::Write(WriteError::Cancelled))
+    ));
+    assert_eq!(repository.read_entry(&path)?, original);
+    assert!(matches!(
+        service.generate_with_rng(
+            &request(
+                "missing",
+                Some(8),
+                false,
+                false,
+                true,
+                GeneratedPresentation::Terminal
+            ),
+            OverwriteDecision::Allow,
+            None,
+            &mut provider,
+            &mut Committer::default(),
+            &mut rng,
+        ),
+        Err(GenerateError::Repository(_))
+    ));
+
+    let mut failing = Committer {
+        fail: true,
+        ..Committer::default()
+    };
+    assert!(matches!(
+        service.generate_with_rng(
+            &request(
+                "email/personal",
+                Some(8),
+                false,
+                true,
+                false,
+                GeneratedPresentation::Terminal
+            ),
+            OverwriteDecision::Allow,
+            None,
+            &mut provider,
+            &mut failing,
+            &mut rng,
+        ),
+        Err(GenerateError::Write(WriteError::Commit(_)))
+    ));
+    assert_eq!(repository.read_entry(&path)?, original);
+    Ok(())
+}
+
+fn request(
+    entry: &str,
+    length: Option<usize>,
+    no_symbols: bool,
+    force: bool,
+    in_place: bool,
+    presentation: GeneratedPresentation,
+) -> GenerateRequest {
+    GenerateRequest {
+        entry: entry.to_owned(),
+        length: length.map(|length| NonZeroUsize::new(length).expect("test length is nonzero")),
+        no_symbols,
+        force,
+        in_place,
+        presentation,
+    }
+}