use crate::der;
use crate::error::{Error, Result};
use crate::oids;
use rsa::pkcs1::DecodeRsaPrivateKey;
use rsa::pkcs1v15::SigningKey;
use rsa::pkcs8::DecodePrivateKey;
use rsa::signature::{SignatureEncoding, Signer};
use rsa::traits::PublicKeyParts;
use rsa::RsaPrivateKey;
use sha2::Sha256;
pub fn parse_rsa_private_key_pem(pem: &[u8]) -> Result<RsaPrivateKey> {
let s = core::str::from_utf8(pem).map_err(|e| Error::Key(format!("pem utf-8: {e}")))?;
if s.contains("BEGIN PRIVATE KEY") {
return RsaPrivateKey::from_pkcs8_pem(s).map_err(|e| Error::Key(format!("pkcs8: {e}")));
}
if s.contains("BEGIN RSA PRIVATE KEY") {
return RsaPrivateKey::from_pkcs1_pem(s).map_err(|e| Error::Key(format!("pkcs1: {e}")));
}
Err(Error::Key(
"no recognized RSA private key PEM header".into(),
))
}
fn subject_cn(cn: &str) -> Result<Vec<u8>> {
let atv = der::sequence(&[der::oid(oids::AT_COMMON_NAME)?, der::utf8_string(cn)].concat());
let rdn = der::set(&atv);
Ok(der::sequence(&rdn))
}
fn subject_public_key_info(key: &RsaPrivateKey) -> Result<Vec<u8>> {
let algo = der::sequence(&[der::oid(oids::RSA_ENCRYPTION)?, der::null()].concat());
let n = key.n().to_bytes_be();
let e = key.e().to_bytes_be();
let rsa_pubkey =
der::sequence(&[der::integer_be_unsigned(&n), der::integer_be_unsigned(&e)].concat());
let spk_bitstring = der::bit_string_no_unused(&rsa_pubkey);
Ok(der::sequence(&[algo, spk_bitstring].concat()))
}
fn subject_alt_name_upn_ext(upn: &str) -> Result<Vec<u8>> {
let type_id = der::oid(oids::MS_USER_PRINCIPAL_NAME)?;
let value = der::explicit_context(0, &der::utf8_string(upn));
let other_name_inner = [type_id, value].concat();
let general_name = der::implicit_context(0, &other_name_inner);
let san_seq = der::sequence(&general_name);
let ext_value = der::octet_string(&san_seq);
Ok(der::sequence(
&[der::oid(oids::CE_SUBJECT_ALT_NAME)?, ext_value].concat(),
))
}
fn extension_request_attribute(extensions: &[Vec<u8>]) -> Result<Vec<u8>> {
let ext_seq_body: Vec<u8> = extensions.iter().flatten().copied().collect();
let ext_seq = der::sequence(&ext_seq_body);
let set_val = der::set(&ext_seq);
Ok(der::sequence(
&[der::oid(oids::PKCS9_EXTENSION_REQUEST)?, set_val].concat(),
))
}
pub fn build_csr_with_upn_san(subject: &str, upn: &str, key_pem: &[u8]) -> Result<Vec<u8>> {
build_csr_esc(subject, upn, &[], key_pem, EkuCarrier::None)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EkuCarrier {
None,
StandardEku,
ApplicationPolicies,
}
pub fn build_csr_with_upn_san_and_ekus(
subject: &str,
upn: &str,
ekus: &[&str],
key_pem: &[u8],
carrier: EkuCarrier,
) -> Result<Vec<u8>> {
build_csr_esc(subject, upn, ekus, key_pem, carrier)
}
fn build_csr_esc(
subject: &str,
upn: &str,
ekus: &[&str],
key_pem: &[u8],
carrier: EkuCarrier,
) -> Result<Vec<u8>> {
if subject.is_empty() {
return Err(Error::Invalid("subject must not be empty".into()));
}
if !upn.contains('@') {
return Err(Error::Invalid("upn must be user@realm".into()));
}
if carrier == EkuCarrier::None && !ekus.is_empty() {
return Err(Error::Invalid(
"ekus supplied with EkuCarrier::None — pick StandardEku or ApplicationPolicies".into(),
));
}
if carrier != EkuCarrier::None && ekus.is_empty() {
return Err(Error::Invalid(
"EkuCarrier requested but ekus list is empty".into(),
));
}
let key = parse_rsa_private_key_pem(key_pem)?;
let version = der::integer_small(0);
let subject_seq = subject_cn(subject)?;
let spki = subject_public_key_info(&key)?;
let mut exts: Vec<Vec<u8>> = vec![subject_alt_name_upn_ext(upn)?];
match carrier {
EkuCarrier::None => {}
EkuCarrier::StandardEku => exts.push(standard_eku_ext(ekus)?),
EkuCarrier::ApplicationPolicies => exts.push(application_policies_ext(ekus)?),
}
let attr = extension_request_attribute(&exts)?;
let attributes = der::implicit_context(0, &attr);
let cri_body: Vec<u8> = [version, subject_seq, spki, attributes].concat();
let cri = der::sequence(&cri_body);
let signing_key = SigningKey::<Sha256>::new(key);
let sig = signing_key
.try_sign(&cri)
.map_err(|e| Error::Sign(format!("{e}")))?;
let sig_bytes = sig.to_bytes();
let sig_algo = der::sequence(&[der::oid(oids::SHA256_WITH_RSA)?, der::null()].concat());
let sig_bitstring = der::bit_string_no_unused(&sig_bytes);
let csr = der::sequence(&[cri, sig_algo, sig_bitstring].concat());
Ok(csr)
}
fn standard_eku_ext(ekus: &[&str]) -> Result<Vec<u8>> {
let mut body: Vec<u8> = Vec::new();
for k in ekus {
body.extend_from_slice(&der::oid(k)?);
}
let seq = der::sequence(&body);
let ext_value = der::octet_string(&seq);
Ok(der::sequence(
&[der::oid(oids::CE_EXT_KEY_USAGE)?, ext_value].concat(),
))
}
fn application_policies_ext(ekus: &[&str]) -> Result<Vec<u8>> {
let mut policies: Vec<u8> = Vec::new();
for k in ekus {
let policy_info = der::sequence(&der::oid(k)?);
policies.extend_from_slice(&policy_info);
}
let outer = der::sequence(&policies);
let ext_value = der::octet_string(&outer);
Ok(der::sequence(
&[der::oid(oids::MS_APPLICATION_POLICIES)?, ext_value].concat(),
))
}