Modify data_reduction_proxy_header to support tamper detection logic.

components/data_reduction_proxy/common/data_reduction_proxy_headers.cc

 // Copyright 2014 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/data_reduction_proxy/common/data_reduction_proxy_headers.h"
 
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/proxy/proxy_service.h"
 
 using base::StringPiece;
 using base::TimeDelta;
 using net::ProxyService;
 
 namespace data_reduction_proxy {
 
+bool GetDataReductionProxyActionValue(
+    const net::HttpResponseHeaders* headers,
+    const std::string& action_prefix,
+    std::string* action_value) {
+  DCHECK(action_prefix.size());

[bengr, 2014/07/16 19:23:56]

DCHECK(!action_prefix.empty());

[xingx, 2014/07/16 21:22:33]

Done.

+  void* iter = NULL;
+  std::string value;
+  std::string name = "chrome-proxy";

[bengr, 2014/07/16 19:23:56]

Add an anonymous namespace above this namespace and add this as const char [],
e.g.:

namespace {
const char kChromeProxyHeader[] = "chrome-proxy";
}

Use this constant directly in EnumerateHeader here and below.

[xingx, 2014/07/16 21:22:33]

Done.

+
+  while (headers->EnumerateHeader(&iter, name, &value)) {
+    if (value.size() > action_prefix.size()) {
+      if (LowerCaseEqualsASCII(value.begin(),
+                               value.begin() + action_prefix.size(),
+                               action_prefix.c_str()) &&
+          value[action_prefix.size()] == '=') {

[bengr, 2014/07/16 19:23:56]

I think it's better to add '=' to the prefix before the loop. You should enforce
that the last character of the prefix is not an '=' before doing so.

[xingx, 2014/07/16 21:22:33]

Done. 

"enforce the last character is not '='", by DCHECK? If so, Done.

+        if (action_value)
+          *action_value = value.substr(action_prefix.size() + 1);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 bool GetDataReductionProxyBypassDuration(
     const net::HttpResponseHeaders* headers,
     const std::string& action_prefix,
     base::TimeDelta* duration) {
+  DCHECK(action_prefix.size());
   void* iter = NULL;
   std::string value;
   std::string name = "chrome-proxy";
 
   while (headers->EnumerateHeader(&iter, name, &value)) {
     if (value.size() > action_prefix.size()) {
       if (LowerCaseEqualsASCII(value.begin(),
                                value.begin() + action_prefix.size(),
-                               action_prefix.c_str())) {
+                               action_prefix.c_str()) &&
+          value[action_prefix.size()] == '=') {

[bengr, 2014/07/16 19:23:56]

See above comment. The loop logic shouldn't change.

[xingx, 2014/07/16 21:22:33]

Done.

[xingx, 2014/07/16 21:22:33]

Done.

         int64 seconds;
         if (!base::StringToInt64(
-                StringPiece(value.begin() + action_prefix.size(), value.end()),
+                StringPiece(value.begin() + action_prefix.size() + 1,
+                            value.end()),
                 &seconds) || seconds < 0) {
           continue;  // In case there is a well formed instruction.
         }
         *duration = TimeDelta::FromSeconds(seconds);
         return true;
       }
     }
   }
   return false;
 }
 
 bool GetDataReductionProxyInfo(const net::HttpResponseHeaders* headers,
                                DataReductionProxyInfo* proxy_info) {
   DCHECK(proxy_info);
   proxy_info->bypass_all = false;
   proxy_info->bypass_duration = TimeDelta();
   // Support header of the form Chrome-Proxy: bypass|block=<duration>, where
   // <duration> is the number of seconds to wait before retrying
   // the proxy. If the duration is 0, then the default proxy retry delay
   // (specified in |ProxyList::UpdateRetryInfoOnFallback|) will be used.
   // 'bypass' instructs Chrome to bypass the currently connected data reduction
   // proxy, whereas 'block' instructs Chrome to bypass all available data
   // reduction proxies.
 
   // 'block' takes precedence over 'bypass', so look for it first.
   // TODO(bengr): Reduce checks for 'block' and 'bypass' to a single loop.
   if (GetDataReductionProxyBypassDuration(
-      headers, "block=", &proxy_info->bypass_duration)) {
+      headers, "block", &proxy_info->bypass_duration)) {
     proxy_info->bypass_all = true;
     return true;
   }
 
   // Next, look for 'bypass'.
   if (GetDataReductionProxyBypassDuration(
-      headers, "bypass=", &proxy_info->bypass_duration)) {
+      headers, "bypass", &proxy_info->bypass_duration)) {
     return true;
   }
   return false;
 }
 
-bool HasDataReductionProxyViaHeader(const net::HttpResponseHeaders* headers) {
+bool HasDataReductionProxyViaHeader(const net::HttpResponseHeaders* headers,
+                                    bool* is_the_last) {

[bengr, 2014/07/16 19:23:56]

change to has_intermediary.

[xingx, 2014/07/16 21:22:33]

Done.

   const size_t kVersionSize = 4;
   const char kDataReductionProxyViaValue[] = "Chrome-Compression-Proxy";
   size_t value_len = strlen(kDataReductionProxyViaValue);
   void* iter = NULL;
   std::string value;
 
   // Case-sensitive comparison of |value|. Assumes the received protocol and the
   // space following it are always |kVersionSize| characters. E.g.,
   // 'Via: 1.1 Chrome-Compression-Proxy'
   while (headers->EnumerateHeader(&iter, "via", &value)) {
     if (value.size() >= kVersionSize + value_len &&
-        !value.compare(kVersionSize, value_len, kDataReductionProxyViaValue))
+        !value.compare(kVersionSize, value_len, kDataReductionProxyViaValue)) {
+      if (is_the_last)
+        *is_the_last = !(headers->EnumerateHeader(&iter, "via", &value));
       return true;
+    }
   }
 
   // TODO(bengr): Remove deprecated header value.
   const char kDeprecatedDataReductionProxyViaValue[] =
       "1.1 Chrome Compression Proxy";
   iter = NULL;
   while (headers->EnumerateHeader(&iter, "via", &value))
-    if (value == kDeprecatedDataReductionProxyViaValue)
+    if (value == kDeprecatedDataReductionProxyViaValue) {
+      if (is_the_last)
+        *is_the_last = !(headers->EnumerateHeader(&iter, "via", &value));
       return true;
+    }
 
   return false;
 }
 
 net::ProxyService::DataReductionProxyBypassEventType
 GetDataReductionProxyBypassEventType(
     const net::HttpResponseHeaders* headers,
     DataReductionProxyInfo* data_reduction_proxy_info) {
   DCHECK(data_reduction_proxy_info);
   if (GetDataReductionProxyInfo(headers, data_reduction_proxy_info)) {
     // A chrome-proxy response header is only present in a 502. For proper
     // reporting, this check must come before the 5xx checks below.
     if (data_reduction_proxy_info->bypass_duration < TimeDelta::FromMinutes(30))
       return ProxyService::SHORT_BYPASS;
     return ProxyService::LONG_BYPASS;
   }
   if (headers->response_code() == net::HTTP_INTERNAL_SERVER_ERROR ||
       headers->response_code() == net::HTTP_BAD_GATEWAY ||
       headers->response_code() == net::HTTP_SERVICE_UNAVAILABLE) {
     // Fall back if a 500, 502 or 503 is returned.
     return ProxyService::INTERNAL_SERVER_ERROR_BYPASS;
   }
-  if (!HasDataReductionProxyViaHeader(headers) &&
+  if (!HasDataReductionProxyViaHeader(headers, NULL) &&
       (headers->response_code() != net::HTTP_NOT_MODIFIED)) {
     // A Via header might not be present in a 304. Since the goal of a 304
     // response is to minimize information transfer, a sender in general
     // should not generate representation metadata other than Cache-Control,
     // Content-Location, Date, ETag, Expires, and Vary.
 
     // The proxy Via header might also not be present in a 4xx response.
     // Separate this case from other responses that are missing the header.
     if (headers->response_code() >= net::HTTP_BAD_REQUEST &&
         headers->response_code() < net::HTTP_INTERNAL_SERVER_ERROR) {
       return ProxyService::PROXY_4XX_BYPASS;
     }
     return ProxyService::MISSING_VIA_HEADER;
   }
   // There is no bypass event.
   return ProxyService::BYPASS_EVENT_TYPE_MAX;
 }
 
 }  // namespace data_reduction_proxy