use anyhow::{Context as _, Result};
use argon2::password_hash::{PasswordHash, PasswordHasher as _, PasswordVerifier as _, SaltString};
use argon2::Argon2;
use async_trait::async_trait;
use std::collections::BTreeMap;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Identity {
pub username: String,
}
#[async_trait]
pub trait CredentialStore: Send + Sync {
async fn verify(&self, username: &str, password: &str) -> Result<Option<Identity>>;
}
const DUMMY_PHC_HASH: &str = "$argon2id$v=19$m=19456,t=2,p=1$MDAwMDAwMDAwMDAwMDAwMA$pdaCoLR3xX/D3xQMKQPvvUM8YtOKLQP2VwvUqTcHmoU";
pub fn hash_password(password: &str) -> Result<String> {
let salt = SaltString::generate(&mut argon2::password_hash::rand_core::OsRng);
Argon2::default()
.hash_password(password.as_bytes(), &salt)
.map(|hash| hash.to_string())
.map_err(|err| anyhow::anyhow!("failed to hash password: {err}"))
}
pub fn is_valid_password_hash(value: &str) -> bool {
let Ok(parsed) = PasswordHash::new(value) else {
return false;
};
let is_argon2 = matches!(
parsed.algorithm.as_str(),
"argon2d" | "argon2i" | "argon2id"
);
is_argon2 && parsed.salt.is_some() && parsed.hash.is_some()
}
pub fn verify_password(password: &str, hash: &str) -> Result<bool> {
let parsed = PasswordHash::new(hash)
.map_err(|err| anyhow::anyhow!("stored credential is not a valid PHC hash: {err}"))?;
Ok(Argon2::default()
.verify_password(password.as_bytes(), &parsed)
.is_ok())
}
#[derive(Debug, Clone, Default)]
pub struct EnvHashCredentialStore {
users: BTreeMap<String, String>,
}
impl EnvHashCredentialStore {
pub fn from_json(raw: &str) -> Result<Self> {
let users: BTreeMap<String, String> = serde_json::from_str(raw)
.context("credential map must be a JSON object of username -> PHC hash")?;
for (username, hash) in &users {
anyhow::ensure!(
is_valid_password_hash(hash),
"credential for user '{username}' is not a PHC-format password hash; \
store an Argon2id hash (see `krab auth hash-password`), not a plaintext password"
);
}
Ok(Self { users })
}
pub fn from_map(users: BTreeMap<String, String>) -> Result<Self> {
for (username, hash) in &users {
anyhow::ensure!(
is_valid_password_hash(hash),
"credential for user '{username}' is not a PHC-format password hash"
);
}
Ok(Self { users })
}
pub fn len(&self) -> usize {
self.users.len()
}
pub fn is_empty(&self) -> bool {
self.users.is_empty()
}
}
#[async_trait]
impl CredentialStore for EnvHashCredentialStore {
async fn verify(&self, username: &str, password: &str) -> Result<Option<Identity>> {
match self.users.get(username) {
Some(hash) => {
if verify_password(password, hash)? {
Ok(Some(Identity {
username: username.to_string(),
}))
} else {
Ok(None)
}
}
None => {
let _ = verify_password(password, DUMMY_PHC_HASH);
Ok(None)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn hash_of(password: &str) -> String {
hash_password(password).expect("hashing should succeed")
}
#[test]
fn hash_password_emits_argon2id_phc_and_round_trips() {
let hash = hash_of("correct horse battery staple");
assert!(hash.starts_with("$argon2id$"), "unexpected format: {hash}");
assert!(is_valid_password_hash(&hash));
assert!(verify_password("correct horse battery staple", &hash).unwrap());
}
#[test]
fn hashing_the_same_password_twice_gives_different_hashes() {
assert_ne!(hash_of("same"), hash_of("same"));
}
#[test]
fn wrong_password_does_not_verify() {
let hash = hash_of("right");
assert!(!verify_password("wrong", &hash).unwrap());
}
#[test]
fn plaintext_is_not_a_valid_password_hash() {
assert!(!is_valid_password_hash("change-me"));
assert!(!is_valid_password_hash(""));
assert!(!is_valid_password_hash("hunter2"));
}
#[test]
fn structurally_valid_phc_without_a_digest_is_rejected() {
assert!(!is_valid_password_hash("$argon2id$nonsense"));
assert!(!is_valid_password_hash("$argon2id$v=19$m=19456,t=2,p=1"));
}
#[test]
fn a_non_argon2_algorithm_is_rejected() {
assert!(!is_valid_password_hash(
"$pbkdf2-sha256$i=1000$c2FsdHNhbHQ$Fh5eLnV5b25l0kQwT0hFUkVIRVJFSEU"
));
}
#[test]
fn verify_password_errors_on_a_non_phc_hash() {
let err = verify_password("any", "change-me").unwrap_err().to_string();
assert!(err.contains("not a valid PHC hash"), "unhelpful: {err}");
}
#[test]
fn the_dummy_hash_is_parseable_so_unknown_user_timing_is_real_work() {
assert!(is_valid_password_hash(DUMMY_PHC_HASH));
assert!(!verify_password("anything at all", DUMMY_PHC_HASH).unwrap());
}
#[test]
fn from_json_rejects_a_plaintext_password() {
let err = EnvHashCredentialStore::from_json(r#"{"admin":"hunter2"}"#)
.unwrap_err()
.to_string();
assert!(err.contains("admin"), "error should name the user: {err}");
assert!(err.contains("PHC"), "error should name the format: {err}");
assert!(
!err.contains("hunter2"),
"error must not echo the secret: {err}"
);
}
#[test]
fn from_json_rejects_malformed_json() {
assert!(EnvHashCredentialStore::from_json("not json").is_err());
}
#[tokio::test]
async fn correct_password_verifies_and_returns_the_identity() {
let store =
EnvHashCredentialStore::from_json(&format!(r#"{{"admin":"{}"}}"#, hash_of("s3cret")))
.unwrap();
let identity = store.verify("admin", "s3cret").await.unwrap();
assert_eq!(
identity,
Some(Identity {
username: "admin".to_string()
})
);
}
#[tokio::test]
async fn wrong_password_rejects() {
let store =
EnvHashCredentialStore::from_json(&format!(r#"{{"admin":"{}"}}"#, hash_of("s3cret")))
.unwrap();
assert_eq!(store.verify("admin", "wrong").await.unwrap(), None);
}
#[tokio::test]
async fn unknown_user_rejects_without_erroring() {
let store =
EnvHashCredentialStore::from_json(&format!(r#"{{"admin":"{}"}}"#, hash_of("s3cret")))
.unwrap();
assert_eq!(store.verify("nobody", "s3cret").await.unwrap(), None);
}
#[tokio::test]
async fn an_empty_store_rejects_everything() {
let store = EnvHashCredentialStore::from_json("{}").unwrap();
assert!(store.is_empty());
assert_eq!(store.verify("admin", "anything").await.unwrap(), None);
}
}