Encode SubjectAlternativeName extension

Currently, only the otherName choice is supported.

dpe/src/commands/certify_key.rs

@@ -16,7 +16,7 @@ use caliptra_cfi_lib_git::cfi_launder;
 use caliptra_cfi_lib_git::{cfi_assert, cfi_assert_eq};
 use cfg_if::cfg_if;
 use crypto::{Crypto, Hasher};
-use platform::{Platform, MAX_ISSUER_NAME_SIZE, MAX_KEY_IDENTIFIER_SIZE};
+use platform::{Platform, PlatformError, MAX_ISSUER_NAME_SIZE, MAX_KEY_IDENTIFIER_SIZE};
 
 #[repr(C)]
 #[derive(Debug, PartialEq, Eq, zerocopy::FromBytes, zerocopy::AsBytes)]
@@ -142,13 +142,20 @@ impl CommandExecution for CertifyKeyCmd {
  env.platform
  .get_issuer_key_identifier(&mut authority_key_identifier)?;
 
+ let subject_alt_name = match env.platform.get_subject_alternative_name() {
+ Ok(subject_alt_name) => Some(subject_alt_name),
+ Err(PlatformError::NotImplemented) => None,
+ Err(e) => Err(DpeErrorCode::Platform(e))?,
+ };
+
  let measurements = MeasurementData {
  label: &self.label,
  tci_nodes: &nodes[..tcb_count],
  is_ca: self.uses_is_ca(),
  supports_recursive: dpe.support.recursive(),
  subject_key_identifier,
  authority_key_identifier,
+ subject_alt_name,
  };
 
  let mut issuer_name = [0u8; MAX_ISSUER_NAME_SIZE];

dpe/src/x509.rs

@@ -12,7 +12,9 @@ use crate::{
 };
 use bitflags::bitflags;
 use crypto::{EcdsaPub, EcdsaSig};
-use platform::{CertValidity, SignerIdentifier, MAX_KEY_IDENTIFIER_SIZE};
+use platform::{
+ CertValidity, OtherName, SignerIdentifier, SubjectAltName, MAX_KEY_IDENTIFIER_SIZE,
+};
 
 pub enum DirectoryString<'a> {
  PrintableString(&'a [u8]),
@@ -51,6 +53,7 @@ pub struct MeasurementData<'a> {
  pub supports_recursive: bool,
  pub subject_key_identifier: [u8; MAX_KEY_IDENTIFIER_SIZE],
  pub authority_key_identifier: [u8; MAX_KEY_IDENTIFIER_SIZE],
+ pub subject_alt_name: Option<SubjectAltName>,
 }
 
 pub struct CertWriter<'a> {
@@ -145,6 +148,9 @@ impl CertWriter<'_> {
  // RFC 5280 2.5.29.35
  const AUTHORITY_KEY_IDENTIFIER_OID: &'static [u8] = &[0x55, 0x1D, 0x23];
 
+ // RFC 5280 2.5.29.17
+ const SUBJECT_ALTERNATIVE_NAME_OID: &'static [u8] = &[0x55, 0x1D, 0x11];
+
  // RFC 5652 1.2.840.113549.1.7.2
  const ID_SIGNED_DATA_OID: &'static [u8] =
  &[0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x02];
@@ -502,6 +508,49 @@ impl CertWriter<'_> {
  Self::get_structure_size(size, tagged)
  }
 
