use mlua::Lua;
use crate::crypto::VERIFY_REASONS;
use crate::crypto::create_crypto_table;
use crate::crypto::password::{DECOY_HASH, MAX_PASSWORD_BYTES, hash_ident, parse_stored_hash};
fn password_fns(lua: &Lua) -> (mlua::Function, mlua::Function, mlua::Function) {
let crypto = create_crypto_table(lua).expect("crypto table");
(
crypto.get("password_hash").expect("password_hash"),
crypto.get("password_verify").expect("password_verify"),
crypto
.get("password_verify_dummy")
.expect("password_verify_dummy"),
)
}
fn pw<R: mlua::FromLuaMulti + 'static>(
f: &mlua::Function,
args: impl mlua::IntoLuaMulti,
) -> mlua::Result<R> {
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("test runtime")
.block_on(f.call_async::<R>(args))
}
#[test]
fn passwords_hash_and_verify() {
let lua = Lua::new();
let (hash_fn, verify, _) = password_fns(&lua);
let hash: String = pw(&hash_fn, "hunter2").expect("hash");
assert!(hash.starts_with("$argon2id$"), "got: {hash}");
let (ok, why): (bool, Option<String>) = pw(&verify, ("hunter2", hash.clone())).expect("verify");
assert!(ok);
assert_eq!(why, None);
let (ok, why): (bool, Option<String>) = pw(&verify, ("wrong", hash)).expect("verify");
assert!(!ok);
assert_eq!(why, None);
let hash: String = pw(&hash_fn, "hunter2").expect("hash");
assert!(pw::<bool>(&verify, ("hunter2", hash)).expect("verify"));
}
#[test]
fn an_unusable_stored_hash_is_distinguishable_from_a_wrong_password() {
let lua = Lua::new();
let (_, verify, _) = password_fns(&lua);
for (stored, expected) in [
(
"$2b$12$K3JNi5tR9lHnKKfKzXBDUuJ7dK1nGVX8UEcqfQe5NRaTZY0aWkNSe",
"unsupported hash format",
),
(
"$2y$10$abcdefghijklmnopqrstuv0123456789012345678901234567890",
"unsupported hash format",
),
("$1$salt$qJH7.N4xYta3aEG/dfqo/0", "unsupported hash format"),
(
"$6$salt$IxDD3jeSOb5eB1CX5LBsqZFVkJdido3OUILO5Ifz5iwMuTS4XMS130MTSuDDl3aCI6WouIL9AjRbLCelDCy.g.",
"unsupported hash format",
),
("not-a-hash", "unsupported hash format"),
("", "unsupported hash format"),
(
"$scrypt$ln=16,r=8,p=1$aM15713r3Xsvxbi31lqr1Q$nFNh2CVHVjNldFVKDHDlm4CmdRSCdEBsjjJxD+iCs5E",
"unsupported hash algorithm",
),
("$argon2id$v=19$m=19456,t=2,p=1", "incomplete hash"),
(
"$argon2id$v=19$m=19456,t=2,p=1$c29tZXNhbHQ",
"incomplete hash",
),
(
"$argon2id$v=19$m=4194304,t=2,p=1$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObG",
"hash parameters out of range",
),
(
"$argon2id$v=19$m=19456,t=4294967295,p=1$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObG",
"hash parameters out of range",
),
(
"$argon2id$v=19$m=19456,t=2,p=1,zz=9$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObG",
"unusable hash",
),
(
"$argon2id$v=99$m=19456,t=2,p=1$c29tZXNhbHQ$RdescudvJCsgt3ub+b+dWRWJTmaaJObG",
"unusable hash",
),
] {
let (ok, why): (bool, Option<String>) = pw(&verify, ("hunter2", stored)).expect("verify");
assert!(!ok, "{stored:?} verified");
assert_eq!(why.as_deref(), Some(expected), "for {stored:?}");
assert!(
VERIFY_REASONS.contains(&expected),
"{expected:?} is not in VERIFY_REASONS"
);
}
let (ok, why): (bool, Option<String>) = pw(
&verify,
(
"hunter2",
"$argon2id$v=19$m=8,t=1,p=1$mHVoGfzni7/d60QmEsVJlw$\
7rFvapCGZeh96Zf4R2I/pEVmV2YRWxfl6xo5yGL3F6Q",
),
)
.expect("verify");
assert!(!ok);
assert_eq!(why, None);
assert_eq!(
hash_ident("$argon2id$v=19$m=8,t=1,p=1$c2E$aGFzaA"),
"argon2id"
);
assert_eq!(hash_ident("$2b$12$xxxx"), "2b");
assert_eq!(hash_ident("not-a-hash"), "unknown");
assert_eq!(hash_ident("$$empty"), "unknown");
assert_eq!(hash_ident(&format!("${}$x", "a".repeat(33))), "unknown");
assert_eq!(hash_ident("$argon2 id$x"), "unknown");
}
#[test]
fn oversized_passwords_are_refused_before_any_argon2_work() {
let lua = Lua::new();
let (hash_fn, verify, dummy) = password_fns(&lua);
let at_cap = "x".repeat(MAX_PASSWORD_BYTES);
let over_cap = "x".repeat(MAX_PASSWORD_BYTES + 1);
let hash: String = pw(&hash_fn, at_cap.clone()).expect("a 1 KiB password hashes");
assert!(pw::<bool>(&verify, (at_cap.clone(), hash)).expect("verify"));
assert!(!pw::<bool>(&dummy, at_cap).expect("dummy"));
let err = pw::<String>(&hash_fn, over_cap.clone()).expect_err("1 KiB + 1 byte must not hash");
assert!(
err.to_string().contains("at most 1024 bytes"),
"unhelpful error: {err}"
);
let (ok, why): (bool, Option<String>) = pw(&verify, (over_cap.clone(), "$argon2id$"))
.expect("an over-cap password answers, it does not raise");
assert!(!ok);
assert_eq!(why, None, "an over-cap password is an ordinary miss");
assert!(!pw::<bool>(&dummy, over_cap).expect("dummy answers false"));
let published: usize = create_crypto_table(&lua)
.expect("crypto table")
.get("max_password_bytes")
.expect("max_password_bytes");
assert_eq!(published, MAX_PASSWORD_BYTES);
}
#[test]
fn the_dummy_verify_is_always_false_and_costs_a_real_hash() {
let lua = Lua::new();
let (_, _, dummy) = password_fns(&lua);
for password in ["", "hunter2", "\0\u{feff}ñ", &"x".repeat(512)] {
assert!(!pw::<bool>(&dummy, password).expect("dummy"));
}
let decoy = DECOY_HASH.get().expect("built by the calls above");
assert!(
decoy.starts_with("$argon2id$v=19$m=19456,t=2,p=1$"),
"{decoy}"
);
assert!(parse_stored_hash(decoy).is_ok());
}
proptest::proptest! {
#![proptest_config(proptest::prelude::ProptestConfig::with_cases(8))]
#[test]
fn prop_password_round_trips_and_rejects_every_other_password(
password in proptest::collection::vec(proptest::prelude::any::<u8>(), 0..96),
other in proptest::collection::vec(proptest::prelude::any::<u8>(), 0..96),
) {
let lua = Lua::new();
let (hash_fn, verify, dummy) = password_fns(&lua);
let secret = lua.create_string(&password).expect("bytes");
let hash: String = pw(&hash_fn, &secret).expect("hash");
proptest::prop_assert!(hash.starts_with("$argon2id$"), "got: {}", hash);
let (ok, why): (bool, Option<String>) =
pw(&verify, (&secret, hash.clone())).expect("verify");
proptest::prop_assert!(ok, "a password did not verify against its own hash");
proptest::prop_assert_eq!(why, None);
if other != password {
let wrong = lua.create_string(&other).expect("bytes");
let (ok, why): (bool, Option<String>) =
pw(&verify, (&wrong, hash)).expect("verify");
proptest::prop_assert!(!ok, "a different password verified");
proptest::prop_assert_eq!(why, None);
}
proptest::prop_assert!(!pw::<bool>(&dummy, &secret).expect("dummy"));
}
}