WebCrypto: Implement digest() using NSS

content/renderer/webcrypto_digest_unittest.cc

Index: content/renderer/webcrypto_digest_unittest.cc
diff --git a/content/renderer/webcrypto_digest_unittest.cc b/content/renderer/webcrypto_digest_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4688da476275797bda1f0590b2ec24f3b5c15259
--- /dev/null
+++ b/content/renderer/webcrypto_digest_unittest.cc
@@ -0,0 +1,266 @@
+// Copyright (c) 2013 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 "webcrypto_digest.h"
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/string_number_conversions.h"
+#include "content/renderer/webcrypto_impl.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebArrayBuffer.h"
+
+namespace content {
+
+// Algorithms include SHA1, SHA224, SHA256, SHA384, and SHA512
+WebKit::WebCryptoAlgorithmId algorithm_ids[] = {
+  WebKit::WebCryptoAlgorithmIdSha1,
+  WebKit::WebCryptoAlgorithmIdSha224,
+  WebKit::WebCryptoAlgorithmIdSha256,
+  WebKit::WebCryptoAlgorithmIdSha384,
+  WebKit::WebCryptoAlgorithmIdSha512

[Ryan Sleevi, 2013/08/02 23:29:27]

style nit: four spaces

[Bryan Eyler, 2013/08/03 00:16:45]

Done.

+};
+
+class TestWebCryptoOperationResult
+    : public WebKit::WebCryptoOperationResultPrivate,
+      public base::RefCountedThreadSafe<TestWebCryptoOperationResult> {
+ public:
+  TestWebCryptoOperationResult()
+      : error_encountered_(false),
+        operation_(NULL) {
+  }
+
+  // There's no need to implement the initialization* routines because the

[eroman, 2013/08/02 21:41:39]

Perhaps this comment is no longer relevant.

[Bryan Eyler, 2013/08/03 00:16:45]

Removed.

+  // initialization is already checked for failure in the tests.
+  virtual void initializationFailed() OVERRIDE {
+    error_encountered_ = true;
+  }
+
+  virtual void initializationSucceeded(
+      WebKit::WebCryptoOperation* op) OVERRIDE {
+    operation_ = op;
+  }
+
+  virtual void completeWithArrayBuffer(
+      const WebKit::WebArrayBuffer& array_buffer) OVERRIDE {
+    // Might as well just store the array_buffer in hex, since it's going to be
+    // converted anyway for better error reporting.  +1 for the nul terminator.
+    array_buffer_data_hex_ =
+        base::HexEncode(array_buffer.data(), array_buffer.byteLength());
+  }
+
+  virtual void completeWithBoolean(bool boolean) OVERRIDE {
+    NOTREACHED();
+  }
+
+  virtual void completeWithError() OVERRIDE {
+    error_encountered_ = true;
+  }
+
+  virtual void ref() {
+    RefCountedThreadSafe<TestWebCryptoOperationResult>::AddRef();
+  }
+
+  virtual void deref() {
+    RefCountedThreadSafe<TestWebCryptoOperationResult>::Release();
+  }
+
+  const char* array_buffer_data_hex() const {
+    return array_buffer_data_hex_.c_str();
+  }
+
+  bool error_encountered() const {
+    return error_encountered_;
+  }
+
+  WebKit::WebCryptoOperation* operation() {
+    return operation_;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<TestWebCryptoOperationResult>;
+  virtual ~TestWebCryptoOperationResult() {}
+
+  std::string array_buffer_data_hex_;
+  bool error_encountered_;
+  WebKit::WebCryptoOperation* operation_;
+};
+
+TEST(WebCryptoDigest, SampleEmptySet) {

[Ryan Sleevi, 2013/08/02 23:29:27]

As we start implementing layers, I'm a little nervous about possible duplication
of tests.

WebCrypto itself will definitely need a series of known answer tests / test
vectors - eg: the NIST Sample Test Vectors for Byte-Oriented messages (
http://csrc.nist.gov/groups/STM/cavp/index.html#03 ).

So what are we trying to test here that those tests would not test? Or what
value do these tests bring in particular?

Are we testing implementation? Interface? what?

[eroman, 2013/08/03 00:11:19]

tl;dr: Let's keep these unittests here.

I asked Bryan for these tests, so I can explain the reasoning.

The idea is to exercise the chromium side code, and do some basic sanity checks
that it is doing the right cryptographic operation. This gives code coverage to
make sure there aren't any egregious use after frees, leaks, or crashes.

Extensive layout tests may be the answer later down the road once there is a
conformance suite for WebCrypto that can be used. However in the inter-rim,
LayoutTests are very kludgy while trying to glue pieces together. I tried going
that route initially but it proved frustrating:
  
   * The tests live in blink and hence can't be committed atomically with the
platform implementation added in Chrome (leading to ugliness)

   * Require larger changes in order to have it be testable via a LayoutTest
(again having to go back and forth with blink). For instance both the NSS and
OpenSSL versions of digest would need to be committed before it can be tested
via a layout test, or need to mark the tests disabled on some platforms but not
others, losing coverage on them.

   * Quite a bit harder to debug layout tests over unit tests.


For these reasons, I have adopted a testing strategy which isolates Blink and
Chromium sides, so it is easier to develop them in isolation, and more
parallelism.

Blink is using a mock Platform layer for WebCrypto, allowing it to exercise the
embedder API, and stress all of the error cases (which would otherwise be
difficult or impossible to do with the real implementation).

And the content/renderer side tests itself with unittest.

Once there is a critical mass of stuff working, the LayoutTests can start using
the real implementation rather than mock. (Although I could also see the
argument to sticking with the mock implementation to allow testing more edge
cases).

[Bryan Eyler, 2013/08/03 00:16:45]

This certainly could be changed to use the NIST sample test vectors.  While that
set intends to ensure correctness, I was trying to ensure that the interface
would perform properly here under the various use conditions.

+  // For readability and maintainability of the results, the results are
+  // stored here in hex format.
+  const char* hex_result[arraysize(algorithm_ids)] = {
+    // echo -n "" | sha1sum
+    "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+    // echo -n "" | sha224sum
+    "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f",
+    // echo -n "" | sha256sum
+    "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    // echo -n "" | sha384sum
+    "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274e"
+    "debfe76f65fbd51ad2f14898b95b",
+    // echo -n "" | sha512sum
+    "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0"
+    "d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
+  };
+
+  for (unsigned int id_index = 0;
+       id_index < arraysize(algorithm_ids); id_index++) {
+    WebKit::WebCryptoAlgorithm algorithm(
+        WebKit::WebCryptoAlgorithm::adoptParamsAndCreate(
+            algorithm_ids[id_index], "SHA", NULL));
+
+    // No process() call.
+    {
+      scoped_refptr<TestWebCryptoOperationResult> result_impl(
+          new TestWebCryptoOperationResult);
+      WebKit::WebCryptoOperationResult result(result_impl.get());
+
+      WebCryptoImpl crypto;
+      crypto.digest(algorithm, result);
+
+      EXPECT_FALSE(result_impl->error_encountered());
+      ASSERT_TRUE(result_impl->operation() != NULL);
+
+      result_impl->operation()->finish();
+
+      EXPECT_FALSE(result_impl->error_encountered());
+      // Ignore case, it's checking the hex value.
+      EXPECT_STRCASEEQ(
+          result_impl->array_buffer_data_hex(),
+          hex_result[id_index]);
+    }
+
+    // No-op process() call.
+    {
+      scoped_refptr<TestWebCryptoOperationResult> result_impl(
+          new TestWebCryptoOperationResult);
+      WebKit::WebCryptoOperationResult result(result_impl.get());
+
+      WebCryptoImpl crypto;
+      crypto.digest(algorithm, result);
+
+      EXPECT_FALSE(result_impl->error_encountered());
+      ASSERT_TRUE(result_impl->operation() != NULL);
+
+      result_impl->operation()->process(NULL, 0);
+      result_impl->operation()->process(NULL, 0);
+      result_impl->operation()->finish();
+
+      EXPECT_FALSE(result_impl->error_encountered());
+      // Ignore case, it's checking the hex value.
+      EXPECT_STRCASEEQ(
+          result_impl->array_buffer_data_hex(),
+          hex_result[id_index]);
+    }
+  }
+}
+
+TEST(WebCryptoDigest, SampleSimpleSet) {
+  // For readability and maintainability of the results, the results are
+  // stored here in hex format.
+  const unsigned char* kInput = reinterpret_cast<const unsigned char*>("\0");
+  const size_t kInputLength = 1;
+  const char* hex_result[arraysize(algorithm_ids)] = {
+    // echo -n -e "\000" | sha1sum
+    "5ba93c9db0cff93f52b521d7420e43f6eda2784f",
+    // echo -n -e "\000" | sha224sum
+    "fff9292b4201617bdc4d3053fce02734166a683d7d858a7f5f59b073",
+    // echo -n -e "\000" | sha256sum
+    "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d",
+    // echo -n -e "\000" | sha384sum
+    "bec021b4f368e3069134e012c2b4307083d3a9bdd206e24e5f0d86e13d6636655933"
+    "ec2b413465966817a9c208a11717",
+    // echo -n -e "\000" | sha512sum
+    "b8244d028981d693af7b456af8efa4cad63d282e19ff14942c246e50d9351d22704a"
+    "802a71c3580b6370de4ceb293c324a8423342557d4e5c38438f0e36910ee",
+  };
+
+  for (unsigned int id_index = 0;
+       id_index < arraysize(algorithm_ids); id_index++) {
+    scoped_refptr<TestWebCryptoOperationResult> result_impl(
+        new TestWebCryptoOperationResult);
+    WebKit::WebCryptoOperationResult result(result_impl.get());
+    WebKit::WebCryptoAlgorithm algorithm(
+        WebKit::WebCryptoAlgorithm::adoptParamsAndCreate(
+            algorithm_ids[id_index], "SHA", NULL));
+
+    WebCryptoImpl crypto;
+    crypto.digest(algorithm, result);
+
+    EXPECT_FALSE(result_impl->error_encountered());
+    ASSERT_TRUE(result_impl->operation() != NULL);
+
+    result_impl->operation()->process(kInput, kInputLength);
+    result_impl->operation()->finish();
+
+    EXPECT_FALSE(result_impl->error_encountered());
+    // Ignore case, it's checking the hex value.
+    EXPECT_STRCASEEQ(
+        result_impl->array_buffer_data_hex(),
+        hex_result[id_index]);
+  }
+}
+
+TEST(WebCryptoDigest, SampleMultipartSet) {
+  // For readability and maintainability of the results, the results are
+  // stored here in hex format.
+  struct {
+    const unsigned char* input;
+    size_t input_length;
+  } input_set[] = {
+    { reinterpret_cast<const unsigned char*>("\x00"), 1},
+    { reinterpret_cast<const unsigned char*>("\x01"), 1},
+    { reinterpret_cast<const unsigned char*>("\x02"), 1},
+    { reinterpret_cast<const unsigned char*>("\x03"), 1},
+    { reinterpret_cast<const unsigned char*>("\x04"), 1},
+    { reinterpret_cast<const unsigned char*>("\x05"), 1},
+  };
+  const char* hex_result[arraysize(algorithm_ids)] = {
+    // echo -n -e "\000\001\002\003\004\005" | sha1sum
+    "868460d98d09d8bbb93d7b6cdd15cc7fbec676b9",
+    // echo -n -e "\000\001\002\003\004\005" | sha224sum
+    "7d92e7f1cad1818ed1d13ab41f04ebabfe1fef6bb4cbeebac34c29bc",
+    // echo -n -e "\000\001\002\003\004\005" | sha256sum
+    "17e88db187afd62c16e5debf3e6527cd006bc012bc90b51a810cd80c2d511f43",
+    // echo -n -e "\000\001\002\003\004\005" | sha384sum
+    "79f4738706fce9650ac60266675c3cd07298b09923850d525604d040e6e448adc7dc"
+    "22780d7e1b95bfeaa86a678e4552",
+    // echo -n -e "\000\001\002\003\004\005" | sha512sum
+    "2f3831bccc94cf061bcfa5f8c23c1429d26e3bc6b76edad93d9025cb91c903af6cf9"
+    "c935dc37193c04c2c66e7d9de17c358284418218afea2160147aaa912f4c",
+  };
+
+  for (unsigned int id_index = 0;
+       id_index < arraysize(algorithm_ids); id_index++) {
+    scoped_refptr<TestWebCryptoOperationResult> result_impl(
+        new TestWebCryptoOperationResult);
+    WebKit::WebCryptoOperationResult result(result_impl.get());
+    WebKit::WebCryptoAlgorithm algorithm(
+        WebKit::WebCryptoAlgorithm::adoptParamsAndCreate(
+            algorithm_ids[id_index], "SHA", NULL));
+
+    WebCryptoImpl crypto;
+    crypto.digest(algorithm, result);
+
+    EXPECT_FALSE(result_impl->error_encountered());
+    ASSERT_TRUE(result_impl->operation() != NULL);
+
+    for (unsigned int i = 0; i < ARRAYSIZE_UNSAFE(input_set); i++) {
+      result_impl->operation()->process(input_set[i].input,
+                                        input_set[i].input_length);
+    }
+
+    result_impl->operation()->finish();
+
+    EXPECT_FALSE(result_impl->error_encountered());
+    // Ignore case, it's checking the hex value.
+    EXPECT_STRCASEEQ(
+        result_impl->array_buffer_data_hex(),
+        hex_result[id_index]);
+  }
+}
+
+}  // namespace content