Ignore Crypto-Key header values that do not have "dh" values

components/gcm_driver/crypto/gcm_encryption_provider_unittest.cc

 // 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/gcm_encryption_provider.h"
 
 #include <stddef.h>
 
 #include <sstream>
 #include <string>
@@ skipping 22 matching lines @@
 const char kExampleAuthorizedEntity[] = "my-sender-id";
 const char kExampleMessage[] = "Hello, world, this is the GCM Driver!";
 
 const char kValidEncryptionHeader[] =
     "keyid=foo;salt=MTIzNDU2Nzg5MDEyMzQ1Ng;rs=1024";
 const char kInvalidEncryptionHeader[] = "keyid";
 
 const char kValidCryptoKeyHeader[] =
     "keyid=foo;dh=BL_UGhfudEkXMUd4U4-D4nP5KHxKjQHsW6j88ybbehXM7fqi1OMFefDUEi0eJ"
     "vsKfyVBWYkQjH-lSPJKxjAyslg";
+const char kValidThreeValueCryptoKeyHeader[] =
+    "keyid=foo,keyid=bar,keyid=baz;dh=BL_UGhfudEkXMUd4U4-D4nP5KHxKjQHsW6j88ybbe"
+    "hXM7fqi1OMFefDUEi0eJvsKfyVBWYkQjH-lSPJKxjAyslg";
+
 const char kInvalidCryptoKeyHeader[] = "keyid";
+const char kInValidThreeValueCryptoKeyHeader[] =

[johnme, 2016/06/30 18:07:26]

Micro-nit: lowercase V for consistency

[Peter Beverloo, 2016/06/30 18:09:37]

Done.

+    "keyid=foo,dh=BL_UGhfudEkXMUd4U4-D4nP5KHxKjQHsW6j88ybbehXM7fqi1OMFefDUEi0eJ"

[johnme, 2016/06/30 18:07:26]

Would it be clearer to use `keyid=foo;dh` instead of `keyid=foo,dh` (similarly
for baz)? Seems that would make it more like the other examples.

[Peter Beverloo, 2016/06/30 18:09:37]

This way it skips headers, which is the new logic introduced by this CL.

+    "vsKfyVBWYkQjH-lSPJKxjAyslg,keyid=baz,dh=BL_UGhfudEkXMUd4U4-D4nP5KHxKjQHsW6"
+    "j88ybbehXM7fqi1OMFefDUEi0eJvsKfyVBWYkQjH-lSPJKxjAyslg";
 
 }  // namespace
 
 class GCMEncryptionProviderTest : public ::testing::Test {
  public:
   void SetUp() override {
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
 
     encryption_provider_.reset(new GCMEncryptionProvider);
     encryption_provider_->Init(scoped_temp_dir_.path(),
@@ skipping 143 matching lines @@
   valid_message.data["encryption"] = kValidEncryptionHeader;
   valid_message.data["crypto-key"] = kInvalidCryptoKeyHeader;
   valid_message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
   EXPECT_NE(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_ENCRYPTION_HEADER,
             decryption_result());
 }
 
 TEST_F(GCMEncryptionProviderTest, VerifiesCryptoKeyHeaderParsing) {
-  // The Encryption-Key header must be parsable and contain valid values.
+  // The Crypto-Key header must be parsable and contain valid values.
   // Note that this is more extensively tested in EncryptionHeaderParsersTest.
 
   IncomingMessage invalid_message;
   invalid_message.data["encryption"] = kValidEncryptionHeader;
   invalid_message.data["crypto-key"] = kInvalidCryptoKeyHeader;
   invalid_message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(invalid_message));
   EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER,
             decryption_result());
 
   IncomingMessage valid_message;
-  valid_message.data["encryption"] = kInvalidEncryptionHeader;
+  valid_message.data["encryption"] = kValidEncryptionHeader;
   valid_message.data["crypto-key"] = kValidCryptoKeyHeader;
   valid_message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
   EXPECT_NE(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER,
             decryption_result());
 }
 
+TEST_F(GCMEncryptionProviderTest, VerifiesCryptoKeyHeaderParsingThirdValue) {
+  // The Crypto-Key header must be parsable and contain valid values, in which
+  // values will be ignored unless they contain a "dh" property.
+
+  IncomingMessage valid_message;
+  valid_message.data["encryption"] = kValidEncryptionHeader;
+  valid_message.data["crypto-key"] = kValidThreeValueCryptoKeyHeader;
+  valid_message.raw_data = "foo";
+
+  ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
+  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER,
+            decryption_result());
+}
+
+TEST_F(GCMEncryptionProviderTest, VerifiesCryptoKeyHeaderSingleDhEntry) {
+  // The Crypto-Key header must include at most one value that contains the
+  // "dh" property. Having more than once occurrence is forbidden.
+
+  IncomingMessage valid_message;
+  valid_message.data["encryption"] = kValidEncryptionHeader;
+  valid_message.data["crypto-key"] = kInValidThreeValueCryptoKeyHeader;
+  valid_message.raw_data = "foo";
+
+  ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
+  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER,
+            decryption_result());
+}
+
 TEST_F(GCMEncryptionProviderTest, VerifiesExistingKeys) {
   // When both headers are valid, the encryption keys still must be known to
   // the GCM key store before the message can be decrypted.
 
   IncomingMessage message;
   message.data["encryption"] = kValidEncryptionHeader;
   message.data["crypto-key"] = kValidCryptoKeyHeader;
   message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(message));
@@ skipping 262 matching lines @@
 }
 
 TEST_F(GCMEncryptionProviderTest, EncryptionRoundTripInstanceIDToken) {
   // GCMEncryptionProvider::DecryptMessage should succeed when the message was
   // sent to an InstanceID token (non-empty authorized_entity).
   ASSERT_NO_FATAL_FAILURE(
       TestEncryptionRoundTrip(kExampleAppId, kExampleAuthorizedEntity));
 }
 
 }  // namespace gcm