use heapless::Vec;
use crate::crypto::{KeyHandle, KeyStore, PublicKey, Signature, SymmetricKey, verify};
use crate::der::{
DerReader, DerWriter, OID_ECDSA_WITH_SHA256, OID_EXTENSION_REQUEST, OID_ORGANIZATION_NAME,
TAG_BIT_STRING, TAG_INTEGER, TAG_SEQUENCE, TAG_SET, TAG_UTF8_STRING, context_constructed,
ecdsa_sig_value_to_raw,
};
use crate::error::{Error, ErrorCode, Result, bail};
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, Value, set_once};
use super::CSR_NONCE_LEN;
const TAG_ATTRIBUTES: u8 = context_constructed(0);
pub const CSR_SUBJECT_ORGANIZATION: &str = "CSA";
pub const MAX_CSR_LEN: usize = 320;
pub const MAX_NOCSR_ELEMENTS: usize = MAX_CSR_LEN + 256;
pub const MAX_VENDOR_RESERVED: usize = 64;
fn malformed() -> Error {
Error::new(ErrorCode::DerMalformed)
}
pub fn build_csr<'b, K: KeyStore>(
keys: &K,
operational_key: KeyHandle,
buf: &'b mut [u8],
) -> Result<&'b [u8]> {
let public_key = keys.public_key(operational_key)?;
let mut tbs_buf = [0u8; MAX_CSR_LEN];
let tbs = certification_request_info(&public_key, &mut tbs_buf)?;
let signature = keys.sign(operational_key, tbs)?;
let mut w = DerWriter::new(buf);
let mark = w.mark();
let sig_mark = w.mark();
w.ecdsa_sig_value(signature.as_bytes())?;
w.byte(0)?;
w.header(TAG_BIT_STRING, sig_mark)?;
w.algorithm_identifier(OID_ECDSA_WITH_SHA256)?;
w.slice(tbs)?;
w.header(TAG_SEQUENCE, mark)?;
if w.len() > MAX_CSR_LEN {
return Err(malformed());
}
Ok(w.finish())
}
fn certification_request_info<'b>(public_key: &PublicKey, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut w = DerWriter::new(buf);
let mark = w.mark();
let attrs = w.mark();
let attr = w.mark();
let values = w.mark();
let empty = w.mark();
w.header(TAG_SEQUENCE, empty)?;
w.header(TAG_SET, values)?;
w.primitive(crate::der::TAG_OID, OID_EXTENSION_REQUEST)?;
w.header(TAG_SEQUENCE, attr)?;
w.header(TAG_ATTRIBUTES, attrs)?;
w.subject_public_key_info(public_key.as_bytes())?;
let name = w.mark();
let rdn = w.mark();
let atv = w.mark();
w.primitive(TAG_UTF8_STRING, CSR_SUBJECT_ORGANIZATION.as_bytes())?;
w.primitive(crate::der::TAG_OID, OID_ORGANIZATION_NAME)?;
w.header(TAG_SEQUENCE, atv)?;
w.header(TAG_SET, rdn)?;
w.header(TAG_SEQUENCE, name)?;
w.primitive(TAG_INTEGER, &[0])?;
w.header(TAG_SEQUENCE, mark)?;
Ok(w.finish())
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Csr<'a> {
pub tbs: &'a [u8],
pub public_key: PublicKey,
pub signature: Signature,
}
impl<'a> Csr<'a> {
pub fn parse(der: &'a [u8]) -> Result<Self> {
if der.len() > MAX_CSR_LEN {
return Err(malformed());
}
let mut outer = DerReader::new(der);
let mut request = outer.expect_sequence()?;
outer.finish()?;
let tbs_element = request.expect(TAG_SEQUENCE)?;
let mut tbs = tbs_element.content_reader();
if tbs.expect_uint()? != 0 {
return Err(malformed());
}
let _ = tbs.expect(TAG_SEQUENCE)?;
let mut spki = tbs.expect_sequence()?;
let mut algo = spki.expect_sequence()?;
algo.expect_oid(crate::der::OID_EC_PUBLIC_KEY)?;
algo.expect_oid(crate::der::OID_PRIME256V1)?;
algo.finish()?;
let public_key = PublicKey::from_slice(spki.expect(TAG_BIT_STRING)?.bit_string_octets()?)?;
spki.finish()?;
let _ = tbs.take_if(TAG_ATTRIBUTES)?;
tbs.finish()?;
let mut sig_algo = request.expect_sequence()?;
sig_algo.expect_oid(OID_ECDSA_WITH_SHA256)?;
sig_algo.finish()?;
let signature_der = request.expect(TAG_BIT_STRING)?.bit_string_octets()?;
request.finish()?;
let mut raw = [0u8; 64];
ecdsa_sig_value_to_raw(signature_der, &mut raw)?;
Ok(Self {
tbs: tbs_element.raw,
public_key,
signature: Signature::from_bytes(raw),
})
}
pub fn verify(&self) -> Result<bool> {
verify(&self.public_key, self.tbs, &self.signature)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NocsrElements<'a> {
pub csr: &'a [u8],
pub csr_nonce: [u8; CSR_NONCE_LEN],
pub vendor_reserved: Vec<(u8, &'a [u8]), 3>,
}
impl<'a> NocsrElements<'a> {
#[must_use]
pub fn new(csr: &'a [u8], csr_nonce: [u8; CSR_NONCE_LEN]) -> Self {
Self {
csr,
csr_nonce,
vendor_reserved: Vec::new(),
}
}
pub fn with_vendor_reserved(mut self, tag: u8, value: &'a [u8]) -> Result<Self> {
if !(3..=5).contains(&tag) || value.len() > MAX_VENDOR_RESERVED {
bail!(InvalidArgument)
}
if self.vendor_reserved.iter().any(|(seen, _)| *seen == tag) {
bail!(TlvDuplicateTag)
}
self.vendor_reserved
.push((tag, value))
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
Ok(self)
}
pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.octets(Tag::Context(1), self.csr)?;
w.octets(Tag::Context(2), &self.csr_nonce)?;
let mut sorted = self.vendor_reserved.clone();
sorted.sort_unstable_by_key(|(tag, _)| *tag);
for (tag, value) in &sorted {
w.octets(Tag::Context(*tag), value)?;
}
w.end_container()?;
w.finish()
}
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 csr = None;
let mut csr_nonce = None;
let mut vendor_reserved = Vec::new();
loop {
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(1) => set_once(&mut csr, element.octets()?)?,
Some(2) => {
let value = <[u8; CSR_NONCE_LEN]>::try_from(element.octets()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))?;
set_once(&mut csr_nonce, value)?;
}
Some(tag @ 3..=5) => {
if vendor_reserved.iter().any(|(seen, _)| *seen == tag) {
bail!(TlvDuplicateTag)
}
vendor_reserved
.push((tag, element.octets()?))
.map_err(|_| Error::new(ErrorCode::NoSpace))?;
}
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
csr: csr.ok_or(Error::new(ErrorCode::TlvNotFound))?,
csr_nonce: csr_nonce.ok_or(Error::new(ErrorCode::TlvNotFound))?,
vendor_reserved,
})
}
pub fn parse_csr(&self) -> Result<Csr<'a>> {
Csr::parse(self.csr)
}
}
pub fn sign_nocsr<K: KeyStore>(
keys: &K,
dac_key: KeyHandle,
elements: &[u8],
challenge: &SymmetricKey,
) -> Result<Signature> {
super::with_tbs(elements, challenge, |tbs| keys.sign(dac_key, tbs))
}
pub fn verify_nocsr(
dac_public_key: &PublicKey,
elements: &[u8],
challenge: &SymmetricKey,
signature: &Signature,
) -> Result<bool> {
super::with_tbs(elements, challenge, |tbs| {
verify(dac_public_key, tbs, signature)
})
}