use std::collections::BTreeMap;
use crate::container::{Container, GenericRecord};
use crate::crypto::{derive_master_key, kcdecrypt, unwrap_key_blob, MASTER_KEY_LEN};
use crate::error::KeychainError;
#[derive(Debug)]
pub struct Keychain<'a> {
container: Container<'a>,
}
#[derive(Debug)]
pub struct UnlockedKeychain<'a> {
container: &'a Container<'a>,
key_list: BTreeMap<[u8; 20], [u8; MASTER_KEY_LEN]>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GenericSecret {
pub account: String,
pub service: String,
pub label: String,
pub secret: Vec<u8>,
}
impl GenericSecret {
#[must_use]
pub fn as_text(&self) -> Option<&str> {
std::str::from_utf8(&self.secret).ok()
}
#[must_use]
pub fn display(&self) -> String {
self.as_text().map_or_else(
|| {
let mut s = String::with_capacity(self.secret.len() * 2);
use std::fmt::Write as _;
for b in &self.secret {
let _ = write!(s, "{b:02x}");
}
format!("hex:{s}")
},
ToString::to_string,
)
}
}
impl<'a> Keychain<'a> {
pub fn open(data: &'a [u8]) -> Result<Self, KeychainError> {
Ok(Self {
container: Container::parse(data)?,
})
}
pub fn unlock(&'a self, password: &[u8]) -> Result<UnlockedKeychain<'a>, KeychainError> {
let db = self.container.db_blob()?;
let master = derive_master_key(password, &db.salt);
let plain = kcdecrypt(&master, &db.iv, &db.cipher).map_err(|_| KeychainError::Locked)?;
let dbkey_slice = plain.get(..MASTER_KEY_LEN).ok_or(KeychainError::Locked)?;
let mut dbkey = [0u8; MASTER_KEY_LEN];
dbkey.copy_from_slice(dbkey_slice);
let mut key_list = BTreeMap::new();
for rec in self.container.symmetric_key_records() {
if let Ok(key) = unwrap_key_blob(&dbkey, &rec.iv, &rec.cipher) {
key_list.insert(rec.label, key);
}
}
Ok(UnlockedKeychain {
container: &self.container,
key_list,
})
}
}
impl UnlockedKeychain<'_> {
#[must_use]
pub fn generic_secrets(&self) -> Vec<GenericSecret> {
self.container
.generic_password_records()
.into_iter()
.filter_map(|rec| self.decrypt_generic(rec))
.collect()
}
#[must_use]
pub fn key_count(&self) -> usize {
self.key_list.len()
}
fn decrypt_generic(&self, rec: GenericRecord) -> Option<GenericSecret> {
let ssgp = rec.ssgp?;
let key = self.key_list.get(&ssgp.key_index)?;
let secret = kcdecrypt(key, &ssgp.iv, &ssgp.payload).ok()?;
Some(GenericSecret {
account: rec.account,
service: rec.service,
label: rec.label,
secret,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn open_rejects_garbage() {
assert!(Keychain::open(b"not a keychain at all!!").is_err());
}
#[test]
fn display_renders_binary_as_hex() {
let s = GenericSecret {
account: "Chrome".into(),
service: "Chrome Safe Storage".into(),
label: "Chrome".into(),
secret: vec![0x00, 0xff, 0x10],
};
assert_eq!(s.as_text(), None);
assert_eq!(s.display(), "hex:00ff10");
}
#[test]
fn display_renders_text() {
let s = GenericSecret {
account: "alice".into(),
service: "svc".into(),
label: "l".into(),
secret: b"hunter2".to_vec(),
};
assert_eq!(s.as_text(), Some("hunter2"));
assert_eq!(s.display(), "hunter2");
}
}