Rename Encryption-Key to Crypto-Key, "key" parameter to "aesgcm128".

components/gcm_driver/crypto/encryption_header_parsers.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/encryption_header_parsers.h"
 
 #include "base/base64.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "net/http/http_util.h"
 
 namespace gcm {
 
 namespace {
 
 // The default record size in bytes, as defined in section two of
-// https://tools.ietf.org/html/draft-thomson-http-encryption-01.
+// https://tools.ietf.org/html/draft-thomson-http-encryption-02.
 const uint64_t kDefaultRecordSizeBytes = 4096;
 
 // TODO(peter): Unify the base64url implementations. https://crbug.com/536745
 bool Base64URLDecode(const base::StringPiece& input, std::string* output) {
   // Bail on malformed strings, which already contain a '+' or a '/'. All valid
   // strings should escape these special characters as '-' and '_',
   // respectively.
   if (input.find_first_of("+/") != std::string::npos)
     return false;
 
@@ skipping 49 matching lines @@
 
 // Parses the string between |input_begin| and |input_end| according to the
 // extended ABNF syntax for the Encryption HTTP header, per the "parameter"
 // rule from RFC 7231 (https://tools.ietf.org/html/rfc7231).
 //
 // encryption_params = [ parameter *( ";" parameter ) ]
 //
 // This implementation applies the parameters defined in section 3.1 of the
 // HTTP encryption encoding document:
 //
-// https://tools.ietf.org/html/draft-thomson-http-encryption-01#section-3.1
+// https://tools.ietf.org/html/draft-thomson-http-encryption-02#section-3.1
 //
 // This means that the three supported parameters are:
 //
 //     [ "keyid" "=" string ]
 //     [ ";" "salt" "=" base64url ]
 //     [ ";" "rs" "=" octet-count ]
 bool ParseEncryptionHeaderValuesImpl(std::string::const_iterator input_begin,
                                      std::string::const_iterator input_end,
                                      EncryptionHeaderValues* values) {
   net::HttpUtil::NameValuePairsIterator name_value_pairs(
@@ skipping 19 matching lines @@
       }
     } else {
       // Silently ignore unknown directives for forward compatibility.
     }
   }
 
   return name_value_pairs.valid();
 }
 
 // Parses the string between |input_begin| and |input_end| according to the
-// extended ABNF syntax for the Encryption-Key HTTP header, per the "parameter"
-// rule from RFC 7231 (https://tools.ietf.org/html/rfc7231).
+// extended ABNF syntax for the Crypto-Key HTTP header, per the "parameter" rule
+// from RFC 7231 (https://tools.ietf.org/html/rfc7231).
 //
 // encryption_params = [ parameter *( ";" parameter ) ]
 //
 // This implementation applies the parameters defined in section 4 of the
 // HTTP encryption encoding document:
 //
-//https://tools.ietf.org/html/draft-thomson-http-encryption-01#section-4
+//https://tools.ietf.org/html/draft-thomson-http-encryption-02#section-4
 //
 // This means that the three supported parameters are:
 //
 //     [ "keyid" "=" string ]
-//     [ ";" "key" "=" base64url ]
+//     [ ";" "aesgcm128" "=" base64url ]
 //     [ ";" "dh" "=" base64url ]
-bool ParseEncryptionKeyHeaderValuesImpl(std::string::const_iterator input_begin,
-                                        std::string::const_iterator input_end,
-                                        EncryptionKeyHeaderValues* values) {
+bool ParseCryptoKeyHeaderValuesImpl(std::string::const_iterator input_begin,
+                                    std::string::const_iterator input_end,
+                                    CryptoKeyHeaderValues* values) {
   net::HttpUtil::NameValuePairsIterator name_value_pairs(
       input_begin, input_end, ';',
       net::HttpUtil::NameValuePairsIterator::VALUES_NOT_OPTIONAL);
 
   while (name_value_pairs.GetNext()) {
     const base::StringPiece name(name_value_pairs.name_begin(),
                                  name_value_pairs.name_end());
 
     if (base::LowerCaseEqualsASCII(name, "keyid")) {
       values->keyid.assign(name_value_pairs.value_begin(),
                            name_value_pairs.value_end());
-    } else if (base::LowerCaseEqualsASCII(name, "key")) {
+    } else if (base::LowerCaseEqualsASCII(name, "aesgcm128")) {
       if (!ValueToDecodedString(name_value_pairs.value_begin(),
-                                name_value_pairs.value_end(), &values->key)) {
+                                name_value_pairs.value_end(),
+                                &values->aesgcm128)) {
         return false;
       }
     } else if (base::LowerCaseEqualsASCII(name, "dh")) {
       if (!ValueToDecodedString(name_value_pairs.value_begin(),
                                 name_value_pairs.value_end(), &values->dh)) {
         return false;
       }
     } else {
       // Silently ignore unknown directives for forward compatibility.
     }
@@ skipping 21 matching lines @@
       return false;
     }
 
     candidate_values.push_back(candidate_value);
   }
 
   values->swap(candidate_values);
   return true;
 }
 
-bool ParseEncryptionKeyHeader(const std::string& input,
-                              std::vector<EncryptionKeyHeaderValues>* values) {
+bool ParseCryptoKeyHeader(const std::string& input,
+                          std::vector<CryptoKeyHeaderValues>* values) {
   DCHECK(values);
 
-  std::vector<EncryptionKeyHeaderValues> candidate_values;
+  std::vector<CryptoKeyHeaderValues> candidate_values;
 
   net::HttpUtil::ValuesIterator value_iterator(input.begin(), input.end(), ',');
   while (value_iterator.GetNext()) {
-    EncryptionKeyHeaderValues candidate_value;
-    if (!ParseEncryptionKeyHeaderValuesImpl(value_iterator.value_begin(),
-                                            value_iterator.value_end(),
-                                            &candidate_value)) {
+    CryptoKeyHeaderValues candidate_value;
+    if (!ParseCryptoKeyHeaderValuesImpl(value_iterator.value_begin(),
+                                        value_iterator.value_end(),
+                                        &candidate_value)) {
       return false;
     }
 
     candidate_values.push_back(candidate_value);
   }
 
   values->swap(candidate_values);
   return true;
 }
 
 }  // namespace gcm