use crate::cpe_error::{CpeError, CpeResult};
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64;
use rsa::RsaPrivateKey;
use rsa::pkcs1::DecodeRsaPrivateKey;
use rsa::pkcs1v15::SigningKey;
use rsa::pkcs8::DecodePrivateKey;
use rsa::signature::{SignatureEncoding, SignerMut};
use sha2::{Digest, Sha256};
use std::fmt::Write;
pub trait CpeFirmador {
fn cpe_firmar_xml(&self, xml_sin_firmar: &str) -> CpeResult<String>;
}
#[derive(Clone)]
pub struct CpeCertificadoDigital {
pub clave_privada: RsaPrivateKey,
pub certificado_x509_base64: String,
}
impl CpeCertificadoDigital {
#[must_use]
pub fn nuevo(clave_privada: RsaPrivateKey, certificado_x509_base64: String) -> Self {
Self {
clave_privada,
certificado_x509_base64: certificado_x509_base64.replace(['\r', '\n', ' '], ""),
}
}
pub fn desde_pkcs12(bytes_p12: &[u8], password: &str) -> CpeResult<Self> {
let pfx = p12::PFX::parse(bytes_p12).map_err(|e| {
CpeError::ErrorFirmaDigital(format!(
"Error al parsear archivo PKCS#12 (.p12/.pfx): {e:?}"
))
})?;
let key_bags = pfx.key_bags(password).map_err(|e| {
CpeError::ErrorFirmaDigital(format!(
"Error al desencriptar clave privada PKCS#12: {e:?}"
))
})?;
let key_der = key_bags.into_iter().next().ok_or_else(|| {
CpeError::ErrorFirmaDigital(
"No se encontró clave privada en el archivo PKCS#12".to_string(),
)
})?;
let clave_privada = RsaPrivateKey::from_pkcs8_der(&key_der)
.or_else(|_| RsaPrivateKey::from_pkcs1_der(&key_der))
.map_err(|e| {
CpeError::ErrorFirmaDigital(format!(
"Error al decodificar clave privada RSA desde PKCS#12: {e}"
))
})?;
let cert_bags = pfx.cert_x509_bags(password).map_err(|e| {
CpeError::ErrorFirmaDigital(format!(
"Error al desencriptar certificado X.509 PKCS#12: {e:?}"
))
})?;
let cert_der = cert_bags.into_iter().next().ok_or_else(|| {
CpeError::ErrorFirmaDigital(
"No se encontró certificado X.509 en el archivo PKCS#12".to_string(),
)
})?;
let certificado_x509_base64 = BASE64.encode(&cert_der);
Ok(Self::nuevo(clave_privada, certificado_x509_base64))
}
}
pub fn cpe_extraer_hash_resumen(xml_firmado: &str) -> CpeResult<String> {
if let Some(pos_inicio) = xml_firmado.find("DigestValue>") {
let inicio = pos_inicio + "DigestValue>".len();
if let Some(pos_fin) = xml_firmado[inicio..].find("</") {
let hash = xml_firmado[inicio..inicio + pos_fin].trim();
if !hash.is_empty() {
return Ok(hash.to_string());
}
}
}
Err(CpeError::ErrorFirmaDigital(
"No se encontró el elemento <ds:DigestValue> en el XML firmado".to_string(),
))
}
impl CpeFirmador for CpeCertificadoDigital {
fn cpe_firmar_xml(&self, xml_sin_firmar: &str) -> CpeResult<String> {
let mut hasher = Sha256::new();
hasher.update(xml_sin_firmar.as_bytes());
let digest_bytes = hasher.finalize();
let digest_base64 = BASE64.encode(digest_bytes);
let mut signed_info = String::with_capacity(1024);
signed_info.push_str("<SignedInfo xmlns=\"http://www.w3.org/2000/09/xmldsig#\">\n");
signed_info.push_str(" <CanonicalizationMethod Algorithm=\"http://www.w3.org/TR/2001/REC-xml-c14n-20010315\"/>\n");
signed_info.push_str(" <SignatureMethod Algorithm=\"http://www.w3.org/2001/04/xmldsig-more#rsa-sha256\"/>\n");
signed_info.push_str(" <Reference URI=\"\">\n");
signed_info.push_str(" <Transforms>\n");
signed_info.push_str(" <Transform Algorithm=\"http://www.w3.org/2000/09/xmldsig#enveloped-signature\"/>\n");
signed_info.push_str(" </Transforms>\n");
signed_info.push_str(
" <DigestMethod Algorithm=\"http://www.w3.org/2001/04/xmlenc#sha256\"/>\n",
);
let _ = writeln!(
&mut signed_info,
" <DigestValue>{}</DigestValue>",
digest_base64
);
signed_info.push_str(" </Reference>\n");
signed_info.push_str("</SignedInfo>");
let mut signing_key = SigningKey::<Sha256>::new(self.clave_privada.clone());
let firma = signing_key.sign(signed_info.as_bytes());
let firma_base64 = BASE64.encode(firma.to_vec());
let mut signature_xml = String::with_capacity(2048);
signature_xml.push_str(
"<ds:Signature xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#\" Id=\"SignSUNAT\">\n",
);
let _ = writeln!(&mut signature_xml, " {}", signed_info);
let _ = writeln!(
&mut signature_xml,
" <ds:SignatureValue>{}</ds:SignatureValue>",
firma_base64
);
signature_xml.push_str(" <ds:KeyInfo>\n");
signature_xml.push_str(" <ds:X509Data>\n");
let _ = writeln!(
&mut signature_xml,
" <ds:X509Certificate>{}</ds:X509Certificate>",
self.certificado_x509_base64
);
signature_xml.push_str(" </ds:X509Data>\n");
signature_xml.push_str(" </ds:KeyInfo>\n");
signature_xml.push_str("</ds:Signature>");
if !xml_sin_firmar.contains("<ext:ExtensionContent/>") {
return Err(CpeError::ErrorFirmaDigital(
"No se encontró el elemento <ext:ExtensionContent/> en el XML UBL para inyectar la firma".to_string(),
));
}
let xml_firmado = xml_sin_firmar.replacen(
"<ext:ExtensionContent/>",
&format!(
"<ext:ExtensionContent>\n{}\n </ext:ExtensionContent>",
signature_xml
),
1,
);
Ok(xml_firmado)
}
}