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..709343d2a203a0bfb38781e16b299822522b5572 |
--- /dev/null |
+++ b/components/gcm_driver/crypto/encryption_header_parsers_unittest.cc |
@@ -0,0 +1,196 @@ |
+// 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 uint64_t kDefaultRecordSize = 4096; |
+ |
+TEST(EncryptionHeaderParsersTest, ParseValidEncryptionHeaders) { |
+ struct { |
+ const char* const header; |
+ const char* const parsed_keyid; |
+ const char* const parsed_salt; |
+ uint64_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; |
+ uint64_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=YmV/2ZXJ-sMDA", |
+ "salt=dHdlbHZlY29vbGJ5dGVz=====", |
+ "salt=123$xyz", |
+ "rs", |
+ "rs=", |
+ "rs=0", |
+ "rs=0x13", |
+ "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; |
+ uint64_t rs = kDefaultRecordSize; |
+ |
+ EXPECT_FALSE(ParseEncryptionHeader(expected_failures[i], &keyid, &salt, |
+ &rs)); |
+ } |
+} |
+ |
+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=YmV/2ZXJ-sMDA", |
+ "dh=dHdlbHZlY29vbGJ5dGVz=====", |
+ "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"; |
+ uint64_t rs = 42u; |
+ |
+ ASSERT_FALSE(ParseEncryptionHeader("rs=foobar", &keyid, &salt, &rs)); |
+ |
+ EXPECT_EQ("mykeyid", keyid); |
+ EXPECT_EQ("somesalt", salt); |
+ EXPECT_EQ(42u, 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; |
+ uint64_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 |