DevTools protocol interception, blocking & modification of requests

content/browser/devtools/protocol/network_handler.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 "content/browser/devtools/protocol/network_handler.h"
 
 #include <stddef.h>
 
 #include "base/barrier_closure.h"
+#include "base/base64.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "content/browser/devtools/devtools_session.h"
+#include "content/browser/devtools/devtools_url_interceptor_request_job.h"
 #include "content/browser/devtools/protocol/page.h"
 #include "content/browser/devtools/protocol/security.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/common/navigation_params.h"
 #include "content/common/resource_request.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/browsing_data_remover.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/resource_devtools_info.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/net_errors.h"
+#include "net/base/upload_bytes_element_reader.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace content {
 namespace protocol {
 namespace {
 
 using ProtocolCookieArray = Array<Network::Cookie>;
@@ skipping 282 matching lines @@
     case blink::kWebReferrerPolicyOriginWhenCrossOrigin:
       return Network::Request::ReferrerPolicyEnum::OriginWhenCrossOrigin;
     case blink::kWebReferrerPolicyNoReferrerWhenDowngradeOriginWhenCrossOrigin:
       return Network::Request::ReferrerPolicyEnum::
           NoReferrerWhenDowngradeOriginWhenCrossOrigin;
   }
   NOTREACHED();
   return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
 }
 
+String referrerPolicy(net::URLRequest::ReferrerPolicy referrer_policy) {
+  switch (referrer_policy) {
+    case net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE:
+      return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
+    case net::URLRequest::
+        REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN:
+      return Network::Request::ReferrerPolicyEnum::
+          NoReferrerWhenDowngradeOriginWhenCrossOrigin;
+    case net::URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN:
+      return Network::Request::ReferrerPolicyEnum::
+          NoReferrerWhenDowngradeOriginWhenCrossOrigin;
+    case net::URLRequest::NEVER_CLEAR_REFERRER:
+      return Network::Request::ReferrerPolicyEnum::Origin;
+    case net::URLRequest::ORIGIN:
+      return Network::Request::ReferrerPolicyEnum::Origin;
+    case net::URLRequest::NO_REFERRER:
+      return Network::Request::ReferrerPolicyEnum::NoReferrer;
+    default:
+      break;
+  }
+  NOTREACHED();
+  return Network::Request::ReferrerPolicyEnum::NoReferrerWhenDowngrade;
+}
+
 String securityState(const GURL& url, const net::CertStatus& cert_status) {
   if (!url.SchemeIsCryptographic())
     return Security::SecurityStateEnum::Neutral;
   if (net::IsCertStatusError(cert_status) &&
       !net::IsCertStatusMinorError(cert_status)) {
     return Security::SecurityStateEnum::Insecure;
   }
   return Security::SecurityStateEnum::Secure;
 }
 
+net::Error NetErrorFromString(const std::string& error) {
+  if (error == Network::ErrorReasonEnum::Failed)
+    return net::ERR_FAILED;
+  if (error == Network::ErrorReasonEnum::Aborted)
+    return net::ERR_ABORTED;
+  if (error == Network::ErrorReasonEnum::TimedOut)
+    return net::ERR_TIMED_OUT;
+  if (error == Network::ErrorReasonEnum::AccessDenied)
+    return net::ERR_ACCESS_DENIED;
+  if (error == Network::ErrorReasonEnum::ConnectionClosed)
+    return net::ERR_CONNECTION_CLOSED;
+  if (error == Network::ErrorReasonEnum::ConnectionReset)
+    return net::ERR_CONNECTION_RESET;
+  if (error == Network::ErrorReasonEnum::ConnectionRefused)
+    return net::ERR_CONNECTION_REFUSED;
+  if (error == Network::ErrorReasonEnum::ConnectionAborted)
+    return net::ERR_CONNECTION_ABORTED;
+  if (error == Network::ErrorReasonEnum::ConnectionFailed)
+    return net::ERR_CONNECTION_FAILED;
+  if (error == Network::ErrorReasonEnum::NameNotResolved)
+    return net::ERR_NAME_NOT_RESOLVED;
+  if (error == Network::ErrorReasonEnum::InternetDisconnected)
+    return net::ERR_INTERNET_DISCONNECTED;
+  if (error == Network::ErrorReasonEnum::AddressUnreachable)
+    return net::ERR_ADDRESS_UNREACHABLE;
+  return net::ERR_FAILED;
+}
+
 double timeDelta(base::TimeTicks time,
                  base::TimeTicks start,
                  double invalid_value = -1) {
   return time.is_null() ? invalid_value : (time - start).InMillisecondsF();
 }
 
 std::unique_ptr<Network::ResourceTiming> getTiming(
     const net::LoadTimingInfo& load_timing) {
   const base::TimeTicks kNullTicks;
   return Network::ResourceTiming::Create()
@@ skipping 53 matching lines @@
     }
   }
   return protocol;
 }
 
 }  // namespace
 
 NetworkHandler::NetworkHandler()
     : DevToolsDomainHandler(Network::Metainfo::domainName),
       host_(nullptr),
