Remove platform-specific implementations of RSAPrivateKey and SignatureCreator

net/cert/x509_util_nss.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/cert/x509_util.h"
 #include "net/cert/x509_util_nss.h"
 
 #include <cert.h>  // Must be included before certdb.h
 #include <certdb.h>
 #include <cryptohi.h>
 #include <nss.h>
 #include <pk11pub.h>
 #include <prerror.h>
 #include <secder.h>
 #include <secmod.h>
 #include <secport.h>
 
 #include "base/debug/leak_annotations.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/pickle.h"
 #include "base/strings/stringprintf.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/nss_util.h"
 #include "crypto/nss_util_internal.h"
+#include "crypto/rsa_private_key.h"
 #include "crypto/scoped_nss_types.h"
 #include "crypto/third_party/nss/chromium-nss.h"
 #include "net/cert/x509_certificate.h"
 
 namespace net {
 
 namespace {
 
 class DomainBoundCertOIDWrapper {
  public:
@@ skipping 138 matching lines @@
     DLOG(ERROR) << "DerSignData: " << PORT_GetError();
     return false;
   }
 
   // Save the signed result to the cert.
   cert->derCert = result;
 
   return true;
 }
 
+CERTCertificate* CreateSelfSignedCertInternal(
+    SECKEYPublicKey* public_key,
+    SECKEYPrivateKey* private_key,
+    const std::string& subject,
+    uint32 serial_number,
+    base::Time not_valid_before,
+    base::Time not_valid_after) {
+  CERTCertificate* cert = CreateCertificate(public_key,
+                                            subject,
+                                            serial_number,
+                                            not_valid_before,
+                                            not_valid_after);
+  if (!cert)
+    return NULL;
+
+  if (!SignCertificate(cert, private_key)) {
+    CERT_DestroyCertificate(cert);
+    return NULL;
+  }
+
+  return cert;
+}
+
 bool CreateDomainBoundCertInternal(
     SECKEYPublicKey* public_key,
     SECKEYPrivateKey* private_key,
     const std::string& domain,
     uint32 serial_number,
     base::Time not_valid_before,
     base::Time not_valid_after,
     std::string* der_cert) {
   CERTCertificate* cert = CreateCertificate(public_key,
                                             "CN=anonymous.invalid",
@@ skipping 110 matching lines @@
 
   return name.release();
 }
 
 #endif  // defined(USE_NSS) || defined(OS_IOS)
 
 }  // namespace
 
 namespace x509_util {
 
-CERTCertificate* CreateSelfSignedCert(
-    SECKEYPublicKey* public_key,
-    SECKEYPrivateKey* private_key,
-    const std::string& subject,
-    uint32 serial_number,
-    base::Time not_valid_before,
-    base::Time not_valid_after) {
-  CERTCertificate* cert = CreateCertificate(public_key,
-                                            subject,
-                                            serial_number,
-                                            not_valid_before,
-                                            not_valid_after);
+bool CreateSelfSignedCert(crypto::RSAPrivateKey* key,
+                          const std::string& common_name,
+                          uint32 serial_number,
+                          base::Time not_valid_before,
+                          base::Time not_valid_after,
+                          std::string* der_encoded) {
+  CERTCertificate* cert = CreateSelfSignedCertInternal(

[wtc, 2013/06/20 21:35:56]

I think we can just inline CreateSelfSignedCertInternal here.

+      key->public_key(),
+      key->key(),
+      common_name,
+      serial_number,
+      not_valid_before,
+      not_valid_after);
   if (!cert)
-    return NULL;
+    return false;
 
-  if (!SignCertificate(cert, private_key)) {
-    CERT_DestroyCertificate(cert);
-    return NULL;
-  }
-
-  return cert;
+  der_encoded->assign(reinterpret_cast<char*>(cert->derCert.data),
+                      cert->derCert.len);
+  CERT_DestroyCertificate(cert);
+  return true;
 }
 
 bool IsSupportedValidityRange(base::Time not_valid_before,
                               base::Time not_valid_after) {
   CERTValidity* validity = CERT_CreateValidity(
       crypto::BaseTimeToPRTime(not_valid_before),
       crypto::BaseTimeToPRTime(not_valid_after));
 
   if (!validity)
     return false;
 
   CERT_DestroyValidity(validity);
   return true;
 }
 
 bool CreateDomainBoundCertEC(
     crypto::ECPrivateKey* key,
     const std::string& domain,
     uint32 serial_number,
     base::Time not_valid_before,
     base::Time not_valid_after,
     std::string* der_cert) {
   DCHECK(key);
   return CreateDomainBoundCertInternal(key->public_key(),

[wtc, 2013/06/20 21:35:56]

CreateDomainBoundCertInternal is only used here. It seems that we should
just inline it here.

                                        key->key(),
                                        domain,
                                        serial_number,
                                        not_valid_before,
                                        not_valid_after,
                                        der_cert);
 }
 
 #if defined(USE_NSS) || defined(OS_IOS)
 void ParsePrincipal(CERTName* name, CertPrincipal* principal) {
@@ skipping 256 matching lines @@
   }
 
   return new_name;
 }
 
 #endif  // defined(USE_NSS) || defined(OS_IOS)
 
 } // namespace x509_util
 
 } // namespace net