+ fn get_subject_alt_name_extension_size(
+ measurements: &MeasurementData,
+ tagged: bool,
+ ) -> Result<usize, DpeErrorCode> {
+ match &measurements.subject_alt_name {
+ None => Ok(0),
+ Some(SubjectAltName::OtherName(other_name)) => {
+ let san_size = Self::get_other_name_size(other_name, /*tagged=*/ true)?;
+
+ // Extension data is sequence -> octet string. To compute size, wrap
+ // in tagging twice.
+ let ext_size = Self::get_structure_size(san_size, /*tagged=*/ true)?;
+ let size = Self::get_structure_size(Self::SUBJECT_ALTERNATIVE_NAME_OID.len(), /*tagged=*/true)? // Extension OID
+ + Self::get_structure_size(Self::BOOL_SIZE, /*tagged=*/true)? // Critical bool
+ + Self::get_structure_size(ext_size, /*tagged=*/true)?; // OCTET STRING
+
+ Self::get_structure_size(size, tagged)
+ }
+ }
+ }
+
+ fn get_other_name_size(other_name: &OtherName, tagged: bool) -> Result<usize, DpeErrorCode> {
+ let size = Self::get_structure_size(other_name.oid.len(), /*tagged=*/ true)?
+ + Self::get_other_name_value_size(
+ other_name.other_name.as_slice(),
+ /*tagged=*/ true,
+ /*explicit=*/ true,
+ )?;
+
+ Self::get_structure_size(size, tagged)
+ }
+
+ fn get_other_name_value_size(
+ other_name_value: &[u8],
+ tagged: bool,
+ explicit: bool,
+ ) -> Result<usize, DpeErrorCode> {
+ // Determine whether to include the explicit tag wrapping in the size calculation
+ let size = Self::get_structure_size(other_name_value.len(), explicit)?;
+
+ Self::get_structure_size(size, tagged)
+ }
+
  /// Get the size of the TBS Extensions field.
  fn get_extensions_size(
  measurements: &MeasurementData,
@@ -523,7 +572,8 @@ impl CertWriter<'_> {
  measurements,
  /*tagged=*/ true,
  is_x509,
- )?;
+ )?
+ + Self::get_subject_alt_name_extension_size(measurements, /*tagged=*/ true)?;
 
  // Determine whether to include the explicit tag wrapping in the size calculation
  size = Self::get_structure_size(size, /*tagged=*/ explicit)?;
@@ -1402,6 +1452,104 @@ impl CertWriter<'_> {
  Ok(bytes_written)
  }
 
+ #[allow(clippy::identity_op)]
+ fn encode_other_name_value(&mut self, other_name_value: &[u8]) -> Result<usize, DpeErrorCode> {
+ // value is EXPLICIT field number 0
+ let mut bytes_written =
+ self.encode_byte(Self::CONTEXT_SPECIFIC | Self::CONSTRUCTED | 0x0)?;
+ bytes_written += self.encode_size_field(Self::get_other_name_value_size(
+ other_name_value,
+ /*tagged=*/ true,
+ /*explicit=*/ false,
+ )?)?;
+
+ // value := UTF8STRING
+ bytes_written += self.encode_tag_field(Self::UTF8_STRING_TAG)?;
+ bytes_written += self.encode_size_field(Self::get_other_name_value_size(
+ other_name_value,
+ /*tagged=*/ false,
+ /*explicit=*/ false,
+ )?)?;
+ bytes_written += self.encode_bytes(other_name_value)?;
+
+ Ok(bytes_written)
+ }
+
+ /// OtherName ::= SEQUENCE {
+ /// type-id OBJECT IDENTIFIER,
+ /// value [0] EXPLICIT ANY DEFINED BY type-id
+ /// }
+ #[allow(clippy::identity_op)]
+ fn encode_other_name(&mut self, other_name: &OtherName) -> Result<usize, DpeErrorCode> {
+ // otherName is EXPLICIT field number 0
+ let mut bytes_written =
+ self.encode_byte(Self::CONTEXT_SPECIFIC | Self::CONSTRUCTED | 0x0)?;
+
+ bytes_written += self.encode_size_field(Self::get_other_name_size(
+ other_name, /*tagged=*/ false,
+ )?)?;
+ bytes_written += self.encode_oid(other_name.oid)?;
+ bytes_written += self.encode_other_name_value(other_name.other_name.as_slice())?;
+
+ Ok(bytes_written)
+ }
+
+ /// SubjectAltName ::= GeneralNames
+ ///
+ /// GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
+ ///
+ /// GeneralName ::= CHOICE {
+ /// otherName [0] OtherName,
+ /// rfc822Name [1] IA5String,
+ /// dNSName [2] IA5String,
+ /// x400Address [3] ORAddress,
+ /// directoryName [4] Name,
+ /// ediPartyName [5] EDIPartyName,
+ /// uniformResourceIdentifier [6] IA5String,
+ /// iPAddress [7] OCTET STRING,
+ /// registeredID [8] OBJECT IDENTIFIER
+ /// }
+ ///
+ /// Currently, only otherName is supported.
+ fn encode_subject_alt_name_extension(
+ &mut self,
+ measurements: &MeasurementData,
+ ) -> Result<usize, DpeErrorCode> {
+ match &measurements.subject_alt_name {
+ None => Ok(0),
+ Some(SubjectAltName::OtherName(other_name)) => {
+ // Encode Extension
+ let san_extension_size = Self::get_subject_alt_name_extension_size(
+ measurements,
+ /*tagged=*/ false,
+ )?;
+ let mut bytes_written = self.encode_byte(Self::SEQUENCE_TAG)?;
+ bytes_written += self.encode_size_field(san_extension_size)?;
+ bytes_written += self.encode_oid(Self::SUBJECT_ALTERNATIVE_NAME_OID)?;
+
+ bytes_written += self.encode_byte(Self::BOOL_TAG)?;
+ bytes_written += self.encode_size_field(Self::BOOL_SIZE)?;
+ // authority key identifier extension must NOT be marked critical
+ bytes_written += self.encode_byte(0x00)?;
+
+ // Extension data is sequence -> octet string. To compute size, wrap
+ // in tagging once.
+ let other_name_size = Self::get_other_name_size(other_name, /*tagged=*/ true)?;
+ bytes_written += self.encode_byte(Self::OCTET_STRING_TAG)?;
+ bytes_written += self.encode_size_field(Self::get_structure_size(
+ other_name_size,
+ /*tagged=*/ true,
+ )?)?;
+
+ bytes_written += self.encode_byte(Self::SEQUENCE_TAG)?;
+ bytes_written += self.encode_size_field(other_name_size)?;
+ bytes_written += self.encode_other_name(other_name)?;
+
+ Ok(bytes_written)
+ }
+ }
+ }
+
  /// AuthorityKeyIdentifier ::= SEQUENCE {
  /// keyIdentifier [0] KeyIdentifier OPTIONAL,
  /// authorityCertIssuer [1] GeneralNames OPTIONAL,
