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;
#[derive(Debug, Clone)]
pub struct AuthPack {
pub pk_authenticator: PkAuthenticator,
pub client_public_value: Option<spki::SubjectPublicKeyInfoOwned>,
pub client_dh_nonce: Option<Vec<u8>>,
}
#[derive(Debug, Clone)]
pub struct PkAuthenticator {
pub cusec: i32,
pub ctime: GeneralizedTime,
pub nonce: u32,
pub pa_checksum: Option<Vec<u8>>,
}
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(())
}
pub struct PaPkAsReq {
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(())
}
}
pub struct BuildOptions<'a> {
pub client_cert: &'a Certificate,
pub client_key: &'a RsaPrivateKey,
pub dh_group: DhGroup,
pub as_req_body_checksum: Option<Vec<u8>>,
pub ctime: GeneralizedTime,
pub cusec: i32,
pub nonce: u32,
}
pub fn build_pa_pk_as_req(opts: &BuildOptions<'_>) -> Result<(Vec<u8>, DhKeyPair)> {
let dh = DhKeyPair::generate(opts.dh_group);
let y_int = der::asn1::Int::new(&dh.y.to_bytes_be())?;
let y_bits = BitString::from_bytes(&y_int.to_der()?)?;
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,
};
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()?;
let digest = Sha256::digest(&auth_pack_der).to_vec();
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];
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()?;
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();
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)?,
};
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()?;
let content_info = ContentInfo {
content_type: oid::CMS_SIGNED_DATA,
content: signed_data_der,
};
let content_info_der = content_info.to_der()?;
let req = PaPkAsReq {
signed_auth_pack: content_info_der,
};
Ok((req.to_der()?, dh))
}
#[derive(Sequence)]
struct DomainParameters {
p: der::asn1::Int,
g: der::asn1::Int,
}