use hmac::{Hmac, Mac, NewMac};
use sha1::Sha1;
use super::{Result, HashSetup, IntoHashSetup, consteq};
use crate::enc_dec::{sha1crypt_hash64_encode, bcrypt_hash64_decode};
use crate::error::Error;
use crate::random;
use crate::parse::{self, HashIterator};
const MIN_ROUNDS: u32 = 1;
pub const DEFAULT_ROUNDS: u32 = 24680;
const MAX_SALT_LEN: usize = 64;
pub const DEFAULT_SALT_LEN: usize = 8;
fn do_sha1_crypt(pass: &[u8], salt: &str, rounds: u32) -> Result<String> {
let mut dummy_buf = [0u8; 48];
bcrypt_hash64_decode(salt, &mut dummy_buf)?;
let mut hmac = Hmac::<Sha1>::new_varkey(pass).map_err(|_| Error::InsufficientLength)?;
hmac.update(format!("{}$sha1${}", salt, rounds).as_bytes());
let mut result = hmac.finalize();
for _ in 1..rounds {
let mut hmac = Hmac::<Sha1>::new_varkey(pass).map_err(|_| Error::InsufficientLength)?;
hmac.update(&result.into_bytes());
result = hmac.finalize();
}
Ok(format!("$sha1${}${}${}", rounds, salt, sha1crypt_hash64_encode(&result.into_bytes())))
}
pub fn hash<B: AsRef<[u8]>>(pass: B) -> Result<String> {
let saltstr = random::gen_salt_str(DEFAULT_SALT_LEN);
do_sha1_crypt(pass.as_ref(), &saltstr, random::vary_rounds(DEFAULT_ROUNDS))
}
const MAGIC_LEN: usize = 6;
fn parse_sha1_hash(hash: &str) -> Result<HashSetup> {
let mut hs = parse::HashSlice::new(hash);
if hs.take(MAGIC_LEN).unwrap_or("X") != "$sha1$" {
return Err(Error::InvalidHashString);
}
let rounds = if let Some(rounds_str) = hs.take_until(b'$') {
rounds_str.parse::<u32>().map_err(|_e| Error::InvalidRounds)?
} else {
return Err(Error::InvalidHashString);
};
let salt = if let Some(salt) = hs.take_until(b'$') {
salt
} else {
return Err(Error::InvalidHashString);
};
Ok(HashSetup { salt: Some(salt), rounds: Some(rounds) })
}
pub fn hash_with<'a, IHS, B>(param: IHS, pass: B) -> Result<String>
where IHS: IntoHashSetup<'a>, B: AsRef<[u8]>
{
let hs = IHS::into_hash_setup(param, parse_sha1_hash)?;
let rounds = if let Some(r) = hs.rounds {
if r < MIN_ROUNDS {
return Err(Error::InvalidRounds);
}
r
} else { random::vary_rounds(DEFAULT_ROUNDS) };
if let Some(salt) = hs.salt {
let salt = if salt.len() <= MAX_SALT_LEN {
salt
} else if let Some(truncated_salt) = parse::HashSlice::new(salt).take(MAX_SALT_LEN) {
truncated_salt
} else {
return Err(Error::InvalidHashString);
};
do_sha1_crypt(pass.as_ref(), salt, rounds)
} else {
let salt = random::gen_salt_str(DEFAULT_SALT_LEN);
do_sha1_crypt(pass.as_ref(), &salt, rounds)
}
}
pub fn verify<B: AsRef<[u8]>>(pass: B, hash: &str) -> bool {
consteq(hash, hash_with(hash, pass))
}
#[cfg(test)]
mod tests {
use super::HashSetup;
#[test]
fn custom() {
assert_eq!(super::hash_with("$sha1$19703$iVdJqfSE$v4qYKl1zqYThwpjJAoKX6UvlHq/a", "password").unwrap(),
"$sha1$19703$iVdJqfSE$v4qYKl1zqYThwpjJAoKX6UvlHq/a");
assert_eq!(super::hash_with(HashSetup { salt: Some("iVdJqfSE"), rounds: Some(19703) }, "password").unwrap(),
"$sha1$19703$iVdJqfSE$v4qYKl1zqYThwpjJAoKX6UvlHq/a");
}
#[test]
#[should_panic(expected="value: InvalidRounds")]
fn bad_rounds() {
let _ = super::hash_with(HashSetup { salt: Some("K0Ay"), rounds: Some(0) }, "password").unwrap();
}
}