Remove GCMMessageCryptographer::Label

components/gcm_driver/crypto/gcm_message_cryptographer.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_util.h"
 #include "base/sys_byteorder.h"
 #include "crypto/hkdf.h"
 #include "third_party/boringssl/src/include/openssl/aead.h"
 
 namespace gcm {
 namespace {
 
 // Size, in bytes, of the nonce for a record. This must be at least the size
 // of a uint64_t, which is used to indicate the record sequence number.
 const uint64_t kNonceSize = 12;
 
-// The default record size as defined by draft-thomson-http-encryption.
+// The default record size as defined by httpbis-encryption-encoding-06.
 const size_t kDefaultRecordSize = 4096;
 
 // Key size, in bytes, of a valid AEAD_AES_128_GCM key.
 const size_t kContentEncryptionKeySize = 16;
 
 // The BoringSSL functions used to seal (encrypt) and open (decrypt) a payload
 // follow the same prototype, declared as follows.
 using EVP_AEAD_CTX_TransformFunction =
     int(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len,
         size_t max_out_len, const uint8_t *nonce, size_t nonce_len,
         const uint8_t *in, size_t in_len, const uint8_t *ad, size_t ad_len);
 
 // Creates the info parameter for an HKDF value for the given |content_encoding|
 // in accordance with draft-thomson-http-encryption.
 //
 // cek_info = "Content-Encoding: aesgcm" || 0x00 || context
 // nonce_info = "Content-Encoding: nonce" || 0x00 || context
 //
-// context = label || 0x00 ||
+// context = "P-256" || 0x00 ||
 //           length(recipient_public) || recipient_public ||
 //           length(sender_public) || sender_public
 //
 // The length of the public keys must be written as a two octet unsigned integer
 // in network byte order (big endian).
 std::string InfoForContentEncoding(
     const char* content_encoding,
-    GCMMessageCryptographer::Label label,
     const base::StringPiece& recipient_public_key,
     const base::StringPiece& sender_public_key) {
-  DCHECK(GCMMessageCryptographer::Label::P256 == label);
   DCHECK_EQ(recipient_public_key.size(), 65u);
   DCHECK_EQ(sender_public_key.size(), 65u);
 
   std::stringstream info_stream;
   info_stream << "Content-Encoding: " << content_encoding << '\x00';
-
-  switch (label) {
-    case GCMMessageCryptographer::Label::P256:
-      info_stream << "P-256" << '\x00';
-      break;
-  }
+  info_stream << "P-256" << '\x00';
 
   uint16_t local_len =
       base::HostToNet16(static_cast<uint16_t>(recipient_public_key.size()));
   info_stream.write(reinterpret_cast<char*>(&local_len), sizeof(local_len));
   info_stream << recipient_public_key;
 
   uint16_t peer_len =
       base::HostToNet16(static_cast<uint16_t>(sender_public_key.size()));
   info_stream.write(reinterpret_cast<char*>(&peer_len), sizeof(peer_len));
   info_stream << sender_public_key;
 
   return info_stream.str();
 }
 
 }  // namespace
 
 const size_t GCMMessageCryptographer::kAuthenticationTagBytes = 16;
 const size_t GCMMessageCryptographer::kSaltSize = 16;
 
 GCMMessageCryptographer::GCMMessageCryptographer(
-    Label label,
     const base::StringPiece& recipient_public_key,
     const base::StringPiece& sender_public_key,
     const std::string& auth_secret)
     : content_encryption_key_info_(
-          InfoForContentEncoding("aesgcm", label, recipient_public_key,
+          InfoForContentEncoding("aesgcm", recipient_public_key,
                                  sender_public_key)),
       nonce_info_(
-          InfoForContentEncoding("nonce", label, recipient_public_key,
+          InfoForContentEncoding("nonce", recipient_public_key,
                                  sender_public_key)),
       auth_secret_(auth_secret) {
 }
 
 GCMMessageCryptographer::~GCMMessageCryptographer() {}
 
 bool GCMMessageCryptographer::Encrypt(const base::StringPiece& plaintext,
                                       const base::StringPiece& ikm,
                                       const base::StringPiece& salt,
                                       size_t* record_size,
@@ skipping 190 matching lines @@
                     0   /* subkey_secret_bytes_to_generate */);
 
   // draft-thomson-http-encryption defines that the result should be XOR'ed with
   // the record's sequence number, however, Web Push encryption is limited to a
   // single record per draft-ietf-webpush-encryption.
 
   return hkdf.client_write_key().as_string();
 }
 
 }  // namespace gcm