@@ -1526,6 +1674,7 @@ impl CertWriter<'_> {
  bytes_written += self.encode_extended_key_usage(measurements)?;
  bytes_written += self.encode_subject_key_identifier_extension(measurements, is_x509)?;
  bytes_written += self.encode_authority_key_identifier_extension(measurements, is_x509)?;
+ bytes_written += self.encode_subject_alt_name_extension(measurements)?;
 
  Ok(bytes_written)
  }
@@ -2049,7 +2198,7 @@ pub(crate) mod tests {
  use crate::{DpeProfile, DPE_PROFILE};
  use crypto::{CryptoBuf, EcdsaPub, EcdsaSig};
  use openssl::hash::{Hasher, MessageDigest};
- use platform::{ArrayVec, CertValidity, MAX_KEY_IDENTIFIER_SIZE};
+ use platform::{ArrayVec, CertValidity, OtherName, SubjectAltName, MAX_KEY_IDENTIFIER_SIZE};
  use std::str;
  use x509_parser::certificate::X509CertificateParser;
  use x509_parser::nom::Parser;
@@ -2295,6 +2444,7 @@ pub(crate) mod tests {
  supports_recursive: true,
  subject_key_identifier: [0u8; MAX_KEY_IDENTIFIER_SIZE],
  authority_key_identifier: [0u8; MAX_KEY_IDENTIFIER_SIZE],
+ subject_alt_name: None,
  };
 
  let mut not_before = ArrayVec::new();
@@ -2352,6 +2502,9 @@ pub(crate) mod tests {
 
  const ECC_INT_SIZE: usize = DPE_PROFILE.get_ecc_int_size();
 
+ const DEFAULT_OTHER_NAME_OID: &'static [u8] = &[0, 0, 0];
+ const DEFAULT_OTHER_NAME_VALUE: &str = "default-other-name";
+
  fn build_test_tbs<'a>(is_ca: bool, cert_buf: &'a mut [u8]) -> (usize, TbsCertificate<'a>) {
  let mut issuer_der = [0u8; 1024];
  let mut issuer_writer = CertWriter::new(&mut issuer_der, true);
@@ -2374,13 +2527,22 @@ pub(crate) mod tests {
  let mut subject_key_identifier = [0u8; MAX_KEY_IDENTIFIER_SIZE];
  let digest = &hasher.finish().unwrap();
  subject_key_identifier.copy_from_slice(&digest[..MAX_KEY_IDENTIFIER_SIZE]);
+ let mut other_name = ArrayVec::new();
+ other_name
+ .try_extend_from_slice(DEFAULT_OTHER_NAME_VALUE.as_bytes())
+ .unwrap();
+ let subject_alt_name = SubjectAltName::OtherName(OtherName {
+ oid: DEFAULT_OTHER_NAME_OID,
+ other_name,
+ });
  let measurements = MeasurementData {
  label: &[0; DPE_PROFILE.get_hash_size()],
  tci_nodes: &[node],
  is_ca,
  supports_recursive: true,
  subject_key_identifier,
  authority_key_identifier: subject_key_identifier,
+ subject_alt_name: Some(subject_alt_name),
  };
 
  let mut not_before = ArrayVec::new();
@@ -2488,6 +2650,25 @@ pub(crate) mod tests {
  Err(_) => panic!("multiple authority key identifier extensions found"),
  _ => (),
  }
+
+ match cert.subject_alternative_name() {
+ Ok(Some(ext)) => {
+ assert!(!ext.critical);
+ let san = ext.value;
+ assert_eq!(san.general_names.len(), 1);
+ let general_name = san.general_names.get(0).unwrap();
+ match general_name {
+ GeneralName::OtherName(oid, other_name_value) => {
+ assert_eq!(oid.as_bytes(), DEFAULT_OTHER_NAME_OID);
+ // skip first 4 der encoding bytes
+ assert_eq!(&other_name_value[4..], DEFAULT_OTHER_NAME_VALUE.as_bytes());
+ }
+ _ => panic!("Wrong SubjectAlternativeName"),
+ };
+ }
+ Ok(None) => panic!("No SubjectAltName extension found!"),
+ Err(e) => panic!("Error {} parsing SubjectAltName extension", e.to_string()),
+ }
  }
 
  #[test]

platform/src/default.rs

@@ -1,8 +1,8 @@
 // Licensed under the Apache-2.0 license
 
 use crate::{
- CertValidity, Platform, PlatformError, SignerIdentifier, MAX_CHUNK_SIZE, MAX_ISSUER_NAME_SIZE,
- MAX_KEY_IDENTIFIER_SIZE,
+ CertValidity, Platform, PlatformError, SignerIdentifier, SubjectAltName, MAX_CHUNK_SIZE,
+ MAX_ISSUER_NAME_SIZE, MAX_KEY_IDENTIFIER_SIZE,
 };
 use arrayvec::ArrayVec;
 use cfg_if::cfg_if;
@@ -197,4 +197,8 @@ impl Platform for DefaultPlatform {
  not_after: not_after_vec,
  })
  }
