use heapless::Vec;
use crate::crypto::{PublicKey, Signature, verify};
use crate::der::{
DerReader, OID_ECDSA_WITH_SHA256, OID_PKCS7_DATA, OID_SHA256, OID_SIGNED_DATA,
TAG_OCTET_STRING, TAG_SEQUENCE, TAG_SET, context_constructed, context_primitive,
ecdsa_sig_value_to_raw,
};
use crate::error::{Error, ErrorCode, Result, bail};
use crate::msg::VendorId;
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, Value, set_once};
const TAG_EXPLICIT_0: u8 = context_constructed(0);
const TAG_SKI: u8 = context_primitive(0);
pub const CMS_VERSION: u64 = 3;
pub const KEY_ID_LEN: usize = 20;
pub const MAX_PRODUCT_IDS: usize = 100;
pub const MAX_AUTHORIZED_PAAS: usize = 10;
pub const CERTIFICATE_ID_LEN: usize = 19;
pub const MAX_CD_LEN: usize = 1024;
fn malformed() -> Error {
Error::new(ErrorCode::DerMalformed)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CertificationType {
DevelopmentAndTest,
Provisional,
Official,
Reserved(u8),
}
impl CertificationType {
#[must_use]
pub const fn from_value(value: u8) -> Self {
match value {
0 => Self::DevelopmentAndTest,
1 => Self::Provisional,
2 => Self::Official,
other => Self::Reserved(other),
}
}
#[must_use]
pub const fn value(self) -> u8 {
match self {
Self::DevelopmentAndTest => 0,
Self::Provisional => 1,
Self::Official => 2,
Self::Reserved(v) => v,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CertificationElements<'a> {
pub format_version: u16,
pub vendor_id: VendorId,
pub product_ids: Vec<u16, MAX_PRODUCT_IDS>,
pub device_type_id: u32,
pub certificate_id: &'a str,
pub security_level: u8,
pub security_information: u16,
pub version_number: u16,
pub certification_type: CertificationType,
pub dac_origin_vendor_id: Option<VendorId>,
pub dac_origin_product_id: Option<u16>,
pub authorized_paas: Option<Vec<[u8; KEY_ID_LEN], MAX_AUTHORIZED_PAAS>>,
}
impl<'a> CertificationElements<'a> {
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = TlvReader::new(buf);
let Some(head) = reader.next_element()? else {
bail!(TlvTruncated)
};
if head.value.container() != Some(ContainerKind::Structure) || !head.tag.is_anonymous() {
bail!(TlvWrongType)
}
let mut format_version = None;
let mut vendor_id = None;
let mut product_ids = Vec::new();
let mut has_product_ids = false;
let mut device_type_id = None;
let mut certificate_id = None;
let mut security_level = None;
let mut security_information = None;
let mut version_number = None;
let mut certification_type = None;
let mut dac_origin_vendor_id = None;
let mut dac_origin_product_id = None;
let mut authorized_paas = None;
loop {
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
let Some(tag) = element.tag.context() else {
bail!(TlvInvalidTag)
};
match tag {
0 => set_once(&mut format_version, narrow_u16(element.unsigned()?)?)?,
1 => set_once(&mut vendor_id, VendorId(narrow_u16(element.unsigned()?)?))?,
2 => {
if element.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
if has_product_ids {
bail!(TlvDuplicateTag)
}
has_product_ids = true;
read_u16_array(&mut reader, &mut product_ids)?;
}
3 => {
let value = u32::try_from(element.unsigned()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))?;
set_once(&mut device_type_id, value)?;
}
4 => {
let text = element.utf8()?;
if text.len() != CERTIFICATE_ID_LEN {
bail!(TlvOutOfRange)
}
set_once(&mut certificate_id, text)?;
}
5 => {
let value = u8::try_from(element.unsigned()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))?;
set_once(&mut security_level, value)?;
}
6 => set_once(&mut security_information, narrow_u16(element.unsigned()?)?)?,
7 => set_once(&mut version_number, narrow_u16(element.unsigned()?)?)?,
8 => {
let value = CertificationType::from_value(
u8::try_from(element.unsigned()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))?,
);
set_once(&mut certification_type, value)?;
}
9 => {
set_once(
&mut dac_origin_vendor_id,
VendorId(narrow_u16(element.unsigned()?)?),
)?;
}
10 => set_once(&mut dac_origin_product_id, narrow_u16(element.unsigned()?)?)?,
11 => {
if element.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
set_once(&mut authorized_paas, read_key_id_array(&mut reader)?)?;
}
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
if !has_product_ids || product_ids.is_empty() {
bail!(TlvNotFound)
}
if dac_origin_vendor_id.is_some() != dac_origin_product_id.is_some() {
bail!(TlvNotFound)
}
Ok(Self {
format_version: format_version.ok_or(Error::new(ErrorCode::TlvNotFound))?,
vendor_id: vendor_id.ok_or(Error::new(ErrorCode::TlvNotFound))?,
product_ids,
device_type_id: device_type_id.ok_or(Error::new(ErrorCode::TlvNotFound))?,
certificate_id: certificate_id.ok_or(Error::new(ErrorCode::TlvNotFound))?,
security_level: security_level.ok_or(Error::new(ErrorCode::TlvNotFound))?,
security_information: security_information.ok_or(Error::new(ErrorCode::TlvNotFound))?,
version_number: version_number.ok_or(Error::new(ErrorCode::TlvNotFound))?,
certification_type: certification_type.ok_or(Error::new(ErrorCode::TlvNotFound))?,
dac_origin_vendor_id,
dac_origin_product_id,
authorized_paas,
})
}
pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(0), u64::from(self.format_version))?;
w.unsigned(Tag::Context(1), u64::from(self.vendor_id.0))?;
w.start_array(Tag::Context(2))?;
for pid in &self.product_ids {
w.unsigned(Tag::Anonymous, u64::from(*pid))?;
}
w.end_container()?;
w.unsigned(Tag::Context(3), u64::from(self.device_type_id))?;
w.utf8(Tag::Context(4), self.certificate_id)?;
w.unsigned(Tag::Context(5), u64::from(self.security_level))?;
w.unsigned(Tag::Context(6), u64::from(self.security_information))?;
w.unsigned(Tag::Context(7), u64::from(self.version_number))?;
w.unsigned(Tag::Context(8), u64::from(self.certification_type.value()))?;
if let Some(vid) = self.dac_origin_vendor_id {
w.unsigned(Tag::Context(9), u64::from(vid.0))?;
}
if let Some(pid) = self.dac_origin_product_id {
w.unsigned(Tag::Context(10), u64::from(pid))?;
}
if let Some(paas) = self.authorized_paas.as_ref() {
w.start_array(Tag::Context(11))?;
for ski in paas {
w.octets(Tag::Anonymous, ski)?;
}
w.end_container()?;
}
w.end_container()?;
w.finish()
}
#[must_use]
pub fn covers_product(&self, product_id: u16) -> bool {
self.product_ids.contains(&product_id)
}
#[must_use]
pub fn authorizes_paa(&self, ski: &[u8; KEY_ID_LEN]) -> bool {
self.authorized_paas
.as_ref()
.is_none_or(|list| list.contains(ski))
}
}
fn narrow_u16(value: u64) -> Result<u16> {
u16::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}
fn read_u16_array(reader: &mut TlvReader<'_>, out: &mut Vec<u16, MAX_PRODUCT_IDS>) -> Result<()> {
loop {
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
return Ok(());
}
if !element.tag.is_anonymous() {
bail!(TlvInvalidTag)
}
out.push(narrow_u16(element.unsigned()?)?)
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
}
}
fn read_key_id_array(
reader: &mut TlvReader<'_>,
) -> Result<Vec<[u8; KEY_ID_LEN], MAX_AUTHORIZED_PAAS>> {
let mut out = Vec::new();
loop {
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
if out.is_empty() {
bail!(TlvNotFound)
}
return Ok(out);
}
if !element.tag.is_anonymous() {
bail!(TlvInvalidTag)
}
let ski = <[u8; KEY_ID_LEN]>::try_from(element.octets()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))?;
out.push(ski).map_err(|_| Error::new(ErrorCode::NoSpace))?;
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SignedData<'a> {
pub content: &'a [u8],
pub signer_key_id: [u8; KEY_ID_LEN],
pub signature: Signature,
}
impl<'a> SignedData<'a> {
pub fn parse(der: &'a [u8]) -> Result<Self> {
if der.len() > MAX_CD_LEN {
return Err(malformed());
}
let mut outer = DerReader::new(der);
let mut content_info = outer.expect_sequence()?;
outer.finish()?;
content_info.expect_oid(OID_SIGNED_DATA)?;
let mut explicit = content_info.expect(TAG_EXPLICIT_0)?.content_reader();
content_info.finish()?;
let mut signed = explicit.expect_sequence()?;
explicit.finish()?;
if signed.expect_uint()? != CMS_VERSION {
return Err(malformed());
}
let mut digests = signed.expect_set()?;
let mut digest = digests.expect_sequence()?;
digest.expect_oid(OID_SHA256)?;
digests.finish()?;
let mut encap = signed.expect_sequence()?;
encap.expect_oid(OID_PKCS7_DATA)?;
let mut econtent = encap.expect(TAG_EXPLICIT_0)?.content_reader();
let content = econtent.expect(TAG_OCTET_STRING)?.content;
econtent.finish()?;
encap.finish()?;
let _ = signed.take_if(context_constructed(0))?;
let _ = signed.take_if(context_constructed(1))?;
let mut signers = signed.expect(TAG_SET)?.content_reader();
signed.finish()?;
let mut signer = signers.expect_sequence()?;
signers.finish()?;
if signer.expect_uint()? != CMS_VERSION {
return Err(malformed());
}
let signer_key_id = <[u8; KEY_ID_LEN]>::try_from(signer.expect(TAG_SKI)?.content)
.map_err(|_| malformed())?;
let mut signer_digest = signer.expect_sequence()?;
signer_digest.expect_oid(OID_SHA256)?;
if signer.peek_tag() == Some(context_constructed(0)) {
return Err(Error::new(ErrorCode::Unsupported));
}
let mut sig_algo = signer.expect_sequence()?;
sig_algo.expect_oid(OID_ECDSA_WITH_SHA256)?;
let signature_der = signer.expect(TAG_OCTET_STRING)?.content;
let mut raw = [0u8; 64];
ecdsa_sig_value_to_raw(signature_der, &mut raw)?;
Ok(Self {
content,
signer_key_id,
signature: Signature::from_bytes(raw),
})
}
pub fn verify(&self, csa_public_key: &PublicKey) -> Result<bool> {
verify(csa_public_key, self.content, &self.signature)
}
pub fn elements(&self) -> Result<CertificationElements<'a>> {
CertificationElements::decode(self.content)
}
}
pub const TAG_CMS_SEQUENCE: u8 = TAG_SEQUENCE;