use core::fmt;
#[cfg(feature = "alloc")]
use alloc::string::String;
use crate::base64;
use crate::error::BcryptError;
const HASH_STRING_LEN: usize = 60;
const SALT_START: usize = 7;
const HASH_START: usize = SALT_START + base64::SALT_B64_LEN;
const _: () = assert!(
HASH_START + base64::HASH_B64_LEN == HASH_STRING_LEN,
"field offsets must tile the 60-byte hash string exactly"
);
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Version {
TwoA,
TwoX,
TwoY,
TwoB,
}
impl Version {
pub(crate) const fn marker(self) -> u8 {
match self {
Version::TwoA => b'a',
Version::TwoX => b'x',
Version::TwoY => b'y',
Version::TwoB => b'b',
}
}
}
impl fmt::Display for Version {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(match self {
Version::TwoA => "2a",
Version::TwoX => "2x",
Version::TwoY => "2y",
Version::TwoB => "2b",
})
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct HashParts {
cost: u32,
salt: [u8; 16],
hash: [u8; 23],
}
impl HashParts {
pub(crate) fn new(cost: u32, salt: [u8; 16], hash: [u8; 23]) -> Self {
debug_assert!((crate::core::MIN_COST..=crate::core::MAX_COST).contains(&cost));
HashParts { cost, salt, hash }
}
#[must_use]
pub fn get_cost(&self) -> u32 {
self.cost
}
#[cfg(feature = "alloc")]
#[must_use]
pub fn get_salt(&self) -> String {
String::from_utf8_lossy(&base64::encode_16(&self.salt)).into_owned()
}
#[must_use]
pub fn get_salt_raw(&self) -> [u8; 16] {
self.salt
}
#[must_use]
pub fn get_hash(&self) -> [u8; 23] {
self.hash
}
#[cfg(feature = "alloc")]
#[must_use]
pub fn format_for_version(&self, version: Version) -> String {
String::from_utf8_lossy(&self.format_bytes(version)).into_owned()
}
pub fn write_for_version<W: fmt::Write>(
&self,
version: Version,
w: &mut W,
) -> fmt::Result {
let bytes = self.format_bytes(version);
match core::str::from_utf8(&bytes) {
Ok(s) => w.write_str(s),
Err(_) => Err(fmt::Error),
}
}
pub(crate) fn format_bytes(&self, version: Version) -> [u8; HASH_STRING_LEN] {
let mut out = [0u8; HASH_STRING_LEN];
out[0] = b'$';
out[1] = b'2';
out[2] = version.marker();
out[3] = b'$';
out[4] = b'0' + (self.cost / 10) as u8;
out[5] = b'0' + (self.cost % 10) as u8;
out[6] = b'$';
out[SALT_START..HASH_START].copy_from_slice(&base64::encode_16(&self.salt));
out[HASH_START..HASH_STRING_LEN].copy_from_slice(&base64::encode_23(&self.hash));
out
}
}
impl core::str::FromStr for HashParts {
type Err = BcryptError;
fn from_str(s: &str) -> Result<Self, BcryptError> {
let b = s.as_bytes();
if b.len() != HASH_STRING_LEN {
return Err(BcryptError::InvalidHash("length"));
}
if b[0] != b'$' || b[1] != b'2' || b[3] != b'$' {
return Err(BcryptError::InvalidHash("prefix"));
}
match b[2] {
b'a' | b'b' | b'x' | b'y' => {}
_ => return Err(BcryptError::InvalidHash("prefix")),
}
if !b[4].is_ascii_digit() || !b[5].is_ascii_digit() {
return Err(BcryptError::InvalidHash("cost"));
}
let cost = u32::from(b[4] - b'0') * 10 + u32::from(b[5] - b'0');
if !(crate::core::MIN_COST..=crate::core::MAX_COST).contains(&cost) {
return Err(BcryptError::InvalidHash("cost"));
}
if b[6] != b'$' {
return Err(BcryptError::InvalidHash("prefix"));
}
let salt = base64::decode_16(&b[SALT_START..HASH_START])
.map_err(|()| BcryptError::InvalidHash("salt"))?;
let hash = base64::decode_23(&b[HASH_START..HASH_STRING_LEN])
.map_err(|()| BcryptError::InvalidHash("hash"))?;
Ok(HashParts { cost, salt, hash })
}
}
impl fmt::Display for HashParts {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
self.write_for_version(Version::TwoB, f)
}
}
#[cfg(test)]
mod tests {
use super::*;
const GOOD: &str = "$2a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW";
struct StackWriter<'a> {
buf: &'a mut [u8],
len: usize,
}
impl fmt::Write for StackWriter<'_> {
fn write_str(&mut self, s: &str) -> fmt::Result {
let end = self.len + s.len();
if end > self.buf.len() {
return Err(fmt::Error);
}
self.buf[self.len..end].copy_from_slice(s.as_bytes());
self.len = end;
Ok(())
}
}
fn rejection_part(s: &str) -> &'static str {
match s.parse::<HashParts>() {
Err(BcryptError::InvalidHash(part)) => part,
other => panic!("expected InvalidHash, got {other:?}"),
}
}
#[test]
fn parses_all_four_prefixes_identically() {
let parts: HashParts = GOOD.parse().expect("the OpenBSD vector parses");
for marker in *b"abxy" {
let mut bytes = [0u8; HASH_STRING_LEN];
bytes.copy_from_slice(GOOD.as_bytes());
bytes[2] = marker;
let s = core::str::from_utf8(&bytes).expect("still ASCII");
assert_eq!(s.parse::<HashParts>(), Ok(parts.clone()));
}
}
#[test]
fn getters_return_the_vector_fields() {
let parts: HashParts = GOOD.parse().expect("the OpenBSD vector parses");
assert_eq!(parts.get_cost(), 5);
assert_eq!(
parts.get_salt_raw(),
base64::decode_16(b"CCCCCCCCCCCCCCCCCCCCC.").expect("salt decodes")
);
assert_eq!(
parts.get_hash(),
base64::decode_23(b"E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW").expect("hash decodes")
);
}
#[test]
fn format_bytes_round_trips_through_the_parser() {
let parts: HashParts = GOOD.parse().expect("the OpenBSD vector parses");
for (version, prefix) in [
(Version::TwoA, "$2a$"),
(Version::TwoB, "$2b$"),
(Version::TwoX, "$2x$"),
(Version::TwoY, "$2y$"),
] {
let bytes = parts.format_bytes(version);
let s = core::str::from_utf8(&bytes).expect("format_bytes emits ASCII");
assert_eq!(s.len(), HASH_STRING_LEN);
assert!(s.starts_with(prefix));
assert_eq!(s.parse::<HashParts>(), Ok(parts.clone()));
}
}
#[test]
fn display_defaults_to_2b() {
let parts: HashParts = GOOD.parse().expect("the OpenBSD vector parses");
let expected = parts.format_bytes(Version::TwoB);
let mut buf = [0u8; HASH_STRING_LEN];
let mut w = StackWriter {
buf: &mut buf,
len: 0,
};
fmt::write(&mut w, format_args!("{parts}")).expect("Display fits the buffer");
assert_eq!(w.len, HASH_STRING_LEN);
assert_eq!(w.buf, &expected);
assert!(expected.starts_with(b"$2b$"));
}
#[test]
fn write_for_version_matches_format_bytes() {
let parts: HashParts = GOOD.parse().expect("the OpenBSD vector parses");
for version in [Version::TwoA, Version::TwoB, Version::TwoX, Version::TwoY] {
let mut buf = [0u8; HASH_STRING_LEN];
let mut w = StackWriter {
buf: &mut buf,
len: 0,
};
parts
.write_for_version(version, &mut w)
.expect("writing to a stack buffer fits");
assert_eq!(w.len, HASH_STRING_LEN);
assert_eq!(w.buf, &parts.format_bytes(version));
}
}
#[test]
fn parser_rejection_matrix() {
assert_eq!(rejection_part(""), "length");
assert_eq!(rejection_part(&GOOD[..59]), "length");
let mut longer = [0u8; 61];
longer[..60].copy_from_slice(GOOD.as_bytes());
longer[60] = b'W';
let longer = core::str::from_utf8(&longer).expect("ASCII");
assert_eq!(rejection_part(longer), "length");
for bad in [
"$1a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW",
"$2z$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW",
"$2aX05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW",
"$2a$05XCCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW",
] {
assert_eq!(rejection_part(bad), "prefix", "{bad}");
}
for bad in [
"$2a$0x$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW",
"$2a$03$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW",
"$2a$32$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW",
] {
assert_eq!(rejection_part(bad), "cost", "{bad}");
}
assert_eq!(
rejection_part("$2a$05$CCC!CCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW"),
"salt"
);
assert_eq!(
rejection_part("$2a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOe*"),
"hash"
);
let non_ascii = "$2a$05$éCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW";
assert_eq!(non_ascii.len(), HASH_STRING_LEN);
assert_eq!(rejection_part(non_ascii), "salt");
}
#[cfg(feature = "alloc")]
#[test]
fn alloc_helpers_agree_with_the_stack_core() {
use alloc::string::{String, ToString};
let parts: HashParts = GOOD.parse().expect("the OpenBSD vector parses");
assert_eq!(parts.get_salt(), "CCCCCCCCCCCCCCCCCCCCC.");
assert_eq!(parts.format_for_version(Version::TwoA), GOOD);
assert_eq!(parts.to_string().len(), HASH_STRING_LEN);
assert!(parts.to_string().starts_with("$2b$"));
let mut s = String::new();
parts
.write_for_version(Version::TwoB, &mut s)
.expect("writing to a String is infallible");
assert_eq!(s, parts.format_for_version(Version::TwoB));
}
#[test]
fn version_display_and_marker_agree() {
for (version, text, marker) in [
(Version::TwoA, "2a", b'a'),
(Version::TwoX, "2x", b'x'),
(Version::TwoY, "2y", b'y'),
(Version::TwoB, "2b", b'b'),
] {
assert_eq!(version.marker(), marker);
let mut buf = [0u8; 2];
let mut w = StackWriter {
buf: &mut buf,
len: 0,
};
fmt::write(&mut w, format_args!("{version}")).expect("two bytes fit");
assert_eq!(w.len, 2);
assert_eq!(w.buf, text.as_bytes());
}
}
}