| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master