footing 0.6.5

Feature-gated foundations for Rust backend services
Documentation
use super::*;
use crate::auth::{Argon2idProfile, PasswordLimits, PasswordVerificationLimits};

fn service(limits: PasswordWorkLimits) -> TokioPasswordService {
    TokioPasswordService::new(
        PasswordService::new().with_profile(Argon2idProfile::new(16, 1, 1, 32).unwrap()),
        limits,
    )
}

#[test]
fn admission_limits_reject_invalid_sizes_and_deadlines() {
    for concurrency in [0, usize::MAX] {
        assert!(matches!(
            PasswordWorkLimits::new(concurrency),
            Err(TokioPasswordError::InvalidConcurrency)
        ));
    }
    let limits = PasswordWorkLimits::new(2).unwrap();
    assert_eq!(limits.concurrency(), 2);
    assert_eq!(limits.max_waiters(), 0);
    assert_eq!(limits.wait_timeout(), Duration::ZERO);
    for (count, timeout) in [
        (0, Duration::from_secs(1)),
        (usize::MAX, Duration::from_secs(1)),
        (1, Duration::ZERO),
        (1, Duration::MAX),
    ] {
        assert!(matches!(
            limits.with_queue(count, timeout),
            Err(TokioPasswordError::InvalidQueue)
        ));
    }
}

#[test]
fn missing_tokio_runtime_is_an_error_instead_of_a_panic() {
    use std::{
        future::Future,
        task::{Context, Poll, Waker},
    };

    let passwords = service(PasswordWorkLimits::new(1).unwrap());
    let mut operation = std::pin::pin!(passwords.hash_password("secret".into()));
    assert!(matches!(
        operation
            .as_mut()
            .poll(&mut Context::from_waker(Waker::noop())),
        Poll::Ready(Err(TokioPasswordError::NoRuntime))
    ));
}

#[tokio::test]
async fn hashes_verifies_and_rehashes_only_successfully_verified_passwords() {
    let passwords = service(PasswordWorkLimits::new(1).unwrap());
    let legacy = PasswordService::new()
        .with_profile(Argon2idProfile::new(8, 1, 1, 32).unwrap())
        .hash_password("correct password")
        .unwrap();
    let assessment = passwords
        .verify_and_assess("correct password".into(), legacy.clone().into())
        .await
        .unwrap();
    assert!(assessment.verified());
    assert!(assessment.needs_rehash());
    let rejected = passwords
        .verify_and_rehash("wrong password".into(), legacy.clone().into())
        .await
        .unwrap();
    assert!(!rejected.verification().verified());
    assert!(rejected.replacement_hash().is_none());

    let upgraded = passwords
        .clone()
        .verify_and_rehash("correct password".into(), legacy.into())
        .await
        .unwrap();
    assert!(upgraded.verification().verified());
    assert!(upgraded.verification().needs_rehash());
    assert!(!format!("{upgraded:?}").contains("$argon2"));
    let (_, replacement) = upgraded.into_parts();
    let current = passwords
        .verify_and_rehash("correct password".into(), replacement.unwrap())
        .await
        .unwrap();
    assert!(current.verification().verified());
    assert!(!current.verification().needs_rehash());
    assert!(current.replacement_hash().is_none());

    let hash = passwords
        .hash_password("new password".into())
        .await
        .unwrap();
    assert_eq!(format!("{hash:?}"), "[REDACTED]");
    assert!(
        passwords
            .verify_password("new password".into(), hash.clone())
            .await
            .unwrap()
    );
    assert!(
        !passwords
            .verify_password("wrong password".into(), hash)
            .await
            .unwrap()
    );
}

