Remove the fingerprint and ca_fingerprint from X509Certificate

net/cert/x509_certificate_win.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 <memory>
 
 #include <openssl/sha.h>
 
@@ skipping 126 matching lines @@
 void X509Certificate::Initialize() {
   DCHECK(cert_handle_);
   subject_.ParseDistinguishedName(cert_handle_->pCertInfo->Subject.pbData,
                                   cert_handle_->pCertInfo->Subject.cbData);
   issuer_.ParseDistinguishedName(cert_handle_->pCertInfo->Issuer.pbData,
                                  cert_handle_->pCertInfo->Issuer.cbData);
 
   valid_start_ = Time::FromFileTime(cert_handle_->pCertInfo->NotBefore);
   valid_expiry_ = Time::FromFileTime(cert_handle_->pCertInfo->NotAfter);
 
-  fingerprint_ = CalculateFingerprint(cert_handle_);
-  ca_fingerprint_ = CalculateCAFingerprint(intermediate_ca_certs_);
-
   const CRYPT_INTEGER_BLOB* serial = &cert_handle_->pCertInfo->SerialNumber;
   std::unique_ptr<uint8_t[]> serial_bytes(new uint8_t[serial->cbData]);
   for (unsigned i = 0; i < serial->cbData; i++)
     serial_bytes[i] = serial->pbData[serial->cbData - i - 1];
   serial_number_ = std::string(
       reinterpret_cast<char*>(serial_bytes.get()), serial->cbData);
 }
 
 void X509Certificate::GetSubjectAltName(
     std::vector<std::string>* dns_names,
@@ skipping 129 matching lines @@
     OSCertHandle cert_handle) {
   return CertDuplicateCertificateContext(cert_handle);
 }
 
 // static
 void X509Certificate::FreeOSCertHandle(OSCertHandle cert_handle) {
   CertFreeCertificateContext(cert_handle);
 }
 
 // static
-SHA1HashValue X509Certificate::CalculateFingerprint(
-    OSCertHandle cert) {
-  DCHECK(NULL != cert->pbCertEncoded);
-  DCHECK_NE(static_cast<DWORD>(0), cert->cbCertEncoded);
-
-  BOOL rv;
-  SHA1HashValue sha1;
-  DWORD sha1_size = sizeof(sha1.data);
-  rv = CryptHashCertificate(NULL, CALG_SHA1, 0, cert->pbCertEncoded,
-                            cert->cbCertEncoded, sha1.data, &sha1_size);
-  DCHECK(rv && sha1_size == sizeof(sha1.data));
-  if (!rv)
-    memset(sha1.data, 0, sizeof(sha1.data));
-  return sha1;
-}
-
-// static
 SHA256HashValue X509Certificate::CalculateFingerprint256(OSCertHandle cert) {
   DCHECK(NULL != cert->pbCertEncoded);
   DCHECK_NE(0u, cert->cbCertEncoded);
 
   SHA256HashValue sha256;
   size_t sha256_size = sizeof(sha256.data);
 
   // Use crypto::SHA256HashString for two reasons:
   // * < Windows Vista does not have universal SHA-256 support.
   // * More efficient on Windows > Vista (less overhead since non-default CSP
   // is not needed).
   base::StringPiece der_cert(reinterpret_cast<const char*>(cert->pbCertEncoded),
                              cert->cbCertEncoded);
   crypto::SHA256HashString(der_cert, sha256.data, sha256_size);
   return sha256;
 }
 
-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 ctx;
-  if (!SHA1_Init(&ctx))
-    return sha1;
+  if (!SHA256_Init(&ctx))
+    return sha256;
   for (size_t i = 0; i < intermediates.size(); ++i) {
     PCCERT_CONTEXT ca_cert = intermediates[i];
-    if (!SHA1_Update(&ctx, ca_cert->pbCertEncoded, ca_cert->cbCertEncoded))
-      return sha1;
+    if (!SHA256_Update(&ctx, ca_cert->pbCertEncoded, ca_cert->cbCertEncoded))
+      return sha256;
   }
-  SHA1_Final(sha1.data, &ctx);
+  SHA256_Final(sha256.data, &ctx);
 
-  return sha1;
+  return sha256;
 }
 
 // static
 X509Certificate::OSCertHandle X509Certificate::ReadOSCertHandleFromPickle(
     base::PickleIterator* pickle_iter) {
   const char* data;
   int length;
   if (!pickle_iter->ReadData(&data, &length))
     return NULL;
 
@@ skipping 110 matching lines @@
       X509_ASN_ENCODING,
       CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT,
       reinterpret_cast<void*>(const_cast<PCERT_CONTEXT>(cert_handle)),
       CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT,
       reinterpret_cast<void*>(const_cast<PCERT_CONTEXT>(cert_handle)),
       0,
       NULL);
 }
 
 }  // namespace net