Merge pull request #554 from brave/disable_webtorrent_in_tor

Disable WebTorrent in Tor profile

Author: yrliou

components/brave_webtorrent/browser/content_browser_client_helper.h

@@ -67,11 +67,13 @@ static bool HandleTorrentURLRewrite(GURL* url,
   return false;
 }
 
-static bool IsWebtorrentInstalled(content::BrowserContext* browser_context) {
+static bool IsWebtorrentEnabled(content::BrowserContext* browser_context) {
+  bool isTorProfile =
+    Profile::FromBrowserContext(browser_context)->IsTorProfile();
   extensions::ExtensionRegistry* registry =
     extensions::ExtensionRegistry::Get(browser_context);
-  return registry->enabled_extensions().Contains(
-      brave_webtorrent_extension_id);
+  return !isTorProfile &&
+    registry->enabled_extensions().Contains(brave_webtorrent_extension_id);
 }
 
 static void LoadOrLaunchMagnetURL(
@@ -83,7 +85,7 @@ static void LoadOrLaunchMagnetURL(
   if (!web_contents)
     return;
 
-  if (IsWebtorrentInstalled(web_contents->GetBrowserContext())) {
+  if (IsWebtorrentEnabled(web_contents->GetBrowserContext())) {
     web_contents->GetController().LoadURL(url, content::Referrer(),
         page_transition, std::string());
   } else {
@@ -96,7 +98,7 @@ static void LoadOrLaunchMagnetURL(
 
 static bool HandleMagnetURLRewrite(GURL* url,
     content::BrowserContext* browser_context) {
-  if (IsWebtorrentInstalled(browser_context) && url->SchemeIs(kMagnetScheme)) {
+  if (IsWebtorrentEnabled(browser_context) && url->SchemeIs(kMagnetScheme)) {
     *url = TranslateMagnetURL(*url);
     return true;
   }

components/brave_webtorrent/browser/net/brave_torrent_redirect_network_delegate_helper.cc

@@ -6,8 +6,10 @@
 
 #include "base/strings/strcat.h"
 #include "base/strings/string_util.h"
+#include "brave/browser/renderer_host/brave_navigation_ui_data.h"
 #include "brave/common/network_constants.h"
 #include "brave/common/extensions/extension_constants.h"
+#include "content/public/browser/resource_request_info.h"
 #include "extensions/common/constants.h"
 #include "net/http/http_content_disposition.h"
 #include "net/http/http_response_headers.h"
@@ -63,6 +65,23 @@ bool IsWebtorrentInitiated(net::URLRequest* request) {
       brave_webtorrent_extension_id, "/"});
 }
 
+bool IsTorProfile(net::URLRequest* request) {
+  const content::ResourceRequestInfo* resource_info =
+    content::ResourceRequestInfo::ForRequest(request);
+  if (!resource_info) {
+    return false;
+  }
+
+  const BraveNavigationUIData* ui_data =
+    static_cast<const BraveNavigationUIData*>(
+        resource_info->GetNavigationUIData());
+  if (!ui_data) {
+    return false;
+  }
+
+  return ui_data->GetTorProfileService() ? true : false;
+}
+
 } // namespace
 
 namespace webtorrent {
@@ -76,6 +95,7 @@ int OnHeadersReceived_TorrentRedirectWork(
     std::shared_ptr<brave::BraveRequestInfo> ctx) {
 
   if (!request || !original_response_headers ||
+      IsTorProfile(request) ||
       IsWebtorrentInitiated(request) || // download .torrent, do not redirect
       !IsTorrentFile(request, original_response_headers)) {
     return net::OK;

components/brave_webtorrent/browser/net/brave_torrent_redirect_network_delegate_helper_unittest.cc

@@ -4,35 +4,64 @@
 
 #include "brave/components/brave_webtorrent/browser/net/brave_torrent_redirect_network_delegate_helper.h"
 
+#include "base/files/file_path.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/strings/strcat.h"
 #include "brave/browser/net/url_context.h"
+#include "brave/browser/profiles/brave_profile_manager.h"
+#include "brave/browser/profiles/tor_unittest_profile_manager.h"
+#include "brave/browser/renderer_host/brave_navigation_ui_data.h"
+#include "brave/browser/tor/mock_tor_profile_service_factory.h"
 #include "brave/common/network_constants.h"
+#include "chrome/test/base/scoped_testing_local_state.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "content/public/browser/resource_request_info.h"
+#include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
+int kRenderProcessId = 1;
+int kRenderFrameId = 2;
+
+} // namespace
+
 class BraveTorrentRedirectNetworkDelegateHelperTest: public testing::Test {
  public:
   BraveTorrentRedirectNetworkDelegateHelperTest()
-      : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+      : local_state_(TestingBrowserProcess::GetGlobal()),
+        thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         context_(new net::TestURLRequestContext(true)) {
   }
 
   ~BraveTorrentRedirectNetworkDelegateHelperTest() override {}
 
   void SetUp() override {
+    // Create a new temporary directory, and store the path
+    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
+    TestingBrowserProcess::GetGlobal()->SetProfileManager(
+        new TorUnittestProfileManager(temp_dir_.GetPath()));
     context_->Init();
+
     torrent_url_ = GURL("https://webtorrent.io/torrents/sintel.torrent");
     non_torrent_url_ = GURL("https://webtorrent.io/torrents/sintel");
     extension_url_ = GURL("chrome-extension://lgjmpdmojkpocjcopdikifhejkkjglho/extension/brave_webtorrent.html?https://webtorrent.io/torrents/sintel.torrent");
     non_torrent_extension_url_ = GURL("chrome-extension://lgjmpdmojkpocjcopdikifhejkkjglho/extension/brave_webtorrent.html?https://webtorrent.io/torrents/sintel");
   }
 
+  void TearDown() override {
+    TestingBrowserProcess::GetGlobal()->SetProfileManager(nullptr);
+  }
+
   net::TestURLRequestContext* context() { return context_.get(); }
 
+  content::MockResourceContext* resource_context() {
+    return resource_context_.get();
+  }
+
   const GURL& torrent_url() {
     return torrent_url_;
   }
@@ -49,13 +78,19 @@ class BraveTorrentRedirectNetworkDelegateHelperTest: public testing::Test {
     return non_torrent_extension_url_;
   }
 
+ protected:
+  // The path to temporary directory used to contain the test operations.
+  base::ScopedTempDir temp_dir_;
+  ScopedTestingLocalState local_state_;
+
  private:
   GURL torrent_url_;
   GURL non_torrent_url_;
   GURL extension_url_;
   GURL non_torrent_extension_url_;
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<net::TestURLRequestContext> context_;
+  std::unique_ptr<content::MockResourceContext> resource_context_;
 };
 
 TEST_F(BraveTorrentRedirectNetworkDelegateHelperTest, NoRedirectWithoutMimeType) {
@@ -283,4 +318,52 @@ TEST_F(BraveTorrentRedirectNetworkDelegateHelperTest, WebtorrentInitiatedNoRedir
   EXPECT_EQ(ret, net::OK);
 }
 
-} // namespace
+TEST_F(BraveTorrentRedirectNetworkDelegateHelperTest, NoRedirectTorProfile) {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  base::FilePath tor_path = BraveProfileManager::GetTorProfilePath();
+  Profile* profile = profile_manager->GetProfile(tor_path);
+  ASSERT_TRUE(profile);
+
+  net::TestDelegate test_delegate;
+  std::unique_ptr<net::URLRequest> request =
+      context()->CreateRequest(torrent_url(), net::IDLE, &test_delegate,
+                               TRAFFIC_ANNOTATION_FOR_TESTS);
+
+  scoped_refptr<net::HttpResponseHeaders> orig_response_headers =
+    new net::HttpResponseHeaders(std::string());
+  orig_response_headers->AddHeader(
+      base::StrCat({"Content-Type: ", kBittorrentMimeType}));
+  std::string mimeType;
+  ASSERT_TRUE(orig_response_headers->GetMimeType(&mimeType));
+  ASSERT_EQ(mimeType, kBittorrentMimeType);
+
+  scoped_refptr<net::HttpResponseHeaders> overwrite_response_headers =
+    new net::HttpResponseHeaders(std::string());
+  GURL allowed_unsafe_redirect_url = GURL::EmptyGURL();
+  std::shared_ptr<brave::BraveRequestInfo>
+      brave_request_info(new brave::BraveRequestInfo());
+  brave::ResponseCallback callback;
+
+  std::unique_ptr<BraveNavigationUIData> navigation_ui_data =
+    std::make_unique<BraveNavigationUIData>();
+  BraveNavigationUIData* navigation_ui_data_ptr = navigation_ui_data.get();
+
+  content::ResourceRequestInfo::AllocateForTesting(
+    request.get(), content::RESOURCE_TYPE_MAIN_FRAME, resource_context(),
+    kRenderProcessId, /*render_view_id=*/-1, kRenderFrameId,
+    /*is_main_frame=*/true, /*allow_download=*/false, /*is_async=*/true,
+    content::PREVIEWS_OFF, std::move(navigation_ui_data));
+
+  MockTorProfileServiceFactory::SetTorNavigationUIData(profile,
+                                                   navigation_ui_data_ptr);
+
+  int ret = webtorrent::OnHeadersReceived_TorrentRedirectWork(request.get(),
+      orig_response_headers.get(), &overwrite_response_headers,
+      &allowed_unsafe_redirect_url, callback, brave_request_info);
+
+  EXPECT_EQ(overwrite_response_headers->GetStatusLine(), "HTTP/1.0 200 OK");
+  std::string location;
+  EXPECT_FALSE(overwrite_response_headers->EnumerateHeader(nullptr, "Location", &location));
+  EXPECT_EQ(allowed_unsafe_redirect_url, GURL::EmptyGURL());
+  EXPECT_EQ(ret, net::OK);
+}