ms-pkca 0.1.0-dev

PKINIT (RFC 4556) client — PA-PK-AS-REQ / PA-PK-AS-REP with X.509 cert + UnPAC-the-hash (pre-alpha)
Documentation
//! Minimal CMS SignedData (RFC 5652) construction for PKINIT PA-PK-AS-REQ.
//!
//! We hand-roll the structures using the `der` crate rather than pulling
//! `rasn-cms` — CMS is stable, tightly scoped for our need, and this keeps
//! the dep graph small.
//!
//! Only the fields PKINIT actually requires are populated:
//!   - digestAlgorithms = { SHA-256 }
//!   - encapContentInfo.eContentType = id-pkinit-authData (1.3.6.1.5.2.3.1)
//!   - certificates = [ signer_cert ]
//!   - one SignerInfo (version 1, IssuerAndSerial, sha256WithRSAEncryption)
//!   - signedAttrs = { contentType, messageDigest }
//!
//! Verification-side parsing is intentionally minimal — we only need to be able
//! to round-trip the emitted DER back into these structures for tests. The
//! server side of the exchange (the KDC) is what actually validates PKINIT
//! CMS.

use der::{
    asn1::{ContextSpecificRef, ObjectIdentifier, OctetString, SetOfVec},
    Any, Decode, Encode, Length, Sequence, Tag, TagMode, TagNumber, ValueOrd, Writer,
};
use x509_cert::{
    attr::{Attribute, AttributeValue},
    Certificate,
};

use crate::error::Result;
use crate::oid;

// ---------------------------------------------------------------------------
// AlgorithmIdentifier — we reuse x509_cert's spki::AlgorithmIdentifier via the
// `Any` parameter path (matches CMS's spec exactly).
pub use spki::AlgorithmIdentifierOwned;

// ---------------------------------------------------------------------------
// SignerIdentifier — we only emit IssuerAndSerialNumber form (CMS v1).
//
// `x509_cert::serial_number::SerialNumber` DER-encodes as an INTEGER with the
// same on-the-wire bytes CMS wants, and it already implements Encode + ValueOrd.
#[derive(Debug, Clone, Sequence, ValueOrd)]
pub struct IssuerAndSerialNumber {
    pub issuer: x509_cert::name::Name,
    pub serial_number: x509_cert::serial_number::SerialNumber,
}

// ---------------------------------------------------------------------------
// SignerInfo (RFC 5652 §5.3) — cut down to what we build.
//
//   SignerInfo ::= SEQUENCE {
//     version                    CMSVersion,
//     sid                        SignerIdentifier,
//     digestAlgorithm            DigestAlgorithmIdentifier,
//     signedAttrs           [0] IMPLICIT SignedAttributes OPTIONAL,
//     signatureAlgorithm         SignatureAlgorithmIdentifier,
//     signature                  SignatureValue,
//     unsignedAttrs         [1] IMPLICIT UnsignedAttributes OPTIONAL }
//
// We encode signedAttrs as an *explicit* SET wrapped in an IMPLICIT [0] tag —
// per RFC 5652 the on-the-wire form is `[0] IMPLICIT SET OF Attribute`.
#[derive(Debug, Clone)]
pub struct SignerInfo {
    pub version: u8,
    pub sid: IssuerAndSerialNumber,
    pub digest_algorithm: AlgorithmIdentifierOwned,
    pub signed_attrs: Option<Vec<Attribute>>,
    pub signature_algorithm: AlgorithmIdentifierOwned,
    pub signature: OctetString,
}

impl Encode for SignerInfo {
    fn encoded_len(&self) -> der::Result<Length> {
        let mut len = Length::ZERO;
        len = (len + self.version.encoded_len()?)?;
        len = (len + self.sid.encoded_len()?)?;
        len = (len + self.digest_algorithm.encoded_len()?)?;
        if let Some(attrs) = &self.signed_attrs {
            let set = attrs_as_set(attrs)?;
            let ctx = ContextSpecificRef::<SetOfVec<Attribute>> {
                tag_number: TagNumber::new(0),
                tag_mode: TagMode::Implicit,
                value: &set,
            };
            len = (len + ctx.encoded_len()?)?;
        }
        len = (len + self.signature_algorithm.encoded_len()?)?;
        len = (len + self.signature.encoded_len()?)?;
        // Header for the outer SEQUENCE.
        let header = der::Header::new(Tag::Sequence, len)?;
        Ok((header.encoded_len()? + len)?)
    }

    fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
        let body_len = inner_len(self)?;
        der::Header::new(Tag::Sequence, body_len)?.encode(writer)?;
        self.version.encode(writer)?;
        self.sid.encode(writer)?;
        self.digest_algorithm.encode(writer)?;
        if let Some(attrs) = &self.signed_attrs {
            let set = attrs_as_set(attrs)?;
            let ctx = ContextSpecificRef::<SetOfVec<Attribute>> {
                tag_number: TagNumber::new(0),
                tag_mode: TagMode::Implicit,
                value: &set,
            };
            ctx.encode(writer)?;
        }
        self.signature_algorithm.encode(writer)?;
        self.signature.encode(writer)?;
        Ok(())
    }
}

