Remove the fingerprint and ca_fingerprint from X509Certificate

net/cert/x509_certificate_ios.cc

 // Copyright (c) 2016 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 <Security/Security.h>
 
 #include <openssl/x509.h>
@@ skipping 155 matching lines @@
 }
 
 // static
 void X509Certificate::FreeOSCertHandle(OSCertHandle cert_handle) {
   if (cert_handle)
     CFRelease(cert_handle);
 }
 
 void X509Certificate::Initialize() {
   crypto::EnsureOpenSSLInit();
-  fingerprint_ = CalculateFingerprint(cert_handle_);
-  ca_fingerprint_ = CalculateCAFingerprint(intermediate_ca_certs_);
   ScopedX509 x509_cert = OSCertHandleToOpenSSL(cert_handle_);
   if (!x509_cert)
     return;
   ASN1_INTEGER* serial_num = X509_get_serialNumber(x509_cert.get());
   if (serial_num) {
     // ASN1_INTEGERS represent the decoded number, in a format internal to
     // OpenSSL. Most notably, this may have leading zeroes stripped off for
     // numbers whose first byte is >= 0x80. Thus, it is necessary to
     // re-encoded the integer back into DER, which is what the interface
     // of X509Certificate exposes, to ensure callers get the proper (DER)
     // value.
     int bytes_required = i2c_ASN1_INTEGER(serial_num, nullptr);
     unsigned char* buffer = reinterpret_cast<unsigned char*>(
         base::WriteInto(&serial_number_, bytes_required + 1));
     int bytes_written = i2c_ASN1_INTEGER(serial_num, &buffer);
     DCHECK_EQ(static_cast<size_t>(bytes_written), serial_number_.size());
   }
 
   ParsePrincipal(cert_handle_, X509_get_subject_name(x509_cert.get()),
                  &subject_);
   ParsePrincipal(cert_handle_, X509_get_issuer_name(x509_cert.get()), &issuer_);
   x509_util::ParseDate(X509_get_notBefore(x509_cert.get()), &valid_start_);
   x509_util::ParseDate(X509_get_notAfter(x509_cert.get()), &valid_expiry_);
 }
 
 // static
-SHA1HashValue X509Certificate::CalculateFingerprint(OSCertHandle cert) {
-  SHA1HashValue sha1;
-  memset(sha1.data, 0, sizeof(sha1.data));
-
-  ScopedCFTypeRef<CFDataRef> cert_data(SecCertificateCopyData(cert));
-  if (!cert_data)
-    return sha1;
-  DCHECK(CFDataGetBytePtr(cert_data));
-  DCHECK_NE(0, CFDataGetLength(cert_data));
-  CC_SHA1(CFDataGetBytePtr(cert_data), CFDataGetLength(cert_data), sha1.data);
-
-  return sha1;
-}
-
-// static
 SHA256HashValue X509Certificate::CalculateFingerprint256(OSCertHandle cert) {
   SHA256HashValue sha256;
   memset(sha256.data, 0, sizeof(sha256.data));
 
   ScopedCFTypeRef<CFDataRef> cert_data(SecCertificateCopyData(cert));
   if (!cert_data)
     return sha256;
   DCHECK(CFDataGetBytePtr(cert_data));
   DCHECK_NE(0, CFDataGetLength(cert_data));
   CC_SHA256(CFDataGetBytePtr(cert_data), CFDataGetLength(cert_data),
             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));
 
-  CC_SHA1_CTX sha1_ctx;
-  CC_SHA1_Init(&sha1_ctx);
+  CC_SHA256_CTX sha256_ctx;
+  CC_SHA256_Init(&sha256_ctx);
   for (size_t i = 0; i < intermediates.size(); ++i) {
     ScopedCFTypeRef<CFDataRef> cert_data(
         SecCertificateCopyData(intermediates[i]));
     if (!cert_data)
-      return sha1;
-    CC_SHA1_Update(&sha1_ctx, CFDataGetBytePtr(cert_data),
-                   CFDataGetLength(cert_data));
+      return sha256;
+    CC_SHA256_Update(&sha256_ctx, CFDataGetBytePtr(cert_data),
+                     CFDataGetLength(cert_data));
   }
-  CC_SHA1_Final(sha1.data, &sha1_ctx);
-  return sha1;
+  CC_SHA256_Final(sha256.data, &sha256_ctx);
+  return sha256;
 }
 
 // static
 X509Certificate::OSCertHandle X509Certificate::CreateOSCertHandleFromBytes(
     const char* data,
     size_t length) {
   ScopedCFTypeRef<CFDataRef> cert_data(CFDataCreateWithBytesNoCopy(
       kCFAllocatorDefault, reinterpret_cast<const UInt8*>(data),
       base::checked_cast<CFIndex>(length), kCFAllocatorNull));
   if (!cert_data)
@@ skipping 203 matching lines @@
     return false;
   crypto::ScopedEVP_PKEY scoped_key(X509_get_pubkey(cert.get()));
   if (!scoped_key)
     return false;
   if (!X509_verify(cert.get(), scoped_key.get()))
     return false;
   return X509_check_issued(cert.get(), cert.get()) == X509_V_OK;
 }
 
 }  // namespace net