Remove the fingerprint and ca_fingerprint from X509Certificate

net/cert/x509_certificate_nss.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 <cert.h>
 #include <cryptohi.h>
 #include <keyhi.h>
 #include <nss.h>
 #include <pk11pub.h>
 #include <prtime.h>
@@ skipping 15 matching lines @@
 
 namespace net {
 
 void X509Certificate::Initialize() {
   x509_util::ParsePrincipal(&cert_handle_->subject, &subject_);
   x509_util::ParsePrincipal(&cert_handle_->issuer, &issuer_);
 
   x509_util::ParseDate(&cert_handle_->validity.notBefore, &valid_start_);
   x509_util::ParseDate(&cert_handle_->validity.notAfter, &valid_expiry_);
 
-  fingerprint_ = CalculateFingerprint(cert_handle_);
-  ca_fingerprint_ = CalculateCAFingerprint(intermediate_ca_certs_);
-
   serial_number_ = x509_util::ParseSerialNumber(cert_handle_);
 }
 
 // static
 scoped_refptr<X509Certificate> X509Certificate::CreateFromBytesWithNickname(
     const char* data,
     size_t length,
     const char* nickname) {
   OSCertHandle cert_handle = CreateOSCertHandleFromBytesWithNickname(data,
                                                                      length,
@@ skipping 152 matching lines @@
     OSCertHandle cert_handle) {
   return CERT_DupCertificate(cert_handle);
 }
 
 // static
 void X509Certificate::FreeOSCertHandle(OSCertHandle cert_handle) {
   CERT_DestroyCertificate(cert_handle);
 }
 
 // static
-SHA1HashValue X509Certificate::CalculateFingerprint(
-    OSCertHandle cert) {
-  SHA1HashValue sha1;
-  memset(sha1.data, 0, sizeof(sha1.data));
-
-  DCHECK(NULL != cert->derCert.data);
-  DCHECK_NE(0U, cert->derCert.len);
-
-  SECStatus rv = HASH_HashBuf(HASH_AlgSHA1, sha1.data,
-                              cert->derCert.data, cert->derCert.len);
-  DCHECK_EQ(SECSuccess, rv);
-
-  return sha1;
-}
-
-// static
 SHA256HashValue X509Certificate::CalculateFingerprint256(OSCertHandle cert) {
   SHA256HashValue sha256;
   memset(sha256.data, 0, sizeof(sha256.data));
 
   DCHECK(NULL != cert->derCert.data);
   DCHECK_NE(0U, cert->derCert.len);
 
   SECStatus rv = HASH_HashBuf(
       HASH_AlgSHA256, sha256.data, cert->derCert.data, cert->derCert.len);
   DCHECK_EQ(SECSuccess, rv);
 
   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));
 
-  HASHContext* sha1_ctx = HASH_Create(HASH_AlgSHA1);
-  if (!sha1_ctx)
-    return sha1;
-  HASH_Begin(sha1_ctx);
+  HASHContext* sha256_ctx = HASH_Create(HASH_AlgSHA256);
+  if (!sha256_ctx)
+    return sha256;
+  HASH_Begin(sha256_ctx);
   for (size_t i = 0; i < intermediates.size(); ++i) {
     CERTCertificate* ca_cert = intermediates[i];
-    HASH_Update(sha1_ctx, ca_cert->derCert.data, ca_cert->derCert.len);
+    HASH_Update(sha256_ctx, ca_cert->derCert.data, ca_cert->derCert.len);
   }
   unsigned int result_len;
-  HASH_End(sha1_ctx, sha1.data, &result_len, HASH_ResultLenContext(sha1_ctx));
-  HASH_Destroy(sha1_ctx);
+  HASH_End(sha256_ctx, sha256.data, &result_len,
+           HASH_ResultLenContext(sha256_ctx));
+  HASH_Destroy(sha256_ctx);
 
-  return sha1;
+  return sha256;
 }
 
 // static
 X509Certificate::OSCertHandle X509Certificate::ReadOSCertHandleFromPickle(
     base::PickleIterator* pickle_iter) {
   return x509_util::ReadOSCertHandleFromPickle(pickle_iter);
 }
 
 // static
 bool X509Certificate::WriteOSCertHandleToPickle(OSCertHandle cert_handle,
@@ skipping 17 matching lines @@
     return false;
   if (SECSuccess != CERT_VerifySignedDataWithPublicKey(
                         &cert_handle->signatureWrap, public_key.get(), NULL)) {
     return false;
   }
   return CERT_CompareName(&cert_handle->subject, &cert_handle->issuer) ==
          SECEqual;
 }
 
 }  // namespace net