net/cert/x509_certificate_openssl.cc

   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_certificate.h"
   6
   7 #include <openssl/asn1.h>
   8 #include <openssl/bytestring.h>
   9 #include <openssl/crypto.h>
  10 #include <openssl/obj_mac.h>
  11 #include <openssl/pem.h>
  12 #include <openssl/sha.h>
  13 #include <openssl/ssl.h>
  14 #include <openssl/x509v3.h>
  15
  16 #include "base/memory/singleton.h"
  17 #include "base/pickle.h"
  18 #include "base/sha1.h"
  19 #include "base/strings/string_number_conversions.h"
  20 #include "base/strings/string_piece.h"
  21 #include "base/strings/string_util.h"
  22 #include "crypto/openssl_util.h"
  23 #include "crypto/scoped_openssl_types.h"
  24 #include "net/base/net_errors.h"
  25 #include "net/base/net_util.h"
  26 #include "net/cert/x509_util_openssl.h"
  27
  28 #if defined(OS_ANDROID)
  29 #include "base/logging.h"
  30 #include "net/android/network_library.h"
  31 #endif
  32
  33 namespace net {
  34
  35 namespace {
  36
  37 typedef crypto::ScopedOpenSSL<GENERAL_NAMES, GENERAL_NAMES_free>::Type
  38     ScopedGENERAL_NAMES;
  39
  40 void CreateOSCertHandlesFromPKCS7Bytes(
  41     const char* data, int length,
  42     X509Certificate::OSCertHandles* handles) {
  43   crypto::EnsureOpenSSLInit();
  44   crypto::OpenSSLErrStackTracer err_cleaner(FROM_HERE);
  45
  46   CBS der_data;
  47   CBS_init(&der_data, reinterpret_cast<const uint8_t*>(data), length);
  48   STACK_OF(X509)* certs = sk_X509_new_null();
  49
  50   if (PKCS7_get_certificates(certs, &der_data)) {
  51     for (size_t i = 0; i < sk_X509_num(certs); ++i) {
  52       X509* x509_cert =
  53           X509Certificate::DupOSCertHandle(sk_X509_value(certs, i));
  54       handles->push_back(x509_cert);
  55     }
  56   }
  57   sk_X509_pop_free(certs, X509_free);
  58 }
  59
  60 void ParsePrincipalValues(X509_NAME* name,
  61                           int nid,
  62                           std::vector<std::string>* fields) {
  63   for (int index = -1;
  64        (index = X509_NAME_get_index_by_NID(name, nid, index)) != -1;) {
  65     std::string field;
  66     if (!x509_util::ParsePrincipalValueByIndex(name, index, &field))
  67       break;
  68     fields->push_back(field);
  69   }
  70 }
  71
  72 void ParsePrincipal(X509Certificate::OSCertHandle cert,
  73                     X509_NAME* x509_name,
  74                     CertPrincipal* principal) {
  75   if (!x509_name)
  76     return;
  77
  78   ParsePrincipalValues(x509_name, NID_streetAddress,
  79                        &principal->street_addresses);
  80   ParsePrincipalValues(x509_name, NID_organizationName,
  81                        &principal->organization_names);
  82   ParsePrincipalValues(x509_name, NID_organizationalUnitName,
  83                        &principal->organization_unit_names);
  84   ParsePrincipalValues(x509_name, NID_domainComponent,
  85                        &principal->domain_components);
  86
  87   x509_util::ParsePrincipalValueByNID(x509_name, NID_commonName,
  88                                       &principal->common_name);
  89   x509_util::ParsePrincipalValueByNID(x509_name, NID_localityName,
  90                                       &principal->locality_name);
  91   x509_util::ParsePrincipalValueByNID(x509_name, NID_stateOrProvinceName,
  92                                       &principal->state_or_province_name);
  93   x509_util::ParsePrincipalValueByNID(x509_name, NID_countryName,
  94                                       &principal->country_name);
  95 }
  96
  97 void ParseSubjectAltName(X509Certificate::OSCertHandle cert,
  98                          std::vector<std::string>* dns_names,
  99                          std::vector<std::string>* ip_addresses) {
 100   DCHECK(dns_names || ip_addresses);
 101   int index = X509_get_ext_by_NID(cert, NID_subject_alt_name, -1);
 102   X509_EXTENSION* alt_name_ext = X509_get_ext(cert, index);
 103   if (!alt_name_ext)
 104     return;
 105
 106   ScopedGENERAL_NAMES alt_names(
 107       reinterpret_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(alt_name_ext)));
 108   if (!alt_names.get())
 109     return;
 110
 111   for (size_t i = 0; i < sk_GENERAL_NAME_num(alt_names.get()); ++i) {
 112     const GENERAL_NAME* name = sk_GENERAL_NAME_value(alt_names.get(), i);
 113     if (name->type == GEN_DNS && dns_names) {
 114       const unsigned char* dns_name = ASN1_STRING_data(name->d.dNSName);
 115       if (!dns_name)
 116         continue;
 117       int dns_name_len = ASN1_STRING_length(name->d.dNSName);
 118       dns_names->push_back(
 119           std::string(reinterpret_cast<const char*>(dns_name), dns_name_len));
 120     } else if (name->type == GEN_IPADD && ip_addresses) {
 121       const unsigned char* ip_addr = name->d.iPAddress->data;
 122       if (!ip_addr)
 123         continue;
 124       int ip_addr_len = name->d.iPAddress->length;
 125       if (ip_addr_len != static_cast<int>(kIPv4AddressSize) &&
 126           ip_addr_len != static_cast<int>(kIPv6AddressSize)) {
 127         // http://www.ietf.org/rfc/rfc3280.txt requires subjectAltName iPAddress
 128         // to have 4 or 16 bytes, whereas in a name constraint it includes a
 129         // net mask hence 8 or 32 bytes. Logging to help diagnose any mixup.
 130         LOG(WARNING) << "Bad sized IP Address in cert: " << ip_addr_len;
 131         continue;
 132       }
 133       ip_addresses->push_back(
 134           std::string(reinterpret_cast<const char*>(ip_addr), ip_addr_len));
 135     }
 136   }
 137 }
 138
 139 class X509InitSingleton {
 140  public:
 141   static X509InitSingleton* GetInstance() {
 142     // We allow the X509 store to leak, because it is used from a non-joinable
 143     // worker that is not stopped on shutdown, hence may still be using
 144     // OpenSSL library after the AtExit runner has completed.
 145     return Singleton<X509InitSingleton,
 146                      LeakySingletonTraits<X509InitSingleton> >::get();
 147   }
 148   X509_STORE* store() const { return store_.get(); }
 149
 150   void ResetCertStore() {
 151     store_.reset(X509_STORE_new());
 152     DCHECK(store_.get());
 153     X509_STORE_set_default_paths(store_.get());
 154     // TODO(joth): Enable CRL (see X509_STORE_set_flags(X509_V_FLAG_CRL_CHECK)).
 155   }
 156
 157  private:
 158   friend struct DefaultSingletonTraits<X509InitSingleton>;
 159   X509InitSingleton() {
 160     crypto::EnsureOpenSSLInit();
 161     ResetCertStore();
 162   }
 163
 164   crypto::ScopedOpenSSL<X509_STORE, X509_STORE_free>::Type store_;
 165
 166   DISALLOW_COPY_AND_ASSIGN(X509InitSingleton);
 167 };
 168
 169 // Used to free a list of X509_NAMEs and the objects it points to.
 170 void sk_X509_NAME_free_all(STACK_OF(X509_NAME)* sk) {
 171   sk_X509_NAME_pop_free(sk, X509_NAME_free);
 172 }
 173
 174 }  // namespace
 175
 176 // static
 177 X509Certificate::OSCertHandle X509Certificate::DupOSCertHandle(
 178     OSCertHandle cert_handle) {
 179   DCHECK(cert_handle);
 180   return X509_up_ref(cert_handle);
 181 }
 182
 183 // static
 184 void X509Certificate::FreeOSCertHandle(OSCertHandle cert_handle) {
 185   // Decrement the ref-count for the cert and, if all references are gone,
 186   // free the memory and any application-specific data associated with the
 187   // certificate.
 188   X509_free(cert_handle);
 189 }
 190
 191 void X509Certificate::Initialize() {
 192   crypto::EnsureOpenSSLInit();
 193   fingerprint_ = CalculateFingerprint(cert_handle_);
 194   ca_fingerprint_ = CalculateCAFingerprint(intermediate_ca_certs_);
 195
 196   ASN1_INTEGER* serial_num = X509_get_serialNumber(cert_handle_);
 197   if (serial_num) {
 198     // ASN1_INTEGERS represent the decoded number, in a format internal to
 199     // OpenSSL. Most notably, this may have leading zeroes stripped off for
 200     // numbers whose first byte is >= 0x80. Thus, it is necessary to
 201     // re-encoded the integer back into DER, which is what the interface
 202     // of X509Certificate exposes, to ensure callers get the proper (DER)
 203     // value.
 204     int bytes_required = i2c_ASN1_INTEGER(serial_num, NULL);
 205     unsigned char* buffer = reinterpret_cast<unsigned char*>(
 206         WriteInto(&serial_number_, bytes_required + 1));
 207     int bytes_written = i2c_ASN1_INTEGER(serial_num, &buffer);
 208     DCHECK_EQ(static_cast<size_t>(bytes_written), serial_number_.size());
 209   }
 210
 211   ParsePrincipal(cert_handle_, X509_get_subject_name(cert_handle_), &subject_);
 212   ParsePrincipal(cert_handle_, X509_get_issuer_name(cert_handle_), &issuer_);
 213   x509_util::ParseDate(X509_get_notBefore(cert_handle_), &valid_start_);
 214   x509_util::ParseDate(X509_get_notAfter(cert_handle_), &valid_expiry_);
 215 }
 216
 217 // static
 218 void X509Certificate::ResetCertStore() {
 219   X509InitSingleton::GetInstance()->ResetCertStore();
 220 }
 221
 222 // static
 223 SHA1HashValue X509Certificate::CalculateFingerprint(OSCertHandle cert) {
 224   SHA1HashValue sha1;
 225   unsigned int sha1_size = static_cast<unsigned int>(sizeof(sha1.data));
 226   int ret = X509_digest(cert, EVP_sha1(), sha1.data, &sha1_size);
 227   CHECK(ret);
 228   CHECK_EQ(sha1_size, sizeof(sha1.data));
 229   return sha1;
 230 }
 231
 232 // static
 233 SHA1HashValue X509Certificate::CalculateCAFingerprint(
 234     const OSCertHandles& intermediates) {
 235   SHA1HashValue sha1;
 236   memset(sha1.data, 0, sizeof(sha1.data));
 237
 238   SHA_CTX sha1_ctx;
 239   SHA1_Init(&sha1_ctx);
 240   base::StringPiece der;
 241   for (size_t i = 0; i < intermediates.size(); ++i) {
 242     if (!x509_util::GetDER(intermediates[i], &der))
 243       return sha1;
 244     SHA1_Update(&sha1_ctx, der.data(), der.length());
 245   }
 246   SHA1_Final(sha1.data, &sha1_ctx);
 247
 248   return sha1;
 249 }
 250
 251 // static
 252 X509Certificate::OSCertHandle X509Certificate::CreateOSCertHandleFromBytes(
 253     const char* data, int length) {
 254   if (length < 0)
 255     return NULL;
 256   crypto::EnsureOpenSSLInit();
 257   const unsigned char* d2i_data =
 258       reinterpret_cast<const unsigned char*>(data);
 259   // Don't cache this data for x509_util::GetDER as this wire format
 260   // may be not be identical from the i2d_X509 roundtrip.
 261   X509* cert = d2i_X509(NULL, &d2i_data, length);
 262   return cert;
 263 }
 264
 265 // static
 266 X509Certificate::OSCertHandles X509Certificate::CreateOSCertHandlesFromBytes(
 267     const char* data, int length, Format format) {
 268   OSCertHandles results;
 269   if (length < 0)
 270     return results;
 271
 272   switch (format) {
 273     case FORMAT_SINGLE_CERTIFICATE: {
 274       OSCertHandle handle = CreateOSCertHandleFromBytes(data, length);
 275       if (handle)
 276         results.push_back(handle);
 277       break;
 278     }
 279     case FORMAT_PKCS7: {
 280       CreateOSCertHandlesFromPKCS7Bytes(data, length, &results);
 281       break;
 282     }
 283     default: {
 284       NOTREACHED() << "Certificate format " << format << " unimplemented";
 285       break;
 286     }
 287   }
 288
 289   return results;
 290 }
 291
 292 void X509Certificate::GetSubjectAltName(
 293     std::vector<std::string>* dns_names,
 294     std::vector<std::string>* ip_addrs) const {
 295   if (dns_names)
 296     dns_names->clear();
 297   if (ip_addrs)
 298     ip_addrs->clear();
 299
 300   ParseSubjectAltName(cert_handle_, dns_names, ip_addrs);
 301 }
 302
 303 // static
 304 X509_STORE* X509Certificate::cert_store() {
 305   return X509InitSingleton::GetInstance()->store();
 306 }
 307
 308 // static
 309 bool X509Certificate::GetDEREncoded(X509Certificate::OSCertHandle cert_handle,
 310                                     std::string* encoded) {
 311   base::StringPiece der;
 312   if (!cert_handle || !x509_util::GetDER(cert_handle, &der))
 313     return false;
 314   encoded->assign(der.data(), der.length());
 315   return true;
 316 }
 317
 318 // static
 319 bool X509Certificate::IsSameOSCert(X509Certificate::OSCertHandle a,
 320                                    X509Certificate::OSCertHandle b) {
 321   DCHECK(a && b);
 322   if (a == b)
 323     return true;
 324
 325   // X509_cmp only checks the fingerprint, but we want to compare the whole
 326   // DER data. Encoding it from OSCertHandle is an expensive operation, so we
 327   // cache the DER (if not already cached via X509_set_ex_data).
 328   base::StringPiece der_a, der_b;
 329
 330   return x509_util::GetDER(a, &der_a) &&
 331       x509_util::GetDER(b, &der_b) &&
 332       der_a == der_b;
 333 }
 334
 335 // static
 336 X509Certificate::OSCertHandle
 337 X509Certificate::ReadOSCertHandleFromPickle(PickleIterator* pickle_iter) {
 338   const char* data;
 339   int length;
 340   if (!pickle_iter->ReadData(&data, &length))
 341     return NULL;
 342
 343   return CreateOSCertHandleFromBytes(data, length);
 344 }
 345
 346 // static
 347 bool X509Certificate::WriteOSCertHandleToPickle(OSCertHandle cert_handle,
 348                                                 Pickle* pickle) {
 349   base::StringPiece der;
 350   if (!x509_util::GetDER(cert_handle, &der))
 351     return false;
 352
 353   return pickle->WriteData(der.data(), der.length());
 354 }
 355
 356 // static
 357 void X509Certificate::GetPublicKeyInfo(OSCertHandle cert_handle,
 358                                        size_t* size_bits,
 359                                        PublicKeyType* type) {
 360   *type = kPublicKeyTypeUnknown;
 361   *size_bits = 0;
 362
 363   crypto::ScopedEVP_PKEY scoped_key(X509_get_pubkey(cert_handle));
 364   if (!scoped_key.get())
 365     return;
 366
 367   CHECK(scoped_key.get());
 368   EVP_PKEY* key = scoped_key.get();
 369
 370   switch (key->type) {
 371     case EVP_PKEY_RSA:
 372       *type = kPublicKeyTypeRSA;
 373       *size_bits = EVP_PKEY_size(key) * 8;
 374       break;
 375     case EVP_PKEY_DSA:
 376       *type = kPublicKeyTypeDSA;
 377       *size_bits = EVP_PKEY_size(key) * 8;
 378       break;
 379     case EVP_PKEY_EC:
 380       *type = kPublicKeyTypeECDSA;
 381       *size_bits = EVP_PKEY_bits(key);
 382       break;
 383     case EVP_PKEY_DH:
 384       *type = kPublicKeyTypeDH;
 385       *size_bits = EVP_PKEY_size(key) * 8;
 386       break;
 387   }
 388 }
 389
 390 bool X509Certificate::IsIssuedByEncoded(
 391     const std::vector<std::string>& valid_issuers) {
 392   if (valid_issuers.empty())
 393     return false;
 394
 395   // Convert to a temporary list of X509_NAME objects.
 396   // It will own the objects it points to.
 397   crypto::ScopedOpenSSL<STACK_OF(X509_NAME), sk_X509_NAME_free_all>::Type
 398       issuer_names(sk_X509_NAME_new_null());
 399   if (!issuer_names.get())
 400     return false;
 401
 402   for (std::vector<std::string>::const_iterator it = valid_issuers.begin();
 403       it != valid_issuers.end(); ++it) {
 404     const unsigned char* p =
 405         reinterpret_cast<const unsigned char*>(it->data());
 406     long len = static_cast<long>(it->length());
 407     X509_NAME* ca_name = d2i_X509_NAME(NULL, &p, len);
 408     if (ca_name == NULL)
 409       return false;
 410     sk_X509_NAME_push(issuer_names.get(), ca_name);
 411   }
 412
 413   // Create a temporary list of X509_NAME objects corresponding
 414   // to the certificate chain. It doesn't own the object it points to.
 415   std::vector<X509_NAME*> cert_names;
 416   X509_NAME* issuer = X509_get_issuer_name(cert_handle_);
 417   if (issuer == NULL)
 418     return false;
 419
 420   cert_names.push_back(issuer);
 421   for (OSCertHandles::iterator it = intermediate_ca_certs_.begin();
 422       it != intermediate_ca_certs_.end(); ++it) {
 423     issuer = X509_get_issuer_name(*it);
 424     if (issuer == NULL)
 425       return false;
 426     cert_names.push_back(issuer);
 427   }
 428
 429   // and 'cert_names'.
 430   for (size_t n = 0; n < cert_names.size(); ++n) {
 431     for (size_t m = 0; m < sk_X509_NAME_num(issuer_names.get()); ++m) {
 432       X509_NAME* issuer = sk_X509_NAME_value(issuer_names.get(), m);
 433       if (X509_NAME_cmp(issuer, cert_names[n]) == 0) {
 434         return true;
 435       }
 436     }
 437   }
 438
 439   return false;
 440 }
 441
 442 }  // namespace net