#[tokio::test]
async fn malformed_or_unsupported_phc_is_rejected_before_rehash() {
    for verification_limits in [
        None,
        Some(PasswordVerificationLimits::new(8, 1, 1).unwrap()),
    ] {
        let passwords = TokioPasswordService::new(
            PasswordService::new()
                .with_profile(Argon2idProfile::new(8, 1, 1, 32).unwrap())
                .with_limits(
                    PasswordLimits::default().with_verification_limits(verification_limits),
                ),
            PasswordWorkLimits::new(1).unwrap(),
        );
        for (hash, expected) in [
            (
                "$argon2id$v=19$m=8,t=1,p=1",
                PasswordError::InvalidPasswordHash,
            ),
            (
                "$argon2id$v=19$m=8,t=1,p=1$Zm9vdGluZy11cGdyYWRlIQ",
                PasswordError::InvalidPasswordHash,
            ),
            (
                "$argon2id$v=19$m=0,t=1,p=1$Zm9vdGluZy11cGdyYWRlIQ$HeOmHGQWjqcYomRPMGL9XOICZdk+hUcvgRJdEyVgsj0",
                PasswordError::InvalidPasswordHash,
            ),
            (
                "$argon2id$v=99$m=8,t=1,p=1$Zm9vdGluZy11cGdyYWRlIQ$HeOmHGQWjqcYomRPMGL9XOICZdk+hUcvgRJdEyVgsj0",
                PasswordError::UnsupportedPasswordHash,
            ),
            (
                "$unknown$v=19$m=8,t=1,p=1$Zm9vdGluZy11cGdyYWRlIQ$HeOmHGQWjqcYomRPMGL9XOICZdk+hUcvgRJdEyVgsj0",
                PasswordError::UnsupportedPasswordHash,
            ),
        ] {
            let errors = [
                passwords
                    .verify_password("password".into(), hash.into())
                    .await
                    .unwrap_err(),
                passwords
                    .verify_and_rehash("password".into(), hash.into())
                    .await
                    .expect_err("an invalid stored hash must not produce a replacement"),
            ];
            for error in errors {
                assert_eq!(error.error_kind(), ErrorKind::Validation);
                assert_eq!(error.error_code(), expected.error_code());
                assert!(
                    matches!(error, TokioPasswordError::Password(source) if source == expected)
                );
            }
        }
    }
}

#[tokio::test]
async fn limits_and_hash_errors_survive_the_async_boundary() {
    let sync = PasswordService::new().with_profile(Argon2idProfile::new(16, 1, 1, 32).unwrap());
    let hash = sync.hash_password("secret").unwrap();
    let passwords = TokioPasswordService::new(
        sync.with_limits(
            PasswordLimits::new(8)
                .unwrap()
                .with_verification_limits(Some(PasswordVerificationLimits::new(8, 1, 1).unwrap())),
        ),
        PasswordWorkLimits::new(1).unwrap(),
    );
    let error = passwords
        .verify_password("secret".into(), hash.into())
        .await
        .unwrap_err();
    assert!(matches!(
        error,
        TokioPasswordError::Password(PasswordError::VerificationCostExceeded { .. })
    ));
    assert_eq!(error.error_kind(), ErrorKind::Validation);
    assert_eq!(error.error_code(), "password_verification_cost_exceeded");
    assert!(matches!(
        passwords
            .verify_password("secret".into(), "invalid".into())
            .await,
        Err(TokioPasswordError::Password(
            PasswordError::InvalidPasswordHash
        ))
    ));
    // Reject excessive input before waiting for a scarce execution permit.
    let _busy = passwords.inner.running.acquire().await.unwrap();
    assert!(matches!(
        passwords.hash_password("too long password".into()).await,
        Err(TokioPasswordError::Password(
            PasswordError::PasswordTooLong { max: 8 }
        ))
    ));
}

