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(())
+}