diff options
Diffstat (limited to 'chromium/weblayer/browser/safe_browsing')
11 files changed, 344 insertions, 116 deletions
diff --git a/chromium/weblayer/browser/safe_browsing/BUILD.gn b/chromium/weblayer/browser/safe_browsing/BUILD.gn deleted file mode 100644 index 001f036d3e8..00000000000 --- a/chromium/weblayer/browser/safe_browsing/BUILD.gn +++ /dev/null @@ -1,41 +0,0 @@ -# Copyright 2020 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. - -import("//build/config/android/config.gni") - -assert(is_android) - -source_set("safe_browsing") { - sources = [ - "safe_browsing_blocking_page.cc", - "safe_browsing_blocking_page.h", - "safe_browsing_navigation_throttle.cc", - "safe_browsing_navigation_throttle.h", - "safe_browsing_service.cc", - "safe_browsing_service.h", - "safe_browsing_subresource_helper.cc", - "safe_browsing_subresource_helper.h", - "safe_browsing_ui_manager.cc", - "safe_browsing_ui_manager.h", - "url_checker_delegate_impl.cc", - "url_checker_delegate_impl.h", - ] - deps = [ - "//components/safe_browsing/android:remote_database_manager", - "//components/safe_browsing/android:safe_browsing_api_handler", - "//components/safe_browsing/content", - "//components/safe_browsing/content/browser", - "//components/safe_browsing/content/renderer:throttles", - "//components/safe_browsing/core/browser", - "//components/safe_browsing/core/browser:network_context", - "//components/safe_browsing/core/common", - "//components/safe_browsing/core/db:database_manager", - "//components/security_interstitials/content:security_interstitial_page", - "//components/security_interstitials/core:unsafe_resource", - "//components/security_interstitials/core/", - "//content/public/browser", - "//skia", - "//third_party/blink/public/common", - ] -} diff --git a/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.cc b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.cc new file mode 100644 index 00000000000..d3bee53a080 --- /dev/null +++ b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.cc @@ -0,0 +1,60 @@ +// Copyright 2020 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 "weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.h" + +#include "components/keyed_service/content/browser_context_dependency_manager.h" +#include "components/safe_browsing/core/common/utils.h" +#include "components/safe_browsing/core/realtime/url_lookup_service.h" +#include "content/public/browser/browser_context.h" +#include "services/network/public/cpp/cross_thread_pending_shared_url_loader_factory.h" +#include "weblayer/browser/browser_context_impl.h" +#include "weblayer/browser/browser_process.h" +#include "weblayer/browser/feature_list_creator.h" +#include "weblayer/browser/safe_browsing/safe_browsing_service.h" +#include "weblayer/browser/user_agent.h" +#include "weblayer/browser/verdict_cache_manager_factory.h" + +namespace weblayer { + +// static +safe_browsing::RealTimeUrlLookupService* +RealTimeUrlLookupServiceFactory::GetForBrowserContext( + content::BrowserContext* browser_context) { + return static_cast<safe_browsing::RealTimeUrlLookupService*>( + GetInstance()->GetServiceForBrowserContext(browser_context, + /* create= */ true)); +} + +// static +RealTimeUrlLookupServiceFactory* +RealTimeUrlLookupServiceFactory::GetInstance() { + return base::Singleton<RealTimeUrlLookupServiceFactory>::get(); +} + +RealTimeUrlLookupServiceFactory::RealTimeUrlLookupServiceFactory() + : BrowserContextKeyedServiceFactory( + "RealTimeUrlLookupService", + BrowserContextDependencyManager::GetInstance()) {} + +KeyedService* RealTimeUrlLookupServiceFactory::BuildServiceInstanceFor( + content::BrowserContext* context) const { + auto url_loader_factory = + std::make_unique<network::CrossThreadPendingSharedURLLoaderFactory>( + BrowserProcess::GetInstance() + ->GetSafeBrowsingService(weblayer::GetUserAgent()) + ->GetURLLoaderFactory()); + + return new safe_browsing::RealTimeUrlLookupService( + network::SharedURLLoaderFactory::Create(std::move(url_loader_factory)), + VerdictCacheManagerFactory::GetForBrowserContext(context), + nullptr /* identity manager */, nullptr /* profile sync service */, + static_cast<BrowserContextImpl*>(context)->pref_service(), + safe_browsing::GetProfileManagementStatus(nullptr), + false /* is_under_advanced_protection */, + static_cast<BrowserContextImpl*>(context)->IsOffTheRecord(), + FeatureListCreator::GetInstance()->variations_service()); +} + +} // namespace weblayer diff --git a/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.h b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.h new file mode 100644 index 00000000000..1d9e6780a26 --- /dev/null +++ b/chromium/weblayer/browser/safe_browsing/real_time_url_lookup_service_factory.h @@ -0,0 +1,53 @@ +// Copyright 2020 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. + +#ifndef WEBLAYER_BROWSER_SAFE_BROWSING_REAL_TIME_URL_LOOKUP_SERVICE_FACTORY_H_ +#define WEBLAYER_BROWSER_SAFE_BROWSING_REAL_TIME_URL_LOOKUP_SERVICE_FACTORY_H_ + +#include "base/memory/singleton.h" +#include "components/keyed_service/content/browser_context_keyed_service_factory.h" + +class KeyedService; + +namespace content { +class BrowserContext; +} + +namespace safe_browsing { +class RealTimeUrlLookupService; +} // namespace safe_browsing + +namespace weblayer { + +// Singleton that owns RealTimeUrlLookupService objects and associates them +// them with BrowserContextImpl instances. +class RealTimeUrlLookupServiceFactory + : public BrowserContextKeyedServiceFactory { + public: + // Creates the service if it doesn't exist already for the given + // |browser_context|. If the service already exists, return its pointer. + static safe_browsing::RealTimeUrlLookupService* GetForBrowserContext( + content::BrowserContext* browser_context); + + // Get the singleton instance. + static RealTimeUrlLookupServiceFactory* GetInstance(); + + private: + friend struct base::DefaultSingletonTraits<RealTimeUrlLookupServiceFactory>; + + RealTimeUrlLookupServiceFactory(); + ~RealTimeUrlLookupServiceFactory() override = default; + RealTimeUrlLookupServiceFactory(const RealTimeUrlLookupServiceFactory&) = + delete; + RealTimeUrlLookupServiceFactory& operator=( + const RealTimeUrlLookupServiceFactory&) = delete; + + // BrowserContextKeyedServiceFactory: + KeyedService* BuildServiceInstanceFor( + content::BrowserContext* context) const override; +}; + +} // namespace weblayer + +#endif // WEBLAYER_BROWSER_SAFE_BROWSING_REAL_TIME_URL_LOOKUP_SERVICE_FACTORY_H_ diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc index 34cf6cb561d..fd6c603a40f 100644 --- a/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc +++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_blocking_page.cc @@ -6,7 +6,9 @@ #include "components/security_interstitials/content/security_interstitial_controller_client.h" #include "components/security_interstitials/content/unsafe_resource_util.h" +#include "components/security_interstitials/core/base_safe_browsing_error_ui.h" #include "content/public/browser/navigation_entry.h" +#include "weblayer/browser/browser_context_impl.h" #include "weblayer/browser/safe_browsing/safe_browsing_ui_manager.h" namespace weblayer { @@ -43,11 +45,23 @@ SafeBrowsingBlockingPage* SafeBrowsingBlockingPage::CreateBlockingPage( GURL url = (main_frame_url.is_empty() && entry) ? entry->GetURL() : main_frame_url; + BrowserContextImpl* browser_context = + static_cast<BrowserContextImpl*>(web_contents->GetBrowserContext()); + security_interstitials::BaseSafeBrowsingErrorUI::SBErrorDisplayOptions + display_options = + BaseBlockingPage::CreateDefaultDisplayOptions(unsafe_resources); + display_options.is_extended_reporting_opt_in_allowed = + safe_browsing::IsExtendedReportingOptInAllowed( + *(browser_context->pref_service())); + display_options.is_extended_reporting_enabled = + safe_browsing::IsExtendedReportingEnabled( + *(browser_context->pref_service())); + return new SafeBrowsingBlockingPage( ui_manager, web_contents, url, unsafe_resources, CreateControllerClient(web_contents, unsafe_resources, ui_manager, - nullptr /*pref_service*/), - BaseBlockingPage::CreateDefaultDisplayOptions(unsafe_resources)); + browser_context->pref_service()), + display_options); } security_interstitials::SecurityInterstitialPage::TypeID diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc index 51bd76179c4..77975384186 100644 --- a/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc +++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_browsertest.cc @@ -4,21 +4,28 @@ #include <map> -#include "base/task/post_task.h" +#include "components/prefs/pref_service.h" #include "components/safe_browsing/android/safe_browsing_api_handler.h" #include "components/safe_browsing/content/base_blocking_page.h" #include "components/safe_browsing/core/db/v4_protocol_manager_util.h" #include "components/security_interstitials/content/security_interstitial_page.h" #include "components/security_interstitials/content/security_interstitial_tab_helper.h" +#include "components/user_prefs/user_prefs.h" +#include "content/public/browser/browser_context.h" #include "content/public/browser/browser_task_traits.h" #include "content/public/browser/browser_thread.h" +#include "content/public/browser/render_process_host.h" #include "content/public/browser/web_contents.h" #include "content/public/test/test_utils.h" #include "net/test/embedded_test_server/embedded_test_server.h" +#include "weblayer/browser/browser_context_impl.h" +#include "weblayer/browser/browser_impl.h" +#include "weblayer/browser/profile_impl.h" #include "weblayer/browser/safe_browsing/safe_browsing_blocking_page.h" #include "weblayer/browser/tab_impl.h" #include "weblayer/public/navigation.h" #include "weblayer/public/navigation_controller.h" +#include "weblayer/public/profile.h" #include "weblayer/public/tab.h" #include "weblayer/shell/browser/shell.h" #include "weblayer/test/load_completion_observer.h" @@ -34,8 +41,8 @@ void RunCallbackOnIOThread( callback, safe_browsing::SBThreatType threat_type, const safe_browsing::ThreatMetadata& metadata) { - base::PostTask(FROM_HERE, {content::BrowserThread::IO}, - base::BindOnce(std::move(*callback), threat_type, metadata)); + content::GetIOThreadTaskRunner({})->PostTask( + FROM_HERE, base::BindOnce(std::move(*callback), threat_type, metadata)); } } // namespace @@ -79,14 +86,29 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest { SafeBrowsingBrowserTest() : fake_handler_(new FakeSafeBrowsingApiHandler()) {} ~SafeBrowsingBrowserTest() override = default; - // WebLayerBrowserTest: void SetUpOnMainThread() override { + InitializeOnMainThread(); + // Safe Browsing is enabled by default + ASSERT_TRUE(GetSafeBrowsingEnabled()); + } + + void InitializeOnMainThread() { NavigateAndWaitForCompletion(GURL("about:blank"), shell()); safe_browsing::SafeBrowsingApiHandler::SetInstance(fake_handler_.get()); ASSERT_TRUE(embedded_test_server()->Start()); url_ = embedded_test_server()->GetURL("/simple_page.html"); } + void SetSafeBrowsingEnabled(bool value) { + GetProfile()->SetBooleanSetting(SettingType::BASIC_SAFE_BROWSING_ENABLED, + value); + } + + bool GetSafeBrowsingEnabled() { + return GetProfile()->GetBooleanSetting( + SettingType::BASIC_SAFE_BROWSING_ENABLED); + } + void NavigateWithThreatType(const safe_browsing::SBThreatType& threatType, bool expect_interstitial) { fake_handler_->AddRestriction(url_, threatType); @@ -106,6 +128,16 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest { } } + void NavigateWithSubResourceAndThreatType( + const safe_browsing::SBThreatType& threat_type, + bool expect_interstitial) { + GURL page_with_script_url = + embedded_test_server()->GetURL("/simple_page_with_script.html"); + GURL script_url = embedded_test_server()->GetURL("/script.js"); + fake_handler_->AddRestriction(script_url, threat_type); + Navigate(page_with_script_url, expect_interstitial); + } + protected: content::WebContents* GetWebContents() { Tab* tab = shell()->tab(); @@ -126,6 +158,19 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest { bool HasInterstitial() { return GetSecurityInterstitialPage() != nullptr; } + void KillRenderer() { + content::RenderProcessHost* child_process = + static_cast<TabImpl*>(shell()->tab()) + ->web_contents() + ->GetMainFrame() + ->GetProcess(); + content::RenderProcessHostWatcher crash_observer( + child_process, + content::RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT); + child_process->Shutdown(0); + crash_observer.Wait(); + } + std::unique_ptr<FakeSafeBrowsingApiHandler> fake_handler_; GURL url_; @@ -133,6 +178,21 @@ class SafeBrowsingBrowserTest : public WebLayerBrowserTest { DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBrowserTest); }; +class SafeBrowsingDisabledBrowserTest : public SafeBrowsingBrowserTest { + public: + SafeBrowsingDisabledBrowserTest() {} + ~SafeBrowsingDisabledBrowserTest() override = default; + + void SetUpOnMainThread() override { + SetSafeBrowsingEnabled(false); + SafeBrowsingBrowserTest::InitializeOnMainThread(); + ASSERT_FALSE(GetSafeBrowsingEnabled()); + } + + private: + DISALLOW_COPY_AND_ASSIGN(SafeBrowsingDisabledBrowserTest); +}; + IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, DoesNotShowInterstitial_NoRestriction) { Navigate(url_, false); @@ -160,12 +220,70 @@ IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, ShowsInterstitial_Billing) { IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, ShowsInterstitial_Malware_Subresource) { - GURL page_with_script_url = - embedded_test_server()->GetURL("/simple_page_with_script.html"); - GURL script_url = embedded_test_server()->GetURL("/script.js"); - fake_handler_->AddRestriction(script_url, - safe_browsing::SB_THREAT_TYPE_URL_MALWARE); - Navigate(page_with_script_url, true); + NavigateWithSubResourceAndThreatType( + safe_browsing::SB_THREAT_TYPE_URL_MALWARE, true); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, + DoesNotShowInterstitial_Phishing_disableSB) { + // Test that the browser checks the safe browsing setting for new navigations. + SetSafeBrowsingEnabled(false); + NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_PHISHING, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, + DoesNotShowInterstitial_Malware_Subresource_disableSB) { + // Test that new renderer checks the safe browsing setting. + SetSafeBrowsingEnabled(false); + KillRenderer(); + NavigateWithSubResourceAndThreatType( + safe_browsing::SB_THREAT_TYPE_URL_MALWARE, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingBrowserTest, CheckSetsPrefs) { + // Check that changing safe browsing setting sets corresponding pref, + // which is persistent. + PrefService* prefs = GetProfile()->GetBrowserContext()->pref_service(); + SetSafeBrowsingEnabled(true); + EXPECT_TRUE(prefs->GetBoolean(::prefs::kSafeBrowsingEnabled)); + SetSafeBrowsingEnabled(false); + EXPECT_FALSE(prefs->GetBoolean(::prefs::kSafeBrowsingEnabled)); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest, + DoesNotShowInterstitial_NoRestriction) { + Navigate(url_, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest, + DoesNotShowInterstitial_Safe) { + NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_SAFE, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest, + DoesNotShowInterstitial_Malware) { + NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_MALWARE, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest, + DoesNotShowInterstitial_Phishing) { + NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_PHISHING, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest, + DoesNotShowInterstitial_Unwanted) { + NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_URL_UNWANTED, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest, + DoesNotShowInterstitial_Billing) { + NavigateWithThreatType(safe_browsing::SB_THREAT_TYPE_BILLING, false); +} + +IN_PROC_BROWSER_TEST_F(SafeBrowsingDisabledBrowserTest, + DoesNotShowInterstitial_Malware_Subresource) { + NavigateWithSubResourceAndThreatType( + safe_browsing::SB_THREAT_TYPE_URL_MALWARE, false); } -} // namespace weblayer +} // namespace weblayer
\ No newline at end of file diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc index 915e9a26f89..fca167feed4 100644 --- a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc +++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.cc @@ -6,19 +6,24 @@ #include "base/bind.h" #include "base/path_service.h" -#include "base/task/post_task.h" +#include "components/prefs/pref_service.h" #include "components/safe_browsing/android/remote_database_manager.h" #include "components/safe_browsing/android/safe_browsing_api_handler_bridge.h" #include "components/safe_browsing/content/browser/browser_url_loader_throttle.h" #include "components/safe_browsing/content/browser/mojo_safe_browsing_impl.h" #include "components/safe_browsing/core/browser/safe_browsing_network_context.h" +#include "components/safe_browsing/core/common/safe_browsing_prefs.h" +#include "components/safe_browsing/core/realtime/url_lookup_service.h" #include "content/public/browser/browser_context.h" #include "content/public/browser/browser_task_traits.h" #include "content/public/browser/browser_thread.h" +#include "content/public/browser/network_service_instance.h" #include "content/public/browser/render_process_host.h" #include "content/public/browser/resource_context.h" +#include "services/network/public/mojom/network_context.mojom.h" #include "services/network/public/mojom/network_service.mojom.h" #include "third_party/blink/public/common/loader/url_loader_throttle.h" +#include "weblayer/browser/browser_context_impl.h" #include "weblayer/browser/safe_browsing/safe_browsing_navigation_throttle.h" #include "weblayer/browser/safe_browsing/url_checker_delegate_impl.h" @@ -30,12 +35,15 @@ network::mojom::NetworkContextParamsPtr CreateDefaultNetworkContextParams( const std::string& user_agent) { network::mojom::NetworkContextParamsPtr network_context_params = network::mojom::NetworkContextParams::New(); + network_context_params->cert_verifier_params = content::GetCertVerifierParams( + network::mojom::CertVerifierCreationParams::New()); network_context_params->user_agent = user_agent; return network_context_params; } -// Helper method that checks the RenderProcessHost is still alive before hopping -// over to the IO thread. +// Helper method that checks the RenderProcessHost is still alive and checks the +// latest Safe Browsing pref value on the UI thread before hopping over to the +// IO thread. void MaybeCreateSafeBrowsing( int rph_id, content::ResourceContext* resource_context, @@ -49,8 +57,16 @@ void MaybeCreateSafeBrowsing( if (!render_process_host) return; - base::PostTask( - FROM_HERE, {content::BrowserThread::IO}, + bool is_safe_browsing_enabled = safe_browsing::IsSafeBrowsingEnabled( + *static_cast<BrowserContextImpl*>( + render_process_host->GetBrowserContext()) + ->pref_service()); + + if (!is_safe_browsing_enabled) + return; + + content::GetIOThreadTaskRunner({})->PostTask( + FROM_HERE, base::BindOnce(&safe_browsing::MojoSafeBrowsingImpl::MaybeCreate, rph_id, resource_context, std::move(get_checker_delegate), std::move(receiver))); @@ -59,7 +75,7 @@ void MaybeCreateSafeBrowsing( } // namespace SafeBrowsingService::SafeBrowsingService(const std::string& user_agent) - : user_agent_(user_agent), safe_browsing_disabled_(false) {} + : user_agent_(user_agent) {} SafeBrowsingService::~SafeBrowsingService() = default; @@ -93,7 +109,8 @@ void SafeBrowsingService::Initialize() { std::unique_ptr<blink::URLLoaderThrottle> SafeBrowsingService::CreateURLLoaderThrottle( const base::RepeatingCallback<content::WebContents*()>& wc_getter, - int frame_tree_node_id) { + int frame_tree_node_id, + safe_browsing::RealTimeUrlLookupServiceBase* url_lookup_service) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); return safe_browsing::BrowserURLLoaderThrottle::Create( @@ -103,10 +120,7 @@ SafeBrowsingService::CreateURLLoaderThrottle( }, base::Unretained(this)), wc_getter, frame_tree_node_id, - // rt_lookup_service are used to - // perform real time url check, which is gated by UKM opted in. Since - // WebLayer currently doesn't support UKM, this feature is not enabled. - /*rt_lookup_service*/ nullptr); + url_lookup_service ? url_lookup_service->GetWeakPtr() : nullptr); } std::unique_ptr<content::NavigationThrottle> @@ -122,8 +136,7 @@ SafeBrowsingService::GetSafeBrowsingUrlCheckerDelegate() { if (!safe_browsing_url_checker_delegate_) { safe_browsing_url_checker_delegate_ = new UrlCheckerDelegateImpl( - GetSafeBrowsingDBManager(), GetSafeBrowsingUIManager(), - safe_browsing_disabled_); + GetSafeBrowsingDBManager(), GetSafeBrowsingUIManager()); } return safe_browsing_url_checker_delegate_; @@ -143,7 +156,7 @@ SafeBrowsingUIManager* SafeBrowsingService::GetSafeBrowsingUIManager() { void SafeBrowsingService::CreateSafeBrowsingUIManager() { DCHECK(!ui_manager_); - ui_manager_ = new SafeBrowsingUIManager(); + ui_manager_ = new SafeBrowsingUIManager(this); } void SafeBrowsingService::CreateAndStartSafeBrowsingDBManager() { @@ -163,8 +176,8 @@ scoped_refptr<network::SharedURLLoaderFactory> SafeBrowsingService::GetURLLoaderFactoryOnIOThread() { DCHECK_CURRENTLY_ON(content::BrowserThread::IO); if (!shared_url_loader_factory_on_io_) { - base::PostTask( - FROM_HERE, {content::BrowserThread::UI}, + content::GetUIThreadTaskRunner({})->PostTask( + FROM_HERE, base::BindOnce(&SafeBrowsingService::CreateURLLoaderFactoryForIO, base::Unretained(this), url_loader_factory_on_io_.BindNewPipeAndPassReceiver())); @@ -198,12 +211,12 @@ void SafeBrowsingService::AddInterface( base::BindRepeating( &SafeBrowsingService::GetSafeBrowsingUrlCheckerDelegate, base::Unretained(this))), - base::CreateSingleThreadTaskRunner({content::BrowserThread::UI})); + content::GetUIThreadTaskRunner({})); } void SafeBrowsingService::StopDBManager() { - base::PostTask(FROM_HERE, {content::BrowserThread::IO}, - base::BindOnce(&SafeBrowsingService::StopDBManagerOnIOThread, + content::GetIOThreadTaskRunner({})->PostTask( + FROM_HERE, base::BindOnce(&SafeBrowsingService::StopDBManagerOnIOThread, base::Unretained(this))); } @@ -215,24 +228,11 @@ void SafeBrowsingService::StopDBManagerOnIOThread() { } } -void SafeBrowsingService::SetSafeBrowsingDisabled(bool disabled) { - content::GetIOThreadTaskRunner({})->PostTask( - FROM_HERE, - base::BindOnce(&SafeBrowsingService::SetSafeBrowsingDisabledOnIOThread, - base::Unretained(this), disabled)); -} - -void SafeBrowsingService::SetSafeBrowsingDisabledOnIOThread(bool disabled) { - DCHECK_CURRENTLY_ON(content::BrowserThread::IO); - - if (safe_browsing_disabled_ != disabled) { - safe_browsing_disabled_ = disabled; - // If there is no safe_browsing_url_checker_delegate_ yet the opt_out - // setting will be set later during its creation. - if (safe_browsing_url_checker_delegate_) { - safe_browsing_url_checker_delegate_->SetSafeBrowsingDisabled(disabled); - } - } +scoped_refptr<network::SharedURLLoaderFactory> +SafeBrowsingService::GetURLLoaderFactory() { + if (!network_context_) + return nullptr; + return network_context_->GetURLLoaderFactory(); } } // namespace weblayer diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h index 3f5506031d5..1de5c0ff021 100644 --- a/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h +++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_service.h @@ -29,6 +29,7 @@ class SharedURLLoaderFactory; namespace safe_browsing { class UrlCheckerDelegate; +class RealTimeUrlLookupServiceBase; class RemoteSafeBrowsingDatabaseManager; class SafeBrowsingApiHandler; class SafeBrowsingNetworkContext; @@ -49,13 +50,14 @@ class SafeBrowsingService { void Initialize(); std::unique_ptr<blink::URLLoaderThrottle> CreateURLLoaderThrottle( const base::RepeatingCallback<content::WebContents*()>& wc_getter, - int frame_tree_node_id); + int frame_tree_node_id, + safe_browsing::RealTimeUrlLookupServiceBase* url_lookup_service); std::unique_ptr<content::NavigationThrottle> CreateSafeBrowsingNavigationThrottle(content::NavigationHandle* handle); void AddInterface(service_manager::BinderRegistry* registry, content::RenderProcessHost* render_process_host); void StopDBManager(); - void SetSafeBrowsingDisabled(bool disabled); + scoped_refptr<network::SharedURLLoaderFactory> GetURLLoaderFactory(); private: SafeBrowsingUIManager* GetSafeBrowsingUIManager(); @@ -72,7 +74,6 @@ class SafeBrowsingService { void CreateURLLoaderFactoryForIO( mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver); void StopDBManagerOnIOThread(); - void SetSafeBrowsingDisabledOnIOThread(bool disabled); // The UI manager handles showing interstitials. Accessed on both UI and IO // thread. @@ -98,8 +99,6 @@ class SafeBrowsingService { std::string user_agent_; - bool safe_browsing_disabled_; - DISALLOW_COPY_AND_ASSIGN(SafeBrowsingService); }; diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc index e2eecc83687..a616dfef1b7 100644 --- a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc +++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.cc @@ -4,15 +4,28 @@ #include "weblayer/browser/safe_browsing/safe_browsing_ui_manager.h" +#include "components/safe_browsing/core/ping_manager.h" #include "content/public/browser/browser_thread.h" #include "weblayer/browser/safe_browsing/safe_browsing_blocking_page.h" +#include "weblayer/browser/safe_browsing/safe_browsing_service.h" #include "weblayer/browser/safe_browsing/safe_browsing_subresource_helper.h" using content::BrowserThread; +namespace { + +std::string GetProtocolConfigClientName() { + // Return a weblayer specific client name. + return "weblayer"; +} + +} // namespace + namespace weblayer { -SafeBrowsingUIManager::SafeBrowsingUIManager() { +SafeBrowsingUIManager::SafeBrowsingUIManager( + SafeBrowsingService* safe_browsing_service) + : safe_browsing_service_(safe_browsing_service) { DCHECK_CURRENTLY_ON(BrowserThread::UI); } @@ -21,8 +34,19 @@ SafeBrowsingUIManager::~SafeBrowsingUIManager() = default; void SafeBrowsingUIManager::SendSerializedThreatDetails( const std::string& serialized) { DCHECK_CURRENTLY_ON(BrowserThread::UI); - // TODO(timvolodine): figure out if we want to send any threat reporting here. - // Note the base implementation does not send anything. + + if (!ping_manager_) { + ping_manager_ = ::safe_browsing::PingManager::Create( + safe_browsing_service_->GetURLLoaderFactory(), + safe_browsing::GetV4ProtocolConfig(GetProtocolConfigClientName(), + false /* auto_update */)); + } + + if (serialized.empty()) + return; + + DVLOG(1) << "Sending serialized threat details"; + ping_manager_->ReportThreatDetails(serialized); } safe_browsing::BaseBlockingPage* diff --git a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h index 54e1c5136b5..989183c9c02 100644 --- a/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h +++ b/chromium/weblayer/browser/safe_browsing/safe_browsing_ui_manager.h @@ -14,16 +14,21 @@ class WebContents; namespace safe_browsing { class BaseBlockingPage; +class PingManager; } namespace weblayer { +class SafeBrowsingService; class SafeBrowsingUIManager : public safe_browsing::BaseUIManager { public: // Construction needs to happen on the UI thread. - SafeBrowsingUIManager(); + SafeBrowsingUIManager(SafeBrowsingService* safe_browsing_service); // BaseUIManager overrides. + + // Called on the UI thread by the ThreatDetails with the serialized + // protocol buffer, so the service can send it over. void SendSerializedThreatDetails(const std::string& serialized) override; protected: @@ -35,6 +40,11 @@ class SafeBrowsingUIManager : public safe_browsing::BaseUIManager { const GURL& blocked_url, const UnsafeResource& unsafe_resource) override; + // Provides phishing and malware statistics. Accessed on IO thread. + std::unique_ptr<safe_browsing::PingManager> ping_manager_; + + SafeBrowsingService* safe_browsing_service_; + DISALLOW_COPY_AND_ASSIGN(SafeBrowsingUIManager); }; diff --git a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc index 5eb42c49e92..7ff46a3158c 100644 --- a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc +++ b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.cc @@ -5,7 +5,6 @@ #include "weblayer/browser/safe_browsing/url_checker_delegate_impl.h" #include "base/bind.h" -#include "base/task/post_task.h" #include "components/safe_browsing/core/db/database_manager.h" #include "components/security_interstitials/core/unsafe_resource.h" #include "content/public/browser/browser_task_traits.h" @@ -16,11 +15,9 @@ namespace weblayer { UrlCheckerDelegateImpl::UrlCheckerDelegateImpl( scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager, - scoped_refptr<SafeBrowsingUIManager> ui_manager, - bool disabled) + scoped_refptr<SafeBrowsingUIManager> ui_manager) : database_manager_(std::move(database_manager)), ui_manager_(std::move(ui_manager)), - safe_browsing_disabled_(disabled), threat_types_(safe_browsing::CreateSBThreatTypeSet( {safe_browsing::SB_THREAT_TYPE_URL_MALWARE, safe_browsing::SB_THREAT_TYPE_URL_PHISHING, @@ -38,8 +35,8 @@ void UrlCheckerDelegateImpl::StartDisplayingBlockingPageHelper( const net::HttpRequestHeaders& headers, bool is_main_frame, bool has_user_gesture) { - base::PostTask( - FROM_HERE, {content::BrowserThread::UI}, + content::GetUIThreadTaskRunner({})->PostTask( + FROM_HERE, base::BindOnce( &UrlCheckerDelegateImpl::StartDisplayingDefaultBlockingPage, base::Unretained(this), resource)); @@ -61,8 +58,8 @@ void UrlCheckerDelegateImpl::StartDisplayingDefaultBlockingPage( } // Report back that it is not ok to proceed with loading the URL. - base::PostTask(FROM_HERE, {content::BrowserThread::IO}, - base::BindOnce(resource.callback, false /* proceed */, + content::GetIOThreadTaskRunner({})->PostTask( + FROM_HERE, base::BindOnce(resource.callback, false /* proceed */, false /* showed_interstitial */)); } @@ -71,17 +68,13 @@ bool UrlCheckerDelegateImpl::IsUrlWhitelisted(const GURL& url) { return false; } -void UrlCheckerDelegateImpl::SetSafeBrowsingDisabled(bool disabled) { - safe_browsing_disabled_ = disabled; -} - bool UrlCheckerDelegateImpl::ShouldSkipRequestCheck( const GURL& original_url, int frame_tree_node_id, int render_process_id, int render_frame_id, bool originated_from_service_worker) { - return safe_browsing_disabled_ ? true : false; + return false; } void UrlCheckerDelegateImpl::NotifySuspiciousSiteDetected( diff --git a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h index d59745bed10..c940d7f7c98 100644 --- a/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h +++ b/chromium/weblayer/browser/safe_browsing/url_checker_delegate_impl.h @@ -23,8 +23,7 @@ class UrlCheckerDelegateImpl : public safe_browsing::UrlCheckerDelegate { UrlCheckerDelegateImpl( scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager, - scoped_refptr<SafeBrowsingUIManager> ui_manager, - bool disabled); + scoped_refptr<SafeBrowsingUIManager> ui_manager); void SetSafeBrowsingDisabled(bool disabled); @@ -61,7 +60,6 @@ class UrlCheckerDelegateImpl : public safe_browsing::UrlCheckerDelegate { scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> database_manager_; scoped_refptr<SafeBrowsingUIManager> ui_manager_; - bool safe_browsing_disabled_; safe_browsing::SBThreatTypeSet threat_types_; DISALLOW_COPY_AND_ASSIGN(UrlCheckerDelegateImpl); |