Home | History | Annotate | Download | only in cert 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/cert/x509_util.h"
      6 #include "net/cert/x509_util_nss.h"
      7 
      8 #include <cert.h>  // Must be included before certdb.h
      9 #include <certdb.h>
     10 #include <cryptohi.h>
     11 #include <nss.h>
     12 #include <pk11pub.h>
     13 #include <prerror.h>
     14 #include <secder.h>
     15 #include <secmod.h>
     16 #include <secport.h>
     17 
     18 #include "base/debug/leak_annotations.h"
     19 #include "base/logging.h"
     20 #include "base/memory/scoped_ptr.h"
     21 #include "base/memory/singleton.h"
     22 #include "base/pickle.h"
     23 #include "base/strings/stringprintf.h"
     24 #include "crypto/ec_private_key.h"
     25 #include "crypto/nss_util.h"
     26 #include "crypto/nss_util_internal.h"
     27 #include "crypto/rsa_private_key.h"
     28 #include "crypto/scoped_nss_types.h"
     29 #include "crypto/third_party/nss/chromium-nss.h"
     30 #include "net/cert/x509_certificate.h"
     31 
     32 namespace net {
     33 
     34 namespace {
     35 
     36 class DomainBoundCertOIDWrapper {
     37  public:
     38   static DomainBoundCertOIDWrapper* GetInstance() {
     39     // Instantiated as a leaky singleton to allow the singleton to be
     40     // constructed on a worker thead that is not joined when a process
     41     // shuts down.
     42     return Singleton<DomainBoundCertOIDWrapper,
     43                      LeakySingletonTraits<DomainBoundCertOIDWrapper> >::get();
     44   }
     45 
     46   SECOidTag domain_bound_cert_oid_tag() const {
     47     return domain_bound_cert_oid_tag_;
     48   }
     49 
     50  private:
     51   friend struct DefaultSingletonTraits<DomainBoundCertOIDWrapper>;
     52 
     53   DomainBoundCertOIDWrapper();
     54 
     55   SECOidTag domain_bound_cert_oid_tag_;
     56 
     57   DISALLOW_COPY_AND_ASSIGN(DomainBoundCertOIDWrapper);
     58 };
     59 
     60 DomainBoundCertOIDWrapper::DomainBoundCertOIDWrapper()
     61     : domain_bound_cert_oid_tag_(SEC_OID_UNKNOWN) {
     62   // 1.3.6.1.4.1.11129.2.1.6
     63   // (iso.org.dod.internet.private.enterprises.google.googleSecurity.
     64   //  certificateExtensions.originBoundCertificate)
     65   static const uint8 kObCertOID[] = {
     66     0x2b, 0x06, 0x01, 0x04, 0x01, 0xd6, 0x79, 0x02, 0x01, 0x06
     67   };
     68   SECOidData oid_data;
     69   memset(&oid_data, 0, sizeof(oid_data));
     70   oid_data.oid.data = const_cast<uint8*>(kObCertOID);
     71   oid_data.oid.len = sizeof(kObCertOID);
     72   oid_data.offset = SEC_OID_UNKNOWN;
     73   oid_data.desc = "Origin Bound Certificate";
     74   oid_data.mechanism = CKM_INVALID_MECHANISM;
     75   oid_data.supportedExtension = SUPPORTED_CERT_EXTENSION;
     76   domain_bound_cert_oid_tag_ = SECOID_AddEntry(&oid_data);
     77   if (domain_bound_cert_oid_tag_ == SEC_OID_UNKNOWN)
     78     LOG(ERROR) << "OB_CERT OID tag creation failed";
     79 }
     80 
     81 // Creates a Certificate object that may be passed to the SignCertificate
     82 // method to generate an X509 certificate.
     83 // Returns NULL if an error is encountered in the certificate creation
     84 // process.
     85 // Caller responsible for freeing returned certificate object.
     86 CERTCertificate* CreateCertificate(
     87     SECKEYPublicKey* public_key,
     88     const std::string& subject,
     89     uint32 serial_number,
     90     base::Time not_valid_before,
     91     base::Time not_valid_after) {
     92   // Create info about public key.
     93   CERTSubjectPublicKeyInfo* spki =
     94       SECKEY_CreateSubjectPublicKeyInfo(public_key);
     95   if (!spki)
     96     return NULL;
     97 
     98   // Create the certificate request.
     99   CERTName* subject_name =
    100       CERT_AsciiToName(const_cast<char*>(subject.c_str()));
    101   CERTCertificateRequest* cert_request =
    102       CERT_CreateCertificateRequest(subject_name, spki, NULL);
    103   SECKEY_DestroySubjectPublicKeyInfo(spki);
    104 
    105   if (!cert_request) {
    106     PRErrorCode prerr = PR_GetError();
    107     LOG(ERROR) << "Failed to create certificate request: " << prerr;
    108     CERT_DestroyName(subject_name);
    109     return NULL;
    110   }
    111 
    112   CERTValidity* validity = CERT_CreateValidity(
    113       crypto::BaseTimeToPRTime(not_valid_before),
    114       crypto::BaseTimeToPRTime(not_valid_after));
    115   if (!validity) {
    116     PRErrorCode prerr = PR_GetError();
    117     LOG(ERROR) << "Failed to create certificate validity object: " << prerr;
    118     CERT_DestroyName(subject_name);
    119     CERT_DestroyCertificateRequest(cert_request);
    120     return NULL;
    121   }
    122   CERTCertificate* cert = CERT_CreateCertificate(serial_number, subject_name,
    123                                                  validity, cert_request);
    124   if (!cert) {
    125     PRErrorCode prerr = PR_GetError();
    126     LOG(ERROR) << "Failed to create certificate: " << prerr;
    127   }
    128 
    129   // Cleanup for resources used to generate the cert.
    130   CERT_DestroyName(subject_name);
    131   CERT_DestroyValidity(validity);
    132   CERT_DestroyCertificateRequest(cert_request);
    133 
    134   return cert;
    135 }
    136 
    137 SECOidTag ToSECOid(x509_util::DigestAlgorithm alg) {
    138   switch (alg) {
    139     case x509_util::DIGEST_SHA1:
    140       return SEC_OID_SHA1;
    141     case x509_util::DIGEST_SHA256:
    142       return SEC_OID_SHA256;
    143   }
    144   return SEC_OID_UNKNOWN;
    145 }
    146 
    147 // Signs a certificate object, with |key| generating a new X509Certificate
    148 // and destroying the passed certificate object (even when NULL is returned).
    149 // The logic of this method references SignCert() in NSS utility certutil:
    150 // http://mxr.mozilla.org/security/ident?i=SignCert.
    151 // Returns true on success or false if an error is encountered in the
    152 // certificate signing process.
    153 bool SignCertificate(
    154     CERTCertificate* cert,
    155     SECKEYPrivateKey* key,
    156     SECOidTag hash_algorithm) {
    157   // |arena| is used to encode the cert.
    158   PLArenaPool* arena = cert->arena;
    159   SECOidTag algo_id = SEC_GetSignatureAlgorithmOidTag(key->keyType,
    160                                                       hash_algorithm);
    161   if (algo_id == SEC_OID_UNKNOWN)
    162     return false;
    163 
    164   SECStatus rv = SECOID_SetAlgorithmID(arena, &cert->signature, algo_id, 0);
    165   if (rv != SECSuccess)
    166     return false;
    167 
    168   // Generate a cert of version 3.
    169   *(cert->version.data) = 2;
    170   cert->version.len = 1;
    171 
    172   SECItem der = { siBuffer, NULL, 0 };
    173 
    174   // Use ASN1 DER to encode the cert.
    175   void* encode_result = SEC_ASN1EncodeItem(
    176       NULL, &der, cert, SEC_ASN1_GET(CERT_CertificateTemplate));
    177   if (!encode_result)
    178     return false;
    179 
    180   // Allocate space to contain the signed cert.
    181   SECItem result = { siBuffer, NULL, 0 };
    182 
    183   // Sign the ASN1 encoded cert and save it to |result|.
    184   rv = DerSignData(arena, &result, &der, key, algo_id);
    185   PORT_Free(der.data);
    186   if (rv != SECSuccess) {
    187     DLOG(ERROR) << "DerSignData: " << PORT_GetError();
    188     return false;
    189   }
    190 
    191   // Save the signed result to the cert.
    192   cert->derCert = result;
    193 
    194   return true;
    195 }
    196 
    197 #if defined(USE_NSS) || defined(OS_IOS)
    198 // Callback for CERT_DecodeCertPackage(), used in
    199 // CreateOSCertHandlesFromBytes().
    200 SECStatus PR_CALLBACK CollectCertsCallback(void* arg,
    201                                            SECItem** certs,
    202                                            int num_certs) {
    203   X509Certificate::OSCertHandles* results =
    204       reinterpret_cast<X509Certificate::OSCertHandles*>(arg);
    205 
    206   for (int i = 0; i < num_certs; ++i) {
    207     X509Certificate::OSCertHandle handle =
    208         X509Certificate::CreateOSCertHandleFromBytes(
    209             reinterpret_cast<char*>(certs[i]->data), certs[i]->len);
    210     if (handle)
    211       results->push_back(handle);
    212   }
    213 
    214   return SECSuccess;
    215 }
    216 
    217 typedef scoped_ptr_malloc<
    218     CERTName,
    219     crypto::NSSDestroyer<CERTName, CERT_DestroyName> > ScopedCERTName;
    220 
    221 // Create a new CERTName object from its encoded representation.
    222 // |arena| is the allocation pool to use.
    223 // |data| points to a DER-encoded X.509 DistinguishedName.
    224 // Return a new CERTName pointer on success, or NULL.
    225 CERTName* CreateCertNameFromEncoded(PLArenaPool* arena,
    226                                     const base::StringPiece& data) {
    227   if (!arena)
    228     return NULL;
    229 
    230   ScopedCERTName name(PORT_ArenaZNew(arena, CERTName));
    231   if (!name.get())
    232     return NULL;
    233 
    234   SECItem item;
    235   item.len = static_cast<unsigned int>(data.length());
    236   item.data = reinterpret_cast<unsigned char*>(
    237       const_cast<char*>(data.data()));
    238 
    239   SECStatus rv = SEC_ASN1DecodeItem(
    240       arena, name.get(), SEC_ASN1_GET(CERT_NameTemplate), &item);
    241   if (rv != SECSuccess)
    242     return NULL;
    243 
    244   return name.release();
    245 }
    246 
    247 #endif  // defined(USE_NSS) || defined(OS_IOS)
    248 
    249 }  // namespace
    250 
    251 namespace x509_util {
    252 
    253 bool CreateSelfSignedCert(crypto::RSAPrivateKey* key,
    254                           DigestAlgorithm alg,
    255                           const std::string& subject,
    256                           uint32 serial_number,
    257                           base::Time not_valid_before,
    258                           base::Time not_valid_after,
    259                           std::string* der_cert) {
    260   DCHECK(key);
    261   DCHECK(!strncmp(subject.c_str(), "CN=", 3U));
    262   CERTCertificate* cert = CreateCertificate(key->public_key(),
    263                                             subject,
    264                                             serial_number,
    265                                             not_valid_before,
    266                                             not_valid_after);
    267   if (!cert)
    268     return false;
    269 
    270   if (!SignCertificate(cert, key->key(), ToSECOid(alg))) {
    271     CERT_DestroyCertificate(cert);
    272     return false;
    273   }
    274 
    275   der_cert->assign(reinterpret_cast<char*>(cert->derCert.data),
    276                    cert->derCert.len);
    277   CERT_DestroyCertificate(cert);
    278   return true;
    279 }
    280 
    281 bool IsSupportedValidityRange(base::Time not_valid_before,
    282                               base::Time not_valid_after) {
    283   CERTValidity* validity = CERT_CreateValidity(
    284       crypto::BaseTimeToPRTime(not_valid_before),
    285       crypto::BaseTimeToPRTime(not_valid_after));
    286 
    287   if (!validity)
    288     return false;
    289 
    290   CERT_DestroyValidity(validity);
    291   return true;
    292 }
    293 
    294 bool CreateDomainBoundCertEC(crypto::ECPrivateKey* key,
    295                              DigestAlgorithm alg,
    296                              const std::string& domain,
    297                              uint32 serial_number,
    298                              base::Time not_valid_before,
    299                              base::Time not_valid_after,
    300                              std::string* der_cert) {
    301   DCHECK(key);
    302 
    303   CERTCertificate* cert = CreateCertificate(key->public_key(),
    304                                             "CN=anonymous.invalid",
    305                                             serial_number,
    306                                             not_valid_before,
    307                                             not_valid_after);
    308 
    309   if (!cert)
    310     return false;
    311 
    312   // Create opaque handle used to add extensions later.
    313   void* cert_handle;
    314   if ((cert_handle = CERT_StartCertExtensions(cert)) == NULL) {
    315     LOG(ERROR) << "Unable to get opaque handle for adding extensions";
    316     CERT_DestroyCertificate(cert);
    317     return false;
    318   }
    319 
    320   // Create SECItem for IA5String encoding.
    321   SECItem domain_string_item = {
    322     siAsciiString,
    323     (unsigned char*)domain.data(),
    324     static_cast<unsigned>(domain.size())
    325   };
    326 
    327   // IA5Encode and arena allocate SECItem
    328   SECItem* asn1_domain_string = SEC_ASN1EncodeItem(
    329       cert->arena, NULL, &domain_string_item,
    330       SEC_ASN1_GET(SEC_IA5StringTemplate));
    331   if (asn1_domain_string == NULL) {
    332     LOG(ERROR) << "Unable to get ASN1 encoding for domain in domain_bound_cert"
    333                   " extension";
    334     CERT_DestroyCertificate(cert);
    335     return false;
    336   }
    337 
    338   // Add the extension to the opaque handle
    339   if (CERT_AddExtension(
    340       cert_handle,
    341       DomainBoundCertOIDWrapper::GetInstance()->domain_bound_cert_oid_tag(),
    342       asn1_domain_string,
    343       PR_TRUE,
    344       PR_TRUE) != SECSuccess){
    345     LOG(ERROR) << "Unable to add domain bound cert extension to opaque handle";
    346     CERT_DestroyCertificate(cert);
    347     return false;
    348   }
    349 
    350   // Copy extension into x509 cert
    351   if (CERT_FinishExtensions(cert_handle) != SECSuccess){
    352     LOG(ERROR) << "Unable to copy extension to X509 cert";
    353     CERT_DestroyCertificate(cert);
    354     return false;
    355   }
    356 
    357   if (!SignCertificate(cert, key->key(), ToSECOid(alg))) {
    358     CERT_DestroyCertificate(cert);
    359     return false;
    360   }
    361 
    362   DCHECK(cert->derCert.len);
    363   // XXX copied from X509Certificate::GetDEREncoded
    364   der_cert->clear();
    365   der_cert->append(reinterpret_cast<char*>(cert->derCert.data),
    366                    cert->derCert.len);
    367   CERT_DestroyCertificate(cert);
    368   return true;
    369 }
    370 
    371 #if defined(USE_NSS) || defined(OS_IOS)
    372 void ParsePrincipal(CERTName* name, CertPrincipal* principal) {
    373 // Starting in NSS 3.15, CERTGetNameFunc takes a const CERTName* argument.
    374 #if NSS_VMINOR >= 15
    375   typedef char* (*CERTGetNameFunc)(const CERTName* name);
    376 #else
    377   typedef char* (*CERTGetNameFunc)(CERTName* name);
    378 #endif
    379 
    380   // TODO(jcampan): add business_category and serial_number.
    381   // TODO(wtc): NSS has the CERT_GetOrgName, CERT_GetOrgUnitName, and
    382   // CERT_GetDomainComponentName functions, but they return only the most
    383   // general (the first) RDN.  NSS doesn't have a function for the street
    384   // address.
    385   static const SECOidTag kOIDs[] = {
    386     SEC_OID_AVA_STREET_ADDRESS,
    387     SEC_OID_AVA_ORGANIZATION_NAME,
    388     SEC_OID_AVA_ORGANIZATIONAL_UNIT_NAME,
    389     SEC_OID_AVA_DC };
    390 
    391   std::vector<std::string>* values[] = {
    392     &principal->street_addresses,
    393     &principal->organization_names,
    394     &principal->organization_unit_names,
    395     &principal->domain_components };
    396   DCHECK_EQ(arraysize(kOIDs), arraysize(values));
    397 
    398   CERTRDN** rdns = name->rdns;
    399   for (size_t rdn = 0; rdns[rdn]; ++rdn) {
    400     CERTAVA** avas = rdns[rdn]->avas;
    401     for (size_t pair = 0; avas[pair] != 0; ++pair) {
    402       SECOidTag tag = CERT_GetAVATag(avas[pair]);
    403       for (size_t oid = 0; oid < arraysize(kOIDs); ++oid) {
    404         if (kOIDs[oid] == tag) {
    405           SECItem* decode_item = CERT_DecodeAVAValue(&avas[pair]->value);
    406           if (!decode_item)
    407             break;
    408           // TODO(wtc): Pass decode_item to CERT_RFC1485_EscapeAndQuote.
    409           std::string value(reinterpret_cast<char*>(decode_item->data),
    410                             decode_item->len);
    411           values[oid]->push_back(value);
    412           SECITEM_FreeItem(decode_item, PR_TRUE);
    413           break;
    414         }
    415       }
    416     }
    417   }
    418 
    419   // Get CN, L, S, and C.
    420   CERTGetNameFunc get_name_funcs[4] = {
    421     CERT_GetCommonName, CERT_GetLocalityName,
    422     CERT_GetStateName, CERT_GetCountryName };
    423   std::string* single_values[4] = {
    424     &principal->common_name, &principal->locality_name,
    425     &principal->state_or_province_name, &principal->country_name };
    426   for (size_t i = 0; i < arraysize(get_name_funcs); ++i) {
    427     char* value = get_name_funcs[i](name);
    428     if (value) {
    429       single_values[i]->assign(value);
    430       PORT_Free(value);
    431     }
    432   }
    433 }
    434 
    435 void ParseDate(const SECItem* der_date, base::Time* result) {
    436   PRTime prtime;
    437   SECStatus rv = DER_DecodeTimeChoice(&prtime, der_date);
    438   DCHECK_EQ(SECSuccess, rv);
    439   *result = crypto::PRTimeToBaseTime(prtime);
    440 }
    441 
    442 std::string ParseSerialNumber(const CERTCertificate* certificate) {
    443   return std::string(reinterpret_cast<char*>(certificate->serialNumber.data),
    444                      certificate->serialNumber.len);
    445 }
    446 
    447 void GetSubjectAltName(CERTCertificate* cert_handle,
    448                        std::vector<std::string>* dns_names,
    449                        std::vector<std::string>* ip_addrs) {
    450   if (dns_names)
    451     dns_names->clear();
    452   if (ip_addrs)
    453     ip_addrs->clear();
    454 
    455   SECItem alt_name;
    456   SECStatus rv = CERT_FindCertExtension(cert_handle,
    457                                         SEC_OID_X509_SUBJECT_ALT_NAME,
    458                                         &alt_name);
    459   if (rv != SECSuccess)
    460     return;
    461 
    462   PLArenaPool* arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
    463   DCHECK(arena != NULL);
    464 
    465   CERTGeneralName* alt_name_list;
    466   alt_name_list = CERT_DecodeAltNameExtension(arena, &alt_name);
    467   SECITEM_FreeItem(&alt_name, PR_FALSE);
    468 
    469   CERTGeneralName* name = alt_name_list;
    470   while (name) {
    471     // DNSName and IPAddress are encoded as IA5String and OCTET STRINGs
    472     // respectively, both of which can be byte copied from
    473     // SECItemType::data into the appropriate output vector.
    474     if (dns_names && name->type == certDNSName) {
    475       dns_names->push_back(std::string(
    476           reinterpret_cast<char*>(name->name.other.data),
    477           name->name.other.len));
    478     } else if (ip_addrs && name->type == certIPAddress) {
    479       ip_addrs->push_back(std::string(
    480           reinterpret_cast<char*>(name->name.other.data),
    481           name->name.other.len));
    482     }
    483     name = CERT_GetNextGeneralName(name);
    484     if (name == alt_name_list)
    485       break;
    486   }
    487   PORT_FreeArena(arena, PR_FALSE);
    488 }
    489 
    490 X509Certificate::OSCertHandles CreateOSCertHandlesFromBytes(
    491     const char* data,
    492     int length,
    493     X509Certificate::Format format) {
    494   X509Certificate::OSCertHandles results;
    495   if (length < 0)
    496     return results;
    497 
    498   crypto::EnsureNSSInit();
    499 
    500   if (!NSS_IsInitialized())
    501     return results;
    502 
    503   switch (format) {
    504     case X509Certificate::FORMAT_SINGLE_CERTIFICATE: {
    505       X509Certificate::OSCertHandle handle =
    506           X509Certificate::CreateOSCertHandleFromBytes(data, length);
    507       if (handle)
    508         results.push_back(handle);
    509       break;
    510     }
    511     case X509Certificate::FORMAT_PKCS7: {
    512       // Make a copy since CERT_DecodeCertPackage may modify it
    513       std::vector<char> data_copy(data, data + length);
    514 
    515       SECStatus result = CERT_DecodeCertPackage(&data_copy[0],
    516           length, CollectCertsCallback, &results);
    517       if (result != SECSuccess)
    518         results.clear();
    519       break;
    520     }
    521     default:
    522       NOTREACHED() << "Certificate format " << format << " unimplemented";
    523       break;
    524   }
    525 
    526   return results;
    527 }
    528 
    529 X509Certificate::OSCertHandle ReadOSCertHandleFromPickle(
    530     PickleIterator* pickle_iter) {
    531   const char* data;
    532   int length;
    533   if (!pickle_iter->ReadData(&data, &length))
    534     return NULL;
    535 
    536   return X509Certificate::CreateOSCertHandleFromBytes(data, length);
    537 }
    538 
    539 void GetPublicKeyInfo(CERTCertificate* handle,
    540                       size_t* size_bits,
    541                       X509Certificate::PublicKeyType* type) {
    542   // Since we might fail, set the output parameters to default values first.
    543   *type = X509Certificate::kPublicKeyTypeUnknown;
    544   *size_bits = 0;
    545 
    546   crypto::ScopedSECKEYPublicKey key(CERT_ExtractPublicKey(handle));
    547   if (!key.get())
    548     return;
    549 
    550   *size_bits = SECKEY_PublicKeyStrengthInBits(key.get());
    551 
    552   switch (key->keyType) {
    553     case rsaKey:
    554       *type = X509Certificate::kPublicKeyTypeRSA;
    555       break;
    556     case dsaKey:
    557       *type = X509Certificate::kPublicKeyTypeDSA;
    558       break;
    559     case dhKey:
    560       *type = X509Certificate::kPublicKeyTypeDH;
    561       break;
    562     case ecKey:
    563       *type = X509Certificate::kPublicKeyTypeECDSA;
    564       break;
    565     default:
    566       *type = X509Certificate::kPublicKeyTypeUnknown;
    567       *size_bits = 0;
    568       break;
    569   }
    570 }
    571 
    572 bool GetIssuersFromEncodedList(
    573     const std::vector<std::string>& encoded_issuers,
    574     PLArenaPool* arena,
    575     std::vector<CERTName*>* out) {
    576   std::vector<CERTName*> result;
    577   for (size_t n = 0; n < encoded_issuers.size(); ++n) {
    578     CERTName* name = CreateCertNameFromEncoded(arena, encoded_issuers[n]);
    579     if (name != NULL)
    580       result.push_back(name);
    581   }
    582 
    583   if (result.size() == encoded_issuers.size()) {
    584     out->swap(result);
    585     return true;
    586   }
    587 
    588   for (size_t n = 0; n < result.size(); ++n)
    589     CERT_DestroyName(result[n]);
    590   return false;
    591 }
    592 
    593 
    594 bool IsCertificateIssuedBy(const std::vector<CERTCertificate*>& cert_chain,
    595                            const std::vector<CERTName*>& valid_issuers) {
    596   for (size_t n = 0; n < cert_chain.size(); ++n) {
    597     CERTName* cert_issuer = &cert_chain[n]->issuer;
    598     for (size_t i = 0; i < valid_issuers.size(); ++i) {
    599       if (CERT_CompareName(valid_issuers[i], cert_issuer) == SECEqual)
    600         return true;
    601     }
    602   }
    603   return false;
    604 }
    605 
    606 std::string GetUniqueNicknameForSlot(const std::string& nickname,
    607                                      const SECItem* subject,
    608                                      PK11SlotInfo* slot) {
    609   int index = 2;
    610   std::string new_name = nickname;
    611   std::string temp_nickname = new_name;
    612   std::string token_name;
    613 
    614   if (!slot)
    615     return new_name;
    616 
    617   if (!PK11_IsInternalKeySlot(slot)) {
    618     token_name.assign(PK11_GetTokenName(slot));
    619     token_name.append(":");
    620 
    621     temp_nickname = token_name + new_name;
    622   }
    623 
    624   while (SEC_CertNicknameConflict(temp_nickname.c_str(),
    625                                   const_cast<SECItem*>(subject),
    626                                   CERT_GetDefaultCertDB())) {
    627     base::SStringPrintf(&new_name, "%s #%d", nickname.c_str(), index++);
    628     temp_nickname = token_name + new_name;
    629   }
    630 
    631   return new_name;
    632 }
    633 
    634 #endif  // defined(USE_NSS) || defined(OS_IOS)
    635 
    636 } // namespace x509_util
    637 
    638 } // namespace net
    639