Remove residual support for SHA-1 public key pins.

net/base/hash_value.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/base/hash_value.h"
 
 #include <stdlib.h>
 
 #include "base/base64.h"
 #include "base/logging.h"
@@ skipping 19 matching lines @@
   fingerprint.sha1 = hash;
 }
 
 HashValue::HashValue(const SHA256HashValue& hash)
     : HashValue(HASH_VALUE_SHA256) {
   fingerprint.sha256 = hash;
 }
 
 bool HashValue::FromString(const base::StringPiece value) {
   base::StringPiece base64_str;
-  if (value.starts_with("sha1/")) {
-    tag = HASH_VALUE_SHA1;
-    base64_str = value.substr(5);
-  } else if (value.starts_with("sha256/")) {
+  if (value.starts_with("sha256/")) {
     tag = HASH_VALUE_SHA256;
     base64_str = value.substr(7);
   } else {
     return false;
   }
 
   std::string decoded;
   if (!base::Base64Decode(base64_str, &decoded) || decoded.size() != size())
     return false;
 
   memcpy(data(), decoded.data(), size());
   return true;
 }
 
 std::string HashValue::ToString() const {
   std::string base64_str;
   base::Base64Encode(base::StringPiece(reinterpret_cast<const char*>(data()),
                                        size()), &base64_str);
   switch (tag) {
   case HASH_VALUE_SHA1:
     return std::string("sha1/") + base64_str;

[davidben, 2017/06/26 20:15:55]

Out of curiosity, what are the remaining HASH_VALUE_SHA1 uses? I think it's fine
to leave it for now, but I'm curious what's left. Perhaps we shouldn't have had
HPKP's tagged hash type be shared with random other parts of the codebase. Ah
well. :-/ Apologies for the scope creep in the CL. It probably should have
occurred to me that would have been kind of involved.

[davidben, 2017/06/26 20:17:00]

(Hrm. Codesearch seems to think there actually isn't anything left.)

   case HASH_VALUE_SHA256:
     return std::string("sha256/") + base64_str;
   default:
     NOTREACHED() << "Unknown HashValueTag " << tag;
     return std::string("unknown/" + base64_str);
   }
 }
 
 size_t HashValue::size() const {
   switch (tag) {
@@ skipping 29 matching lines @@
 bool IsSHA256HashInSortedArray(const SHA256HashValue& hash,
                                const uint8_t* array,
                                size_t array_byte_len) {
   DCHECK_EQ(0u, array_byte_len % crypto::kSHA256Length);
   const size_t arraylen = array_byte_len / crypto::kSHA256Length;
   return NULL != bsearch(hash.data, array, arraylen, crypto::kSHA256Length,
                          CompareSHA1Hashes);
 }
 
 }  // namespace net