OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "net/base/hash_value.h" |
| 6 |
| 7 #include "base/base64.h" |
| 8 #include "base/logging.h" |
| 9 #include "base/sha1.h" |
| 10 #include "base/string_split.h" |
| 11 #include "base/string_util.h" |
| 12 |
| 13 namespace net { |
| 14 |
| 15 namespace { |
| 16 |
| 17 // CompareSHA1Hashes is a helper function for using bsearch() with an array of |
| 18 // SHA1 hashes. |
| 19 int CompareSHA1Hashes(const void* a, const void* b) { |
| 20 return memcmp(a, b, base::kSHA1Length); |
| 21 } |
| 22 |
| 23 } // namespace |
| 24 |
| 25 |
| 26 bool SHA1HashValue::Equals(const SHA1HashValue& other) const { |
| 27 return memcmp(data, other.data, sizeof(data)) == 0; |
| 28 } |
| 29 |
| 30 bool SHA256HashValue::Equals(const SHA256HashValue& other) const { |
| 31 return memcmp(data, other.data, sizeof(data)) == 0; |
| 32 } |
| 33 |
| 34 bool HashValue::Equals(const HashValue& other) const { |
| 35 if (tag != other.tag) |
| 36 return false; |
| 37 switch (tag) { |
| 38 case HASH_VALUE_SHA1: |
| 39 return fingerprint.sha1.Equals(other.fingerprint.sha1); |
| 40 case HASH_VALUE_SHA256: |
| 41 return fingerprint.sha256.Equals(other.fingerprint.sha256); |
| 42 default: |
| 43 NOTREACHED() << "Unknown HashValueTag " << tag; |
| 44 return false; |
| 45 } |
| 46 } |
| 47 |
| 48 bool HashValue::FromString(const base::StringPiece value) { |
| 49 base::StringPiece base64_str; |
| 50 if (value.starts_with("sha1/")) { |
| 51 tag = HASH_VALUE_SHA1; |
| 52 base64_str = value.substr(5); |
| 53 } else if (value.starts_with("sha256/")) { |
| 54 tag = HASH_VALUE_SHA256; |
| 55 base64_str = value.substr(7); |
| 56 } else { |
| 57 return false; |
| 58 } |
| 59 |
| 60 std::string decoded; |
| 61 if (!base::Base64Decode(base64_str, &decoded) || decoded.size() != size()) |
| 62 return false; |
| 63 |
| 64 memcpy(data(), decoded.data(), size()); |
| 65 return true; |
| 66 } |
| 67 |
| 68 std::string HashValue::ToString() const { |
| 69 std::string base64_str; |
| 70 base::Base64Encode(base::StringPiece(reinterpret_cast<const char*>(data()), |
| 71 size()), &base64_str); |
| 72 switch (tag) { |
| 73 case HASH_VALUE_SHA1: |
| 74 return std::string("sha1/") + base64_str; |
| 75 case HASH_VALUE_SHA256: |
| 76 return std::string("sha256/") + base64_str; |
| 77 default: |
| 78 NOTREACHED() << "Unknown HashValueTag " << tag; |
| 79 return std::string("unknown/" + base64_str); |
| 80 } |
| 81 } |
| 82 |
| 83 size_t HashValue::size() const { |
| 84 switch (tag) { |
| 85 case HASH_VALUE_SHA1: |
| 86 return sizeof(fingerprint.sha1.data); |
| 87 case HASH_VALUE_SHA256: |
| 88 return sizeof(fingerprint.sha256.data); |
| 89 default: |
| 90 NOTREACHED() << "Unknown HashValueTag " << tag; |
| 91 // While an invalid tag should not happen, return a non-zero length |
| 92 // to avoid compiler warnings when the result of size() is |
| 93 // used with functions like memset. |
| 94 return sizeof(fingerprint.sha1.data); |
| 95 } |
| 96 } |
| 97 |
| 98 unsigned char* HashValue::data() { |
| 99 return const_cast<unsigned char*>(const_cast<const HashValue*>(this)->data()); |
| 100 } |
| 101 |
| 102 const unsigned char* HashValue::data() const { |
| 103 switch (tag) { |
| 104 case HASH_VALUE_SHA1: |
| 105 return fingerprint.sha1.data; |
| 106 case HASH_VALUE_SHA256: |
| 107 return fingerprint.sha256.data; |
| 108 default: |
| 109 NOTREACHED() << "Unknown HashValueTag " << tag; |
| 110 return NULL; |
| 111 } |
| 112 } |
| 113 |
| 114 bool IsSHA1HashInSortedArray(const SHA1HashValue& hash, |
| 115 const uint8* array, |
| 116 size_t array_byte_len) { |
| 117 DCHECK_EQ(0u, array_byte_len % base::kSHA1Length); |
| 118 const size_t arraylen = array_byte_len / base::kSHA1Length; |
| 119 return NULL != bsearch(hash.data, array, arraylen, base::kSHA1Length, |
| 120 CompareSHA1Hashes); |
| 121 } |
| 122 |
| 123 } // namespace net |
OLD | NEW |