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
//! PKINIT PA-PK-AS-REQ / PA-PK-AS-REP structure builders (RFC 4556 §3.2).
//!
//! **STATUS 0.1.0-dev** — structural encode only.  A real PA-PK-AS-REQ that a
//! KDC will accept requires:
//!   * an actual RSA signature over the DER of AuthPack using the client key
//!     (this crate produces the digest & signs, but does not yet form the
//!     kerberos AS-REQ body it must checksum first — that hookup belongs to
//!     the enclosing Kerberos stack)
//!   * time skew ≤ 5 min against the KDC
//!   * a KRB5PrincipalName SAN or MS-UPN SAN on the client certificate
//!     matching the Kerberos identity requested.
//!
//! These pieces are noted in the code as `TODO(0.2)` — no `todo!()` panics.

use der::{
    asn1::{BitString, GeneralizedTime, OctetString, SetOfVec},
    Any, Decode, Encode, Sequence,
};
use rsa::{
    signature::{SignatureEncoding, Signer},
    RsaPrivateKey,
};
use sha2::{Digest, Sha256};
use spki::AlgorithmIdentifierOwned;
use x509_cert::Certificate;

use crate::cms::{
    alg_sha256, alg_sha256_with_rsa, attr_content_type, attr_message_digest, ContentInfo,
    EncapsulatedContentInfo, IssuerAndSerialNumber, SignedData, SignerInfo,
};
use crate::dh::{DhGroup, DhKeyPair};
use crate::error::{Error, Result};
use crate::oid;

/// AuthPack (RFC 4556 §3.2.1) — payload signed by the client inside the CMS
/// SignedData.  We emit only the DH branch (which is the only branch the
/// modern Windows KDC accepts by default).
///
///   AuthPack ::= SEQUENCE {
///     pkAuthenticator       [0] PKAuthenticator,
///     clientPublicValue     [1] SubjectPublicKeyInfo OPTIONAL,
///     supportedCMSTypes     [2] SEQUENCE OF AlgorithmIdentifier OPTIONAL,
///     clientDHNonce         [3] DHNonce OPTIONAL }
#[derive(Debug, Clone)]
pub struct AuthPack {
    pub pk_authenticator: PkAuthenticator,
    pub client_public_value: Option<spki::SubjectPublicKeyInfoOwned>,
    pub client_dh_nonce: Option<Vec<u8>>,
}

/// PKAuthenticator (RFC 4556 §3.2.1)
///
///   PKAuthenticator ::= SEQUENCE {
///     cusec                   [0] INTEGER (0..999999),
///     ctime                   [1] KerberosTime,
///     nonce                   [2] INTEGER (0..4294967295),
///     paChecksum              [3] OCTET STRING OPTIONAL }
#[derive(Debug, Clone)]
pub struct PkAuthenticator {
    pub cusec: i32,
    pub ctime: GeneralizedTime,
    pub nonce: u32,
    /// SHA-1 checksum over the AS-REQ body — caller supplies (Kerberos-stack concern).
    pub pa_checksum: Option<Vec<u8>>,
}

// Encoding for AuthPack / PkAuthenticator — kept explicit to preserve tag
// semantics.  Using `der` primitives directly rather than `#[derive(Sequence)]`
// so we can emit context-specific tags with the correct EXPLICIT wrapping.

impl Encode for PkAuthenticator {
    fn encoded_len(&self) -> der::Result<der::Length> {
        let mut len = der::Length::ZERO;
        len = (len + explicit_len(0, self.cusec.encoded_len()?)?)?;
        len = (len + explicit_len(1, self.ctime.encoded_len()?)?)?;
        len = (len + explicit_len(2, self.nonce.encoded_len()?)?)?;
        if let Some(cs) = &self.pa_checksum {
            let os = OctetString::new(cs.clone())?;
            len = (len + explicit_len(3, os.encoded_len()?)?)?;
        }
        Ok((der::Header::new(der::Tag::Sequence, len)?.encoded_len()? + len)?)
    }
    fn encode(&self, writer: &mut impl der::Writer) -> der::Result<()> {
        let body_len = pkauth_inner_len(self)?;
        der::Header::new(der::Tag::Sequence, body_len)?.encode(writer)?;
        emit_explicit(writer, 0, &self.cusec)?;
        emit_explicit(writer, 1, &self.ctime)?;
        emit_explicit(writer, 2, &self.nonce)?;
        if let Some(cs) = &self.pa_checksum {
            let os = OctetString::new(cs.clone())?;
            emit_explicit(writer, 3, &os)?;
        }
        Ok(())
    }
}

fn pkauth_inner_len(pk: &PkAuthenticator) -> der::Result<der::Length> {
    let mut len = der::Length::ZERO;
    len = (len + explicit_len(0, pk.cusec.encoded_len()?)?)?;
    len = (len + explicit_len(1, pk.ctime.encoded_len()?)?)?;
    len = (len + explicit_len(2, pk.nonce.encoded_len()?)?)?;
    if let Some(cs) = &pk.pa_checksum {
        let os = OctetString::new(cs.clone())?;
        len = (len + explicit_len(3, os.encoded_len()?)?)?;
    }
    Ok(len)
}

