Make it a fatal SSL error when encountering certs signed with md[2,4], and interstitial md5

net/base/x509_certificate.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/x509_certificate.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 585 matching lines @@
 
   int rv = VerifyInternal(hostname, flags, verify_result);
 
   // This check is done after VerifyInternal so that VerifyInternal can fill in
   // the list of public key hashes.
   if (IsPublicKeyBlacklisted(verify_result->public_key_hashes)) {
     verify_result->cert_status |= CERT_STATUS_AUTHORITY_INVALID;
     rv = MapCertStatusToNetError(verify_result->cert_status);
   }
 
+  if (verify_result->has_md2 || verify_result->has_md4 ||
+      verify_result->has_md5) {

[palmer, 2011/10/24 18:22:31]

wtc does not want to ban MD5 yet. To ban MD5, and we ultimately must, we will
want to collaborate with other browser vendors and CA/B Forum. For now, let's
only ban MD2 and MD5.

NOTE that we MUST NOT ban the 4 known Verisign MD2-signed root certs. (I don't
know if this code applies to roots, or just end entities and intermediaries?)

We could conceivably ban MD2 (and MD4) also for roots but special-case the 4
known MD2 root certs. That would be the tightest solution, if feasible.

[wtc, 2011/10/24 22:41:14]

The signatures in the self-signed certificates of root CAs
used as trust anchors are not important.

rsleevi: please make sure verify_result->has_md[2,4,5]
do not include the root CA certificates.  We should document
their meanings in net/base/cert_verify_result.h.  Thanks!

[Ryan Sleevi, 2011/10/24 23:16:32]

The logic currently includes roots (both has_mdX and has_mdX_ca have made no
remark towards roots]. I will adjust that accordingly.

+    verify_result->cert_status |= CERT_STATUS_WEAK_SIGNATURE_ALGORITHM;
+    rv = MapCertStatusToNetError(verify_result->cert_status);
+  }
+
   return rv;
 }
 
 #if !defined(USE_NSS)
 bool X509Certificate::VerifyNameMatch(const std::string& hostname) const {
   std::vector<std::string> dns_names, ip_addrs;
   GetSubjectAltName(&dns_names, &ip_addrs);
   return VerifyHostname(hostname, subject_.common_name, dns_names, ip_addrs);
 }
 #endif
@@ skipping 386 matching lines @@
 bool X509Certificate::IsSHA1HashInSortedArray(const SHA1Fingerprint& hash,
                                               const uint8* array,
                                               size_t array_byte_len) {
   DCHECK_EQ(0u, array_byte_len % base::kSHA1Length);
   const size_t arraylen = array_byte_len / base::kSHA1Length;
   return NULL != bsearch(hash.data, array, arraylen, base::kSHA1Length,
                          CompareSHA1Hashes);
 }
 
 }  // namespace net