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>> {
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()));
}
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 san_ext = subject_alt_name_upn_ext(upn)?;
let attr = extension_request_attribute(&[san_ext])?;
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)
}