Change Origin bound certs -> Domain bound certs.

net/base/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/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/scoped_nss_types.h"
 #include "crypto/third_party/nss/chromium-nss.h"
 
 namespace {
 
-class ObCertOIDWrapper {
+class DomainBoundCertOIDWrapper {
  public:
-  static ObCertOIDWrapper* GetInstance() {
+  static DomainBoundCertOIDWrapper* 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,
-                     LeakySingletonTraits<ObCertOIDWrapper> >::get();
+    return Singleton<DomainBoundCertOIDWrapper,
+                     LeakySingletonTraits<DomainBoundCertOIDWrapper> >::get();
   }
 
-  SECOidTag ob_cert_oid_tag() const {
-    return ob_cert_oid_tag_;
+  SECOidTag domain_bound_cert_oid_tag() const {
+    return domain_bound_cert_oid_tag_;
   }
 
  private:
-  friend struct DefaultSingletonTraits<ObCertOIDWrapper>;
+  friend struct DefaultSingletonTraits<DomainBoundCertOIDWrapper>;
 
-  ObCertOIDWrapper();
+  DomainBoundCertOIDWrapper();
 
-  SECOidTag ob_cert_oid_tag_;
+  SECOidTag domain_bound_cert_oid_tag_;
 
-  DISALLOW_COPY_AND_ASSIGN(ObCertOIDWrapper);
+  DISALLOW_COPY_AND_ASSIGN(DomainBoundCertOIDWrapper);
 };
 
-ObCertOIDWrapper::ObCertOIDWrapper(): ob_cert_oid_tag_(SEC_OID_UNKNOWN) {
+DomainBoundCertOIDWrapper::DomainBoundCertOIDWrapper()
+    : domain_bound_cert_oid_tag_(SEC_OID_UNKNOWN) {
   // 1.3.6.1.4.1.11129.2.1.6
   // (iso.org.dod.internet.private.enterprises.google.googleSecurity.
   //  certificateExtensions.originBoundCertificate)
   static const uint8 kObCertOID[] = {
     0x2b, 0x06, 0x01, 0x04, 0x01, 0xd6, 0x79, 0x02, 0x01, 0x06
   };
   SECOidData oid_data;
   memset(&oid_data, 0, sizeof(oid_data));
   oid_data.oid.data = const_cast<uint8*>(kObCertOID);
   oid_data.oid.len = sizeof(kObCertOID);
   oid_data.offset = SEC_OID_UNKNOWN;
   oid_data.desc = "Origin Bound Certificate";
   oid_data.mechanism = CKM_INVALID_MECHANISM;
   oid_data.supportedExtension = SUPPORTED_CERT_EXTENSION;
-  ob_cert_oid_tag_ = SECOID_AddEntry(&oid_data);
-  if (ob_cert_oid_tag_ == SEC_OID_UNKNOWN)
+  domain_bound_cert_oid_tag_ = SECOID_AddEntry(&oid_data);
+  if (domain_bound_cert_oid_tag_ == SEC_OID_UNKNOWN)
     LOG(ERROR) << "OB_CERT OID tag creation failed";
 }
 
 // Creates a Certificate object that may be passed to the SignCertificate
 // method to generate an X509 certificate.
 // Returns NULL if an error is encountered in the certificate creation
 // process.
 // Caller responsible for freeing returned certificate object.
 CERTCertificate* CreateCertificate(
     SECKEYPublicKey* public_key,
@@ skipping 84 matching lines @@
     DLOG(ERROR) << "DerSignData: " << PORT_GetError();
     return false;
   }
 
   // Save the signed result to the cert.
   cert->derCert = *result;
 
   return true;
 }
 
-bool CreateOriginBoundCertInternal(
+bool CreateDomainBoundCertInternal(
     SECKEYPublicKey* public_key,
     SECKEYPrivateKey* private_key,
-    const std::string& origin,
+    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",
                                             serial_number,
                                             not_valid_before,
                                             not_valid_after);
 
   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 = {
+  SECItem domain_string_item = {
     siAsciiString,
-    (unsigned char*)origin.data(),
-    origin.size()
+    (unsigned char*)domain.data(),
+    domain.size()
   };
 
   // IA5Encode and arena allocate SECItem
-  SECItem* asn1_origin_string = SEC_ASN1EncodeItem(
-      cert->arena, NULL, &origin_string_item,
+  SECItem* asn1_domain_string = SEC_ASN1EncodeItem(
+      cert->arena, NULL, &domain_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";
+  if (asn1_domain_string == NULL) {
+    LOG(ERROR) << "Unable to get ASN1 encoding for domain in domain_bound_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";
+  if (CERT_AddExtension(
+      cert_handle,
+      DomainBoundCertOIDWrapper::GetInstance()->domain_bound_cert_oid_tag(),
+      asn1_domain_string, PR_TRUE, PR_TRUE) != SECSuccess){
+    LOG(ERROR) << "Unable to add domain 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;
   }
@@ skipping 34 matching lines @@
     return NULL;
 
   if (!SignCertificate(cert, private_key)) {
     CERT_DestroyCertificate(cert);
     return NULL;
   }
 
   return cert;
 }
 
-bool CreateOriginBoundCertEC(
+bool CreateDomainBoundCertEC(
     crypto::ECPrivateKey* key,
-    const std::string& origin,
+    const std::string& domain,
     uint32 serial_number,
     base::Time not_valid_before,
     base::Time not_valid_after,
     std::string* der_cert) {
   DCHECK(key);
-  return CreateOriginBoundCertInternal(key->public_key(),
+  return CreateDomainBoundCertInternal(key->public_key(),
                                        key->key(),
-                                       origin,
+                                       domain,
                                        serial_number,
                                        not_valid_before,
                                        not_valid_after,
                                        der_cert);
 }
 
 } // namespace x509_util
 
 } // namespace net