-      enabled_(false) {
-}
+      enabled_(false),
+      interception_enabled_(false),
+      weak_factory_(this) {}
 
 NetworkHandler::~NetworkHandler() {
 }
 
 // static
 std::vector<NetworkHandler*> NetworkHandler::ForAgentHost(
     DevToolsAgentHostImpl* host) {
   return DevToolsSession::HandlersForAgentHost<NetworkHandler>(
       host, Network::Metainfo::domainName);
 }
 
 void NetworkHandler::Wire(UberDispatcher* dispatcher) {
   frontend_.reset(new Network::Frontend(dispatcher->channel()));
   Network::Dispatcher::wire(dispatcher, this);
 }
 
 void NetworkHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
   host_ = host;
 }
 
 Response NetworkHandler::Enable(Maybe<int> max_total_size,
                                 Maybe<int> max_resource_size) {
   enabled_ = true;
   return Response::FallThrough();
 }
 
 Response NetworkHandler::Disable() {
   enabled_ = false;
   user_agent_ = std::string();
+  EnableRequestInterception(false);
   return Response::FallThrough();
 }
 
 Response NetworkHandler::ClearBrowserCache() {
   if (host_) {
     content::BrowsingDataRemover* remover =
         content::BrowserContext::GetBrowsingDataRemover(
             host_->GetSiteInstance()->GetProcess()->GetBrowserContext());
     remover->Remove(base::Time(), base::Time::Max(),
                     content::BrowsingDataRemover::DATA_TYPE_CACHE,
@@ skipping 299 matching lines @@
       request_id,
       base::TimeTicks::Now().ToInternalValue() /
           static_cast<double>(base::Time::kMicrosecondsPerSecond),
       Page::ResourceTypeEnum::Document, error_string, cancelled);
 }
 
 std::string NetworkHandler::UserAgentOverride() const {
   return enabled_ ? user_agent_ : std::string();
 }
 
+DispatchResponse NetworkHandler::EnableRequestInterception(bool enabled) {
+  if (interception_enabled_ == enabled)
+    return Response::OK();  // Nothing to do.
+
+  WebContents* web_contents = WebContents::FromRenderFrameHost(host_);
+  if (!web_contents)
+    return Response::OK();
+
+  DevToolsURLRequestInterceptor* devtools_url_request_interceptor =
+      DevToolsURLRequestInterceptor::FromBrowserContext(
+          web_contents->GetBrowserContext());
+  if (!devtools_url_request_interceptor)
+    return Response::OK();
+
+  if (enabled) {
+    devtools_url_request_interceptor->state()->StartInterceptingRequests(
+        web_contents, weak_factory_.GetWeakPtr());
+  } else {
+    devtools_url_request_interceptor->state()->StopInterceptingRequests(
+        web_contents);
+  }
+  interception_enabled_ = enabled;
+  return Response::OK();
+}
+
+namespace {
+bool GetPostData(const net::URLRequest* request, std::string* post_data) {
+  if (!request->has_upload())
+    return false;
+
+  const net::UploadDataStream* stream = request->get_upload();
+  if (!stream->GetElementReaders())
+    return false;
+
+  const auto* element_readers = stream->GetElementReaders();
+  if (element_readers->empty())
+    return false;
+
+  *post_data = "";
+  for (const auto& element_reader : *element_readers) {
+    const net::UploadBytesElementReader* reader =
+        element_reader->AsBytesReader();
+    // TODO(alexclarke): This should really be base64 encoded.
+    *post_data += std::string(reader->bytes(), reader->length());
+  }
+  return true;
+}
+}  // namespace
+
+// TODO(alexclarke): Support structured data as well as |base64_raw_response|.
+void NetworkHandler::ContinueInterceptedRequest(
+    const std::string& interception_id,
+    Maybe<std::string> error_reason,
+    Maybe<std::string> base64_raw_response,
+    Maybe<std::string> url,
+    Maybe<std::string> method,
+    Maybe<std::string> post_data,
+    Maybe<protocol::Network::Headers> headers,
+    std::unique_ptr<ContinueInterceptedRequestCallback> callback) {
+  DevToolsURLRequestInterceptor* devtools_url_request_interceptor =
+      DevToolsURLRequestInterceptor::FromBrowserContext(
+          WebContents::FromRenderFrameHost(host_)->GetBrowserContext());
+  if (!devtools_url_request_interceptor) {
+    callback->sendFailure(Response::InternalError());
+    return;
+  }
+
+  base::Optional<net::Error> error;
+  if (error_reason.isJust())
+    error = NetErrorFromString(error_reason.fromJust());
+
+  base::Optional<std::string> raw_response;
+  if (base64_raw_response.isJust()) {
+    std::string decoded;
+    if (!base::Base64Decode(base64_raw_response.fromJust(), &decoded)) {
+      callback->sendFailure(Response::InvalidParams("Invalid rawResponse."));
+      return;
+    }
+    raw_response = decoded;
+  }
+
+  devtools_url_request_interceptor->state()->ContinueInterceptedRequest(
+      interception_id,
+      base::MakeUnique<DevToolsURLRequestInterceptor::Modifications>(
+          std::move(error), std::move(raw_response), std::move(url),
+          std::move(method), std::move(post_data), std::move(headers)),
+      std::move(callback));
+}
+
+// static
+std::unique_ptr<Network::Request> NetworkHandler::CreateRequestFromURLRequest(
+    const net::URLRequest* request) {
+  std::unique_ptr<DictionaryValue> headers_dict(DictionaryValue::create());
+  for (net::HttpRequestHeaders::Iterator it(request->extra_request_headers());
+       it.GetNext();) {
+    headers_dict->setString(it.name(), it.value());
+  }
+  std::unique_ptr<protocol::Network::Request> request_object =
+      Network::Request::Create()
+          .SetUrl(request->url().spec())
+          .SetMethod(request->method())
+          .SetHeaders(Object::fromValue(headers_dict.get(), nullptr))
+          .SetInitialPriority(resourcePriority(request->priority()))
+          .SetReferrerPolicy(referrerPolicy(request->referrer_policy()))
+          .Build();
+  std::string post_data;
+  if (GetPostData(request, &post_data))
+    request_object->SetPostData(std::move(post_data));
+  return request_object;
+}
+
 }  // namespace protocol
 }  // namespace content