Remove the fingerprint and ca_fingerprint from X509Certificate

net/cert/x509_certificate_mac.cc

 // Copyright (c) 2012 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/cert/x509_certificate.h"
 
 #include <CommonCrypto/CommonDigest.h>
 #include <CoreServices/CoreServices.h>
 #include <Security/Security.h>
 
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/singleton.h"
 #include "base/pickle.h"
-#include "base/sha1.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "crypto/cssm_init.h"
 #include "crypto/mac_security_services_lock.h"
 #include "net/cert/x509_util_mac.h"
 
 using base::ScopedCFTypeRef;
 using base::Time;
 
@@ skipping 179 matching lines @@
     GetCertDistinguishedName(cached_cert, &CSSMOID_X509V1SubjectNameStd,
                              &subject_);
     GetCertDistinguishedName(cached_cert, &CSSMOID_X509V1IssuerNameStd,
                              &issuer_);
     GetCertDateForOID(cached_cert, &CSSMOID_X509V1ValidityNotBefore,
                       &valid_start_);
     GetCertDateForOID(cached_cert, &CSSMOID_X509V1ValidityNotAfter,
                       &valid_expiry_);
     serial_number_ = GetCertSerialNumber(cached_cert);
   }
-
-  fingerprint_ = CalculateFingerprint(cert_handle_);
-  ca_fingerprint_ = CalculateCAFingerprint(intermediate_ca_certs_);
 }
 
 bool X509Certificate::IsIssuedByEncoded(
     const std::vector<std::string>& valid_issuers) {
   if (IsCertIssuerInEncodedList(cert_handle_, valid_issuers))
     return true;
 
   for (OSCertHandles::iterator it = intermediate_ca_certs_.begin();
        it != intermediate_ca_certs_.end(); ++it) {
     if (IsCertIssuerInEncodedList(*it, valid_issuers))
@@ skipping 124 matching lines @@
   return reinterpret_cast<OSCertHandle>(const_cast<void*>(CFRetain(handle)));
 }
 
 // static
 void X509Certificate::FreeOSCertHandle(OSCertHandle cert_handle) {
   if (cert_handle)
     CFRelease(cert_handle);
 }
 
 // static
-SHA1HashValue X509Certificate::CalculateFingerprint(
-    OSCertHandle cert) {
-  SHA1HashValue sha1;
-  memset(sha1.data, 0, sizeof(sha1.data));
-
-  CSSM_DATA cert_data;
-  OSStatus status = SecCertificateGetData(cert, &cert_data);
-  if (status)
-    return sha1;
-
-  DCHECK(cert_data.Data);
-  DCHECK_NE(cert_data.Length, 0U);
-
-  CC_SHA1(cert_data.Data, cert_data.Length, sha1.data);
-
-  return sha1;
-}
-
-// static
 SHA256HashValue X509Certificate::CalculateFingerprint256(OSCertHandle cert) {
   SHA256HashValue sha256;
   memset(sha256.data, 0, sizeof(sha256.data));
 
   CSSM_DATA cert_data;
   OSStatus status = SecCertificateGetData(cert, &cert_data);
   if (status)
     return sha256;
 
   DCHECK(cert_data.Data);
   DCHECK_NE(cert_data.Length, 0U);
 
   CC_SHA256(cert_data.Data, cert_data.Length, sha256.data);
 
   return sha256;
 }
 
 // static
-SHA1HashValue X509Certificate::CalculateCAFingerprint(
+SHA256HashValue X509Certificate::CalculateCAFingerprint256(
     const OSCertHandles& intermediates) {
-  SHA1HashValue sha1;
-  memset(sha1.data, 0, sizeof(sha1.data));
+  SHA256HashValue sha256;
+  memset(sha256.data, 0, sizeof(sha256.data));
 
-  // The CC_SHA(3cc) man page says all CC_SHA1_xxx routines return 1, so
+  // The CC_SHA(3cc) man page says all CC_SHA256_xxx routines return 1, so
   // we don't check their return values.
-  CC_SHA1_CTX sha1_ctx;
-  CC_SHA1_Init(&sha1_ctx);
+  CC_SHA256_CTX sha256_ctx;
+  CC_SHA256_Init(&sha256_ctx);
   CSSM_DATA cert_data;
   for (size_t i = 0; i < intermediates.size(); ++i) {
     OSStatus status = SecCertificateGetData(intermediates[i], &cert_data);
     if (status)
-      return sha1;
-    CC_SHA1_Update(&sha1_ctx, cert_data.Data, cert_data.Length);
+      return sha256;
+    CC_SHA256_Update(&sha256_ctx, cert_data.Data, cert_data.Length);
   }
-  CC_SHA1_Final(sha1.data, &sha1_ctx);
+  CC_SHA256_Final(sha256.data, &sha256_ctx);
 
-  return sha1;
+  return sha256;
 }
 
 bool X509Certificate::SupportsSSLClientAuth() const {
   x509_util::CSSMCachedCertificate cached_cert;
   OSStatus status = cached_cert.Init(cert_handle_);
   if (status)
     return false;
 
   // RFC5280 says to take the intersection of the two extensions.
   //
@@ skipping 142 matching lines @@
     return false;
 
   if (CSSM_CL_CertVerify(cl_handle, 0, &cert_data, &cert_data, NULL, 0))
     return false;
   return true;
 }
 
 #pragma clang diagnostic pop  // "-Wdeprecated-declarations"
 
 }  // namespace net