use keyring::Entry;
pub const DEFAULT_SERVICE: &str = "com.incokit.encryption";
fn entry(service: &str, account: &str) -> Result<Entry, String> {
Entry::new(service, account).map_err(|e| format!("Keychain entry error: {}", e))
}
pub fn save_master_key_in_service(
service: &str,
account: &str,
master_key: &[u8; 32],
) -> Result<(), String> {
use base64::Engine;
let encoded = base64::engine::general_purpose::STANDARD.encode(master_key);
entry(service, account)?
.set_password(&encoded)
.map_err(|e| format!("Keychain save error: {}", e))
}
pub fn load_master_key_in_service(
service: &str,
account: &str,
) -> Result<Option<[u8; 32]>, String> {
match entry(service, account)?.get_password() {
Ok(encoded) => Ok(Some(decode_key(&encoded)?)),
Err(keyring::Error::NoEntry) => Ok(None),
Err(e) => Err(format!("Keychain load error: {}", e)),
}
}
pub fn delete_master_key_in_service(service: &str, account: &str) -> Result<(), String> {
match entry(service, account)?.delete_credential() {
Ok(()) => Ok(()),
Err(keyring::Error::NoEntry) => Ok(()),
Err(e) => Err(format!("Keychain delete error: {}", e)),
}
}
pub fn has_master_key_in_service(service: &str, account: &str) -> bool {
matches!(load_master_key_in_service(service, account), Ok(Some(_)))
}
pub fn save_master_key(account: &str, master_key: &[u8; 32]) -> Result<(), String> {
save_master_key_in_service(DEFAULT_SERVICE, account, master_key)
}
pub fn load_master_key(account: &str) -> Result<Option<[u8; 32]>, String> {
load_master_key_in_service(DEFAULT_SERVICE, account)
}
pub fn delete_master_key(account: &str) -> Result<(), String> {
delete_master_key_in_service(DEFAULT_SERVICE, account)
}
pub fn has_master_key(account: &str) -> bool {
has_master_key_in_service(DEFAULT_SERVICE, account)
}
fn decode_key(encoded: &str) -> Result<[u8; 32], String> {
use base64::Engine;
let bytes = base64::engine::general_purpose::STANDARD
.decode(encoded)
.map_err(|e| format!("Keychain decode error: {}", e))?;
if bytes.len() != 32 {
return Err(format!(
"Invalid key length in keychain: expected 32, got {}",
bytes.len()
));
}
let mut key = [0u8; 32];
key.copy_from_slice(&bytes);
Ok(key)
}
#[cfg(test)]
mod tests {
use super::*;
use base64::Engine;
#[test]
fn key_encoding_roundtrips() {
let key = [9u8; 32];
let encoded = base64::engine::general_purpose::STANDARD.encode(key);
assert_eq!(decode_key(&encoded).unwrap(), key);
}
#[test]
fn decode_rejects_wrong_length() {
let short = base64::engine::general_purpose::STANDARD.encode([1u8; 16]);
let err = decode_key(&short).unwrap_err();
assert!(err.contains("expected 32"), "got: {err}");
}
#[test]
fn decode_rejects_garbage_base64() {
assert!(decode_key("!!!not base64!!!").is_err());
}
#[test]
fn default_service_name_is_stable() {
assert_eq!(DEFAULT_SERVICE, "com.incokit.encryption");
}
}