Remove the fingerprint and ca_fingerprint from X509Certificate

net/cert/x509_certificate_openssl.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 <openssl/asn1.h>
 #include <openssl/bytestring.h>
 #include <openssl/crypto.h>
 #include <openssl/obj_mac.h>
@@ skipping 175 matching lines @@
 // static
 void X509Certificate::FreeOSCertHandle(OSCertHandle cert_handle) {
   // Decrement the ref-count for the cert and, if all references are gone,
   // free the memory and any application-specific data associated with the
   // certificate.
   X509_free(cert_handle);
 }
 
 void X509Certificate::Initialize() {
   crypto::EnsureOpenSSLInit();
-  fingerprint_ = CalculateFingerprint(cert_handle_);
-  ca_fingerprint_ = CalculateCAFingerprint(intermediate_ca_certs_);
 
   ASN1_INTEGER* serial_num = X509_get_serialNumber(cert_handle_);
   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, NULL);
     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(cert_handle_), &subject_);
   ParsePrincipal(cert_handle_, X509_get_issuer_name(cert_handle_), &issuer_);
   x509_util::ParseDate(X509_get_notBefore(cert_handle_), &valid_start_);
   x509_util::ParseDate(X509_get_notAfter(cert_handle_), &valid_expiry_);
 }
 
 // static
 void X509Certificate::ResetCertStore() {
   X509InitSingleton::GetInstance()->ResetCertStore();
 }
 
 // static
-SHA1HashValue X509Certificate::CalculateFingerprint(OSCertHandle cert) {
-  SHA1HashValue sha1;
-  unsigned int sha1_size = static_cast<unsigned int>(sizeof(sha1.data));
-  int ret = X509_digest(cert, EVP_sha1(), sha1.data, &sha1_size);
-  CHECK(ret);
-  CHECK_EQ(sha1_size, sizeof(sha1.data));
-  return sha1;
-}
-
-// static
 SHA256HashValue X509Certificate::CalculateFingerprint256(OSCertHandle cert) {
   SHA256HashValue sha256;
   unsigned int sha256_size = static_cast<unsigned int>(sizeof(sha256.data));
   int ret = X509_digest(cert, EVP_sha256(), sha256.data, &sha256_size);
   CHECK(ret);
   CHECK_EQ(sha256_size, sizeof(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));
 
-  SHA_CTX sha1_ctx;
-  SHA1_Init(&sha1_ctx);
+  SHA256_CTX sha256_ctx;
+  SHA256_Init(&sha256_ctx);
   base::StringPiece der;
   for (size_t i = 0; i < intermediates.size(); ++i) {
     if (!x509_util::GetDER(intermediates[i], &der))
-      return sha1;
-    SHA1_Update(&sha1_ctx, der.data(), der.length());
+      return sha256;
+    SHA256_Update(&sha256_ctx, der.data(), der.length());
   }
-  SHA1_Final(sha1.data, &sha1_ctx);
+  SHA256_Final(sha256.data, &sha256_ctx);
 
-  return sha1;
+  return sha256;
 }
 
 // static
 X509Certificate::OSCertHandle X509Certificate::CreateOSCertHandleFromBytes(
     const char* data,
     size_t length) {
   crypto::EnsureOpenSSLInit();
   const unsigned char* d2i_data =
       reinterpret_cast<const unsigned char*>(data);
   // Don't cache this data for x509_util::GetDER as this wire format
@@ skipping 183 matching lines @@
 bool X509Certificate::IsSelfSigned(OSCertHandle cert_handle) {
   crypto::ScopedEVP_PKEY scoped_key(X509_get_pubkey(cert_handle));
   if (!scoped_key)
     return false;
   if (!X509_verify(cert_handle, scoped_key.get()))
     return false;
   return X509_check_issued(cert_handle, cert_handle) == X509_V_OK;
 }
 
 }  // namespace net