crypto: add X.509 generation with CSR support

Expose callback-based generateX509Certificate() and synchronous
generateX509CertificateSync(), producing X509Certificate objects for
self-signed and issuer-signed X.509 v3 certificates. Accept grouped
distinguished names or exact subject DER, public keys, serial numbers,
validity dates, and an explicit signing digest. Reuse crypto.sign() key
inputs and RSA options, including OpenSSL STORE-backed keys.

A PKCS#10 request can supply the subject and public key instead.
Require a synchronous selectExtensions callback to accept, replace, or
amend the requested extensions. Verify the request signature before
signing the certificate, in the selected sync or async mode.

Provide typed Basic Constraints, Key Usage, Extended Key Usage, SAN,
SKI, and AKI, plus arbitrary raw extensions. Add none implicitly and
leave raw extension semantics to the caller. Copy mutable inputs
before queueing asynchronous work. Certificate trust and CA
authorization remain the caller's responsibility.

Fixes: #51169
Assisted-by: Codex
Signed-off-by: Filip Skokan <panva.ip@gmail.com>
PR-URL: #67245
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

Author: panva

deps/ncrypto/ncrypto.cc

@@ -1742,16 +1742,13 @@ std::optional<X509NameInspection> InspectName(const X509_NAME* name) {
   return output;
 }
 
