Implement base::SHA1HashSpan().

Hopefully this can replace base::SHA1HashBytes() in the long run.

Change-Id: Ie9138b569d59c8b252fa14262a56ced56f74a397
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1827647
Commit-Queue: Lei Zhang <thestig@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: David Benjamin <davidben@chromium.org>
Cr-Commit-Position: refs/heads/master@{#702097}

base/hash/sha1.cc

@@ -187,6 +187,12 @@ void SecureHashAlgorithm::Process() {
   cursor = 0;
 }
 
+std::array<uint8_t, kSHA1Length> SHA1HashSpan(span<const uint8_t> data) {
+  std::array<uint8_t, kSHA1Length> hash;
+  SHA1HashBytes(data.data(), data.size(), hash.data());
+  return hash;
+}
+
 std::string SHA1HashString(const std::string& str) {
   char hash[SecureHashAlgorithm::kDigestSizeBytes];
   SHA1HashBytes(reinterpret_cast<const unsigned char*>(str.c_str()),

base/hash/sha1.h

@@ -7,9 +7,11 @@
 
 #include <stddef.h>
 
+#include <array>
 #include <string>
 
 #include "base/base_export.h"
+#include "base/containers/span.h"
 
 namespace base {
 
@@ -17,6 +19,10 @@ namespace base {
 
 enum { kSHA1Length = 20 };  // Length in bytes of a SHA-1 hash.
 
+// Computes the SHA-1 hash of the input |data| and returns the full hash.
+BASE_EXPORT std::array<uint8_t, kSHA1Length> SHA1HashSpan(
+    span<const uint8_t> data);
+
 // Computes the SHA-1 hash of the input string |str| and returns the full
 // hash.
 BASE_EXPORT std::string SHA1HashString(const std::string& str);

base/hash/sha1_boringssl.cc

@@ -12,17 +12,24 @@
 
 namespace base {
 
-void SHA1HashBytes(const unsigned char* data, size_t len, unsigned char* hash) {
+std::array<uint8_t, kSHA1Length> SHA1HashSpan(span<const uint8_t> data) {
   CRYPTO_library_init();
-  SHA1(data, len, hash);
+  std::array<uint8_t, kSHA1Length> digest;
+  SHA1(data.data(), data.size(), digest.data());
+  return digest;
 }
 
 std::string SHA1HashString(const std::string& str) {
   CRYPTO_library_init();
   std::string digest;
   SHA1(reinterpret_cast<const uint8_t*>(str.data()), str.size(),
-       reinterpret_cast<uint8_t*>(base::WriteInto(&digest, kSHA1Length + 1)));
+       reinterpret_cast<uint8_t*>(WriteInto(&digest, kSHA1Length + 1)));
   return digest;
 }
 
+void SHA1HashBytes(const unsigned char* data, size_t len, unsigned char* hash) {
+  CRYPTO_library_init();
+  SHA1(data, len, hash);
+}
+
 }  // namespace base

base/hash/sha1_unittest.cc

@@ -19,6 +19,7 @@ TEST(SHA1Test, Test1) {
                                       0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d};
 
   std::string output = base::SHA1HashString(input);
+  ASSERT_EQ(base::kSHA1Length, output.size());
   for (size_t i = 0; i < base::kSHA1Length; i++)
     EXPECT_EQ(kExpected[i], output[i] & 0xFF);
 }
@@ -33,6 +34,7 @@ TEST(SHA1Test, Test2) {
                                       0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1};
 
   std::string output = base::SHA1HashString(input);
+  ASSERT_EQ(base::kSHA1Length, output.size());
   for (size_t i = 0; i < base::kSHA1Length; i++)
     EXPECT_EQ(kExpected[i], output[i] & 0xFF);
 }
@@ -46,11 +48,12 @@ TEST(SHA1Test, Test3) {
                                       0x27, 0x31, 0x65, 0x34, 0x01, 0x6f};
 
   std::string output = base::SHA1HashString(input);
+  ASSERT_EQ(base::kSHA1Length, output.size());
   for (size_t i = 0; i < base::kSHA1Length; i++)
     EXPECT_EQ(kExpected[i], output[i] & 0xFF);
 }
 
-TEST(SHA1Test, Test1Bytes) {
+TEST(SHA1Test, Test1BytesAndSpan) {
   // Example A.1 from FIPS 180-2: one-block message.
   std::string input = "abc";
   unsigned char output[base::kSHA1Length];
@@ -60,12 +63,17 @@ TEST(SHA1Test, Test1Bytes) {
       0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d};
 
   base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
-                      input.length(), output);
+                      input.size(), output);
   for (size_t i = 0; i < base::kSHA1Length; i++)
     EXPECT_EQ(kExpected[i], output[i]);
+
+  std::array<uint8_t, base::kSHA1Length> output_array =
+      base::SHA1HashSpan(base::as_bytes(base::make_span(input)));
+  for (size_t i = 0; i < base::kSHA1Length; i++)
+    EXPECT_EQ(kExpected[i], output_array[i]);
 }
 
-TEST(SHA1Test, Test2Bytes) {
+TEST(SHA1Test, Test2BytesAndSpan) {
   // Example A.2 from FIPS 180-2: multi-block message.
   std::string input =
       "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
@@ -76,12 +84,17 @@ TEST(SHA1Test, Test2Bytes) {
       0x4a, 0xa1, 0xf9, 0x51, 0x29, 0xe5, 0xe5, 0x46, 0x70, 0xf1};
 
   base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
-                      input.length(), output);
+                      input.size(), output);
   for (size_t i = 0; i < base::kSHA1Length; i++)
     EXPECT_EQ(kExpected[i], output[i]);
+
+  std::array<uint8_t, base::kSHA1Length> output_array =
+      base::SHA1HashSpan(base::as_bytes(base::make_span(input)));
+  for (size_t i = 0; i < base::kSHA1Length; i++)
+    EXPECT_EQ(kExpected[i], output_array[i]);
 }
 
-TEST(SHA1Test, Test3Bytes) {
+TEST(SHA1Test, Test3BytesAndSpan) {
   // Example A.3 from FIPS 180-2: long message.
   std::string input(1000000, 'a');
   unsigned char output[base::kSHA1Length];
@@ -91,7 +104,12 @@ TEST(SHA1Test, Test3Bytes) {
       0xeb, 0x2b, 0xdb, 0xad, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6f};
 
   base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(input.c_str()),
-                      input.length(), output);
+                      input.size(), output);
   for (size_t i = 0; i < base::kSHA1Length; i++)
     EXPECT_EQ(kExpected[i], output[i]);
+
+  std::array<uint8_t, base::kSHA1Length> output_array =
+      base::SHA1HashSpan(base::as_bytes(base::make_span(input)));
+  for (size_t i = 0; i < base::kSHA1Length; i++)
+    EXPECT_EQ(kExpected[i], output_array[i]);
 }