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.
5 #include "net/cert/cert_verify_proc.h"
7 #include "base/basictypes.h"
8 #include "base/metrics/histogram.h"
10 #include "base/strings/stringprintf.h"
11 #include "build/build_config.h"
12 #include "net/base/net_errors.h"
13 #include "net/base/net_util.h"
14 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
15 #include "net/cert/cert_status_flags.h"
16 #include "net/cert/cert_verifier.h"
17 #include "net/cert/cert_verify_result.h"
18 #include "net/cert/crl_set.h"
19 #include "net/cert/x509_certificate.h"
20 #include "url/url_canon.h"
22 #if defined(USE_NSS) || defined(OS_IOS)
23 #include "net/cert/cert_verify_proc_nss.h"
24 #elif defined(USE_OPENSSL_CERTS) && !defined(OS_ANDROID)
25 #include "net/cert/cert_verify_proc_openssl.h"
26 #elif defined(OS_ANDROID)
27 #include "net/cert/cert_verify_proc_android.h"
28 #elif defined(OS_MACOSX)
29 #include "net/cert/cert_verify_proc_mac.h"
31 #include "net/cert/cert_verify_proc_win.h"
33 #error Implement certificate verification.
41 // Constants used to build histogram names
42 const char kLeafCert
[] = "Leaf";
43 const char kIntermediateCert
[] = "Intermediate";
44 const char kRootCert
[] = "Root";
45 // Matches the order of X509Certificate::PublicKeyType
46 const char* const kCertTypeStrings
[] = {
54 // Histogram buckets for RSA/DSA/DH key sizes.
55 const int kRsaDsaKeySizes
[] = {512, 768, 1024, 1536, 2048, 3072, 4096, 8192,
57 // Histogram buckets for ECDSA/ECDH key sizes. The list is based upon the FIPS
58 // 186-4 approved curves.
59 const int kEccKeySizes
[] = {163, 192, 224, 233, 256, 283, 384, 409, 521, 571};
61 const char* CertTypeToString(int cert_type
) {
63 static_cast<size_t>(cert_type
) >= arraysize(kCertTypeStrings
)) {
66 return kCertTypeStrings
[cert_type
];
69 void RecordPublicKeyHistogram(const char* chain_position
,
70 bool baseline_keysize_applies
,
72 X509Certificate::PublicKeyType cert_type
) {
73 std::string histogram_name
=
74 base::StringPrintf("CertificateType2.%s.%s.%s",
75 baseline_keysize_applies
? "BR" : "NonBR",
77 CertTypeToString(cert_type
));
78 // Do not use UMA_HISTOGRAM_... macros here, as it caches the Histogram
79 // instance and thus only works if |histogram_name| is constant.
80 base::HistogramBase
* counter
= NULL
;
82 // Histogram buckets are contingent upon the underlying algorithm being used.
83 if (cert_type
== X509Certificate::kPublicKeyTypeECDH
||
84 cert_type
== X509Certificate::kPublicKeyTypeECDSA
) {
85 // Typical key sizes match SECP/FIPS 186-3 recommendations for prime and
86 // binary curves - which range from 163 bits to 571 bits.
87 counter
= base::CustomHistogram::FactoryGet(
89 base::CustomHistogram::ArrayToCustomRanges(kEccKeySizes
,
90 arraysize(kEccKeySizes
)),
91 base::HistogramBase::kUmaTargetedHistogramFlag
);
93 // Key sizes < 1024 bits should cause errors, while key sizes > 16K are not
94 // uniformly supported by the underlying cryptographic libraries.
95 counter
= base::CustomHistogram::FactoryGet(
97 base::CustomHistogram::ArrayToCustomRanges(kRsaDsaKeySizes
,
98 arraysize(kRsaDsaKeySizes
)),
99 base::HistogramBase::kUmaTargetedHistogramFlag
);
101 counter
->Add(size_bits
);
104 // Returns true if |type| is |kPublicKeyTypeRSA| or |kPublicKeyTypeDSA|, and
105 // if |size_bits| is < 1024. Note that this means there may be false
106 // negatives: keys for other algorithms and which are weak will pass this
108 bool IsWeakKey(X509Certificate::PublicKeyType type
, size_t size_bits
) {
110 case X509Certificate::kPublicKeyTypeRSA
:
111 case X509Certificate::kPublicKeyTypeDSA
:
112 return size_bits
< 1024;
118 // Returns true if |cert| contains a known-weak key. Additionally, histograms
119 // the observed keys for future tightening of the definition of what
120 // constitutes a weak key.
121 bool ExaminePublicKeys(const scoped_refptr
<X509Certificate
>& cert
,
122 bool should_histogram
) {
123 // The effective date of the CA/Browser Forum's Baseline Requirements -
124 // 2012-07-01 00:00:00 UTC.
125 const base::Time kBaselineEffectiveDate
=
126 base::Time::FromInternalValue(GG_INT64_C(12985574400000000));
127 // The effective date of the key size requirements from Appendix A, v1.1.5
128 // 2014-01-01 00:00:00 UTC.
129 const base::Time kBaselineKeysizeEffectiveDate
=
130 base::Time::FromInternalValue(GG_INT64_C(13033008000000000));
132 size_t size_bits
= 0;
133 X509Certificate::PublicKeyType type
= X509Certificate::kPublicKeyTypeUnknown
;
134 bool weak_key
= false;
135 bool baseline_keysize_applies
=
136 cert
->valid_start() >= kBaselineEffectiveDate
&&
137 cert
->valid_expiry() >= kBaselineKeysizeEffectiveDate
;
139 X509Certificate::GetPublicKeyInfo(cert
->os_cert_handle(), &size_bits
, &type
);
140 if (should_histogram
) {
141 RecordPublicKeyHistogram(kLeafCert
, baseline_keysize_applies
, size_bits
,
144 if (IsWeakKey(type
, size_bits
))
147 const X509Certificate::OSCertHandles
& intermediates
=
148 cert
->GetIntermediateCertificates();
149 for (size_t i
= 0; i
< intermediates
.size(); ++i
) {
150 X509Certificate::GetPublicKeyInfo(intermediates
[i
], &size_bits
, &type
);
151 if (should_histogram
) {
152 RecordPublicKeyHistogram(
153 (i
< intermediates
.size() - 1) ? kIntermediateCert
: kRootCert
,
154 baseline_keysize_applies
,
158 if (!weak_key
&& IsWeakKey(type
, size_bits
))
168 CertVerifyProc
* CertVerifyProc::CreateDefault() {
169 #if defined(USE_NSS) || defined(OS_IOS)
170 return new CertVerifyProcNSS();
171 #elif defined(USE_OPENSSL_CERTS) && !defined(OS_ANDROID)
172 return new CertVerifyProcOpenSSL();
173 #elif defined(OS_ANDROID)
174 return new CertVerifyProcAndroid();
175 #elif defined(OS_MACOSX)
176 return new CertVerifyProcMac();
177 #elif defined(OS_WIN)
178 return new CertVerifyProcWin();
184 CertVerifyProc::CertVerifyProc() {}
186 CertVerifyProc::~CertVerifyProc() {}
188 int CertVerifyProc::Verify(X509Certificate
* cert
,
189 const std::string
& hostname
,
192 const CertificateList
& additional_trust_anchors
,
193 CertVerifyResult
* verify_result
) {
194 verify_result
->Reset();
195 verify_result
->verified_cert
= cert
;
197 if (IsBlacklisted(cert
)) {
198 verify_result
->cert_status
|= CERT_STATUS_REVOKED
;
199 return ERR_CERT_REVOKED
;
202 // We do online revocation checking for EV certificates that aren't covered
203 // by a fresh CRLSet.
204 // TODO(rsleevi): http://crbug.com/142974 - Allow preferences to fully
205 // disable revocation checking.
206 if (flags
& CertVerifier::VERIFY_EV_CERT
)
207 flags
|= CertVerifier::VERIFY_REV_CHECKING_ENABLED_EV_ONLY
;
209 int rv
= VerifyInternal(cert
, hostname
, flags
, crl_set
,
210 additional_trust_anchors
, verify_result
);
212 UMA_HISTOGRAM_BOOLEAN("Net.CertCommonNameFallback",
213 verify_result
->common_name_fallback_used
);
214 if (!verify_result
->is_issued_by_known_root
) {
215 UMA_HISTOGRAM_BOOLEAN("Net.CertCommonNameFallbackPrivateCA",
216 verify_result
->common_name_fallback_used
);
219 // This check is done after VerifyInternal so that VerifyInternal can fill
220 // in the list of public key hashes.
221 if (IsPublicKeyBlacklisted(verify_result
->public_key_hashes
)) {
222 verify_result
->cert_status
|= CERT_STATUS_REVOKED
;
223 rv
= MapCertStatusToNetError(verify_result
->cert_status
);
226 std::vector
<std::string
> dns_names
, ip_addrs
;
227 cert
->GetSubjectAltName(&dns_names
, &ip_addrs
);
228 if (HasNameConstraintsViolation(verify_result
->public_key_hashes
,
229 cert
->subject().common_name
,
232 verify_result
->cert_status
|= CERT_STATUS_NAME_CONSTRAINT_VIOLATION
;
233 rv
= MapCertStatusToNetError(verify_result
->cert_status
);
236 // Check for weak keys in the entire verified chain.
237 bool weak_key
= ExaminePublicKeys(verify_result
->verified_cert
,
238 verify_result
->is_issued_by_known_root
);
241 verify_result
->cert_status
|= CERT_STATUS_WEAK_KEY
;
242 // Avoid replacing a more serious error, such as an OS/library failure,
243 // by ensuring that if verification failed, it failed with a certificate
245 if (rv
== OK
|| IsCertificateError(rv
))
246 rv
= MapCertStatusToNetError(verify_result
->cert_status
);
249 // Treat certificates signed using broken signature algorithms as invalid.
250 if (verify_result
->has_md2
|| verify_result
->has_md4
) {
251 verify_result
->cert_status
|= CERT_STATUS_INVALID
;
252 rv
= MapCertStatusToNetError(verify_result
->cert_status
);
255 // Flag certificates using weak signature algorithms.
256 if (verify_result
->has_md5
) {
257 verify_result
->cert_status
|= CERT_STATUS_WEAK_SIGNATURE_ALGORITHM
;
258 // Avoid replacing a more serious error, such as an OS/library failure,
259 // by ensuring that if verification failed, it failed with a certificate
261 if (rv
== OK
|| IsCertificateError(rv
))
262 rv
= MapCertStatusToNetError(verify_result
->cert_status
);
265 if (verify_result
->has_sha1
)
266 verify_result
->cert_status
|= CERT_STATUS_SHA1_SIGNATURE_PRESENT
;
268 // Flag certificates from publicly-trusted CAs that are issued to intranet
269 // hosts. While the CA/Browser Forum Baseline Requirements (v1.1) permit
270 // these to be issued until 1 November 2015, they represent a real risk for
271 // the deployment of gTLDs and are being phased out ahead of the hard
273 if (verify_result
->is_issued_by_known_root
&& IsHostnameNonUnique(hostname
)) {
274 verify_result
->cert_status
|= CERT_STATUS_NON_UNIQUE_NAME
;
275 // CERT_STATUS_NON_UNIQUE_NAME will eventually become a hard error. For
276 // now treat it as a warning and do not map it to an error return value.
283 bool CertVerifyProc::IsBlacklisted(X509Certificate
* cert
) {
284 static const unsigned kComodoSerialBytes
= 16;
285 static const uint8 kComodoSerials
[][kComodoSerialBytes
] = {
286 // Not a real certificate. For testing only.
287 {0x07,0x7a,0x59,0xbc,0xd5,0x34,0x59,0x60,0x1c,0xa6,0x90,0x72,0x67,0xa6,0xdd,0x1c},
289 // The next nine certificates all expire on Fri Mar 14 23:59:59 2014.
290 // Some serial numbers actually have a leading 0x00 byte required to
291 // encode a positive integer in DER if the most significant bit is 0.
292 // We omit the leading 0x00 bytes to make all serial numbers 16 bytes.
294 // Subject: CN=mail.google.com
295 // subjectAltName dNSName: mail.google.com, www.mail.google.com
296 {0x04,0x7e,0xcb,0xe9,0xfc,0xa5,0x5f,0x7b,0xd0,0x9e,0xae,0x36,0xe1,0x0c,0xae,0x1e},
297 // Subject: CN=global trustee
298 // subjectAltName dNSName: global trustee
299 // Note: not a CA certificate.
300 {0xd8,0xf3,0x5f,0x4e,0xb7,0x87,0x2b,0x2d,0xab,0x06,0x92,0xe3,0x15,0x38,0x2f,0xb0},
301 // Subject: CN=login.live.com
302 // subjectAltName dNSName: login.live.com, www.login.live.com
303 {0xb0,0xb7,0x13,0x3e,0xd0,0x96,0xf9,0xb5,0x6f,0xae,0x91,0xc8,0x74,0xbd,0x3a,0xc0},
304 // Subject: CN=addons.mozilla.org
305 // subjectAltName dNSName: addons.mozilla.org, www.addons.mozilla.org
306 {0x92,0x39,0xd5,0x34,0x8f,0x40,0xd1,0x69,0x5a,0x74,0x54,0x70,0xe1,0xf2,0x3f,0x43},
307 // Subject: CN=login.skype.com
308 // subjectAltName dNSName: login.skype.com, www.login.skype.com
309 {0xe9,0x02,0x8b,0x95,0x78,0xe4,0x15,0xdc,0x1a,0x71,0x0a,0x2b,0x88,0x15,0x44,0x47},
310 // Subject: CN=login.yahoo.com
311 // subjectAltName dNSName: login.yahoo.com, www.login.yahoo.com
312 {0xd7,0x55,0x8f,0xda,0xf5,0xf1,0x10,0x5b,0xb2,0x13,0x28,0x2b,0x70,0x77,0x29,0xa3},
313 // Subject: CN=www.google.com
314 // subjectAltName dNSName: www.google.com, google.com
315 {0xf5,0xc8,0x6a,0xf3,0x61,0x62,0xf1,0x3a,0x64,0xf5,0x4f,0x6d,0xc9,0x58,0x7c,0x06},
316 // Subject: CN=login.yahoo.com
317 // subjectAltName dNSName: login.yahoo.com
318 {0x39,0x2a,0x43,0x4f,0x0e,0x07,0xdf,0x1f,0x8a,0xa3,0x05,0xde,0x34,0xe0,0xc2,0x29},
319 // Subject: CN=login.yahoo.com
320 // subjectAltName dNSName: login.yahoo.com
321 {0x3e,0x75,0xce,0xd4,0x6b,0x69,0x30,0x21,0x21,0x88,0x30,0xae,0x86,0xa8,0x2a,0x71},
324 const std::string
& serial_number
= cert
->serial_number();
325 if (!serial_number
.empty() && (serial_number
[0] & 0x80) != 0) {
326 // This is a negative serial number, which isn't technically allowed but
327 // which probably happens. In order to avoid confusing a negative serial
328 // number with a positive one once the leading zeros have been removed, we
333 base::StringPiece
serial(serial_number
);
334 // Remove leading zeros.
335 while (serial
.size() > 1 && serial
[0] == 0)
336 serial
.remove_prefix(1);
338 if (serial
.size() == kComodoSerialBytes
) {
339 for (unsigned i
= 0; i
< arraysize(kComodoSerials
); i
++) {
340 if (memcmp(kComodoSerials
[i
], serial
.data(), kComodoSerialBytes
) == 0) {
341 UMA_HISTOGRAM_ENUMERATION("Net.SSLCertBlacklisted", i
,
342 arraysize(kComodoSerials
) + 1);
348 // CloudFlare revoked all certificates issued prior to April 2nd, 2014. Thus
349 // all certificates where the CN ends with ".cloudflare.com" with a prior
350 // issuance date are rejected.
352 // The old certs had a lifetime of five years, so this can be removed April
354 const std::string
& cn
= cert
->subject().common_name
;
355 static const char kCloudFlareCNSuffix
[] = ".cloudflare.com";
356 // kCloudFlareEpoch is the base::Time internal value for midnight at the
357 // beginning of April 2nd, 2014, UTC.
358 static const int64 kCloudFlareEpoch
= INT64_C(13040870400000000);
359 if (cn
.size() > arraysize(kCloudFlareCNSuffix
) - 1 &&
360 cn
.compare(cn
.size() - (arraysize(kCloudFlareCNSuffix
) - 1),
361 arraysize(kCloudFlareCNSuffix
) - 1,
362 kCloudFlareCNSuffix
) == 0 &&
363 cert
->valid_start() < base::Time::FromInternalValue(kCloudFlareEpoch
)) {
371 // NOTE: This implementation assumes and enforces that the hashes are SHA1.
372 bool CertVerifyProc::IsPublicKeyBlacklisted(
373 const HashValueVector
& public_key_hashes
) {
374 static const unsigned kNumHashes
= 17;
375 static const uint8 kHashes
[kNumHashes
][base::kSHA1Length
] = {
376 // Subject: CN=DigiNotar Root CA
377 // Issuer: CN=Entrust.net x2 and self-signed
378 {0x41, 0x0f, 0x36, 0x36, 0x32, 0x58, 0xf3, 0x0b, 0x34, 0x7d,
379 0x12, 0xce, 0x48, 0x63, 0xe4, 0x33, 0x43, 0x78, 0x06, 0xa8},
380 // Subject: CN=DigiNotar Cyber CA
381 // Issuer: CN=GTE CyberTrust Global Root
382 {0xc4, 0xf9, 0x66, 0x37, 0x16, 0xcd, 0x5e, 0x71, 0xd6, 0x95,
383 0x0b, 0x5f, 0x33, 0xce, 0x04, 0x1c, 0x95, 0xb4, 0x35, 0xd1},
384 // Subject: CN=DigiNotar Services 1024 CA
385 // Issuer: CN=Entrust.net
386 {0xe2, 0x3b, 0x8d, 0x10, 0x5f, 0x87, 0x71, 0x0a, 0x68, 0xd9,
387 0x24, 0x80, 0x50, 0xeb, 0xef, 0xc6, 0x27, 0xbe, 0x4c, 0xa6},
388 // Subject: CN=DigiNotar PKIoverheid CA Organisatie - G2
389 // Issuer: CN=Staat der Nederlanden Organisatie CA - G2
390 {0x7b, 0x2e, 0x16, 0xbc, 0x39, 0xbc, 0xd7, 0x2b, 0x45, 0x6e,
391 0x9f, 0x05, 0x5d, 0x1d, 0xe6, 0x15, 0xb7, 0x49, 0x45, 0xdb},
392 // Subject: CN=DigiNotar PKIoverheid CA Overheid en Bedrijven
393 // Issuer: CN=Staat der Nederlanden Overheid CA
394 {0xe8, 0xf9, 0x12, 0x00, 0xc6, 0x5c, 0xee, 0x16, 0xe0, 0x39,
395 0xb9, 0xf8, 0x83, 0x84, 0x16, 0x61, 0x63, 0x5f, 0x81, 0xc5},
396 // Subject: O=Digicert Sdn. Bhd.
397 // Issuer: CN=GTE CyberTrust Global Root
398 // Expires: Jul 17 15:16:54 2012 GMT
399 {0x01, 0x29, 0xbc, 0xd5, 0xb4, 0x48, 0xae, 0x8d, 0x24, 0x96,
400 0xd1, 0xc3, 0xe1, 0x97, 0x23, 0x91, 0x90, 0x88, 0xe1, 0x52},
401 // Subject: O=Digicert Sdn. Bhd.
402 // Issuer: CN=Entrust.net Certification Authority (2048)
403 // Expires: Jul 16 17:53:37 2015 GMT
404 {0xd3, 0x3c, 0x5b, 0x41, 0xe4, 0x5c, 0xc4, 0xb3, 0xbe, 0x9a,
405 0xd6, 0x95, 0x2c, 0x4e, 0xcc, 0x25, 0x28, 0x03, 0x29, 0x81},
406 // Issuer: CN=Trustwave Organization Issuing CA, Level 2
407 // Covers two certificates, the latter of which expires Apr 15 21:09:30
409 {0xe1, 0x2d, 0x89, 0xf5, 0x6d, 0x22, 0x76, 0xf8, 0x30, 0xe6,
410 0xce, 0xaf, 0xa6, 0x6c, 0x72, 0x5c, 0x0b, 0x41, 0xa9, 0x32},
411 // Cyberoam CA certificate. Private key leaked, but this certificate would
412 // only have been installed by Cyberoam customers. The certificate expires
413 // in 2036, but we can probably remove in a couple of years (2014).
414 {0xd9, 0xf5, 0xc6, 0xce, 0x57, 0xff, 0xaa, 0x39, 0xcc, 0x7e,
415 0xd1, 0x72, 0xbd, 0x53, 0xe0, 0xd3, 0x07, 0x83, 0x4b, 0xd1},
416 // Win32/Sirefef.gen!C generates fake certificates with this public key.
417 {0xa4, 0xf5, 0x6e, 0x9e, 0x1d, 0x9a, 0x3b, 0x7b, 0x1a, 0xc3,
418 0x31, 0xcf, 0x64, 0xfc, 0x76, 0x2c, 0xd0, 0x51, 0xfb, 0xa4},
419 // ANSSI certificate under which a MITM proxy was mistakenly operated.
420 // Expires: Jul 18 10:05:28 2014 GMT
421 {0x3e, 0xcf, 0x4b, 0xbb, 0xe4, 0x60, 0x96, 0xd5, 0x14, 0xbb,
422 0x53, 0x9b, 0xb9, 0x13, 0xd7, 0x7a, 0xa4, 0xef, 0x31, 0xbf},
423 // Three retired intermediate certificates from Symantec. No compromise;
424 // just for robustness. All expire May 17 23:59:59 2018.
425 // See https://bugzilla.mozilla.org/show_bug.cgi?id=966060
426 {0x68, 0x5e, 0xec, 0x0a, 0x39, 0xf6, 0x68, 0xae, 0x8f, 0xd8,
427 0x96, 0x4f, 0x98, 0x74, 0x76, 0xb4, 0x50, 0x4f, 0xd2, 0xbe},
428 {0x0e, 0x50, 0x2d, 0x4d, 0xd1, 0xe1, 0x60, 0x36, 0x8a, 0x31,
429 0xf0, 0x6a, 0x81, 0x04, 0x31, 0xba, 0x6f, 0x72, 0xc0, 0x41},
430 {0x93, 0xd1, 0x53, 0x22, 0x29, 0xcc, 0x2a, 0xbd, 0x21, 0xdf,
431 0xf5, 0x97, 0xee, 0x32, 0x0f, 0xe4, 0x24, 0x6f, 0x3d, 0x0c},
432 // C=IN, O=National Informatics Centre, OU=NICCA, CN=NIC Certifying
433 // Authority. Issued by C=IN, O=India PKI, CN=CCA India 2007.
434 // Expires July 4th, 2015.
435 {0xf5, 0x71, 0x79, 0xfa, 0xea, 0x10, 0xc5, 0x43, 0x8c, 0xb0,
436 0xc6, 0xe1, 0xcc, 0x27, 0x7b, 0x6e, 0x0d, 0xb2, 0xff, 0x54},
437 // C=IN, O=National Informatics Centre, CN=NIC CA 2011. Issued by
438 // C=IN, O=India PKI, CN=CCA India 2011.
439 // Expires March 11th 2016.
440 {0x07, 0x7a, 0xc7, 0xde, 0x8d, 0xa5, 0x58, 0x64, 0x3a, 0x06,
441 0xc5, 0x36, 0x9e, 0x55, 0x4f, 0xae, 0xb3, 0xdf, 0xa1, 0x66},
442 // C=IN, O=National Informatics Centre, CN=NIC CA 2014. Issued by
443 // C=IN, O=India PKI, CN=CCA India 2014.
444 // Expires: March 5th, 2024.
445 {0xe5, 0x8e, 0x31, 0x5b, 0xaa, 0xee, 0xaa, 0xc6, 0xe7, 0x2e,
446 0xc9, 0x57, 0x36, 0x70, 0xca, 0x2f, 0x25, 0x4e, 0xc3, 0x47},
449 for (unsigned i
= 0; i
< kNumHashes
; i
++) {
450 for (HashValueVector::const_iterator j
= public_key_hashes
.begin();
451 j
!= public_key_hashes
.end(); ++j
) {
452 if (j
->tag
== HASH_VALUE_SHA1
&&
453 memcmp(j
->data(), kHashes
[i
], base::kSHA1Length
) == 0) {
462 static const size_t kMaxDomainLength
= 18;
464 // CheckNameConstraints verifies that every name in |dns_names| is in one of
465 // the domains specified by |domains|. The |domains| array is terminated by an
467 static bool CheckNameConstraints(const std::vector
<std::string
>& dns_names
,
468 const char domains
[][kMaxDomainLength
]) {
469 for (std::vector
<std::string
>::const_iterator i
= dns_names
.begin();
470 i
!= dns_names
.end(); ++i
) {
472 url::CanonHostInfo host_info
;
473 const std::string dns_name
= CanonicalizeHost(*i
, &host_info
);
474 if (host_info
.IsIPAddress())
477 const size_t registry_len
= registry_controlled_domains::GetRegistryLength(
479 registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES
,
480 registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES
);
481 // If the name is not in a known TLD, ignore it. This permits internal
483 if (registry_len
== 0)
486 for (size_t j
= 0; domains
[j
][0]; ++j
) {
487 const size_t domain_length
= strlen(domains
[j
]);
488 // The DNS name must have "." + domains[j] as a suffix.
489 if (i
->size() <= (1 /* period before domain */ + domain_length
))
492 const char* suffix
= &dns_name
[i
->size() - domain_length
- 1];
493 if (suffix
[0] != '.')
495 if (memcmp(&suffix
[1], domains
[j
], domain_length
) != 0)
508 // PublicKeyDomainLimitation contains a SHA1, SPKI hash and a pointer to an
509 // array of fixed-length strings that contain the domains that the SPKI is
510 // allowed to issue for.
511 struct PublicKeyDomainLimitation
{
512 uint8 public_key
[base::kSHA1Length
];
513 const char (*domains
)[kMaxDomainLength
];
517 bool CertVerifyProc::HasNameConstraintsViolation(
518 const HashValueVector
& public_key_hashes
,
519 const std::string
& common_name
,
520 const std::vector
<std::string
>& dns_names
,
521 const std::vector
<std::string
>& ip_addrs
) {
522 static const char kDomainsANSSI
[][kMaxDomainLength
] = {
529 "pm", // Saint-Pierre et Miquelon
530 "bl", // Saint Barthélemy
531 "mf", // Saint Martin
532 "wf", // Wallis et Futuna
533 "pf", // Polynésie française
534 "nc", // Nouvelle Calédonie
535 "tf", // Terres australes et antarctiques françaises
539 static const char kDomainsIndiaCCA
[][kMaxDomainLength
] = {
550 static const char kDomainsTest
[][kMaxDomainLength
] = {
555 static const PublicKeyDomainLimitation kLimits
[] = {
556 // C=FR, ST=France, L=Paris, O=PM/SGDN, OU=DCSSI,
557 // CN=IGC/A/emailAddress=igca@sgdn.pm.gouv.fr
559 {0x79, 0x23, 0xd5, 0x8d, 0x0f, 0xe0, 0x3c, 0xe6, 0xab, 0xad,
560 0xae, 0x27, 0x1a, 0x6d, 0x94, 0xf4, 0x14, 0xd1, 0xa8, 0x73},
563 // C=IN, O=India PKI, CN=CCA India 2007
564 // Expires: July 4th 2015.
566 {0xfe, 0xe3, 0x95, 0x21, 0x2d, 0x5f, 0xea, 0xfc, 0x7e, 0xdc,
567 0xcf, 0x88, 0x3f, 0x1e, 0xc0, 0x58, 0x27, 0xd8, 0xb8, 0xe4},
570 // C=IN, O=India PKI, CN=CCA India 2011
571 // Expires: March 11 2016.
573 {0xf1, 0x42, 0xf6, 0xa2, 0x7d, 0x29, 0x3e, 0xa8, 0xf9, 0x64,
574 0x52, 0x56, 0xed, 0x07, 0xa8, 0x63, 0xf2, 0xdb, 0x1c, 0xdf},
577 // C=IN, O=India PKI, CN=CCA India 2014
578 // Expires: March 5 2024.
580 {0x36, 0x8c, 0x4a, 0x1e, 0x2d, 0xb7, 0x81, 0xe8, 0x6b, 0xed,
581 0x5a, 0x0a, 0x42, 0xb8, 0xc5, 0xcf, 0x6d, 0xb3, 0x57, 0xe1},
584 // Not a real certificate - just for testing. This is the SPKI hash of
585 // the keys used in net/data/ssl/certificates/name_constraint_*.crt.
587 {0x61, 0xec, 0x82, 0x8b, 0xdb, 0x5c, 0x78, 0x2a, 0x8f, 0xcc,
588 0x4f, 0x0f, 0x14, 0xbb, 0x85, 0x31, 0x93, 0x9f, 0xf7, 0x3d},
593 for (unsigned i
= 0; i
< arraysize(kLimits
); ++i
) {
594 for (HashValueVector::const_iterator j
= public_key_hashes
.begin();
595 j
!= public_key_hashes
.end(); ++j
) {
596 if (j
->tag
== HASH_VALUE_SHA1
&&
597 memcmp(j
->data(), kLimits
[i
].public_key
, base::kSHA1Length
) == 0) {
598 if (dns_names
.empty() && ip_addrs
.empty()) {
599 std::vector
<std::string
> dns_names
;
600 dns_names
.push_back(common_name
);
601 if (!CheckNameConstraints(dns_names
, kLimits
[i
].domains
))
604 if (!CheckNameConstraints(dns_names
, kLimits
[i
].domains
))