Add parsers for the Encryption and Encryption-Key HTTP headers.

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/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 {
+
+const int64_t kDefaultRecordSize = 4096;

[whywhat, 2015/09/14 14:57:43]

Is this size in bytes? Kb?

[Peter Beverloo, 2015/09/15 19:41:11]

Done. Also clarified the origin of this value.

+
+bool Base64DecodeURLSafe(const base::StringPiece& input, std::string* output) {

[whywhat, 2015/09/14 14:57:43]

perhaps a comment what you mean by safe here?
You add a padding and replace two chars with other two chars.

[Peter Beverloo, 2015/09/15 19:41:11]

Renamed to the more appropriate Base64URLDecode.

+  size_t padded_size = (input.size() + 3) - (input.size() + 3) % 4;

[whywhat, 2015/09/14 14:57:43]

Does it have to be an arithmetic expression? I had to wrap my head around it for
a couple of minutes to extract the logic of:

padded_size = (input.size() % 4) ? input.size() : input.size() + 4 -
(input.size() % 4);

If it needs to be superfast, you could go with bitwise logic perhaps:
size_t padded_size = without_last_two_bits(input.size()) +
(is_last_or_penultimate_bit_set(input.size)) << 2;
where without_last_two_bits(i) => i & ~3 and is_last_or_penultimate_bit_set(i)
=> is_bit_set(i, 0) | is_bit_set(i, 1) and is_bit_set(i, n) => (i & (1U << n) >>
n)

:)

[Peter Beverloo, 2015/09/15 19:41:11]

Hah. I adopted your suggestion. This is not performance sensitive, so the branch
is OK.

+
+  // Add padding to |input|.
+  std::string padded_input(input.begin(), input.end());
+  padded_input.resize(padded_size, '=');
+
+  // Convert to standard base64 alphabet.
+  base::ReplaceChars(padded_input, "-", "+", &padded_input);
+  base::ReplaceChars(padded_input, "_", "/", &padded_input);
+
+  return base::Base64Decode(padded_input, output);
+}
+
+bool ValueToDecodedString(std::string::const_iterator begin,

[whywhat, 2015/09/14 14:57:43]

can you pass iterators by reference (perhaps only valuable in debug builds on
some platforms but who knows)?

[Peter Beverloo, 2015/09/15 19:41:11]

Done.

+                          std::string::const_iterator end,
+                          std::string* salt) {
+  const base::StringPiece value(begin, end);
+  if (value.empty())

[whywhat, 2015/09/14 14:57:43]

you could check if begin == end before constructing StringPiece?
also, if the value is empty, does Base64Decode return true?

[Peter Beverloo, 2015/09/15 19:41:11]

Construction of the StringPiece should be inline, so this shouldn't matter a
lot.

Yes, Base64Decode will return true.

+    return false;
+
+  return Base64DecodeURLSafe(value, salt);
+}
+
+bool RecordSizeToInt(std::string::const_iterator begin,

[whywhat, 2015/09/14 14:57:43]

Read this a "record (verb) a size to an int". Maybe different naming?
(SizeToInt, HeaderRecordSizeToInt)

[Peter Beverloo, 2015/09/15 19:41:11]

As discussed offline - I understand you concern but the implementation is
trivial enough that it will quickly become obvious to the reader.

+                     std::string::const_iterator end,
+                     int64_t* rs) {
+  const base::StringPiece value(begin, end);
+  if (value.empty())
+    return false;
+
+  if (!base::StringToInt64(value, rs))
+    return false;
+
+  // The record size MUST be greater than 1.
+  return *rs > 1;

[whywhat, 2015/09/14 14:57:43]

this has a possible unintended effect of changing |rs| even if false is
returned. you're safe by not using this value later on in the public function
though.

[Peter Beverloo, 2015/09/15 19:41:11]

Ack, that's why we use temps in the public :)

+}
+
+bool ParseEncryptionHeaderImpl(const std::string& input,
+                               std::string* keyid,
+                               std::string* salt,
+                               int64_t* rs) {
+  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 =

[whywhat, 2015/09/14 14:57:43]

can't you do:

const base::StringPiece name(n_v_p.name_begin(), n_v_p.name_end()) 

[Peter Beverloo, 2015/09/15 19:41:11]

Done.

+        base::StringPiece(name_value_pairs.name_begin(),
+                          name_value_pairs.name_end());
+
+    if (base::LowerCaseEqualsASCII(name, "keyid")) {

[whywhat, 2015/09/14 14:57:43]

give names to the magic constants? you only reuse "keyid" though.

[Peter Beverloo, 2015/09/15 19:41:11]

As you say, the gain is minimal while this is much easier to read.

+      keyid->assign(name_value_pairs.value_begin(),
+                    name_value_pairs.value_end());
+    } else if (base::LowerCaseEqualsASCII(name, "salt")) {
+      if (!ValueToDecodedString(name_value_pairs.value_begin(),
+                                name_value_pairs.value_end(), salt)) {
+        return false;
+      }
+    } else if (base::LowerCaseEqualsASCII(name, "rs")) {
+      if (!RecordSizeToInt(name_value_pairs.value_begin(),
+                           name_value_pairs.value_end(), rs)) {
+        return false;
+      }
+    } else {
+      // Silently ignore unknown directives for forward compatibility.
+    }
+  }
+
+  return name_value_pairs.valid();
+}
+
+bool ParseEncryptionKeyHeaderImpl(const std::string& input,
+                                  std::string* keyid,
+                                  std::string* key,
+                                  std::string* dh) {
+  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 =
+        base::StringPiece(name_value_pairs.name_begin(),
+                          name_value_pairs.name_end());
+
+    if (base::LowerCaseEqualsASCII(name, "keyid")) {
+      keyid->assign(name_value_pairs.value_begin(),
+                    name_value_pairs.value_end());
+    } else if (base::LowerCaseEqualsASCII(name, "key")) {
+      if (!ValueToDecodedString(name_value_pairs.value_begin(),
+                                name_value_pairs.value_end(), key)) {
+        return false;
+      }
+    } else if (base::LowerCaseEqualsASCII(name, "dh")) {
+      if (!ValueToDecodedString(name_value_pairs.value_begin(),
+                                name_value_pairs.value_end(), dh)) {
+        return false;
+      }
+    } else {
+      // Silently ignore unknown directives for forward compatibility.
+    }
+  }
+
+  return name_value_pairs.valid();
+}
+
+}  // namespace
+
+// "Encryption" ":"
+//     [ "keyid" "=" string ]
+//     [ ";" "salt" "=" base64url ]
+//     [ ";" "rs" "=" octet-count ]
+bool ParseEncryptionHeader(const std::string& input,
+                           std::string* keyid,
+                           std::string* salt,
+                           int64_t* rs) {
+  std::string candidate_keyid;
+  std::string candidate_salt;
+  int64_t candidate_rs = kDefaultRecordSize;
+
+  if (!ParseEncryptionHeaderImpl(input, &candidate_keyid, &candidate_salt,
+                                 &candidate_rs)) {
+    return false;
+  }
+
+  keyid->swap(candidate_keyid);
+  salt->swap(candidate_salt);
+  *rs = candidate_rs;
+  return true;
+}
+
+// "Encryption-Key" ":"
+//     [ "keyid" "=" string ]
+//     [ ";" "key" "=" base64url ]
+//     [ ";" "dh" "=" base64url ]
+bool ParseEncryptionKeyHeader(const std::string& input,
+                              std::string* keyid,
+                              std::string* key,
+                              std::string* dh) {
+  std::string candidate_keyid;
+  std::string candidate_key;
+  std::string candidate_dh;
+
+  if (!ParseEncryptionKeyHeaderImpl(input, &candidate_keyid, &candidate_key,
+                                    &candidate_dh)) {
+    return false;
+  }
+
+  keyid->swap(candidate_keyid);
+  key->swap(candidate_key);
+  dh->swap(candidate_dh);
+  return true;
+}
+
+}  // namespace gcm