Add a parser for messages with a Web Push Protocol-based payload

components/gcm_driver/crypto/gcm_message_cryptographer_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_message_cryptographer.h"
 
 #include <memory>
 
 #include "base/base64url.h"
 #include "base/big_endian.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
+#include "components/gcm_driver/crypto/message_payload_parser.h"
 #include "components/gcm_driver/crypto/p256_key_util.h"
 #include "crypto/random.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
 // Example plaintext data to use in the tests.
 const char kExamplePlaintext[] = "Example plaintext";
 
 // Expected sizes of the different input given to the cryptographer.
-constexpr size_t kUncompressedPointSize = 65;
 constexpr size_t kEcdhSharedSecretSize = 32;
 constexpr size_t kAuthSecretSize = 16;
 constexpr size_t kSaltSize = 16;
 
 // Keying material for both parties as P-256 EC points. Used to make sure that
 // the test vectors are reproducible.
 const unsigned char kCommonSenderPublicKey[] = {
     0x04, 0x05, 0x3C, 0xA1, 0xB9, 0xA5, 0xAB, 0xB8, 0x2D, 0x88, 0x48,
     0x82, 0xC9, 0x49, 0x19, 0x91, 0xD5, 0xFD, 0xD1, 0x92, 0xDB, 0xA7,
     0x7E, 0x70, 0x48, 0x37, 0x41, 0xCD, 0x90, 0x05, 0x80, 0xDF, 0x65,
@@ skipping 822 matching lines @@
       "DGv6ra1nlYgDCS1FRnbzlwAAEABBBP4z9KsN6nGRTbVYI_"
       "c7VJSPQTBtkgcy27mlmlMoZIIgDll6e3vCYLocInmYWAmS6TlzAC8wEqKK6PBru3jl7A_"
       "yl95bQpu6cVPTpK4Mqgkf1CXztLVBSt2Ks3oZwbuwXPXLWyouBWLVWGNWQexSgSxsj_"
       "Qulcy4a-fN";
 
   std::string message;
   ASSERT_TRUE(base::Base64UrlDecode(kReferenceMessage,
                                     base::Base64UrlDecodePolicy::IGNORE_PADDING,
                                     &message));
 
-  // TODO(peter): Break out the following in a separate message parser class so
-  // that it can be reused by the GCMEncryptionProvider (on the receiving path)
-  // and the gcm_crypto_test_helpers.cc file (on the sending path) too.
-  //
-  // The message contains a binary header in the following format:
-  //     [ salt(16) | record_size(4) | sender_public_key_len(1) |
-  //       sender_public_key(sender_public_key_len) ]
-  //
-  // For Web Push Encryption, which uses a P-256 sender key as uncompressed
-  // P-256 EC points, the length of the sender key is 65 bytes, making the
-  // total, fixed length of the header 86 bytes.
-  //
-  // The regular AEAD_AES_128_GCM ciphertext follows immediately after this. The
-  // minimum overhead for a single record is 18 bytes. This means that an
-  // incoming message must be at least 104 bytes in size.
-  ASSERT_GE(message.size(), 104u);
+  MessagePayloadParser message_parser(message);
+  ASSERT_TRUE(message_parser.IsValid());
 
-  const char* current = &message.front();
-
-  uint32_t record_size;
-  uint8_t sender_public_key_length;
-
-  base::StringPiece salt(current, kSaltSize);
-  current += kSaltSize;
-
-  base::ReadBigEndian(current, &record_size);
-  current += sizeof(record_size);
-
-  base::ReadBigEndian(current, &sender_public_key_length);
-  current += sizeof(sender_public_key_length);
-
-  ASSERT_EQ(sender_public_key_length, kUncompressedPointSize);
-
-  base::StringPiece sender_public_key(current, sender_public_key_length);
-  current += sender_public_key_length;
-
-  base::StringPiece ciphertext(
-      current, message.size() - kSaltSize - sizeof(record_size) -
-                   sizeof(sender_public_key_length) - sender_public_key_length);
+  base::StringPiece salt = message_parser.salt();
+  uint32_t record_size = message_parser.record_size();
+  base::StringPiece sender_public_key = message_parser.public_key();
+  base::StringPiece ciphertext = message_parser.ciphertext();
 
   std::string sender_shared_secret, receiver_shared_secret;
 
   // Compute the shared secrets between the sender and receiver's keys.
   ASSERT_NO_FATAL_FAILURE(ComputeSharedSecret(kSenderPrivate, kSenderPublicX509,
                                               kRecipientPublicKeyUncompressed,
                                               &sender_shared_secret));
 
   // Compute the shared secret based on the sender's public key, which isn't a
   // constant but instead is included in the message's binary header.
@@ skipping 37 matching lines @@
 
   ASSERT_TRUE(cryptographer.Encrypt(recipient_public_key, sender_public_key,
                                     sender_shared_secret, auth_secret, salt,
                                     kPlaintext, &record_size2, &ciphertext2));
 
   EXPECT_GE(record_size2, record_size);
   EXPECT_EQ(ciphertext2, ciphertext);
 }
 
 }  // namespace gcm