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_openssl.h"
      6 
      7 #include <algorithm>
      8 #include <openssl/asn1.h>
      9 
     10 #include "base/lazy_instance.h"
     11 #include "base/logging.h"
     12 #include "base/strings/string_piece.h"
     13 #include "base/strings/string_util.h"
     14 #include "crypto/ec_private_key.h"
     15 #include "crypto/openssl_util.h"
     16 #include "crypto/rsa_private_key.h"
     17 #include "crypto/scoped_openssl_types.h"
     18 #include "net/cert/x509_cert_types.h"
     19 #include "net/cert/x509_util.h"
     20 
     21 namespace net {
     22 
     23 namespace {
     24 
     25 typedef crypto::ScopedOpenSSL<ASN1_INTEGER, ASN1_INTEGER_free>::Type
     26     ScopedASN1_INTEGER;
     27 typedef crypto::ScopedOpenSSL<ASN1_OCTET_STRING, ASN1_OCTET_STRING_free>::Type
     28     ScopedASN1_OCTET_STRING;
     29 typedef crypto::ScopedOpenSSL<ASN1_STRING, ASN1_STRING_free>::Type
     30     ScopedASN1_STRING;
     31 typedef crypto::ScopedOpenSSL<ASN1_TIME, ASN1_TIME_free>::Type ScopedASN1_TIME;
     32 typedef crypto::ScopedOpenSSL<X509, X509_free>::Type ScopedX509;
     33 typedef crypto::ScopedOpenSSL<X509_EXTENSION, X509_EXTENSION_free>::Type
     34     ScopedX509_EXTENSION;
     35 typedef crypto::ScopedOpenSSL<X509_NAME, X509_NAME_free>::Type ScopedX509_NAME;
     36 
     37 const EVP_MD* ToEVP(x509_util::DigestAlgorithm alg) {
     38   switch (alg) {
     39     case x509_util::DIGEST_SHA1:
     40       return EVP_sha1();
     41     case x509_util::DIGEST_SHA256:
     42       return EVP_sha256();
     43   }
     44   return NULL;
     45 }
     46 
     47 }  // namespace
     48 
     49 namespace x509_util {
     50 
     51 namespace {
     52 
     53 X509* CreateCertificate(EVP_PKEY* key,
     54                         DigestAlgorithm alg,
     55                         const std::string& common_name,
     56                         uint32_t serial_number,
     57                         base::Time not_valid_before,
     58                         base::Time not_valid_after) {
     59   // Put the serial number into an OpenSSL-friendly object.
     60   ScopedASN1_INTEGER asn1_serial(ASN1_INTEGER_new());
     61   if (!asn1_serial.get() ||
     62       !ASN1_INTEGER_set(asn1_serial.get(), static_cast<long>(serial_number))) {
     63     LOG(ERROR) << "Invalid serial number " << serial_number;
     64     return NULL;
     65   }
     66 
     67   // Do the same for the time stamps.
     68   ScopedASN1_TIME asn1_not_before_time(
     69       ASN1_TIME_set(NULL, not_valid_before.ToTimeT()));
     70   if (!asn1_not_before_time.get()) {
     71     LOG(ERROR) << "Invalid not_valid_before time: "
     72                << not_valid_before.ToTimeT();
     73     return NULL;
     74   }
     75 
     76   ScopedASN1_TIME asn1_not_after_time(
     77       ASN1_TIME_set(NULL, not_valid_after.ToTimeT()));
     78   if (!asn1_not_after_time.get()) {
     79     LOG(ERROR) << "Invalid not_valid_after time: " << not_valid_after.ToTimeT();
     80     return NULL;
     81   }
     82 
     83   // Because |common_name| only contains a common name and starts with 'CN=',
     84   // there is no need for a full RFC 2253 parser here. Do some sanity checks
     85   // though.
     86   static const char kCommonNamePrefix[] = "CN=";
     87   const size_t kCommonNamePrefixLen = sizeof(kCommonNamePrefix) - 1;
     88   if (common_name.size() < kCommonNamePrefixLen ||
     89       strncmp(common_name.c_str(), kCommonNamePrefix, kCommonNamePrefixLen)) {
     90     LOG(ERROR) << "Common name must begin with " << kCommonNamePrefix;
     91     return NULL;
     92   }
     93   if (common_name.size() > INT_MAX) {
     94     LOG(ERROR) << "Common name too long";
     95     return NULL;
     96   }
     97   unsigned char* common_name_str =
     98       reinterpret_cast<unsigned char*>(const_cast<char*>(common_name.data())) +
     99       kCommonNamePrefixLen;
    100   int common_name_len =
    101       static_cast<int>(common_name.size() - kCommonNamePrefixLen);
    102 
    103   ScopedX509_NAME name(X509_NAME_new());
    104   if (!name.get() || !X509_NAME_add_entry_by_NID(name.get(),
    105                                                  NID_commonName,
    106                                                  MBSTRING_ASC,
    107                                                  common_name_str,
    108                                                  common_name_len,
    109                                                  -1,
    110                                                  0)) {
    111     LOG(ERROR) << "Can't parse common name: " << common_name.c_str();
    112     return NULL;
    113   }
    114 
    115   // Now create certificate and populate it.
    116   ScopedX509 cert(X509_new());
    117   if (!cert.get() || !X509_set_version(cert.get(), 2L) /* i.e. version 3 */ ||
    118       !X509_set_pubkey(cert.get(), key) ||
    119       !X509_set_serialNumber(cert.get(), asn1_serial.get()) ||
    120       !X509_set_notBefore(cert.get(), asn1_not_before_time.get()) ||
    121       !X509_set_notAfter(cert.get(), asn1_not_after_time.get()) ||
    122       !X509_set_subject_name(cert.get(), name.get()) ||
    123       !X509_set_issuer_name(cert.get(), name.get())) {
    124     LOG(ERROR) << "Could not create certificate";
    125     return NULL;
    126   }
    127 
    128   return cert.release();
    129 }
    130 
    131 // DER-encodes |x509|. On success, returns true and writes the
    132 // encoding to |*out_der|.
    133 bool DerEncodeCert(X509* x509, std::string* out_der) {
    134   int len = i2d_X509(x509, NULL);
    135   if (len < 0)
    136     return false;
    137 
    138   uint8_t* ptr = reinterpret_cast<uint8_t*>(WriteInto(out_der, len + 1));
    139   if (i2d_X509(x509, &ptr) < 0) {
    140     NOTREACHED();
    141     out_der->clear();
    142     return false;
    143   }
    144   return true;
    145 }
    146 
    147 bool SignAndDerEncodeCert(X509* cert,
    148                           EVP_PKEY* key,
    149                           DigestAlgorithm alg,
    150                           std::string* der_encoded) {
    151   // Get the message digest algorithm
    152   const EVP_MD* md = ToEVP(alg);
    153   if (!md) {
    154     LOG(ERROR) << "Unrecognized hash algorithm.";
    155     return false;
    156   }
    157 
    158   // Sign it with the private key.
    159   if (!X509_sign(cert, key, md)) {
    160     LOG(ERROR) << "Could not sign certificate with key.";
    161     return false;
    162   }
    163 
    164   // Convert it into a DER-encoded string copied to |der_encoded|.
    165   return DerEncodeCert(cert, der_encoded);
    166 }
    167 
    168 // There is no OpenSSL NID for the 'originBoundCertificate' extension OID yet,
    169 // so create a global ASN1_OBJECT lazily with the right parameters.
    170 class DomainBoundOid {
    171  public:
    172   DomainBoundOid() : obj_(OBJ_txt2obj(kDomainBoundOidText, 1)) { CHECK(obj_); }
    173 
    174   ~DomainBoundOid() {
    175     if (obj_)
    176       ASN1_OBJECT_free(obj_);
    177   }
    178 
    179   ASN1_OBJECT* obj() const { return obj_; }
    180 
    181  private:
    182   static const char kDomainBoundOidText[];
    183 
    184   ASN1_OBJECT* obj_;
    185 };
    186 
    187 // 1.3.6.1.4.1.11129.2.1.6
    188 // (iso.org.dod.internet.private.enterprises.google.googleSecurity.
    189 //  certificateExtensions.originBoundCertificate)
    190 const char DomainBoundOid::kDomainBoundOidText[] = "1.3.6.1.4.1.11129.2.1.6";
    191 
    192 ASN1_OBJECT* GetDomainBoundOid() {
    193   static base::LazyInstance<DomainBoundOid>::Leaky s_lazy =
    194       LAZY_INSTANCE_INITIALIZER;
    195   return s_lazy.Get().obj();
    196 }
    197 
    198 
    199 struct DERCache {
    200   std::string data;
    201 };
    202 
    203 void DERCache_free(void* parent, void* ptr, CRYPTO_EX_DATA* ad, int idx,
    204                    long argl, void* argp) {
    205   DERCache* der_cache = static_cast<DERCache*>(ptr);
    206   delete der_cache;
    207 }
    208 
    209 class DERCacheInitSingleton {
    210  public:
    211   DERCacheInitSingleton() {
    212     crypto::EnsureOpenSSLInit();
    213     der_cache_ex_index_ = X509_get_ex_new_index(0, 0, 0, 0, DERCache_free);
    214     DCHECK_NE(-1, der_cache_ex_index_);
    215   }
    216 
    217   int der_cache_ex_index() const { return der_cache_ex_index_; }
    218 
    219  private:
    220   int der_cache_ex_index_;
    221 
    222   DISALLOW_COPY_AND_ASSIGN(DERCacheInitSingleton);
    223 };
    224 
    225 base::LazyInstance<DERCacheInitSingleton>::Leaky g_der_cache_singleton =
    226     LAZY_INSTANCE_INITIALIZER;
    227 
    228 }  // namespace
    229 
    230 bool IsSupportedValidityRange(base::Time not_valid_before,
    231                               base::Time not_valid_after) {
    232   if (not_valid_before > not_valid_after)
    233     return false;
    234 
    235   // The validity field of a certificate can only encode years 1-9999.
    236 
    237   // Compute the base::Time values corresponding to Jan 1st,0001 and
    238   // Jan 1st, 10000 respectively. Done by using the pre-computed numbers
    239   // of days between these dates and the Unix epoch, i.e. Jan 1st, 1970,
    240   // using the following Python script:
    241   //
    242   //     from datetime import date as D
    243   //     print (D(1970,1,1)-D(1,1,1))        # -> 719162 days
    244   //     print (D(9999,12,31)-D(1970,1,1))   # -> 2932896 days
    245   //
    246   // Note: This ignores leap seconds, but should be enough in practice.
    247   //
    248   const int64 kDaysFromYear0001ToUnixEpoch = 719162;
    249   const int64 kDaysFromUnixEpochToYear10000 = 2932896 + 1;
    250   const base::Time kEpoch = base::Time::UnixEpoch();
    251   const base::Time kYear0001 = kEpoch -
    252       base::TimeDelta::FromDays(kDaysFromYear0001ToUnixEpoch);
    253   const base::Time kYear10000 = kEpoch +
    254       base::TimeDelta::FromDays(kDaysFromUnixEpochToYear10000);
    255 
    256   if (not_valid_before < kYear0001 || not_valid_before >= kYear10000 ||
    257       not_valid_after < kYear0001 || not_valid_after >= kYear10000)
    258     return false;
    259 
    260   return true;
    261 }
    262 
    263 bool CreateChannelIDEC(
    264     crypto::ECPrivateKey* key,
    265     DigestAlgorithm alg,
    266     const std::string& domain,
    267     uint32 serial_number,
    268     base::Time not_valid_before,
    269     base::Time not_valid_after,
    270     std::string* der_cert) {
    271   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
    272   // Create certificate.
    273   ScopedX509 cert(CreateCertificate(key->key(),
    274                                     alg,
    275                                     "CN=anonymous.invalid",
    276                                     serial_number,
    277                                     not_valid_before,
    278                                     not_valid_after));
    279   if (!cert.get())
    280     return false;
    281 
    282   // Add TLS-Channel-ID extension to the certificate before signing it.
    283   // The value must be stored DER-encoded, as a ASN.1 IA5String.
    284   ScopedASN1_STRING domain_ia5(ASN1_IA5STRING_new());
    285   if (!domain_ia5.get() ||
    286       !ASN1_STRING_set(domain_ia5.get(), domain.data(), domain.size()))
    287     return false;
    288 
    289   std::string domain_der;
    290   int domain_der_len = i2d_ASN1_IA5STRING(domain_ia5.get(), NULL);
    291   if (domain_der_len < 0)
    292     return false;
    293 
    294   domain_der.resize(domain_der_len);
    295   unsigned char* domain_der_data =
    296       reinterpret_cast<unsigned char*>(&domain_der[0]);
    297   if (i2d_ASN1_IA5STRING(domain_ia5.get(), &domain_der_data) < 0)
    298     return false;
    299 
    300   ScopedASN1_OCTET_STRING domain_str(ASN1_OCTET_STRING_new());
    301   if (!domain_str.get() ||
    302       !ASN1_STRING_set(domain_str.get(), domain_der.data(), domain_der.size()))
    303     return false;
    304 
    305   ScopedX509_EXTENSION ext(X509_EXTENSION_create_by_OBJ(
    306       NULL, GetDomainBoundOid(), 1 /* critical */, domain_str.get()));
    307   if (!ext.get() || !X509_add_ext(cert.get(), ext.get(), -1)) {
    308     return false;
    309   }
    310 
    311   // Sign and encode it.
    312   return SignAndDerEncodeCert(cert.get(), key->key(), alg, der_cert);
    313 }
    314 
    315 bool CreateSelfSignedCert(crypto::RSAPrivateKey* key,
    316                           DigestAlgorithm alg,
    317                           const std::string& common_name,
    318                           uint32 serial_number,
    319                           base::Time not_valid_before,
    320                           base::Time not_valid_after,
    321                           std::string* der_encoded) {
    322   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
    323   ScopedX509 cert(CreateCertificate(key->key(),
    324                                     alg,
    325                                     common_name,
    326                                     serial_number,
    327                                     not_valid_before,
    328                                     not_valid_after));
    329   if (!cert.get())
    330     return false;
    331 
    332   return SignAndDerEncodeCert(cert.get(), key->key(), alg, der_encoded);
    333 }
    334 
    335 bool ParsePrincipalKeyAndValue(X509_NAME_ENTRY* entry,
    336                                std::string* key,
    337                                std::string* value) {
    338   if (key) {
    339     ASN1_OBJECT* object = X509_NAME_ENTRY_get_object(entry);
    340     key->assign(OBJ_nid2sn(OBJ_obj2nid(object)));
    341   }
    342 
    343   ASN1_STRING* data = X509_NAME_ENTRY_get_data(entry);
    344   if (!data)
    345     return false;
    346 
    347   unsigned char* buf = NULL;
    348   int len = ASN1_STRING_to_UTF8(&buf, data);
    349   if (len <= 0)
    350     return false;
    351 
    352   value->assign(reinterpret_cast<const char*>(buf), len);
    353   OPENSSL_free(buf);
    354   return true;
    355 }
    356 
    357 bool ParsePrincipalKeyAndValueByIndex(X509_NAME* name,
    358                                       int index,
    359                                       std::string* key,
    360                                       std::string* value) {
    361   X509_NAME_ENTRY* entry = X509_NAME_get_entry(name, index);
    362   if (!entry)
    363     return false;
    364 
    365   return ParsePrincipalKeyAndValue(entry, key, value);
    366 }
    367 
    368 bool ParsePrincipalValueByIndex(X509_NAME* name,
    369                                 int index,
    370                                 std::string* value) {
    371   return ParsePrincipalKeyAndValueByIndex(name, index, NULL, value);
    372 }
    373 
    374 bool ParsePrincipalValueByNID(X509_NAME* name, int nid, std::string* value) {
    375   int index = X509_NAME_get_index_by_NID(name, nid, -1);
    376   if (index < 0)
    377     return false;
    378 
    379   return ParsePrincipalValueByIndex(name, index, value);
    380 }
    381 
    382 bool ParseDate(ASN1_TIME* x509_time, base::Time* time) {
    383   if (!x509_time ||
    384       (x509_time->type != V_ASN1_UTCTIME &&
    385        x509_time->type != V_ASN1_GENERALIZEDTIME))
    386     return false;
    387 
    388   base::StringPiece str_date(reinterpret_cast<const char*>(x509_time->data),
    389                              x509_time->length);
    390 
    391   CertDateFormat format = x509_time->type == V_ASN1_UTCTIME ?
    392       CERT_DATE_FORMAT_UTC_TIME : CERT_DATE_FORMAT_GENERALIZED_TIME;
    393   return ParseCertificateDate(str_date, format, time);
    394 }
    395 
    396 // Returns true if |der_cache| points to valid data, false otherwise.
    397 // (note: the DER-encoded data in |der_cache| is owned by |cert|, callers should
    398 // not free it).
    399 bool GetDER(X509* x509, base::StringPiece* der_cache) {
    400   int x509_der_cache_index =
    401       g_der_cache_singleton.Get().der_cache_ex_index();
    402 
    403   // Re-encoding the DER data via i2d_X509 is an expensive operation,
    404   // but it's necessary for comparing two certificates. Re-encode at
    405   // most once per certificate and cache the data within the X509 cert
    406   // using X509_set_ex_data.
    407   DERCache* internal_cache = static_cast<DERCache*>(
    408       X509_get_ex_data(x509, x509_der_cache_index));
    409   if (!internal_cache) {
    410     scoped_ptr<DERCache> new_cache(new DERCache);
    411     if (!DerEncodeCert(x509, &new_cache->data))
    412       return false;
    413     internal_cache = new_cache.get();
    414     X509_set_ex_data(x509, x509_der_cache_index, new_cache.release());
    415   }
    416   *der_cache = base::StringPiece(internal_cache->data);
    417   return true;
    418 }
    419 
    420 }  // namespace x509_util
    421 
    422 }  // namespace net
    423