fn inner_len(si: &SignerInfo) -> der::Result<Length> {
    let mut len = Length::ZERO;
    len = (len + si.version.encoded_len()?)?;
    len = (len + si.sid.encoded_len()?)?;
    len = (len + si.digest_algorithm.encoded_len()?)?;
    if let Some(attrs) = &si.signed_attrs {
        let set = attrs_as_set(attrs)?;
        let ctx = ContextSpecificRef::<SetOfVec<Attribute>> {
            tag_number: TagNumber::new(0),
            tag_mode: TagMode::Implicit,
            value: &set,
        };
        len = (len + ctx.encoded_len()?)?;
    }
    len = (len + si.signature_algorithm.encoded_len()?)?;
    len = (len + si.signature.encoded_len()?)?;
    Ok(len)
}

fn attrs_as_set(attrs: &[Attribute]) -> der::Result<SetOfVec<Attribute>> {
    let mut set = SetOfVec::new();
    for a in attrs {
        set.insert(a.clone())?;
    }
    Ok(set)
}

// ---------------------------------------------------------------------------
// EncapsulatedContentInfo (RFC 5652 §5.2)
//
//   EncapsulatedContentInfo ::= SEQUENCE {
//     eContentType ContentType,
//     eContent     [0] EXPLICIT OCTET STRING OPTIONAL }
#[derive(Debug, Clone)]
pub struct EncapsulatedContentInfo {
    pub content_type: ObjectIdentifier,
    pub content: Option<OctetString>,
}

impl Encode for EncapsulatedContentInfo {
    fn encoded_len(&self) -> der::Result<Length> {
        let mut inner = self.content_type.encoded_len()?;
        if let Some(c) = &self.content {
            let ctx = ContextSpecificRef::<OctetString> {
                tag_number: TagNumber::new(0),
                tag_mode: TagMode::Explicit,
                value: c,
            };
            inner = (inner + ctx.encoded_len()?)?;
        }
        Ok((der::Header::new(Tag::Sequence, inner)?.encoded_len()? + inner)?)
    }
    fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
        let mut inner = self.content_type.encoded_len()?;
        if let Some(c) = &self.content {
            let ctx = ContextSpecificRef::<OctetString> {
                tag_number: TagNumber::new(0),
                tag_mode: TagMode::Explicit,
                value: c,
            };
            inner = (inner + ctx.encoded_len()?)?;
        }
        der::Header::new(Tag::Sequence, inner)?.encode(writer)?;
        self.content_type.encode(writer)?;
        if let Some(c) = &self.content {
            let ctx = ContextSpecificRef::<OctetString> {
                tag_number: TagNumber::new(0),
                tag_mode: TagMode::Explicit,
                value: c,
            };
            ctx.encode(writer)?;
        }
        Ok(())
    }
}

// ---------------------------------------------------------------------------
// SignedData (RFC 5652 §5.1) — cut-down builder-side view.
//
//   SignedData ::= SEQUENCE {
//     version           CMSVersion,          -- always 3 when we include certs & v1 signerInfo
//     digestAlgorithms  DigestAlgorithmIdentifiers,
//     encapContentInfo  EncapsulatedContentInfo,
//     certificates  [0] IMPLICIT CertificateSet OPTIONAL,
//     crls          [1] IMPLICIT RevocationInfoChoices OPTIONAL,
//     signerInfos       SignerInfos }
#[derive(Debug, Clone)]
pub struct SignedData {
    pub version: u8,
    pub digest_algorithms: Vec<AlgorithmIdentifierOwned>,
    pub encap_content_info: EncapsulatedContentInfo,
    pub certificates: Vec<Certificate>,
    pub signer_infos: Vec<SignerInfo>,
}

impl Encode for SignedData {
    fn encoded_len(&self) -> der::Result<Length> {
        let inner = signed_data_inner_len(self)?;
        Ok((der::Header::new(Tag::Sequence, inner)?.encoded_len()? + inner)?)
    }
    fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
        let inner = signed_data_inner_len(self)?;
        der::Header::new(Tag::Sequence, inner)?.encode(writer)?;
        self.version.encode(writer)?;

        // digestAlgorithms
        let mut da_set = SetOfVec::new();
        for a in &self.digest_algorithms {
            da_set.insert(a.clone())?;
        }
        da_set.encode(writer)?;

        self.encap_content_info.encode(writer)?;

        if !self.certificates.is_empty() {
            let set: SetOfVec<Certificate> = SetOfVec::try_from(self.certificates.clone())?;
            let ctx = ContextSpecificRef::<SetOfVec<Certificate>> {
                tag_number: TagNumber::new(0),
                tag_mode: TagMode::Implicit,
                value: &set,
            };
            ctx.encode(writer)?;
        }