+
+ fn get_subject_alternative_name(&mut self) -> Result<SubjectAltName, PlatformError> {
+ Err(PlatformError::NotImplemented)
+ }
 }

platform/src/lib.rs

@@ -20,6 +20,7 @@ pub const MAX_ISSUER_NAME_SIZE: usize = 128;
 pub const MAX_SN_SIZE: usize = 20;
 pub const MAX_KEY_IDENTIFIER_SIZE: usize = 20;
 pub const MAX_VALIDITY_SIZE: usize = 24;
+pub const MAX_OTHER_NAME_SIZE: usize = 128;
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum SignerIdentifier {
@@ -30,6 +31,17 @@ pub enum SignerIdentifier {
  SubjectKeyIdentifier(ArrayVec<u8, { MAX_KEY_IDENTIFIER_SIZE }>),
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub enum SubjectAltName {
+ OtherName(OtherName),
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct OtherName {
+ pub oid: &'static [u8],
+ pub other_name: ArrayVec<u8, { MAX_OTHER_NAME_SIZE }>,
+}
+
 #[derive(Debug, PartialEq, Eq)]
 pub struct CertValidity {
  pub not_before: ArrayVec<u8, { MAX_VALIDITY_SIZE }>,
@@ -47,6 +59,7 @@ pub enum PlatformError {
  SubjectKeyIdentifierError(u32) = 0x6,
  CertValidityError(u32) = 0x7,
  IssuerKeyIdentifierError(u32) = 0x8,
+ SubjectAlternativeNameError(u32) = 0x9,
 }
 
 impl PlatformError {
@@ -67,6 +80,7 @@ impl PlatformError {
  PlatformError::SubjectKeyIdentifierError(code) => Some(*code),
  PlatformError::CertValidityError(code) => Some(*code),
  PlatformError::IssuerKeyIdentifierError(code) => Some(*code),
+ PlatformError::SubjectAlternativeNameError(code) => Some(*code),
  }
  }
 }
@@ -125,4 +139,11 @@ pub trait Platform {
  ///
  /// Example: 99991231235959Z is December 31st, 9999 23:59:59 UTC
  fn get_cert_validity(&mut self) -> Result<CertValidity, PlatformError>;
+
+ /// Retrieves the SubjectAlternativeName extension
+ ///
+ /// Currently, only the otherName choice is supported. This function
+ /// can be left unimplemented if the SubjectAlternativeName extension is
+ /// not needed in the DPE leaf cert or CSR.
+ fn get_subject_alternative_name(&mut self) -> Result<SubjectAltName, PlatformError>;
 }