Add parsers for the Encryption and Encryption-Key HTTP headers.

components/gcm_driver/crypto/encryption_header_parsers_unittest.cc

Index: components/gcm_driver/crypto/encryption_header_parsers_unittest.cc
diff --git a/components/gcm_driver/crypto/encryption_header_parsers_unittest.cc b/components/gcm_driver/crypto/encryption_header_parsers_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..601cf9e2989b9ce0f60f542a7e7c00e6723a91ff
--- /dev/null
+++ b/components/gcm_driver/crypto/encryption_header_parsers_unittest.cc
@@ -0,0 +1,190 @@
+// Copyright 2015 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 "components/gcm_driver/crypto/encryption_header_parsers.h"
+
+#include <vector>
+
+#include "base/macros.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gcm {
+
+namespace {
+
+const int64_t kDefaultRecordSize = 4096;
+
+TEST(EncryptionHeaderParsersTest, ParseValidEncryptionHeaders) {
+  struct {
+    const char* const header;
+    const char* const parsed_keyid;
+    const char* const parsed_salt;
+    int64_t parsed_rs;
+  } expected_results[] = {
+    { "keyid=foo;salt=c2l4dGVlbmNvb2xieXRlcw;rs=1024",
+      "foo", "sixteencoolbytes", 1024 },
+    { "keyid=foo; salt=c2l4dGVlbmNvb2xieXRlcw; rs=1024",
+      "foo", "sixteencoolbytes", 1024 },
+    { "KEYID=foo;SALT=c2l4dGVlbmNvb2xieXRlcw;RS=1024",
+      "foo", "sixteencoolbytes", 1024 },
+    { " keyid = foo ; salt = c2l4dGVlbmNvb2xieXRlcw ; rs = 1024 ",
+      "foo", "sixteencoolbytes", 1024 },
+    { "keyid=foo", "foo", "", kDefaultRecordSize },
+    { "keyid=foo;", "foo", "", kDefaultRecordSize },
+    { "keyid=\"foo\"", "foo", "", kDefaultRecordSize },
+    { "keyid='foo'", "foo", "", kDefaultRecordSize },
+    { "salt=c2l4dGVlbmNvb2xieXRlcw",
+      "", "sixteencoolbytes", kDefaultRecordSize },
+    { "rs=2048", "", "", 2048 },
+    { "keyid=foo;someothervalue=1;rs=42", "foo", "", 42 },
+    { "keyid=foo;keyid=bar", "bar", "", kDefaultRecordSize },
+  };
+
+  for (size_t i = 0; i < arraysize(expected_results); i++) {
+    SCOPED_TRACE(i);
+
+    std::string keyid, salt;
+    int64_t rs = kDefaultRecordSize;
+
+    ASSERT_TRUE(ParseEncryptionHeader(expected_results[i].header, &keyid,
+                                      &salt, &rs));
+
+    EXPECT_EQ(expected_results[i].parsed_keyid, keyid);
+    EXPECT_EQ(expected_results[i].parsed_salt, salt);
+    EXPECT_EQ(expected_results[i].parsed_rs, rs);
+  }
+}
+
+TEST(EncryptionHeaderParsersTest, ParseInvalidEncryptionHeaders) {
+  const char* const expected_failures[] = {
+    "keyid",
+    "keyid=",
+    "keyid=foo;novaluekey",
+    "salt",
+    "salt=",
+    "salt=123$xyz",
+    "rs",
+    "rs=",
+    "rs=1",
+    "rs=-1",
+    "rs=99999999999999999999999999999999",
+    "rs=foobar",
+  };
+
+  for (size_t i = 0; i < arraysize(expected_failures); i++) {
+    SCOPED_TRACE(i);
+
+    std::string keyid, salt;
+    int64_t rs = kDefaultRecordSize;
+
+    EXPECT_FALSE(ParseEncryptionHeader(expected_failures[i], &keyid, &salt,
+                                       &rs));
+  }

[whywhat, 2015/09/14 14:57:43]

Check that the output values are not modified perhaps?

[Peter Beverloo, 2015/09/15 19:41:11]

We check for that in InvalidHeadersDoNotModifyOutput :)

+}
+
+TEST(EncryptionHeaderParsersTest, ParseValidEncryptionKeyHeaders) {
+  struct {
+    const char* const header;
+    const char* const parsed_keyid;
+    const char* const parsed_key;
+    const char* const parsed_dh;
+  } expected_results[] = {
+    { "keyid=foo;key=c2l4dGVlbmNvb2xieXRlcw;dh=dHdlbHZlY29vbGJ5dGVz",
+      "foo", "sixteencoolbytes", "twelvecoolbytes" },
+    { "keyid=foo; key=c2l4dGVlbmNvb2xieXRlcw; dh=dHdlbHZlY29vbGJ5dGVz",
+      "foo", "sixteencoolbytes", "twelvecoolbytes" },
+    { "keyid = foo ; key = c2l4dGVlbmNvb2xieXRlcw ; dh = dHdlbHZlY29vbGJ5dGVz ",
+      "foo", "sixteencoolbytes", "twelvecoolbytes" },
+    { "KEYID=foo;KEY=c2l4dGVlbmNvb2xieXRlcw;DH=dHdlbHZlY29vbGJ5dGVz",
+      "foo", "sixteencoolbytes", "twelvecoolbytes" },
+    { "keyid=foo", "foo", "", "" },
+    { "key=c2l4dGVlbmNvb2xieXRlcw", "", "sixteencoolbytes", "" },
+    { "key=\"c2l4dGVlbmNvb2xieXRlcw\"", "", "sixteencoolbytes", "" },
+    { "key='c2l4dGVlbmNvb2xieXRlcw'", "", "sixteencoolbytes", "" },
+    { "dh=dHdlbHZlY29vbGJ5dGVz", "", "", "twelvecoolbytes" },
+    { "keyid=foo;someothervalue=bar;key=dHdlbHZlY29vbGJ5dGVz",
+      "foo", "twelvecoolbytes", "" },
+    { "keyid=foo;keyid=bar", "bar", "", "" },
+  };
+
+  for (size_t i = 0; i < arraysize(expected_results); i++) {
+    SCOPED_TRACE(i);
+
+    std::string keyid, key, dh;
+
+    ASSERT_TRUE(ParseEncryptionKeyHeader(expected_results[i].header, &keyid,
+                                         &key, &dh));
+
+    EXPECT_EQ(expected_results[i].parsed_keyid, keyid);
+    EXPECT_EQ(expected_results[i].parsed_key, key);
+    EXPECT_EQ(expected_results[i].parsed_dh, dh);
+  }
+}
+
+TEST(EncryptionHeaderParsersTest, ParseInvalidEncryptionKeyHeaders) {
+  const char* const expected_failures[] = {
+    "keyid",
+    "keyid=",
+    "keyid=foo;novaluekey",
+    "key",
+    "key=",
+    "key=123$xyz",
+    "dh",
+    "dh=",
+    "dh=123$xyz",
+  };
+
+  for (size_t i = 0; i < arraysize(expected_failures); i++) {
+    SCOPED_TRACE(i);
+
+    std::string keyid, key, dh;
+
+    EXPECT_FALSE(ParseEncryptionKeyHeader(expected_failures[i], &keyid, &key,
+                                          &dh));
+  }
+}
+
+TEST(EncryptionHeaderParsersTest, InvalidHeadersDoNotModifyOutput) {
+  std::string keyid = "mykeyid";
+  std::string salt = "somesalt";
+  int64_t rs = 42;
+
+  ASSERT_FALSE(ParseEncryptionHeader("rs=foobar", &keyid, &salt, &rs));
+
+  EXPECT_EQ("mykeyid", keyid);
+  EXPECT_EQ("somesalt", salt);
+  EXPECT_EQ(42, rs);
+
+  std::string key = "akey";
+  std::string dh = "yourdh";
+
+  ASSERT_FALSE(ParseEncryptionKeyHeader("key=$$$", &keyid, &key, &dh));
+
+  EXPECT_EQ("mykeyid", keyid);
+  EXPECT_EQ("akey", key);
+  EXPECT_EQ("yourdh", dh);
+}
+
+TEST(EncryptionHeaderParsersTest, ParseMultipleValueHeaders) {
+  // Chrome currently does not support multiple lists of parameters as part
+  // of the Encryption headers. Make sure we reject such headers until we do.
+  std::string keyid, salt;
+  int64_t rs = kDefaultRecordSize;
+
+  EXPECT_FALSE(ParseEncryptionHeader(
+      "keyid=foo;salt=c2l4dGVlbmNvb2xieXRlcw;rs=12,"
+          "keyid=bar;salt=dHdlbHZlY29vbGJ5dGVzl;rs=24",
+      &keyid, &salt, &rs));
+
+  std::string key, dh;
+
+  EXPECT_FALSE(ParseEncryptionKeyHeader(
+      "keyid=foo;key=c2l4dGVlbmNvb2xieXRlcw;dh=dHdlbHZlY29vbGJ5dGVzl,"
+          "keyid=bar;key=dHdlbHZlY29vbGJ5dGVzl;dh=c2l4dGVlbmNvb2xieXRlcw",
+      &keyid, &key, &dh));
+}
+
+}  // namespace
+
+}  // namespace gcm