#![cfg(feature = "alloc")]
use std::collections::BTreeMap;
use bcrypt_rust::{
BcryptError, HashParts, Version, bcrypt, bcrypt_many, hash, hash_with_salt, verify, verify_many,
};
struct Vector {
password: &'static [u8],
hash: &'static str,
}
const fn build<const N: usize>(block: &[u8], reps: usize, tail: &[u8]) -> [u8; N] {
assert!(block.len() * reps + tail.len() == N);
let mut out = [0u8; N];
let mut i = 0;
while i < reps {
let mut j = 0;
while j < block.len() {
out[i * block.len() + j] = block[j];
j += 1;
}
i += 1;
}
let mut k = 0;
while k < tail.len() {
out[block.len() * reps + k] = tail[k];
k += 1;
}
out
}
static PW26: [u8; 107] = build(b"\xaa", 72, b"chars after 72 are ignored as usual");
static PW27: [u8; 72] = build(b"\xaa\x55", 36, b"");
static PW28: [u8; 72] = build(b"\x55\xaa\xff", 24, b"");
static X100: [u8; 100] = build(b"x", 100, b"");
static PW42: [u8; 72] = build(b"hunter2", 10, b"ab");
static VECTORS: &[Vector] = &[
Vector { password: b"", hash: "$2a$06$DCq7YPn5Rq63x1Lad4cll.TV4S6ytwfsfvkgY8jIucDrjc8deX1s." }, Vector { password: b"", hash: "$2a$08$HqWuK6/Ng6sg9gQzbLrgb.Tl.ZHfXLhvt/SgVyWhQqgqcZ7ZuUtye" }, Vector { password: b"", hash: "$2a$10$k1wbIrmNyFAPwPVPSVa/zecw2BCEnBwVS2GbrmgzxFUOqW9dk4TCW" }, Vector { password: b"", hash: "$2a$12$k42ZFHFWqBp3vWli.nIn8uYyIkbvYRvodzbfbK18SSsY.CsIQPlxO" }, Vector { password: b"a", hash: "$2a$06$m0CrhHm10qJ3lXRY.5zDGO3rS2KdeeWLuGmsfGlMfOxih58VYVfxe" }, Vector { password: b"a", hash: "$2a$08$cfcvVd2aQ8CMvoMpP2EBfeodLEkkFJ9umNEfPD18.hUF62qqlC/V." }, Vector { password: b"a", hash: "$2a$10$k87L/MF28Q673VKh8/cPi.SUl7MU/rWuSiIDDFayrKk/1tBsSQu4u" }, Vector { password: b"a", hash: "$2a$12$8NJH3LsPrANStV6XtBakCez0cKHXVxmvxIlcz785vxAIZrihHZpeS" }, Vector { password: b"abc", hash: "$2a$06$If6bvum7DFjUnE9p2uDeDu0YHzrHM6tf.iqN8.yx.jNN1ILEf7h0i" }, Vector { password: b"abc", hash: "$2a$08$Ro0CUfOqk6cXEKf3dyaM7OhSCvnwM9s4wIX9JeLapehKK5YdLxKcm" }, Vector { password: b"abc", hash: "$2a$10$WvvTPHKwdBJ3uk0Z37EMR.hLA2W6N9AEBhEgrAOljy2Ae5MtaSIUi" }, Vector { password: b"abc", hash: "$2a$12$EXRkfkdmXn2gzds2SSitu.MW9.gAVqa9eLS1//RYtYCmB1eLHg.9q" }, Vector { password: b"abcdefghijklmnopqrstuvwxyz", hash: "$2a$06$.rCVZVOThsIa97pEDOxvGuRRgzG64bvtJ0938xuqzv18d3ZpQhstC" }, Vector { password: b"abcdefghijklmnopqrstuvwxyz", hash: "$2a$08$aTsUwsyowQuzRrDqFflhgekJ8d9/7Z3GV3UcgvzQW3J5zMyrTvlz." }, Vector { password: b"abcdefghijklmnopqrstuvwxyz", hash: "$2a$10$fVH8e28OQRj9tqiDXs1e1uxpsjN0c7II7YPKXua2NAKYvM6iQk7dq" }, Vector { password: b"abcdefghijklmnopqrstuvwxyz", hash: "$2a$12$D4G5f18o7aMMfwasBL7GpuQWuP3pkrZrOAnqP.bmezbMng.QwJ/pG" }, Vector { password: b"~!@#$%^&*() ~!@#$%^&*()PNBFRD", hash: "$2a$06$fPIsBO8qRqkjj273rfaOI.HtSV9jLDpTbZn782DC6/t7qT67P6FfO" }, Vector { password: b"~!@#$%^&*() ~!@#$%^&*()PNBFRD", hash: "$2a$08$Eq2r4G/76Wv39MzSX262huzPz612MZiYHVUJe/OcOql2jo4.9UxTW" }, Vector { password: b"~!@#$%^&*() ~!@#$%^&*()PNBFRD", hash: "$2a$10$LgfYWkbzEvQ4JakH7rOvHe0y8pHKF9OaFgwUZ2q7W2FFZmZzJYlfS" }, Vector { password: b"~!@#$%^&*() ~!@#$%^&*()PNBFRD", hash: "$2a$12$WApznUOJfkEGSmYRfnkrPOr466oFDCaj4b6HY3EXGvfxm43seyhgC" }, Vector { password: b"U*U", hash: "$2a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW" }, Vector { password: b"U*U*", hash: "$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK" }, Vector { password: b"U*U*U", hash: "$2a$05$XXXXXXXXXXXXXXXXXXXXXOAcXxm9kjPGEMsLznoKqmqw7tc8WCx4a" }, Vector { password: b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789chars after 72 are ignored", hash: "$2a$05$abcdefghijklmnopqrstuu5s2v8.iXieOjg/.AySBTTZIIVFJeBui" }, Vector { password: b"", hash: "$2a$05$CCCCCCCCCCCCCCCCCCCCC.7uG0VCzI2bS7j6ymqJi9CdcdxiRTWNy" }, Vector { password: &PW26, hash: "$2a$05$/OK.fbVrR/bpIqNJ5ianF.swQOIzjOiJ9GHEPuhEkvqrUyvWhEMx6" }, Vector { password: &PW27, hash: "$2a$05$/OK.fbVrR/bpIqNJ5ianF.R9xrDjiycxMbQE2bp.vgqlYpW5wx2yy" }, Vector { password: &PW28, hash: "$2a$05$/OK.fbVrR/bpIqNJ5ianF.9tQZzcJfm3uj2NvJ/n5xkhpqLrMpWCe" }, Vector { password: b"\xff\xff\xa3", hash: "$2b$05$/OK.fbVrR/bpIqNJ5ianF.CE5elHaaO4EbggVDjb8P19RukzXSM3e" }, Vector { password: b"\xff\xff\xa3", hash: "$2y$05$/OK.fbVrR/bpIqNJ5ianF.CE5elHaaO4EbggVDjb8P19RukzXSM3e" }, Vector { password: b"\xa3", hash: "$2a$05$/OK.fbVrR/bpIqNJ5ianF.Sa7shbm4.OzKpvFnX1pQLmQW96oUlCq" }, Vector { password: b"\xa3", hash: "$2y$05$/OK.fbVrR/bpIqNJ5ianF.Sa7shbm4.OzKpvFnX1pQLmQW96oUlCq" }, Vector { password: b"\xff\xa334\xff\xff\xff\xa3345", hash: "$2y$05$/OK.fbVrR/bpIqNJ5ianF.o./n25XVfn6oAPaUvHe.Csk4zRfsYPi" }, Vector { password: b"hunter2", hash: "$2b$12$......................21jzCB1r6pN6rp5O2Ev0ejjTAboskKm" }, Vector { password: b"My S3cre7 P@55w0rd!", hash: "$2b$05$HlFShUxTu4ZHHfOLJwfmCeDj/kuKFKboanXtDJXxCC7aIPTUgxNDe" }, Vector { password: &X100, hash: "$2a$05$......................YgIDy4hFBdVlc/6LHnD9mX488r9cLd2" }, Vector { password: b"correctbatteryhorsestapler", hash: "$2b$04$EGdrhbKUv8Oc9vGiXX0HQOxSg445d458Muh7DAHskb6QbtCvdxcie" }, Vector { password: b"correctbatteryhorsestapler", hash: "$2a$04$n4Uy0eSnMfvnESYL.bLwuuj0U/ETSsoTpRT9GVk5bektyVVa5xnIi" }, Vector { password: b"\x1d\xe1\xc3\xa7\xdf\xec\x55\xc3\x72\xe3\x07\x00\xd1\xef\xbd\x18\x33\x69\x7c\xa8\x97\x4b\x90\x40\xc6\xc5\xc4\x04\xf1\x61\x6e\x87", hash: "$2a$04$tjARW6ZON3PhrAIRW2LG/u9aDw5eFdstYLR8nFCNaOQmsH9XD23w." }, Vector { password: "★★★★★★★★".as_bytes(), hash: "$2a$05$......................CVh3qAKQwo3AyWm2sH24x.4W0jOiobK" }, Vector { password: "★★★★★★★★".as_bytes(), hash: "$2b$05$CCCCCCCCCCCCCCCCCCCCC.GKRlRE2yXEq.CPNmj6AdW2OEOSzU/GW" }, Vector { password: &PW42, hash: "$2a$05$......................VbcD.3tcy/UErGUKxMqc6T88xuK4rWq" }, ];
struct Divergent {
password: &'static [u8],
hash: &'static str,
must_verify: bool,
}
static DIVERGENT: &[Divergent] = &[
Divergent {
password: b"\xa3",
hash: "$2x$05$/OK.fbVrR/bpIqNJ5ianF.CE5elHaaO4EbggVDjb8P19RukzXSM3e",
must_verify: false,
},
Divergent {
password: b"\xff\xff\xa3",
hash: "$2x$05$/OK.fbVrR/bpIqNJ5ianF.CE5elHaaO4EbggVDjb8P19RukzXSM3e",
must_verify: true,
},
Divergent {
password: b"\xff\xff\xa3",
hash: "$2a$05$/OK.fbVrR/bpIqNJ5ianF.nqd1wy.pTMdcvrRWxyiGL2eMz.2a85.",
must_verify: false,
},
Divergent {
password: b"1\xa3345",
hash: "$2x$05$/OK.fbVrR/bpIqNJ5ianF.o./n25XVfn6oAPaUvHe.Csk4zRfsYPi",
must_verify: false,
},
Divergent {
password: b"\xff\xa3345",
hash: "$2y$05$/OK.fbVrR/bpIqNJ5ianF.nRht2l/HRhr6zmCp9vYUvvsqynflf9e",
must_verify: true,
},
Divergent {
password: b"\xd1\x91",
hash: "$2x$05$6bNw2HLQYeqHYyBfLMsv/OiwqTymGIGzFsA4hOTWebfehXHNprcAS",
must_verify: false,
},
Divergent {
password: b"\xff\xa334\xff\xff\xff\xa3345",
hash: "$2a$05$/OK.fbVrR/bpIqNJ5ianF.ZC1JEJ8Z4gPfpe1JOr/oyPXTWl9EFd.",
must_verify: false,
},
];
static SIBLINGS: &[(&[u8], &str, &str)] = &[
(
b"\xa3",
"$2x$05$/OK.fbVrR/bpIqNJ5ianF.CE5elHaaO4EbggVDjb8P19RukzXSM3e",
"$2a$05$/OK.fbVrR/bpIqNJ5ianF.Sa7shbm4.OzKpvFnX1pQLmQW96oUlCq",
),
(
b"\xff\xff\xa3",
"$2a$05$/OK.fbVrR/bpIqNJ5ianF.nqd1wy.pTMdcvrRWxyiGL2eMz.2a85.",
"$2b$05$/OK.fbVrR/bpIqNJ5ianF.CE5elHaaO4EbggVDjb8P19RukzXSM3e",
),
(
b"\xff\xa334\xff\xff\xff\xa3345",
"$2a$05$/OK.fbVrR/bpIqNJ5ianF.ZC1JEJ8Z4gPfpe1JOr/oyPXTWl9EFd.",
"$2y$05$/OK.fbVrR/bpIqNJ5ianF.o./n25XVfn6oAPaUvHe.Csk4zRfsYPi",
),
];
fn version_of(hash: &str) -> Version {
match hash.as_bytes()[2] {
b'a' => Version::TwoA,
b'x' => Version::TwoX,
b'y' => Version::TwoY,
_ => Version::TwoB,
}
}
fn wrong_password(pw: &[u8]) -> Vec<u8> {
let mut wrong = pw.to_vec();
if wrong.len() < 72 {
wrong.push(0x21);
} else {
wrong[0] ^= 0x01;
}
wrong
}
#[cfg(feature = "internal-api")]
fn reencode(version: Version, cost: u32, salt: &[u8; 16], out: &[u8; 24]) -> String {
let mut payload = [0u8; 23];
payload.copy_from_slice(&out[..23]);
let salt_b64 = bcrypt_rust::__internal::encode_16(salt);
let hash_b64 = bcrypt_rust::__internal::encode_23(&payload);
format!(
"${}${cost:02}${}{}",
version,
std::str::from_utf8(&salt_b64).expect("bcrypt base64 is ASCII"),
std::str::from_utf8(&hash_b64).expect("bcrypt base64 is ASCII"),
)
}
#[test]
fn positive_vectors_verify() {
assert_eq!(VECTORS.len(), 42);
for (i, v) in VECTORS.iter().enumerate() {
assert_eq!(
verify(v.password, v.hash),
Ok(true),
"vector #{} must verify",
i + 1
);
assert_eq!(
verify(wrong_password(v.password), v.hash),
Ok(false),
"vector #{}: a wrong password must not verify",
i + 1
);
}
}
#[test]
fn positive_vectors_recompute() {
for (i, v) in VECTORS.iter().enumerate() {
let parts: HashParts = v.hash.parse().expect("vector hash parses");
let recomputed = hash_with_salt(v.password, parts.get_cost(), parts.get_salt_raw())
.expect("cost from a valid hash");
assert_eq!(recomputed, parts, "vector #{}", i + 1);
assert_eq!(
recomputed.format_for_version(version_of(v.hash)),
v.hash,
"vector #{} must reproduce its exact string, prefix included",
i + 1
);
}
}
#[test]
fn batch_matches_single() {
let parsed: Vec<HashParts> = VECTORS
.iter()
.map(|v| v.hash.parse().expect("vector hash parses"))
.collect();
let mut by_cost: BTreeMap<u32, Vec<usize>> = BTreeMap::new();
for (i, parts) in parsed.iter().enumerate() {
by_cost.entry(parts.get_cost()).or_default().push(i);
}
for (cost, idxs) in &by_cost {
let passwords: Vec<&[u8]> = idxs.iter().map(|&i| VECTORS[i].password).collect();
let salts: Vec<[u8; 16]> = idxs.iter().map(|&i| parsed[i].get_salt_raw()).collect();
let outs = bcrypt_many(*cost, &passwords, &salts).expect("cost came from a valid hash");
assert_eq!(outs.len(), idxs.len());
for (j, &i) in idxs.iter().enumerate() {
assert_eq!(
outs[j],
bcrypt(*cost, salts[j], VECTORS[i].password),
"vector #{} (cost {cost})",
i + 1
);
#[cfg(feature = "internal-api")]
assert_eq!(
reencode(version_of(VECTORS[i].hash), *cost, &salts[j], &outs[j]),
VECTORS[i].hash,
"vector #{} (cost {cost})",
i + 1
);
}
}
let passwords: Vec<&[u8]> = VECTORS.iter().map(|v| v.password).collect();
let hashes: Vec<&str> = VECTORS.iter().map(|v| v.hash).collect();
let results = verify_many(&passwords, &hashes);
assert_eq!(results.len(), VECTORS.len());
for (i, result) in results.iter().enumerate() {
assert_eq!(*result, Ok(true), "vector #{}", i + 1);
}
}
#[test]
fn divergent_vectors_do_not_match() {
for (i, d) in DIVERGENT.iter().enumerate() {
assert_eq!(
verify(d.password, d.hash),
Ok(d.must_verify),
"divergent row #{} ({})",
i + 1,
d.hash
);
}
for &(password, buggy_hash, correct_hash) in SIBLINGS {
let parts: HashParts = buggy_hash.parse().expect("divergent hash parses");
let computed = hash_with_salt(password, parts.get_cost(), parts.get_salt_raw())
.expect("cost from a valid hash");
assert_eq!(
computed.format_for_version(version_of(correct_hash)),
correct_hash
);
}
}
#[test]
fn invalid_settings_are_rejected() {
const INVALID: [&str; 7] = [
"$2a$03$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW", "$2a$32$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW", "$2c$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW", "$2z$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW", "$2`$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW", "$2{$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW", "*0",
];
for s in INVALID {
assert!(
s.parse::<HashParts>().is_err(),
"{s} must be rejected by HashParts::from_str"
);
assert!(verify(b"pw", s).is_err(), "{s} must be rejected by verify");
}
assert_eq!(hash("pw", 3), Err(BcryptError::CostNotAllowed(3)));
assert_eq!(hash("pw", 32), Err(BcryptError::CostNotAllowed(32)));
}
#[test]
fn edge_case_passwords() {
let salt = VECTORS[20]
.hash
.parse::<HashParts>()
.expect("vector #21 parses")
.get_salt_raw();
let zero_salt = VECTORS[35]
.hash
.parse::<HashParts>()
.expect("vector #36 parses")
.get_salt_raw();
assert_eq!(zero_salt, [0u8; 16]);
let empty = hash_with_salt(b"", 5, salt).expect("cost 5 is valid");
assert_eq!(
empty.format_for_version(Version::TwoA),
"$2a$05$CCCCCCCCCCCCCCCCCCCCC.7uG0VCzI2bS7j6ymqJi9CdcdxiRTWNy"
);
let h71 = hash_with_salt([b'a'; 71], 5, salt).expect("cost 5 is valid");
let h72 = hash_with_salt([b'a'; 72], 5, salt).expect("cost 5 is valid");
let h73 = hash_with_salt([b'a'; 73], 5, salt).expect("cost 5 is valid");
assert_ne!(h71, h72);
assert_eq!(h72, h73);
let high = b"ab\xffcd";
let h_high = hash_with_salt(high, 5, salt).expect("cost 5 is valid");
assert!(verify(high, &h_high.format_for_version(Version::TwoB)).expect("hash parses"));
assert_ne!(
h_high,
hash_with_salt(b"ab\x00cd", 5, salt).expect("cost 5 is valid")
);
assert_ne!(
h_high,
hash_with_salt(b"abcd", 5, salt).expect("cost 5 is valid")
);
let hx100 = hash_with_salt(X100, 5, zero_salt).expect("cost 5 is valid");
assert_eq!(
hx100.format_for_version(Version::TwoA),
"$2a$05$......................YgIDy4hFBdVlc/6LHnD9mX488r9cLd2"
);
assert_eq!(
hx100,
hash_with_salt([b'x'; 72], 5, zero_salt).expect("cost 5 is valid")
);
assert_ne!(
hx100,
hash_with_salt([b'x'; 71], 5, zero_salt).expect("cost 5 is valid")
);
}