use tink_core::TinkError;
use tink_proto::HashType;
const MIN_HKDF_KEY_SIZE_IN_BYTES: usize = 32;
#[derive(Clone)]
pub struct HkdfPrf {
prk: HkdfPrfVariant,
}
#[allow(clippy::large_enum_variant)]
#[derive(Clone)]
enum HkdfPrfVariant {
Sha1(hkdf::Hkdf<sha1::Sha1>),
Sha256(hkdf::Hkdf<sha2::Sha256>),
Sha512(hkdf::Hkdf<sha2::Sha512>),
}
impl HkdfPrf {
pub fn new(hash_alg: HashType, key: &[u8], salt: &[u8]) -> Result<HkdfPrf, TinkError> {
let prk = match hash_alg {
HashType::Sha1 => HkdfPrfVariant::Sha1(hkdf::Hkdf::<sha1::Sha1>::new(Some(salt), key)),
HashType::Sha256 => {
HkdfPrfVariant::Sha256(hkdf::Hkdf::<sha2::Sha256>::new(Some(salt), key))
}
HashType::Sha512 => {
HkdfPrfVariant::Sha512(hkdf::Hkdf::<sha2::Sha512>::new(Some(salt), key))
}
h => return Err(format!("HkdfPrf: unsupported hash {:?}", h).into()),
};
Ok(HkdfPrf { prk })
}
}
pub fn validate_hkdf_prf_params(
hash: HashType,
key_size: usize,
_salt: &[u8],
) -> Result<(), TinkError> {
if key_size < MIN_HKDF_KEY_SIZE_IN_BYTES {
Err("key too short".into())
} else if tink_core::subtle::get_hash_func(hash).is_none() {
Err("invalid hash function".into())
} else if hash != HashType::Sha256 && hash != HashType::Sha512 {
Err("Only SHA-256 and SHA-512 currently allowed for HKDF".into())
} else {
Ok(())
}
}
impl tink_core::Prf for HkdfPrf {
fn compute_prf(&self, data: &[u8], out_len: usize) -> Result<Vec<u8>, TinkError> {
match &self.prk {
HkdfPrfVariant::Sha1(prk) => compute_hkdf_with::<sha1::Sha1>(prk, data, out_len),
HkdfPrfVariant::Sha256(prk) => compute_hkdf_with::<sha2::Sha256>(prk, data, out_len),
HkdfPrfVariant::Sha512(prk) => compute_hkdf_with::<sha2::Sha512>(prk, data, out_len),
}
}
}
fn compute_hkdf_with<D>(
prk: &hkdf::Hkdf<D>,
data: &[u8],
out_len: usize,
) -> Result<Vec<u8>, TinkError>
where
D: digest::Update + digest::BlockInput + digest::FixedOutput + digest::Reset + Default + Clone,
{
let mut okm = vec![0; out_len];
prk.expand(data, &mut okm)
.map_err(|_| "HkdfPrf: compute of hkdf failed")?;
Ok(okm)
}