use cbc::Decryptor;
use cipher::{block_padding::NoPadding, BlockDecryptMut, KeyIvInit};
use des::TdesEde3;
use sha1::Sha1;
use crate::error::KeychainError;
pub const MASTER_KEY_LEN: usize = 24;
pub const BLOCK_SIZE: usize = 8;
pub const PBKDF2_ROUNDS: u32 = 1000;
pub const MAGIC_CMS_IV: [u8; 8] = [0x4a, 0xdd, 0xa2, 0x2c, 0x79, 0xe8, 0x21, 0x05];
#[must_use]
pub fn derive_master_key(password: &[u8], salt: &[u8]) -> [u8; MASTER_KEY_LEN] {
let mut out = [0u8; MASTER_KEY_LEN];
pbkdf2::pbkdf2_hmac::<Sha1>(password, salt, PBKDF2_ROUNDS, &mut out);
out
}
pub fn kcdecrypt(key: &[u8], iv: &[u8], data: &[u8]) -> Result<Vec<u8>, KeychainError> {
if key.len() != MASTER_KEY_LEN || iv.len() != BLOCK_SIZE {
return Err(KeychainError::InvalidKeyLength);
}
if data.is_empty() || data.len() % BLOCK_SIZE != 0 {
return Err(KeychainError::DecryptionFailed);
}
let mut buf = data.to_vec();
let dec = Decryptor::<TdesEde3>::new_from_slices(key, iv)
.map_err(|_| KeychainError::InvalidKeyLength)?;
let plain = dec
.decrypt_padded_mut::<NoPadding>(&mut buf)
.map_err(|_| KeychainError::DecryptionFailed)?;
unpad(plain)
}
fn unpad(plain: &[u8]) -> Result<Vec<u8>, KeychainError> {
let &pad = plain.last().ok_or(KeychainError::DecryptionFailed)?;
let pad = pad as usize;
if pad == 0 || pad > BLOCK_SIZE || pad > plain.len() {
return Err(KeychainError::DecryptionFailed);
}
if plain[plain.len() - pad..]
.iter()
.any(|&b| b as usize != pad)
{
return Err(KeychainError::DecryptionFailed);
}
Ok(plain[..plain.len() - pad].to_vec())
}
pub fn unwrap_key_blob(
dbkey: &[u8],
iv: &[u8],
wrapped: &[u8],
) -> Result<[u8; MASTER_KEY_LEN], KeychainError> {
let first = kcdecrypt(dbkey, &MAGIC_CMS_IV, wrapped)?;
if first.len() < 32 {
return Err(KeychainError::DecryptionFailed);
}
let mut rev = first[..32].to_vec();
rev.reverse();
let second = kcdecrypt(dbkey, iv, &rev)?;
let key = second.get(4..).ok_or(KeychainError::DecryptionFailed)?;
if key.len() != MASTER_KEY_LEN {
return Err(KeychainError::DecryptionFailed);
}
let mut out = [0u8; MASTER_KEY_LEN];
out.copy_from_slice(key);
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pbkdf2_hmac_sha1_matches_rfc6070() {
let mut out = [0u8; 20];
pbkdf2::pbkdf2_hmac::<Sha1>(b"password", b"salt", 1, &mut out);
assert_eq!(
&out[..],
&hex("0c60c80f961f0e71f3a9b524af6012062fe037a6")[..]
);
let mut out = [0u8; 20];
pbkdf2::pbkdf2_hmac::<Sha1>(b"password", b"salt", 4096, &mut out);
assert_eq!(
&out[..],
&hex("4b007901b765489abead49d926f721d065a429c1")[..]
);
}
#[test]
fn derive_master_key_is_1000_round_pbkdf2() {
assert_eq!(PBKDF2_ROUNDS, 1000);
let mut expect = [0u8; MASTER_KEY_LEN];
pbkdf2::pbkdf2_hmac::<Sha1>(b"login-pass", b"0123456789abcdefghij", 1000, &mut expect);
assert_eq!(
derive_master_key(b"login-pass", b"0123456789abcdefghij"),
expect
);
}
#[test]
fn kcdecrypt_roundtrips_3des_cbc() {
use cbc::Encryptor;
use cipher::{block_padding::Pkcs7, BlockEncryptMut};
let key = [0x11u8; 24];
let iv = [0x22u8; 8];
let msg = b"keychain secret payload";
let mut buf = vec![0u8; msg.len() + 8];
buf[..msg.len()].copy_from_slice(msg);
let ct = Encryptor::<TdesEde3>::new_from_slices(&key, &iv)
.unwrap()
.encrypt_padded_mut::<Pkcs7>(&mut buf, msg.len())
.unwrap()
.to_vec();
let pt = kcdecrypt(&key, &iv, &ct).expect("decrypt");
assert_eq!(pt, msg);
}
#[test]
fn kcdecrypt_wrong_key_fails_on_padding() {
use cbc::Encryptor;
use cipher::{block_padding::Pkcs7, BlockEncryptMut};
let key = [0x11u8; 24];
let iv = [0x22u8; 8];
let msg = b"secret!!";
let mut buf = vec![0u8; msg.len() + 8];
buf[..msg.len()].copy_from_slice(msg);
let ct = Encryptor::<TdesEde3>::new_from_slices(&key, &iv)
.unwrap()
.encrypt_padded_mut::<Pkcs7>(&mut buf, msg.len())
.unwrap()
.to_vec();
let wrong = [0x99u8; 24];
assert!(kcdecrypt(&wrong, &iv, &ct).is_err());
}
#[test]
fn kcdecrypt_rejects_bad_lengths() {
assert_eq!(
kcdecrypt(&[0u8; 8], &[0u8; 8], &[0u8; 8]),
Err(KeychainError::InvalidKeyLength)
);
assert_eq!(
kcdecrypt(&[0u8; 24], &[0u8; 8], &[0u8; 7]),
Err(KeychainError::DecryptionFailed)
);
}
fn hex(s: &str) -> Vec<u8> {
(0..s.len())
.step_by(2)
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
.collect()
}
}