Add X509CertificateBuilder to bssl-x509 Add X509CertificateBuilder to construct and sign self-signed X.509v3 certificates with SHA-256 using an existing PrivateKey. Bug: 549745797 Change-Id: I823eb8b1e5fcd03412cb4b900cc88773d8eaa48d Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/103249 Commit-Queue: Xiangfei Ding <xfding@google.com> Reviewed-by: Xiangfei Ding <xfding@google.com>
diff --git a/rust/bssl-x509/Cargo.toml b/rust/bssl-x509/Cargo.toml index 2e2cb9a..06e8a80 100644 --- a/rust/bssl-x509/Cargo.toml +++ b/rust/bssl-x509/Cargo.toml
@@ -20,3 +20,5 @@ # `std` depends on the Rust `std` crate, but adds some useful trait impls if # available. std = ["bssl-crypto/std"] +# `experimental` enables experimental APIs that may change without notice. +experimental = []
diff --git a/rust/bssl-x509/src/certificates.rs b/rust/bssl-x509/src/certificates.rs index 7156d8a..6ad3509 100644 --- a/rust/bssl-x509/src/certificates.rs +++ b/rust/bssl-x509/src/certificates.rs
@@ -74,6 +74,8 @@ use bssl_crypto::FromFfiSlice; +#[cfg(feature = "experimental")] +use crate::check_lib_error; use crate::{ errors::{ PemReason, @@ -421,6 +423,136 @@ } } +/// An X.509v3 certificate builder. +#[cfg(feature = "experimental")] +pub struct X509CertificateBuilder(NonNull<bssl_sys::X509>); + +// Safety: `X509` is ref-counted and `X509CertificateBuilder` always requires exclusive access. +#[cfg(feature = "experimental")] +unsafe impl Send for X509CertificateBuilder {} + +#[cfg(feature = "experimental")] +impl Drop for X509CertificateBuilder { + fn drop(&mut self) { + unsafe { + // Safety: `self.0` is a valid, uniquely owned `X509` handle. + bssl_sys::X509_free(self.0.as_ptr()); + } + } +} + +#[cfg(feature = "experimental")] +impl X509CertificateBuilder { + /// Construct a new X.509v3 certificate builder. + pub fn new() -> Self { + let x509 = unsafe { + // Safety: `X509_new` has no preconditions and returns either null or a newly + // allocated `X509`. + bssl_sys::X509_new() + }; + let Some(x509) = NonNull::new(x509) else { + panic!("allocation error"); + }; + let builder = Self(x509); + let rc = unsafe { + // Safety: `builder.ptr()` is a valid `X509` handle. + bssl_sys::X509_set_version(builder.ptr(), bssl_sys::X509_VERSION_3 as _) + }; + debug_assert!(rc == 1, "we must support X509v3"); + builder + } + + pub(crate) fn ptr(&self) -> *mut bssl_sys::X509 { + self.0.as_ptr() + } + + /// Set the certificate serial number. + pub fn with_serial_number(&mut self, serial: u64) -> Result<&mut Self, PkiError> { + check_lib_error!(unsafe { + // Safety: `self.ptr()` is a valid `X509` handle. + bssl_sys::ASN1_INTEGER_set_uint64(bssl_sys::X509_get_serialNumber(self.ptr()), serial) + }); + Ok(self) + } + + /// Set the `notBefore` validity time as a POSIX timestamp. + pub fn with_not_before(&mut self, posix_time: i64) -> Result<&mut Self, PkiError> { + let res = unsafe { + // Safety: `self.ptr()` is a valid `X509` handle. + bssl_sys::ASN1_TIME_set_posix(bssl_sys::X509_getm_notBefore(self.ptr()), posix_time) + }; + if res.is_null() { + return Err(PkiError::extract_lib_err()); + } + Ok(self) + } + + /// Set the `notAfter` validity time as a POSIX timestamp. + pub fn with_not_after(&mut self, posix_time: i64) -> Result<&mut Self, PkiError> { + let res = unsafe { + // Safety: `self.ptr()` is a valid `X509` handle. + bssl_sys::ASN1_TIME_set_posix(bssl_sys::X509_getm_notAfter(self.ptr()), posix_time) + }; + if res.is_null() { + return Err(PkiError::extract_lib_err()); + } + Ok(self) + } + + /// Append a Common Name (CN) entry to the certificate subject name. + /// + /// Note: Since [RFC 6125], subject Common Name is deprecated for domain validation in Web PKI + /// in favour of Subject Alternative Name (SAN) extensions; setting only `CN` is insufficient + /// for general Web TLS certificates. + /// + /// [RFC 6125]: <https://datatracker.ietf.org/doc/html/rfc6125> + pub fn with_subject_common_name(&mut self, common_name: &str) -> Result<&mut Self, PkiError> { + let (cn_ptr, cn_len) = slice_into_ffi_raw_parts(common_name.as_bytes()); + let Ok(cn_len) = cn_len.try_into() else { + return Err(PkiError::X509(X509Error::InvalidParameters)); + }; + const LOC_APPEND: i32 = -1; // Append entry to the end of `subject`. + const SET_NEW_RDN: i32 = 0; // Create a new singleton RDN for this entry. + check_lib_error!(unsafe { + // Safety: + // - `self.ptr()` is a valid `X509` handle; + // - `cn_ptr` is valid for `cn_len` bytes. + bssl_sys::X509_NAME_add_entry_by_NID( + bssl_sys::X509_get_subject_name(self.ptr()), + bssl_sys::NID_commonName, + bssl_sys::MBSTRING_UTF8 as _, + cn_ptr, + cn_len, + LOC_APPEND, + SET_NEW_RDN, + ) + }); + Ok(self) + } + + /// Finalise and sign a self-signed X.509v3 certificate with SHA-256 using `key`. + /// + /// This sets the certificate public key from `key`, sets the issuer name equal to the + /// subject name, and signs the certificate with `key` and SHA-256. + pub fn build_self_signed(self, key: &PrivateKey) -> Result<X509Certificate, PkiError> { + let ptr = self.ptr(); + unsafe { + // Safety: `ptr` and `key.ptr()` are valid handles. + check_lib_error!(bssl_sys::X509_set_pubkey(ptr, key.ptr())); + check_lib_error!(bssl_sys::X509_set_issuer_name( + ptr, + bssl_sys::X509_get_subject_name(ptr) + )); + if bssl_sys::X509_sign(ptr, key.ptr(), bssl_sys::EVP_sha256()) <= 0 { + return Err(PkiError::extract_lib_err()); + } + } + let x509 = self.0; + forget(self); + Ok(X509Certificate(x509)) + } +} + impl X509Certificate { /// Parse an X.509 certificate from DER and return the remaining bytes. pub fn from_der(der: &[u8]) -> Result<(Self, &[u8]), PkiError> {
diff --git a/rust/bssl-x509/src/tests.rs b/rust/bssl-x509/src/tests.rs index ff7000f..eeae16a 100644 --- a/rust/bssl-x509/src/tests.rs +++ b/rust/bssl-x509/src/tests.rs
@@ -208,3 +208,29 @@ let ec_der_key = keys::PrivateKey::from_der(ec_key.to_der_private_key_info().as_ref()).unwrap(); assert_eq!(ec_der_key.algorithm(), Some(keys::PrivateKeyAlgorithm::Ec)); } + +#[cfg(feature = "experimental")] +#[test] +fn generate_self_signed_cert() -> Result<(), errors::PkiError> { + let ec_key = bssl_crypto::ecdsa::PrivateKey::<bssl_crypto::ec::P256>::generate(); + let key = keys::PrivateKey::from_der(ec_key.to_der_private_key_info().as_ref())?; + let not_before = 1_700_000_000; + let not_after = 1_700_086_400; + let mut builder = certificates::X509CertificateBuilder::new(); + builder + .with_serial_number(42)? + .with_not_before(not_before)? + .with_not_after(not_after)? + .with_subject_common_name("WebRTC")?; + let cert = builder.build_self_signed(&key)?; + assert!(cert.matches_private_key(&key)); + assert_eq!(format!("{:x}", cert.serial_number()), "2a"); + assert_eq!(cert.not_before(), Some(not_before)); + assert_eq!(cert.not_after(), Some(not_after)); + + let der = cert.to_der()?; + let (parsed, rem) = certificates::X509Certificate::from_der(&der)?; + assert!(rem.is_empty()); + assert!(parsed.matches_private_key(&key)); + Ok(()) +}