Allow signing EC certs and creating EC origin-bound certs.

net/base/x509_util_nss.cc

 // Copyright (c) 2011 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/base/x509_util.h"
 #include "net/base/x509_util_nss.h"
 
 #include <cert.h>
 #include <cryptohi.h>
 #include <pk11pub.h>
 #include <prerror.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 "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"
 
 namespace {
 
 class ObCertOIDWrapper {
  public:
   static ObCertOIDWrapper* GetInstance() {
     // Instantiated as a leaky singleton to allow the singleton to be
     // constructed on a worker thead that is not joined when a process
     // shuts down.
     return Singleton<ObCertOIDWrapper,
@@ skipping 117 matching lines @@
       arena, &der, cert, SEC_ASN1_GET(CERT_CertificateTemplate));
   if (!encode_result)
     return false;
 
   // Allocate space to contain the signed cert.
   SECItem* result = SECITEM_AllocItem(arena, NULL, 0);
   if (!result)
     return false;
 
   // Sign the ASN1 encoded cert and save it to |result|.
-  rv = SEC_DerSignData(arena, result, der.data, der.len, key, algo_id);
-  if (rv != SECSuccess)
+  rv = DerSignData(arena, result, &der, key, algo_id);
+  if (rv != SECSuccess) {
+    DLOG(ERROR) << "DerSignData: " << PORT_GetError();
     return false;
+  }
 
   // Save the signed result to the cert.
   cert->derCert = *result;
 
   return true;
 }
 
+bool CreateOriginBoundCert(

[wtc, 2011/11/15 03:10:57]

It may be better to name this function CreateOriginBoundCertCommon
or CreateOriginBoundCertInternal to suggest its relation with
CreateOriginBoundCertRSA and CreateOriginBoundCertEC.

[mattm, 2011/11/15 05:42:31]

Done.

+    SECKEYPublicKey* public_key,
+    SECKEYPrivateKey* private_key,
+    const std::string& origin,
+    uint32 serial_number,
+    base::TimeDelta valid_duration,
+    std::string* der_cert) {
+
+  CERTCertificate* cert = CreateCertificate(public_key,
+                                            "CN=anonymous.invalid",
+                                            serial_number,
+                                            valid_duration);
+
+  if (!cert)
+    return false;
+
+  // Create opaque handle used to add extensions later.
+  void* cert_handle;
+  if ((cert_handle = CERT_StartCertExtensions(cert)) == NULL) {
+    LOG(ERROR) << "Unable to get opaque handle for adding extensions";
+    CERT_DestroyCertificate(cert);
+    return false;
+  }
+
+  // Create SECItem for IA5String encoding.
+  SECItem origin_string_item = {
+    siAsciiString,
+    (unsigned char*)origin.data(),
+    origin.size()
+  };
+
+  // IA5Encode and arena allocate SECItem
+  SECItem* asn1_origin_string = SEC_ASN1EncodeItem(
+      cert->arena, NULL, &origin_string_item,
+      SEC_ASN1_GET(SEC_IA5StringTemplate));
+  if (asn1_origin_string == NULL) {
+    LOG(ERROR) << "Unable to get ASN1 encoding for origin in ob_cert extension";
+    CERT_DestroyCertificate(cert);
+    return false;
+  }
+
+  // Add the extension to the opaque handle
+  if (CERT_AddExtension(cert_handle,
+                        ObCertOIDWrapper::GetInstance()->ob_cert_oid_tag(),
+                        asn1_origin_string,
+                        PR_TRUE, PR_TRUE) != SECSuccess){
+    LOG(ERROR) << "Unable to add origin bound cert extension to opaque handle";
+    CERT_DestroyCertificate(cert);
+    return false;
+  }
+
+  // Copy extension into x509 cert
+  if (CERT_FinishExtensions(cert_handle) != SECSuccess){
+    LOG(ERROR) << "Unable to copy extension to X509 cert";
+    CERT_DestroyCertificate(cert);
+    return false;
+  }
+
+  if (!SignCertificate(cert, private_key)) {
+    CERT_DestroyCertificate(cert);
+    return false;
+  }
+
+  DCHECK(cert->derCert.len);
+  // XXX copied from X509Certificate::GetDEREncoded
+  der_cert->clear();
+  der_cert->append(reinterpret_cast<char*>(cert->derCert.data),
+                   cert->derCert.len);
+  CERT_DestroyCertificate(cert);
+  return true;
+}
+
 }  // namespace
 
 namespace net {
 
 namespace x509_util {
 
 CERTCertificate* CreateSelfSignedCert(
     SECKEYPublicKey* public_key,
     SECKEYPrivateKey* private_key,
     const std::string& subject,
     uint32 serial_number,
     base::TimeDelta valid_duration) {
   CERTCertificate* cert = CreateCertificate(public_key,
                                             subject,
                                             serial_number,
                                             valid_duration);
   if (!cert)
     return NULL;
 
   if (!SignCertificate(cert, private_key)) {
     CERT_DestroyCertificate(cert);
     return NULL;
   }
 
   return cert;
 }
 
-bool CreateOriginBoundCert(
+bool CreateOriginBoundCertRSA(
     crypto::RSAPrivateKey* key,
     const std::string& origin,
     uint32 serial_number,
     base::TimeDelta valid_duration,
     std::string* der_cert) {
   DCHECK(key);
 
   SECKEYPublicKey* public_key;
   SECKEYPrivateKey* private_key;
 #if defined(USE_NSS)
@@ skipping 34 matching lines @@
 
     public_key = SECKEY_ConvertToPublicKey(private_key);
     if (!public_key) {
       NOTREACHED();
       return NULL;
     }
     scoped_public_key.reset(public_key);
   }
 #endif
 
-  CERTCertificate* cert = CreateCertificate(public_key,
-                                            "CN=anonymous.invalid",
-                                            serial_number,
-                                            valid_duration);
+  return CreateOriginBoundCert(public_key,
+                               private_key,
+                               origin,
+                               serial_number,
+                               valid_duration,
+                               der_cert);
+}
 
-  if (!cert)
-    return false;
-
-  // Create opaque handle used to add extensions later.
-  void* cert_handle;
-  if ((cert_handle = CERT_StartCertExtensions(cert)) == NULL) {
-    LOG(ERROR) << "Unable to get opaque handle for adding extensions";
-    CERT_DestroyCertificate(cert);
-    return false;
-  }
-
-  // Create SECItem for IA5String encoding.
-  SECItem origin_string_item = {
-    siAsciiString,
-    (unsigned char*)origin.data(),
-    origin.size()
-  };
-
-  // IA5Encode and arena allocate SECItem
-  SECItem* asn1_origin_string = SEC_ASN1EncodeItem(
-      cert->arena, NULL, &origin_string_item,
-      SEC_ASN1_GET(SEC_IA5StringTemplate));
-  if (asn1_origin_string == NULL) {
-    LOG(ERROR) << "Unable to get ASN1 encoding for origin in ob_cert extension";
-    CERT_DestroyCertificate(cert);
-    return false;
-  }
-
-  // Add the extension to the opaque handle
-  if (CERT_AddExtension(cert_handle,
-                        ObCertOIDWrapper::GetInstance()->ob_cert_oid_tag(),
-                        asn1_origin_string,
-                        PR_TRUE, PR_TRUE) != SECSuccess){
-    LOG(ERROR) << "Unable to add origin bound cert extension to opaque handle";
-    CERT_DestroyCertificate(cert);
-    return false;
-  }
-
-  // Copy extension into x509 cert
-  if (CERT_FinishExtensions(cert_handle) != SECSuccess){
-    LOG(ERROR) << "Unable to copy extension to X509 cert";
-    CERT_DestroyCertificate(cert);
-    return false;
-  }
-
-  if (!SignCertificate(cert, private_key)) {
-    CERT_DestroyCertificate(cert);
-    return false;
-  }
-
-  DCHECK(cert->derCert.len);
-  // XXX copied from X509Certificate::GetDEREncoded
-  der_cert->clear();
-  der_cert->append(reinterpret_cast<char*>(cert->derCert.data),
-                   cert->derCert.len);
-  CERT_DestroyCertificate(cert);
-  return true;
+bool CreateOriginBoundCertEC(
+    crypto::ECPrivateKey* key,
+    const std::string& origin,
+    uint32 serial_number,
+    base::TimeDelta valid_duration,
+    std::string* der_cert) {
+  DCHECK(key);
+  return CreateOriginBoundCert(key->public_key(),
+                               key->key(),
+                               origin,
+                               serial_number,
+                               valid_duration,
+                               der_cert);
 }
 
 } // namespace x509_util
 
 } // namespace net