use crate::error::{CryptoError, CryptoResult};
use hkdf::Hkdf;
use sha2::Sha256;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyNamespace {
Profile,
Proxy,
Session,
Bookmark,
ProfileSharing,
}
impl KeyNamespace {
pub const fn as_str(&self) -> &'static str {
match self {
Self::Profile => "profile",
Self::Proxy => "proxy",
Self::Session => "session",
Self::Bookmark => "bookmark",
Self::ProfileSharing => "profile-sharing-v1",
}
}
pub fn derive_key(&self, master_key: &[u8; 32], id: i64) -> CryptoResult<[u8; 32]> {
let info = match self {
Self::ProfileSharing => format!("incokit-{}", self.as_str()),
_ => format!("incokit-{}:{}", self.as_str(), id),
};
let hk = Hkdf::<Sha256>::new(None, master_key);
let mut key = [0u8; 32];
hk.expand(info.as_bytes(), &mut key)
.map_err(|e| CryptoError::Hkdf(e.to_string()))?;
Ok(key)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn profile_namespace_matches_legacy_inline_format() {
let master = [42u8; 32];
let id = 123_i64;
let via_namespace = KeyNamespace::Profile.derive_key(&master, id).unwrap();
let legacy_info = format!("incokit-profile:{}", id);
let hk = Hkdf::<Sha256>::new(None, &master);
let mut legacy = [0u8; 32];
hk.expand(legacy_info.as_bytes(), &mut legacy).unwrap();
assert_eq!(via_namespace, legacy);
}
#[test]
fn sharing_namespace_matches_legacy_inline_format() {
let shared = [7u8; 32];
let via_namespace = KeyNamespace::ProfileSharing.derive_key(&shared, 0).unwrap();
let hk = Hkdf::<Sha256>::new(None, &shared);
let mut legacy = [0u8; 32];
hk.expand(b"incokit-profile-sharing-v1", &mut legacy)
.unwrap();
assert_eq!(via_namespace, legacy);
}
#[test]
fn different_namespaces_same_id_different_keys() {
let master = [1u8; 32];
let p = KeyNamespace::Profile.derive_key(&master, 1).unwrap();
let x = KeyNamespace::Proxy.derive_key(&master, 1).unwrap();
let s = KeyNamespace::Session.derive_key(&master, 1).unwrap();
let b = KeyNamespace::Bookmark.derive_key(&master, 1).unwrap();
assert_ne!(p, x);
assert_ne!(p, s);
assert_ne!(p, b);
assert_ne!(x, s);
assert_ne!(x, b);
assert_ne!(s, b);
}
#[test]
fn same_namespace_different_ids_different_keys() {
let master = [1u8; 32];
let a = KeyNamespace::Profile.derive_key(&master, 1).unwrap();
let b = KeyNamespace::Profile.derive_key(&master, 2).unwrap();
assert_ne!(a, b);
}
#[test]
fn derive_is_deterministic() {
let master = [9u8; 32];
let k1 = KeyNamespace::Proxy.derive_key(&master, 42).unwrap();
let k2 = KeyNamespace::Proxy.derive_key(&master, 42).unwrap();
assert_eq!(k1, k2);
}
}