+template <typename GetExtension>
 std::optional<std::vector<X509RawExtension>> InspectExtensions(
-    const X509* certificate) {
-  if (certificate == nullptr) return std::nullopt;
-  const int count = X509_get_ext_count(certificate);
-  if (count < 0) return std::nullopt;
-
+    OPENSSL_SIZE_T count, GetExtension get_extension) {
   std::vector<X509RawExtension> output;
   output.reserve(static_cast<size_t>(count));
-  for (int i = 0; i < count; i++) {
-    const X509_EXTENSION* extension = X509_get_ext(certificate, i);
+  for (OPENSSL_SIZE_T i = 0; i < count; i++) {
+    const X509_EXTENSION* extension = get_extension(i);
     if (extension == nullptr) return std::nullopt;
 
     auto* mutable_extension = const_cast<X509_EXTENSION*>(extension);
@@ -1770,6 +1767,15 @@ std::optional<std::vector<X509RawExtension>> InspectExtensions(
 }
 }  // namespace
 
+std::optional<std::vector<X509RawExtension>> inspectX509Extensions(
+    const STACK_OF(X509_EXTENSION) * extensions) {
+  if (extensions == nullptr) return std::nullopt;
+  return InspectExtensions(sk_X509_EXTENSION_num(extensions),
+                           [extensions](OPENSSL_SIZE_T index) {
+                             return sk_X509_EXTENSION_value(extensions, index);
+                           });
+}
+
 std::optional<int64_t> X509View::getVersion() const {
   MarkPopErrorOnReturn mark_pop_error_on_return;
   if (cert_ == nullptr) return std::nullopt;
@@ -1793,7 +1799,13 @@ std::optional<X509NameInspection> X509View::inspectIssuerName() const {
 std::optional<std::vector<X509RawExtension>> X509View::inspectExtensions()
     const {
   MarkPopErrorOnReturn mark_pop_error_on_return;
-  return InspectExtensions(cert_);
+  if (cert_ == nullptr) return std::nullopt;
+  const int count = X509_get_ext_count(cert_);
+  if (count < 0) return std::nullopt;
+  return InspectExtensions(
+      static_cast<OPENSSL_SIZE_T>(count), [this](OPENSSL_SIZE_T index) {
+        return X509_get_ext(cert_, static_cast<int>(index));
+      });
 }
 
 bool X509View::isIssuedBy(const X509View& issuer) const {
@@ -1803,10 +1815,39 @@ bool X509View::isIssuedBy(const X509View& issuer) const {
                            const_cast<X509*>(cert_)) == X509_V_OK;
 }
 
-bool X509View::checkPrivateKey(const EVPKeyPointer& pkey) const {
-  ClearErrorOnReturn clearErrorOnReturn;
-  if (cert_ == nullptr || pkey == nullptr) return false;
-  return X509_check_private_key(const_cast<X509*>(cert_), pkey.get()) == 1;
+X509View::CheckKeyResult X509View::checkPrivateKey(
+    const EVPKeyPointer& pkey) const {
+  MarkPopErrorOnReturn mark_pop_error_on_return;
+  if (cert_ == nullptr || pkey == nullptr) {
+    return CheckKeyResult::OPERATION_FAILED;
+  }
+
+  EVPKeyPointer certificate_key(X509_get_pubkey(const_cast<X509*>(cert_)));
+  if (!certificate_key) return CheckKeyResult::OPERATION_FAILED;
+#if NCRYPTO_USE_BORINGSSL
+  if (EVP_PKEY_is_opaque(certificate_key.get()) ||
+      EVP_PKEY_is_opaque(pkey.get())) {
+    return CheckKeyResult::UNSUPPORTED_OPERATION;
+  }
+#endif
+#if NCRYPTO_USE_OPENSSL_PROVIDER
+  const int result = EVP_PKEY_eq(certificate_key.get(), pkey.get());
+#elif NCRYPTO_USE_BORINGSSL
+  const int result = EVP_PKEY_cmp(certificate_key.get(), pkey.get());
+#else
+#error "Unsupported crypto backend"
+#endif
+  switch (result) {
+    case 1:
+      return CheckKeyResult::MATCH;
+    case 0:
+    case -1:
+      return CheckKeyResult::NO_MATCH;
+    case -2:
+      return CheckKeyResult::UNSUPPORTED_OPERATION;
+    default:
+      return CheckKeyResult::OPERATION_FAILED;
+  }
 }
 
 bool X509View::checkPublicKey(const EVPKeyPointer& pkey) const {

deps/ncrypto/ncrypto.h

@@ -70,6 +70,16 @@
 #define NCRYPTO_HAS_ASN1_BIT_STRING_GET_LENGTH 0
 #endif
 
+// BoringSSL's X.509 signer can encode only its restricted RSA-PSS parameter
+// profile. Other supported backends accept the full runtime signing profile.
+#if NCRYPTO_USE_BORINGSSL
+#define NCRYPTO_HAS_X509_RSA_PSS_FLEXIBLE_PARAMETERS 0
+#elif NCRYPTO_USE_OPENSSL_PROVIDER
+#define NCRYPTO_HAS_X509_RSA_PSS_FLEXIBLE_PARAMETERS 1
+#else
+#error "Unsupported crypto backend"
+#endif
+
 #if NCRYPTO_USE_OPENSSL_PROVIDER
 #include <openssl/core_names.h>
 #include <openssl/encoder.h>
@@ -1683,8 +1693,18 @@ struct X509RawExtension final {
   std::vector<unsigned char> value;
 };
 
+std::optional<std::vector<X509RawExtension>> inspectX509Extensions(
+    const STACK_OF(X509_EXTENSION) * extensions);
+
 class X509View final {
  public:
+  enum class CheckKeyResult {
+    MATCH,                  // The requested comparison passed.
+    NO_MATCH,               // It completed and produced an ordinary mismatch.
+    UNSUPPORTED_OPERATION,  // The backend cannot compare these keys.
+    OPERATION_FAILED,       // The backend failed for another reason.
+  };
+
   static X509View From(const SSLPointer& ssl);
   static X509View From(const SSLCtxPointer& ctx);
 
@@ -1727,7 +1747,7 @@ class X509View final {
 
   bool isCA() const;
   bool isIssuedBy(const X509View& other) const;
-  bool checkPrivateKey(const EVPKeyPointer& pkey) const;
+  CheckKeyResult checkPrivateKey(const EVPKeyPointer& pkey) const;
   bool checkPublicKey(const EVPKeyPointer& pkey) const;
 
   std::optional<std::string> getFingerprint(const Digest& method) const;