use cbc::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
use rsa::{Pkcs1v15Encrypt, RsaPrivateKey};
use crate::der_walk::{extract_signed_data_econtent, tlv_expect_tag, tlv_split};
use crate::error::{Error, Result};
use crate::oid;
type Aes128CbcDec = cbc::Decryptor<aes::Aes128>;
type Aes192CbcDec = cbc::Decryptor<aes::Aes192>;
type Aes256CbcDec = cbc::Decryptor<aes::Aes256>;
pub fn decrypt_enc_key_pack(content_info: &[u8], client_rsa: &RsaPrivateKey) -> Result<Vec<u8>> {
let parsed = parse_enveloped(content_info, client_rsa)?;
if parsed.cek.len() != parsed.expected_cek_len {
return Err(Error::AsRepParse(format!(
"unwrapped CEK is {} bytes, content-encryption algorithm expects {}",
parsed.cek.len(),
parsed.expected_cek_len
)));
}
let plaintext = decrypt_aes_cbc(&parsed.cek, parsed.iv, parsed.ciphertext)?;
let reply_key_pack_der = if looks_like_signed_data_contentinfo(&plaintext) {
extract_signed_data_econtent(&plaintext)?
} else {
plaintext
};
reply_key_pack_extract_key(&reply_key_pack_der)
}
pub fn decrypt_enc_key_pack_full(
content_info: &[u8],
client_rsa: &RsaPrivateKey,
) -> Result<ReplyKey> {
let parsed = parse_enveloped(content_info, client_rsa)?;
if parsed.cek.len() != parsed.expected_cek_len {
return Err(Error::AsRepParse(format!(
"unwrapped CEK is {} bytes, content-encryption algorithm expects {}",
parsed.cek.len(),
parsed.expected_cek_len
)));
}
let plaintext = decrypt_aes_cbc(&parsed.cek, parsed.iv, parsed.ciphertext)?;
let reply_key_pack_der = if looks_like_signed_data_contentinfo(&plaintext) {
extract_signed_data_econtent(&plaintext)?
} else {
plaintext
};
reply_key_pack_extract(&reply_key_pack_der)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ReplyKey {
pub etype: i32,
pub key: Vec<u8>,
}
struct ParsedEnvelope<'a> {
cek: Vec<u8>,
iv: &'a [u8],
ciphertext: &'a [u8],
expected_cek_len: usize,
}
fn parse_enveloped<'a>(
content_info: &'a [u8],
client_rsa: &RsaPrivateKey,
) -> Result<ParsedEnvelope<'a>> {
let (ci_body, _) = tlv_expect_tag(content_info, 0x30)?;
let (ct_oid_val, after_ct_oid) = tlv_expect_tag(ci_body, 0x06)?;
if ct_oid_val != oid::CMS_ENVELOPED_DATA.as_bytes() {
return Err(Error::AsRepParse(
"ContentInfo.contentType is not id-envelopedData".into(),
));
}
let (ctx0_body, _) = tlv_expect_tag(after_ct_oid, 0xA0)?;
let (ed_body, _) = tlv_expect_tag(ctx0_body, 0x30)?;
let (_ver, cursor_after_ver) = tlv_split(ed_body)?;
let mut cursor = cursor_after_ver;
if cursor.first().copied() == Some(0xA0) {
let (_orig, rest) = tlv_split(cursor)?;
cursor = rest;
}
let (ris_body, after_ris) = tlv_expect_tag(cursor, 0x31)?;
let cek = unwrap_cek_from_recipient_infos(ris_body, client_rsa)?;
let (eci_body, _) = tlv_expect_tag(after_ris, 0x30)?;
let (_ec_type, after_ec_type) = tlv_expect_tag(eci_body, 0x06)?;
let (alg_body, after_alg) = tlv_expect_tag(after_ec_type, 0x30)?;
let (alg_oid, after_alg_oid) = tlv_expect_tag(alg_body, 0x06)?;
let (iv_body, _) = tlv_expect_tag(after_alg_oid, 0x04)?;
let (ct_body, _) = tlv_expect_tag(after_alg, 0x80)?;
let expected_cek_len = match_aes_cbc_key_len(alg_oid)?;
Ok(ParsedEnvelope {
cek,
iv: iv_body,
ciphertext: ct_body,
expected_cek_len,
})
}
fn unwrap_cek_from_recipient_infos(ris: &[u8], client_rsa: &RsaPrivateKey) -> Result<Vec<u8>> {
let mut cursor = ris;
let mut last_err: Option<Error> = None;
while !cursor.is_empty() {
let first = cursor[0];
let (ri_body, rest) = tlv_split(cursor)?;
cursor = rest;
if first != 0x30 {
continue;
}
let (_ver, after_ver) = tlv_split(ri_body)?;
let (_rid, after_rid) = tlv_split(after_ver)?;
let (kea_body, after_kea) = tlv_expect_tag(after_rid, 0x30)?;
let (kea_oid, _) = tlv_expect_tag(kea_body, 0x06)?;
if kea_oid != oid::RSA_ENCRYPTION.as_bytes() {
continue;
}
let (ek_body, _) = tlv_expect_tag(after_kea, 0x04)?;
match client_rsa.decrypt(Pkcs1v15Encrypt, ek_body) {
Ok(cek) => return Ok(cek),
Err(e) => {
last_err = Some(Error::Rsa(format!("encryptedKey RSA-unwrap: {e}")));
}
}
}
Err(last_err.unwrap_or_else(|| {
Error::AsRepParse(
"no compatible KeyTransRecipientInfo (rsaEncryption) in EnvelopedData".into(),
)
}))
}
fn match_aes_cbc_key_len(oid_bytes: &[u8]) -> Result<usize> {
if oid_bytes == oid::AES256_CBC.as_bytes() {
Ok(32)
} else if oid_bytes == oid::AES192_CBC.as_bytes() {
Ok(24)
} else if oid_bytes == oid::AES128_CBC.as_bytes() {
Ok(16)
} else {
Err(Error::AsRepParse(
"unsupported content-encryption OID (want aes{128,192,256}-CBC)".into(),
))
}
}
fn decrypt_aes_cbc(key: &[u8], iv: &[u8], ct: &[u8]) -> Result<Vec<u8>> {
if iv.len() != 16 {
return Err(Error::Crypto(format!(
"AES-CBC IV len {} (expected 16)",
iv.len()
)));
}
if ct.is_empty() || ct.len() % 16 != 0 {
return Err(Error::Crypto(format!(
"AES-CBC ciphertext len {} is not a positive multiple of 16",
ct.len()
)));
}
match key.len() {
16 => Aes128CbcDec::new_from_slices(key, iv)
.map_err(|e| Error::Crypto(format!("aes-128-cbc init: {e}")))?
.decrypt_padded_vec_mut::<Pkcs7>(ct)
.map_err(|e| Error::Crypto(format!("aes-128-cbc decrypt: {e}"))),
24 => Aes192CbcDec::new_from_slices(key, iv)
.map_err(|e| Error::Crypto(format!("aes-192-cbc init: {e}")))?
.decrypt_padded_vec_mut::<Pkcs7>(ct)
.map_err(|e| Error::Crypto(format!("aes-192-cbc decrypt: {e}"))),
32 => Aes256CbcDec::new_from_slices(key, iv)
.map_err(|e| Error::Crypto(format!("aes-256-cbc init: {e}")))?
.decrypt_padded_vec_mut::<Pkcs7>(ct)
.map_err(|e| Error::Crypto(format!("aes-256-cbc decrypt: {e}"))),
n => Err(Error::Crypto(format!("unsupported AES key len {n}"))),
}
}
fn looks_like_signed_data_contentinfo(bytes: &[u8]) -> bool {
let Ok((body, _)) = tlv_expect_tag(bytes, 0x30) else {
return false;
};
let Ok((oid_val, _)) = tlv_expect_tag(body, 0x06) else {
return false;
};
oid_val == oid::CMS_SIGNED_DATA.as_bytes()
}
fn reply_key_pack_extract_key(bytes: &[u8]) -> Result<Vec<u8>> {
Ok(reply_key_pack_extract(bytes)?.key)
}
fn reply_key_pack_extract(bytes: &[u8]) -> Result<ReplyKey> {
let (rkp_body, _) = tlv_expect_tag(bytes, 0x30)?;
let (rk_ctx_body, _) = tlv_expect_tag(rkp_body, 0xA0)?;
let (ek_body, _) = tlv_expect_tag(rk_ctx_body, 0x30)?;
let mut cursor = ek_body;
let mut keytype: Option<i32> = None;
let mut keyvalue: Option<Vec<u8>> = None;
while !cursor.is_empty() {
let first = cursor[0];
let (field_body, rest) = tlv_split(cursor)?;
match first {
0xA0 => {
let (int_body, _) = tlv_expect_tag(field_body, 0x02)?;
keytype = Some(decode_der_int_i32(int_body)?);
}
0xA1 => {
let (kv_body, _) = tlv_expect_tag(field_body, 0x04)?;
keyvalue = Some(kv_body.to_vec());
}
_ => {
}
}
cursor = rest;
}
let key = keyvalue
.ok_or_else(|| Error::AsRepParse("ReplyKeyPack.replyKey has no [1] keyvalue".into()))?;
let etype = keytype
.ok_or_else(|| Error::AsRepParse("ReplyKeyPack.replyKey has no [0] keytype".into()))?;
Ok(ReplyKey { etype, key })
}
fn decode_der_int_i32(bytes: &[u8]) -> Result<i32> {
if bytes.is_empty() {
return Err(Error::AsRepParse("INTEGER: zero-length value".into()));
}
if bytes.len() > 5 {
return Err(Error::AsRepParse(format!(
"INTEGER too wide for i32 ({} bytes)",
bytes.len()
)));
}
let mut acc: i32 = if bytes[0] & 0x80 != 0 { -1 } else { 0 };
for &b in bytes {
acc = (acc.wrapping_shl(8)) | (b as i32 & 0xFF);
}
Ok(acc)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn match_aes_cbc_key_len_covers_all_three_sizes() {
assert_eq!(
match_aes_cbc_key_len(oid::AES128_CBC.as_bytes()).unwrap(),
16
);
assert_eq!(
match_aes_cbc_key_len(oid::AES192_CBC.as_bytes()).unwrap(),
24
);
assert_eq!(
match_aes_cbc_key_len(oid::AES256_CBC.as_bytes()).unwrap(),
32
);
assert!(match_aes_cbc_key_len(oid::CMS_DATA.as_bytes()).is_err());
}
#[test]
fn decode_der_int_handles_edge_values() {
assert_eq!(decode_der_int_i32(&[0x00]).unwrap(), 0);
assert_eq!(decode_der_int_i32(&[0x12]).unwrap(), 18);
assert_eq!(decode_der_int_i32(&[0x17]).unwrap(), 23);
assert_eq!(decode_der_int_i32(&[0xFF]).unwrap(), -1);
assert_eq!(decode_der_int_i32(&[0x00, 0x80]).unwrap(), 128);
assert!(decode_der_int_i32(&[]).is_err());
assert!(decode_der_int_i32(&[0; 6]).is_err());
}
#[test]
fn reply_key_pack_roundtrip_extracts_key_and_etype() {
let keyvalue = [0xAAu8; 32];
let cksum = [0x11u8, 0x22, 0x33, 0x44];
let ek_inner = concat_der(&[
explicit_tag(0, &[0x02, 0x01, 18]),
explicit_tag(1, &wrap_tag(0x04, &keyvalue)),
]);
let ek = wrap_tag(0x30, &ek_inner);
let cksum_inner = concat_der(&[
explicit_tag(0, &[0x02, 0x01, 16]),
explicit_tag(1, &wrap_tag(0x04, &cksum)),
]);
let cksum_seq = wrap_tag(0x30, &cksum_inner);
let rkp_inner = concat_der(&[explicit_tag(0, &ek), explicit_tag(1, &cksum_seq)]);
let rkp = wrap_tag(0x30, &rkp_inner);
let out = reply_key_pack_extract(&rkp).unwrap();
assert_eq!(out.etype, 18);
assert_eq!(out.key, keyvalue.to_vec());
}
#[test]
fn looks_like_signed_data_distinguishes_shapes() {
let raw_rkp = wrap_tag(0x30, &explicit_tag(0, &[0x30, 0x00]));
assert!(!looks_like_signed_data_contentinfo(&raw_rkp));
let signed_ci_body = concat_der(&[
wrap_tag(0x06, oid::CMS_SIGNED_DATA.as_bytes()),
explicit_tag(0, &[0x30, 0x00]),
]);
let signed_ci = wrap_tag(0x30, &signed_ci_body);
assert!(looks_like_signed_data_contentinfo(&signed_ci));
}
fn concat_der(parts: &[Vec<u8>]) -> Vec<u8> {
let mut out = Vec::new();
for p in parts {
out.extend_from_slice(p);
}
out
}
fn wrap_tag(tag: u8, body: &[u8]) -> Vec<u8> {
let mut out = vec![tag];
encode_len_into(&mut out, body.len());
out.extend_from_slice(body);
out
}
fn explicit_tag(tag_number: u8, body: &[u8]) -> Vec<u8> {
wrap_tag(0xA0 | tag_number, body)
}
fn encode_len_into(dst: &mut Vec<u8>, len: usize) {
if len < 0x80 {
dst.push(len as u8);
} else if len < 0x100 {
dst.push(0x81);
dst.push(len as u8);
} else if len < 0x10000 {
dst.push(0x82);
dst.push((len >> 8) as u8);
dst.push(len as u8);
} else {
panic!("test helper: unsupported len {len}");
}
}
}