impl Encode for AuthPack {
    fn encoded_len(&self) -> der::Result<der::Length> {
        let mut len = der::Length::ZERO;
        len = (len + explicit_len(0, self.pk_authenticator.encoded_len()?)?)?;
        if let Some(spki) = &self.client_public_value {
            len = (len + explicit_len(1, spki.encoded_len()?)?)?;
        }
        if let Some(n) = &self.client_dh_nonce {
            let os = OctetString::new(n.clone())?;
            len = (len + explicit_len(3, os.encoded_len()?)?)?;
        }
        Ok((der::Header::new(der::Tag::Sequence, len)?.encoded_len()? + len)?)
    }
    fn encode(&self, writer: &mut impl der::Writer) -> der::Result<()> {
        let body_len = authpack_inner_len(self)?;
        der::Header::new(der::Tag::Sequence, body_len)?.encode(writer)?;
        emit_explicit(writer, 0, &self.pk_authenticator)?;
        if let Some(spki) = &self.client_public_value {
            emit_explicit(writer, 1, spki)?;
        }
        if let Some(n) = &self.client_dh_nonce {
            let os = OctetString::new(n.clone())?;
            emit_explicit(writer, 3, &os)?;
        }
        Ok(())
    }
}

fn authpack_inner_len(ap: &AuthPack) -> der::Result<der::Length> {
    let mut len = der::Length::ZERO;
    len = (len + explicit_len(0, ap.pk_authenticator.encoded_len()?)?)?;
    if let Some(spki) = &ap.client_public_value {
        len = (len + explicit_len(1, spki.encoded_len()?)?)?;
    }
    if let Some(n) = &ap.client_dh_nonce {
        let os = OctetString::new(n.clone())?;
        len = (len + explicit_len(3, os.encoded_len()?)?)?;
    }
    Ok(len)
}

fn explicit_len(tag_no: u8, inner: der::Length) -> der::Result<der::Length> {
    let header = der::Header::new(
        der::Tag::ContextSpecific {
            constructed: true,
            number: der::TagNumber::new(tag_no),
        },
        inner,
    )?;
    Ok((header.encoded_len()? + inner)?)
}

fn emit_explicit<T: Encode>(writer: &mut impl der::Writer, tag_no: u8, v: &T) -> der::Result<()> {
    let inner = v.encoded_len()?;
    der::Header::new(
        der::Tag::ContextSpecific {
            constructed: true,
            number: der::TagNumber::new(tag_no),
        },
        inner,
    )?
    .encode(writer)?;
    v.encode(writer)?;
    Ok(())
}

/// PA-PK-AS-REQ (RFC 4556 §3.2.1) — the outer PA-DATA value.
///
///   PA-PK-AS-REQ ::= SEQUENCE {
///     signedAuthPack          [0] IMPLICIT OCTET STRING,
///                                  -- CMS ContentInfo (SignedData)
///     trustedCertifiers       [1] SEQUENCE OF ExternalPrincipalIdentifier OPTIONAL,
///     kdcPkId                 [2] IMPLICIT OCTET STRING OPTIONAL }
///
/// We emit only `signedAuthPack`.
pub struct PaPkAsReq {
    /// Raw DER of CMS ContentInfo carrying the SignedData over AuthPack.
    pub signed_auth_pack: Vec<u8>,
}

impl Encode for PaPkAsReq {
    fn encoded_len(&self) -> der::Result<der::Length> {
        let body_len = der::Length::try_from(self.signed_auth_pack.len())?;
        let inner_header = der::Header::new(
            der::Tag::ContextSpecific {
                constructed: false,
                number: der::TagNumber::new(0),
            },
            body_len,
        )?;
        let inner = (inner_header.encoded_len()? + body_len)?;
        Ok((der::Header::new(der::Tag::Sequence, inner)?.encoded_len()? + inner)?)
    }
    fn encode(&self, writer: &mut impl der::Writer) -> der::Result<()> {
        let body_len = der::Length::try_from(self.signed_auth_pack.len())?;
        let inner_header = der::Header::new(
            der::Tag::ContextSpecific {
                constructed: false,
                number: der::TagNumber::new(0),
            },
            body_len,
        )?;
        let inner = (inner_header.encoded_len()? + body_len)?;
        der::Header::new(der::Tag::Sequence, inner)?.encode(writer)?;
        inner_header.encode(writer)?;
        writer.write(&self.signed_auth_pack)?;
        Ok(())
    }
}

// ---------------------------------------------------------------------------
// Builder — construct PA-PK-AS-REQ DER from a client cert + private key.

pub struct BuildOptions<'a> {
    pub client_cert: &'a Certificate,
    pub client_key: &'a RsaPrivateKey,
    pub dh_group: DhGroup,
    /// AS-REQ body checksum (SHA-1) — caller supplies from the Kerberos stack.
    /// If `None`, `paChecksum` is omitted; most modern KDCs REJECT this.
    pub as_req_body_checksum: Option<Vec<u8>>,
    /// Kerberos time. Caller-provided so tests can be deterministic.
    pub ctime: GeneralizedTime,
    pub cusec: i32,
    pub nonce: u32,
}