        // signerInfos SET OF
        let mut si_set: Vec<u8> = Vec::new();
        // Encode SET OF SignerInfo by hand — SignerInfo doesn't implement
        // ValueOrd so it can't go in a SetOfVec. The PKINIT profile uses a
        // single signer, so ordering across multiple elements isn't observable
        // to us in practice.
        {
            let mut inner_len = Length::ZERO;
            for si in &self.signer_infos {
                inner_len = (inner_len + si.encoded_len()?)?;
            }
            let mut header_buf = Vec::new();
            der::Header::new(Tag::Set, inner_len)?.encode(&mut header_buf)?;
            si_set.extend_from_slice(&header_buf);
            for si in &self.signer_infos {
                let mut tmp = Vec::new();
                si.encode(&mut tmp)?;
                si_set.extend_from_slice(&tmp);
            }
        }
        writer.write(&si_set)?;

        Ok(())
    }
}

fn signed_data_inner_len(sd: &SignedData) -> der::Result<Length> {
    let mut len = Length::ZERO;
    len = (len + sd.version.encoded_len()?)?;

    let mut da_set = SetOfVec::new();
    for a in &sd.digest_algorithms {
        da_set.insert(a.clone())?;
    }
    len = (len + da_set.encoded_len()?)?;

    len = (len + sd.encap_content_info.encoded_len()?)?;

    if !sd.certificates.is_empty() {
        let set: SetOfVec<Certificate> = SetOfVec::try_from(sd.certificates.clone())?;
        let ctx = ContextSpecificRef::<SetOfVec<Certificate>> {
            tag_number: TagNumber::new(0),
            tag_mode: TagMode::Implicit,
            value: &set,
        };
        len = (len + ctx.encoded_len()?)?;
    }

    // signerInfos SET OF wrapper
    let mut si_inner = Length::ZERO;
    for si in &sd.signer_infos {
        si_inner = (si_inner + si.encoded_len()?)?;
    }
    let header = der::Header::new(Tag::Set, si_inner)?;
    len = (len + header.encoded_len()? + si_inner)?;

    Ok(len)
}

// ---------------------------------------------------------------------------
// ContentInfo (RFC 5652 §3) — outer wrapper.
//
//   ContentInfo ::= SEQUENCE {
//     contentType ContentType,
//     content     [0] EXPLICIT ANY DEFINED BY contentType }
#[derive(Debug, Clone)]
pub struct ContentInfo {
    pub content_type: ObjectIdentifier,
    /// DER-encoded inner content (e.g. the encoded SignedData).
    pub content: Vec<u8>,
}

impl Encode for ContentInfo {
    fn encoded_len(&self) -> der::Result<Length> {
        let inner = content_info_inner_len(self)?;
        Ok((der::Header::new(Tag::Sequence, inner)?.encoded_len()? + inner)?)
    }
    fn encode(&self, writer: &mut impl Writer) -> der::Result<()> {
        let inner = content_info_inner_len(self)?;
        der::Header::new(Tag::Sequence, inner)?.encode(writer)?;
        self.content_type.encode(writer)?;
        // [0] EXPLICIT wrapping around raw DER
        let body_len = Length::try_from(self.content.len())?;
        let ctx_header = der::Header::new(
            Tag::ContextSpecific {
                constructed: true,
                number: TagNumber::new(0),
            },
            body_len,
        )?;
        ctx_header.encode(writer)?;
        writer.write(&self.content)?;
        Ok(())
    }
}

fn content_info_inner_len(ci: &ContentInfo) -> der::Result<Length> {
    let mut len = ci.content_type.encoded_len()?;
    let body_len = Length::try_from(ci.content.len())?;
    let ctx_header = der::Header::new(
        Tag::ContextSpecific {
            constructed: true,
            number: TagNumber::new(0),
        },
        body_len,
    )?;
    len = (len + ctx_header.encoded_len()? + body_len)?;
    Ok(len)
}

// ---------------------------------------------------------------------------
// Convenience — build the standard `sha256WithRSAEncryption` /
// `id-sha256` algorithm identifiers.
pub fn alg_sha256() -> AlgorithmIdentifierOwned {
    AlgorithmIdentifierOwned {
        oid: oid::SHA256,
        parameters: None,
    }
}

pub fn alg_sha256_with_rsa() -> AlgorithmIdentifierOwned {
    AlgorithmIdentifierOwned {
        oid: oid::SHA256_WITH_RSA,
        parameters: None,
    }
}

// ---------------------------------------------------------------------------
// Build a minimal Attribute (contentType or messageDigest).
pub fn attr_content_type(oid_val: ObjectIdentifier) -> Result<Attribute> {
    use der::asn1::SetOfVec;
    let any = Any::from_der(&oid_val.to_der()?)?;
    let mut values: SetOfVec<AttributeValue> = SetOfVec::new();
    values.insert(any)?;
    Ok(Attribute {
        oid: oid::CMS_ATTR_CONTENT_TYPE,
        values,
    })
}

pub fn attr_message_digest(digest: &[u8]) -> Result<Attribute> {
    use der::asn1::SetOfVec;
    let os = OctetString::new(digest.to_vec())?;
    let any = Any::from_der(&os.to_der()?)?;
    let mut values: SetOfVec<AttributeValue> = SetOfVec::new();
    values.insert(any)?;
    Ok(Attribute {
        oid: oid::CMS_ATTR_MESSAGE_DIGEST,
        values,
    })
}