#[tokio::test]
async fn dummy_verification_is_cached_shared_and_subject_to_admission() {
    let passwords = service(PasswordWorkLimits::new(1).unwrap());
    assert!(passwords.inner.dummy_hash.get().is_none());
    passwords
        .verify_dummy_password("unknown".into())
        .await
        .unwrap();
    let hash = passwords.inner.dummy_hash.get().unwrap().as_ref().unwrap();
    passwords
        .clone()
        .verify_dummy_password("".into())
        .await
        .unwrap();
    assert!(std::ptr::eq(
        hash,
        passwords.inner.dummy_hash.get().unwrap().as_ref().unwrap()
    ));
    assert!(!format!("{passwords:?}").contains(hash.expose_secret()));
    let _busy = passwords.inner.running.acquire().await.unwrap();
    assert!(matches!(
        passwords
            .clone()
            .verify_dummy_password("unknown".into())
            .await,
        Err(TokioPasswordError::Busy)
    ));
}

#[tokio::test]
async fn cancelling_a_running_caller_does_not_release_its_shared_budget() {
    let passwords = service(PasswordWorkLimits::new(1).unwrap());
    let (started, start) = tokio::sync::oneshot::channel();
    let (release, finish) = std::sync::mpsc::channel();
    let clone = passwords.clone();
    let caller = tokio::spawn(async move {
        clone
            .run("secret".into(), move |_, _| {
                started.send(()).unwrap();
                // Disconnecting the test's sender also releases this task on failure.
                let _ = finish.recv();
                Ok(())
            })
            .await
    });
    start.await.unwrap();
    caller.abort();
    assert!(caller.await.unwrap_err().is_cancelled());
    for _ in 0..3 {
        assert!(matches!(
            passwords.clone().hash_password("secret".into()).await,
            Err(TokioPasswordError::Busy)
        ));
    }
    release.send(()).unwrap();
    let permit = tokio::time::timeout(Duration::from_secs(5), passwords.inner.running.acquire())
        .await
        .unwrap()
        .unwrap();
    drop(permit);
    assert!(passwords.hash_password("secret".into()).await.is_ok());
}

#[tokio::test(start_paused = true)]
async fn queue_bounds_timeouts_and_cancellation_prevent_unbounded_waiters() {
    let passwords = service(
        PasswordWorkLimits::new(1)
            .unwrap()
            .with_queue(1, Duration::from_secs(5))
            .unwrap(),
    );
    let occupied = passwords.inner.running.acquire().await.unwrap();
    let clone = passwords.clone();
    let waiting = tokio::spawn(async move { clone.hash_password("secret".into()).await });
    tokio::task::yield_now().await;
    assert_eq!(passwords.inner.waiting.available_permits(), 0);
    assert!(matches!(
        passwords.clone().hash_password("secret".into()).await,
        Err(TokioPasswordError::Busy)
    ));
    waiting.abort();
    assert!(waiting.await.unwrap_err().is_cancelled());
    assert_eq!(passwords.inner.waiting.available_permits(), 1);

    let clone = passwords.clone();
    let waiting = tokio::spawn(async move { clone.hash_password("secret".into()).await });
    tokio::task::yield_now().await;
    tokio::time::advance(Duration::from_secs(5)).await;
    let error = waiting.await.unwrap().unwrap_err();
    assert!(matches!(error, TokioPasswordError::WaitTimeout));
    assert_eq!(error.error_kind(), ErrorKind::Timeout);
    assert_eq!(passwords.inner.waiting.available_permits(), 1);

    let clone = passwords.clone();
    let waiting = tokio::spawn(async move { clone.hash_password("secret".into()).await });
    tokio::task::yield_now().await;
    drop(occupied);
    assert!(waiting.await.unwrap().is_ok());
    assert_eq!(passwords.inner.waiting.available_permits(), 1);
    assert_eq!(passwords.inner.running.available_permits(), 1);
}

#[tokio::test]
async fn worker_panics_release_the_budget_without_exposing_the_payload_in_errors() {
    let passwords = service(PasswordWorkLimits::new(1).unwrap());
    let error = passwords
        .run::<()>("secret".into(), |_, _| panic!("private panic payload"))
        .await
        .unwrap_err();
    assert!(matches!(error, TokioPasswordError::Task(_)));
    assert!(!format!("{error:?} {error}").contains("private panic payload"));
    assert!(passwords.hash_password("secret".into()).await.is_ok());
}