/// Build a PA-PK-AS-REQ (DER).
///
/// Returns the fully-encoded PA-PK-AS-REQ SEQUENCE and the freshly generated
/// [`DhKeyPair`] so the caller can complete the shared-secret derivation once
/// the AS-REP comes back.
pub fn build_pa_pk_as_req(opts: &BuildOptions<'_>) -> Result<(Vec<u8>, DhKeyPair)> {
    // 1. Generate ephemeral DH keypair
    let dh = DhKeyPair::generate(opts.dh_group);

    // 2. Wrap public value in SPKI with dhpublicnumber OID + DomainParameters.
    //    RFC 4556 §3.2.1: clientPublicValue is a SubjectPublicKeyInfo whose
    //    subjectPublicKey encodes the DH y-value as an INTEGER inside the bit
    //    string.
    let y_int = der::asn1::Int::new(&dh.y.to_bytes_be())?;
    let y_bits = BitString::from_bytes(&y_int.to_der()?)?;

    // DomainParameters ::= SEQUENCE { p INTEGER, g INTEGER, q INTEGER OPTIONAL }
    let p_int = der::asn1::Int::new(&opts.dh_group.modulus().to_bytes_be())?;
    let g_int = der::asn1::Int::new(&opts.dh_group.generator().to_bytes_be())?;
    let dp = DomainParameters { p: p_int, g: g_int };
    let dp_der = dp.to_der()?;
    let params_any = Any::from_der(&dp_der)?;
    let spki_val = spki::SubjectPublicKeyInfoOwned {
        algorithm: AlgorithmIdentifierOwned {
            oid: oid::DH_PUBLIC_NUMBER,
            parameters: Some(params_any),
        },
        subject_public_key: y_bits,
    };

    // 3. Build AuthPack
    let auth_pack = AuthPack {
        pk_authenticator: PkAuthenticator {
            cusec: opts.cusec,
            ctime: opts.ctime,
            nonce: opts.nonce,
            pa_checksum: opts.as_req_body_checksum.clone(),
        },
        client_public_value: Some(spki_val),
        client_dh_nonce: None,
    };
    let auth_pack_der = auth_pack.to_der()?;

    // 4. Build CMS SignedData over AuthPack with id-pkinit-authData eContentType.
    let digest = Sha256::digest(&auth_pack_der).to_vec();

    // Signed attributes: contentType + messageDigest
    let attr_ct = attr_content_type(oid::PKINIT_AUTH_DATA)?;
    let attr_md = attr_message_digest(&digest)?;
    let signed_attrs = vec![attr_ct, attr_md];

    // The bytes that get signed = DER of a SET-OF-Attribute (RFC 5652 §5.4).
    let mut set_of_attrs: SetOfVec<x509_cert::attr::Attribute> = SetOfVec::new();
    for a in &signed_attrs {
        set_of_attrs.insert(a.clone())?;
    }
    let attrs_der = set_of_attrs.to_der()?;

    // 5. Sign attrs_der with PKCS#1 v1.5 RSA-SHA256.
    let signing_key = rsa::pkcs1v15::SigningKey::<Sha256>::new(opts.client_key.clone());
    let sig = signing_key
        .try_sign(&attrs_der)
        .map_err(|e| Error::Rsa(e.to_string()))?;
    let sig_bytes = sig.to_bytes().to_vec();

    // 6. SignerInfo
    let issuer_and_serial = IssuerAndSerialNumber {
        issuer: opts.client_cert.tbs_certificate.issuer.clone(),
        serial_number: opts.client_cert.tbs_certificate.serial_number.clone(),
    };
    let signer_info = SignerInfo {
        version: 1,
        sid: issuer_and_serial,
        digest_algorithm: alg_sha256(),
        signed_attrs: Some(signed_attrs),
        signature_algorithm: alg_sha256_with_rsa(),
        signature: OctetString::new(sig_bytes)?,
    };

    // 7. SignedData
    let signed_data = SignedData {
        version: 3,
        digest_algorithms: vec![alg_sha256()],
        encap_content_info: EncapsulatedContentInfo {
            content_type: oid::PKINIT_AUTH_DATA,
            content: Some(OctetString::new(auth_pack_der)?),
        },
        certificates: vec![opts.client_cert.clone()],
        signer_infos: vec![signer_info],
    };
    let signed_data_der = signed_data.to_der()?;

    // 8. Wrap in ContentInfo
    let content_info = ContentInfo {
        content_type: oid::CMS_SIGNED_DATA,
        content: signed_data_der,
    };
    let content_info_der = content_info.to_der()?;

    // 9. Wrap in PA-PK-AS-REQ
    let req = PaPkAsReq {
        signed_auth_pack: content_info_der,
    };
    Ok((req.to_der()?, dh))
}

// DomainParameters ::= SEQUENCE { p INTEGER, g INTEGER, q INTEGER OPTIONAL }
#[derive(Sequence)]
struct DomainParameters {
    p: der::asn1::Int,
    g: der::asn1::Int,
}