// Copyright 2020 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "components/safe_browsing/content/browser/client_side_detection_host.h" #include #include #include #include #include "base/check_op.h" #include "base/command_line.h" #include "base/containers/flat_set.h" #include "base/containers/span.h" #include "base/files/file_path.h" #include "base/functional/bind.h" #include "base/memory/ptr_util.h" #include "base/memory/raw_ptr.h" #include "base/memory/ref_counted.h" #include "base/metrics/histogram_functions.h" #include "base/rand_util.h" #include "base/strings/string_number_conversions.h" #include "base/strings/string_split.h" #include "base/strings/string_util.h" #include "base/task/sequenced_task_runner_helpers.h" #include "base/task/thread_pool.h" #include "base/time/default_tick_clock.h" #include "base/time/tick_clock.h" #include "base/time/time.h" #include "base/trace_event/trace_event.h" #include "base/uuid.h" #include "components/autofill/content/browser/content_autofill_client.h" #include "components/autofill/core/browser/field_types.h" #include "components/autofill/core/browser/foundations/autofill_client.h" #include "components/autofill/core/browser/foundations/scoped_autofill_managers_observation.h" #include "components/history/core/browser/history_service.h" #include "components/history/core/browser/history_types.h" #include "components/permissions/permission_request_manager.h" #include "components/prefs/pref_service.h" #include "components/safe_browsing/content/browser/base_ui_manager.h" #include "components/safe_browsing/content/browser/client_side_detection_feature_cache.h" #include "components/safe_browsing/content/browser/client_side_detection_service.h" #include "components/safe_browsing/content/browser/content_unsafe_resource_util.h" #include "components/safe_browsing/content/common/safe_browsing.mojom.h" #include "components/safe_browsing/core/browser/credit_card_form_event.h" #include "components/safe_browsing/core/browser/db/allowlist_checker_client.h" #include "components/safe_browsing/core/browser/db/database_manager.h" #include "components/safe_browsing/core/browser/intelligent_scan_delegate.h" #include "components/safe_browsing/core/browser/safe_browsing_token_fetcher.h" #include "components/safe_browsing/core/browser/sync/sync_utils.h" #include "components/safe_browsing/core/browser/verdict_cache_manager.h" #include "components/safe_browsing/core/common/features.h" #include "components/safe_browsing/core/common/proto/csd.pb.h" #include "components/safe_browsing/core/common/safe_browsing_prefs.h" #include "components/safe_browsing/core/common/safebrowsing_switches.h" #include "components/safe_browsing/core/common/utils.h" #include "components/security_interstitials/core/unsafe_resource_locator.h" #include "components/url_formatter/url_fixer.h" #include "components/zoom/zoom_controller.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/global_routing_id.h" #include "content/public/browser/navigation_controller.h" #include "content/public/browser/navigation_entry.h" #include "content/public/browser/navigation_handle.h" #include "content/public/browser/render_frame_host.h" #include "content/public/browser/render_process_host.h" #include "content/public/browser/render_widget_host_view.h" #include "content/public/browser/web_contents.h" #include "content/public/common/url_constants.h" #include "mojo/public/cpp/base/proto_wrapper.h" #include "net/base/ip_endpoint.h" #include "net/base/registry_controlled_domains/registry_controlled_domain.h" #include "net/base/url_util.h" #include "net/http/http_response_headers.h" #include "services/network/public/mojom/url_response_head.mojom.h" #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h" #include "third_party/blink/public/mojom/loader/referrer.mojom.h" #include "third_party/perfetto/include/perfetto/tracing/track.h" #include "ui/base/page_transition_types.h" #include "ui/display/display.h" #include "ui/display/screen.h" #include "url/gurl.h" #include "url/origin.h" #if BUILDFLAG(IS_ANDROID) #include "ui/android/view_android.h" #endif using content::BrowserThread; using content::WebContents; namespace safe_browsing { namespace { // How long to wait to run the user report callback. const int kUserReportCallbackTimer = 30; bool HasDebugFeatureDirectory() { return base::CommandLine::ForCurrentProcess()->HasSwitch( switches::kCsdDebugFeatureDirectoryFlag); } bool ShouldSkipCSDAllowlist() { return base::CommandLine::ForCurrentProcess()->HasSwitch( switches::kSkipCSDAllowlistOnPreclassification); } safe_browsing::mojom::ClientSideDetectionType GetClientSideDetectionMojomType( ClientSideDetectionType client_side_detection_type) { switch (client_side_detection_type) { case safe_browsing::ClientSideDetectionType::FORCE_REQUEST: return safe_browsing::mojom::ClientSideDetectionType::kForceRequest; case safe_browsing::ClientSideDetectionType::NOTIFICATION_PERMISSION_PROMPT: return safe_browsing::mojom::ClientSideDetectionType:: kNotificationPermissionPrompt; case safe_browsing::ClientSideDetectionType::TRIGGER_MODELS: return safe_browsing::mojom::ClientSideDetectionType::kTriggerModels; case safe_browsing::ClientSideDetectionType::KEYBOARD_LOCK_REQUESTED: return safe_browsing::mojom::ClientSideDetectionType::kKeyboardLock; case safe_browsing::ClientSideDetectionType::POINTER_LOCK_REQUESTED: return safe_browsing::mojom::ClientSideDetectionType::kPointerLock; case safe_browsing::ClientSideDetectionType::VIBRATION_API: return safe_browsing::mojom::ClientSideDetectionType::kVibrationApi; case safe_browsing::ClientSideDetectionType::FULLSCREEN_API: return safe_browsing::mojom::ClientSideDetectionType::kFullscreen; case safe_browsing::ClientSideDetectionType::CLIPBOARD_COPY_API: return safe_browsing::mojom::ClientSideDetectionType::kClipboardCopyApi; case safe_browsing::ClientSideDetectionType::CREDIT_CARD_FORM: return safe_browsing::mojom::ClientSideDetectionType::kCreditCardForm; case safe_browsing::ClientSideDetectionType::IMAGE_EMBEDDING_MATCH: return safe_browsing::mojom::ClientSideDetectionType:: kImageEmbeddingMatch; case safe_browsing::ClientSideDetectionType::UNFAMILIAR_LOGIN_PAGE: return safe_browsing::mojom::ClientSideDetectionType:: kUnfamiliarLoginPage; case safe_browsing::ClientSideDetectionType:: CLIENT_SIDE_DETECTION_TYPE_UNSPECIFIED: case safe_browsing::ClientSideDetectionType::USER_REPORT: return safe_browsing::mojom::ClientSideDetectionType::kUserReport; default: NOTREACHED(); } } PhishingDetectorResult GetPhishingDetectorResult( mojom::PhishingDetectorResult result) { switch (result) { case mojom::PhishingDetectorResult::SUCCESS: return PhishingDetectorResult::CLASSIFICATION_SUCCESS; case mojom::PhishingDetectorResult::CLASSIFIER_NOT_READY: return PhishingDetectorResult::CLASSIFIER_NOT_READY; case mojom::PhishingDetectorResult::CANCELLED: return PhishingDetectorResult::CLASSIFICATION_CANCELLED; case mojom::PhishingDetectorResult::FORWARD_BACK_TRANSITION: return PhishingDetectorResult::FORWARD_BACK_TRANSITION; case mojom::PhishingDetectorResult::INVALID_SCORE: return PhishingDetectorResult::INVALID_SCORE; case mojom::PhishingDetectorResult::INVALID_URL_FORMAT_REQUEST: return PhishingDetectorResult::INVALID_URL_FORMAT_REQUEST; case mojom::PhishingDetectorResult::INVALID_DOCUMENT_LOADER: return PhishingDetectorResult::INVALID_DOCUMENT_LOADER; case mojom::PhishingDetectorResult::URL_FEATURE_EXTRACTION_FAILED: return PhishingDetectorResult::URL_FEATURE_EXTRACTION_FAILED; case mojom::PhishingDetectorResult::DOM_EXTRACTION_FAILED: return PhishingDetectorResult::DOM_EXTRACTION_FAILED; case mojom::PhishingDetectorResult::TERM_EXTRACTION_FAILED: return PhishingDetectorResult::TERM_EXTRACTION_FAILED; case mojom::PhishingDetectorResult::VISUAL_EXTRACTION_FAILED: return PhishingDetectorResult::VISUAL_EXTRACTION_FAILED; case mojom::PhishingDetectorResult::CLASSIFICATION_SKIPPED: return PhishingDetectorResult::CLASSIFICATION_SKIPPED; } } ClientSideDetectionHostBase::ImageEmbeddingResult ToImageEmbeddingResult( mojom::PhishingImageEmbeddingResult result) { switch (result) { case mojom::PhishingImageEmbeddingResult::kSuccess: return ClientSideDetectionHostBase::ImageEmbeddingResult::kSuccess; case mojom::PhishingImageEmbeddingResult::kImageEmbedderNotReady: return ClientSideDetectionHostBase::ImageEmbeddingResult:: kImageEmbedderNotReady; case mojom::PhishingImageEmbeddingResult::kCancelled: return ClientSideDetectionHostBase::ImageEmbeddingResult::kCancelled; case mojom::PhishingImageEmbeddingResult::kForwardBackTransition: return ClientSideDetectionHostBase::ImageEmbeddingResult:: kForwardBackTransition; case mojom::PhishingImageEmbeddingResult::kFailed: return ClientSideDetectionHostBase::ImageEmbeddingResult::kFailed; case mojom::PhishingImageEmbeddingResult::kInvalidURLFormatRequest: return ClientSideDetectionHostBase::ImageEmbeddingResult:: kInvalidURLFormatRequest; case mojom::PhishingImageEmbeddingResult::kInvalidDocumentLoader: return ClientSideDetectionHostBase::ImageEmbeddingResult:: kInvalidDocumentLoader; } } } // namespace typedef base::OnceCallback, bool)> ShouldClassifyUrlCallback; // This class is instantiated each time a new toplevel URL loads, and // asynchronously checks whether the phishing classifier should run // for this URL. If so, it notifies the host class by calling the provided // callback from the UI thread. Objects of this class will be destroyed once // nobody uses it anymore. If |web_contents|, |csd_service| or |host| go away // you need to call Cancel(). We keep the |database_manager| alive in a ref // pointer for as long as it takes. class ClientSideDetectionHost::ShouldClassifyUrlRequest { public: ShouldClassifyUrlRequest( const GURL& url, const network::mojom::URLResponseHead* response_head, ShouldClassifyUrlCallback start_phishing_classification, WebContents* web_contents, base::WeakPtr csd_service, SafeBrowsingDatabaseManager* database_manager, ClientSideDetectionType phishing_detection_request_type, base::WeakPtr host) : url_(url), web_contents_(web_contents), csd_service_(csd_service), database_manager_(database_manager), phishing_detection_request_type_(phishing_detection_request_type), host_(host), start_phishing_classification_cb_( std::move(start_phishing_classification)) { DCHECK_CURRENTLY_ON(BrowserThread::UI); DCHECK(web_contents_); DCHECK(csd_service_); DCHECK(database_manager_.get()); DCHECK(host_); if (response_head) { if (response_head->headers) { response_head->headers->GetMimeType(&mime_type_); } remote_endpoint_ = response_head->remote_endpoint; } } ShouldClassifyUrlRequest(const ShouldClassifyUrlRequest&) = delete; ShouldClassifyUrlRequest& operator=(const ShouldClassifyUrlRequest&) = delete; // The destructor can be called either from the UI or the IO thread. ~ShouldClassifyUrlRequest() = default; void Start() { DCHECK_CURRENTLY_ON(BrowserThread::UI); // We start by doing some simple checks that can run on the UI thread. if (url_.SchemeIs(content::kChromeUIScheme)) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_CHROME_UI_PAGE); } if (base::FeatureList::IsEnabled( kClientSideDetectionLocalResourceCheckFix)) { // safe_browsing::CanGetReputationOfUrl() is another option to be // comprehensive, but since IsPrivateIPAddress and SchemeIsHTTPOrHTTPS // are checked below, using net::IsLocalhost() is sufficient. // TODO: Consider safe_browsing::CanGetReputationOfUrl() in the future to // have a consolidated preclassification check result. if (url_.SchemeIsFile() || net::IsLocalhost(url_)) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_LOCAL_RESOURCE); } } else { if (csd_service_ && !remote_endpoint_.address().IsValid()) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_LOCAL_RESOURCE); } } bool is_mime_type_unsupported = mime_type_ != "text/html" && mime_type_ != "application/xhtml+xml"; content::RenderFrameHost* rfh = web_contents_->GetPrimaryMainFrame(); bool is_error_page = rfh && rfh->IsErrorDocument(); if (!is_mime_type_unsupported) { base::UmaHistogramBoolean( "SBClientPhishing.IsErrorDocumentOnSupportedMimeType", is_error_page); } if (base::FeatureList::IsEnabled(kClientSideDetectionSkipErrorPage) && is_error_page) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_ERROR_DOCUMENT); } if (is_mime_type_unsupported) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_UNSUPPORTED_MIME_TYPE); } if (csd_service_ && csd_service_->IsPrivateIPAddress(remote_endpoint_.address())) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_PRIVATE_IP); } // For phishing we only classify HTTP or HTTPS pages. if (!url_.SchemeIsHTTPOrHTTPS()) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_SCHEME_NOT_SUPPORTED); } // Don't run any classifier if the tab is incognito. if (web_contents_->GetBrowserContext()->IsOffTheRecord()) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_OFF_THE_RECORD); } // Don't start classification if |url_| is allowlisted by enterprise policy. if (host_ && host_->GetPrefs() && IsURLAllowlistedByPolicy(url_, *host_->GetPrefs())) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_ALLOWLISTED_BY_POLICY); } // If the tab has a delayed warning, ignore this second verdict. We don't // want to immediately undelay a page that's already blocked as phishy. if (host_ && host_->delegate_->HasSafeBrowsingUserInteractionObserver()) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_HAS_DELAYED_WARNING); } // We lookup the csd-allowlist before we lookup the cache because // a URL may have recently been allowlisted. If the URL matches // the csd-allowlist we won't start phishing classification. if (ShouldClassifyForPhishing()) { CheckSafeBrowsingDatabase(url_); } } void Cancel(ClientSideDetectionType request_type) { // We should only log if the callback has not been answered yet. if (ShouldClassifyForPhishing()) { base::UmaHistogramExactLinear( "SBClientPhishing.PreClassificationCheckCancelActor", request_type, ClientSideDetectionType_MAX + 1); base::UmaHistogramExactLinear( base::StrCat({"SBClientPhishing.PreClassificationCheckCancelActor.", GetRequestTypeName(phishing_detection_request_type_)}), request_type, ClientSideDetectionType_MAX + 1); } Cancel(); } void Cancel() { DontClassifyForPhishing(PreClassificationCheckResult::NO_CLASSIFY_CANCEL); // Just to make sure we don't do anything bad we reset all these // pointers except for the safebrowsing service class which may be // accessed by CheckSafeBrowsingDatabase(). web_contents_ = nullptr; csd_service_ = nullptr; host_ = nullptr; } bool ShouldClassifyForPhishing() const { DCHECK_CURRENTLY_ON(BrowserThread::UI); return !start_phishing_classification_cb_.is_null(); } private: friend class base::RefCountedThreadSafe< ClientSideDetectionHost::ShouldClassifyUrlRequest>; // This enum is used to track the result of the allowlists we use before we // decide to classify. Currently, only the CSD match can halt classification // from going forward. These values are persisted to logs. Entries should not // be renumbered and numeric values should never be reused. enum class ClientSideAllowlistMatchResult { kNoMatch = 0, kCsdMatch = 1, kHighConfidenceMatch = 2, kCsdAndHighConfidenceMatch = 3, kMaxValue = kCsdAndHighConfidenceMatch }; void DontClassifyForPhishing(PreClassificationCheckResult reason) { DCHECK_CURRENTLY_ON(BrowserThread::UI); if (ShouldClassifyForPhishing()) { // Track the first reason why we stopped classifying for phishing. ClientSideDetectionHostBase:: RecordPreClassificationCheckResultWithAndWithoutSuffix( reason, phishing_detection_request_type_); if (host_ && host_->IsEnhancedProtectionEnabled() && // Cancelation happens when the WebContents is destroyed, but we // cannot access ClientSideDetectionFeatureCache at that time. !web_contents_->IsBeingDestroyed()) { ClientSideDetectionFeatureCache::CreateForWebContents(web_contents_); ClientSideDetectionFeatureCache* feature_cache_map = ClientSideDetectionFeatureCache::FromWebContents(web_contents_); // TODO(andysjlim): Investigate why this is null sometimes. LoginReputationClientRequest::DebuggingMetadata* debugging_metadata = feature_cache_map->GetOrCreateDebuggingMetadataForURL(url_); if (debugging_metadata) { debugging_metadata->set_preclassification_check_result(reason); } } std::move(start_phishing_classification_cb_) .Run(false, send_sample_ping_, std::nullopt, !remote_endpoint_.address().IsValid()); } start_phishing_classification_cb_.Reset(); } void CheckSafeBrowsingDatabase(const GURL& url) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); PreClassificationCheckResult phishing_reason = PreClassificationCheckResult::NO_CLASSIFY_MAX; // When doing debug feature dumps, ignore the allowlist. if (HasDebugFeatureDirectory()) { OnAllowlistCheckDone(url, phishing_reason, /*match_allowlist=*/false); return; } if (!database_manager_.get()) { // We cannot check the Safe Browsing allowlists so we stop here // for safety. OnAllowlistCheckDone( url, /*phishing_reason=*/ PreClassificationCheckResult::NO_CLASSIFY_NO_DATABASE_MANAGER, /*match_allowlist=*/false); return; } // If we get a suspcious verdict from RTLookupResponse, we should get a // second opinion on CSD side, so we skip the allowlist. If we get an // explicit request to send a report from the user, we skip the allowlist. // We also check the command line flag if the allowlist should be skipped. if (phishing_detection_request_type_ == safe_browsing::ClientSideDetectionType::FORCE_REQUEST || phishing_detection_request_type_ == safe_browsing::ClientSideDetectionType::USER_REPORT || ShouldSkipCSDAllowlist()) { OnAllowlistCheckDone(url, phishing_reason, /*match_allowlist=*/false); return; } // Query the CSD Allowlist asynchronously. We're already on the IO thread so // can call AllowlistCheckerClient directly. base::OnceCallback result_callback = base::BindOnce(&ClientSideDetectionHost::ShouldClassifyUrlRequest:: OnAllowlistCheckDone, weak_factory_.GetWeakPtr(), url, phishing_reason); AllowlistCheckerClient::StartCheckCsdAllowlist(database_manager_, url, std::move(result_callback)); } void OnAllowlistCheckDone(const GURL& url, PreClassificationCheckResult phishing_reason, bool match_allowlist) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); // On CSD allowlist match, we still want to send a ping on a rare chance. send_sample_ping_ = CanSendSamplePing(); if (match_allowlist && !send_sample_ping_) { phishing_reason = PreClassificationCheckResult::NO_CLASSIFY_MATCH_CSD_ALLOWLIST; } if (phishing_reason != PreClassificationCheckResult::NO_CLASSIFY_NO_DATABASE_MANAGER) { switch (phishing_detection_request_type_) { case CREDIT_CARD_FORM: case CLIPBOARD_COPY_API: case UNFAMILIAR_LOGIN_PAGE: base::UmaHistogramBoolean( base::StrCat( {"SBClientPhishing.MatchCSDAllowlistOn", GetRequestTypeName(phishing_detection_request_type_)}), match_allowlist); break; default: break; } // This check is also for logging purposes although the CSD allowlist // could be matched or not checked at all. Once it completes, // preclassification check will continue. database_manager_->CheckUrlForHighConfidenceAllowlist( url, base::BindOnce(&ClientSideDetectionHost::ShouldClassifyUrlRequest:: OnHighConfidenceAllowlistCheckDone, weak_factory_.GetWeakPtr(), phishing_reason, base::TimeTicks::Now())); } else { CheckCache(phishing_reason); } } void OnHighConfidenceAllowlistCheckDone( PreClassificationCheckResult phishing_reason, base::TimeTicks check_start_time, bool did_match_high_confidence_allowlist, std::optional logging_details) { did_match_high_confidence_allowlist_ = did_match_high_confidence_allowlist; UmaHistogramMediumTimes( "SBClientPhishing.HighConfidenceAllowlistCheckDuration", base::TimeTicks::Now() - check_start_time); // TODO(andysjlim): This histogram will be logged to // PreClassificationCheckResult through |phishing_reason|, but logged // separately now because a new field PreClassificationCheckResult results // in a new server data to be sent through debugging metadata. ClientSideAllowlistMatchResult match_result = GetClientSideAllowlistMatchResult( phishing_reason == PreClassificationCheckResult::NO_CLASSIFY_MATCH_CSD_ALLOWLIST, did_match_high_confidence_allowlist); base::UmaHistogramEnumeration( "SBClientPhishing.MatchHighConfidenceAllowlist", match_result); base::UmaHistogramEnumeration( base::StrCat({"SBClientPhishing.MatchHighConfidenceAllowlist.", GetRequestTypeName(phishing_detection_request_type_)}), match_result); if (phishing_reason == NO_CLASSIFY_MAX && ShouldAcceptHCAllowlist()) { phishing_reason = PreClassificationCheckResult::NO_CLASSIFY_MATCH_HC_ALLOWLIST; } CheckCache(phishing_reason); } void CheckCache(PreClassificationCheckResult phishing_reason) { DCHECK_CURRENTLY_ON(BrowserThread::UI); if (phishing_reason != PreClassificationCheckResult::NO_CLASSIFY_MAX) { DontClassifyForPhishing(phishing_reason); } if (!ShouldClassifyForPhishing()) { return; // No point in doing anything else. } if (ShouldStopAtPreClassification()) { DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_ALLOWLIST_METRIC); } // For trigger model requests, if result is cached, we don't want to run // classification again. In that case we're just trying to show the warning. // If we're dumping features for debugging, ignore the cache. bool is_phishing; if (phishing_detection_request_type_ == ClientSideDetectionType::TRIGGER_MODELS && !HasDebugFeatureDirectory() && host_ && csd_service_ && csd_service_->GetValidCachedResult(url_, &is_phishing)) { // Since we are already on the UI thread, this is safe. host_->MaybeShowPhishingWarning( /*is_from_cache=*/true, ClientSideDetectionType::TRIGGER_MODELS, did_match_high_confidence_allowlist_, url_, is_phishing, /*response_code=*/std::nullopt, /*intelligent_scan_verdict=*/std::nullopt); DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_RESULT_FROM_CACHE); } // We want to limit the number of requests, but if we're dumping features // for debugging or processing an explicit request for a report from a user, // allow us to exceed the report limit. if (!HasDebugFeatureDirectory() && csd_service_ && phishing_detection_request_type_ != ClientSideDetectionType::USER_REPORT && csd_service_->AtPhishingReportLimit()) { base::UmaHistogramExactLinear("SBClientPhishing.RequestTypeAtReportLimit", phishing_detection_request_type_, ClientSideDetectionType_MAX + 1); DontClassifyForPhishing( PreClassificationCheckResult::NO_CLASSIFY_TOO_MANY_REPORTS); } // Everything checks out, so start classification. // |web_contents_| is safe to call as we will be destructed // before it is. if (ShouldClassifyForPhishing()) { ClientSideDetectionHostBase:: RecordPreClassificationCheckResultWithAndWithoutSuffix( PreClassificationCheckResult::CLASSIFY, phishing_detection_request_type_); if (host_ && host_->IsEnhancedProtectionEnabled()) { ClientSideDetectionFeatureCache::CreateForWebContents(web_contents_); ClientSideDetectionFeatureCache* feature_cache_map = ClientSideDetectionFeatureCache::FromWebContents(web_contents_); feature_cache_map->GetOrCreateDebuggingMetadataForURL(url_) ->set_preclassification_check_result( PreClassificationCheckResult::CLASSIFY); } std::move(start_phishing_classification_cb_) .Run(true, send_sample_ping_, did_match_high_confidence_allowlist_, !remote_endpoint_.address().IsValid()); // Reset the callback to make sure ShouldClassifyForPhishing() // returns false. start_phishing_classification_cb_.Reset(); } } bool ShouldStopAtPreClassification() { switch (phishing_detection_request_type_) { case CLIPBOARD_COPY_API: return base::RandDouble() >= kCsdClipboardCopyApiSampleRate.Get(); case CREDIT_CARD_FORM: return base::RandDouble() >= kCsdCreditCardFormSampleRate.Get(); case UNFAMILIAR_LOGIN_PAGE: return base::RandDouble() >= kCsdProactivePasswordProtectionSampleRate.Get(); default: break; } return false; } bool CanSendSamplePing() { return host_ && host_->CanSendSamplePing(phishing_detection_request_type_); } bool ShouldAcceptHCAllowlist() { return host_ && host_->ShouldAcceptHCAllowlist( phishing_detection_request_type_, did_match_high_confidence_allowlist_.value_or(false)); } ClientSideAllowlistMatchResult GetClientSideAllowlistMatchResult( bool match_csd_allowlist, bool match_hc_allowlist) { if (match_csd_allowlist && match_hc_allowlist) { return ClientSideAllowlistMatchResult::kCsdAndHighConfidenceMatch; } else if (match_csd_allowlist) { return ClientSideAllowlistMatchResult::kCsdMatch; } else if (match_hc_allowlist) { return ClientSideAllowlistMatchResult::kHighConfidenceMatch; } else { return ClientSideAllowlistMatchResult::kNoMatch; } } const GURL url_; bool send_sample_ping_ = false; std::optional did_match_high_confidence_allowlist_; std::string mime_type_; net::IPEndPoint remote_endpoint_; raw_ptr web_contents_; base::WeakPtr csd_service_; // We keep a ref pointer here just to make sure the safe browsing // database manager stays alive long enough. scoped_refptr database_manager_; ClientSideDetectionType phishing_detection_request_type_; base::WeakPtr host_; ShouldClassifyUrlCallback start_phishing_classification_cb_; base::WeakPtrFactory weak_factory_{this}; }; // static const int ClientSideDetectionHost::kMaxHighResScreenshotWidth = 4096; const int ClientSideDetectionHost::kMaxHighResScreenshotHeight = 2160; // static std::unique_ptr ClientSideDetectionHost::Create( content::WebContents* tab, std::unique_ptr delegate, IntelligentScanDelegate* intelligent_scan_delegate, PrefService* pref_service, VerdictCacheManager* cache_manager, history::HistoryService* history_service, base::WeakPtr csd_service, std::unique_ptr token_fetcher, bool is_off_the_record, const PrimaryAccountSignedIn& account_signed_in_callback) { return base::WrapUnique(new ClientSideDetectionHost( tab, std::move(delegate), intelligent_scan_delegate, pref_service, cache_manager, history_service, csd_service, std::move(token_fetcher), is_off_the_record, account_signed_in_callback)); } ClientSideDetectionHost::ClientSideDetectionHost( WebContents* tab, std::unique_ptr delegate, IntelligentScanDelegate* intelligent_scan_delegate, PrefService* pref_service, VerdictCacheManager* cache_manager, history::HistoryService* history_service, base::WeakPtr csd_service, std::unique_ptr token_fetcher, bool is_off_the_record, const PrimaryAccountSignedIn& account_signed_in_callback) : ClientSideDetectionHostBase(csd_service, cache_manager, intelligent_scan_delegate, pref_service, std::move(token_fetcher), history_service, is_off_the_record), content::WebContentsObserver(tab), tab_(tab), classification_request_(nullptr), delegate_(std::move(delegate)), account_signed_in_callback_(account_signed_in_callback) { DCHECK(tab); DCHECK(pref_service); // Note: the CSD service will be nullptr here in testing. if (auto service = GetClientSideDetectionService()) { ClientSideDetectionFeatureCache::CreateForWebContents(web_contents()); ClientSideDetectionFeatureCache::FromWebContents(web_contents()) ->AddClearCacheSubscription(service); } // |ui_manager_| and |database_manager_| can // be null if safe browsing service is not available in the embedder. ui_manager_ = delegate_->GetSafeBrowsingUIManager(); database_manager_ = delegate_->GetSafeBrowsingDBManager(); RegisterPermissionRequestManager(); RegisterAsyncCheckTracker(); RegisterAutofillManager(); } ClientSideDetectionHost::~ClientSideDetectionHost() { MaybeRunUserReportCallback(); if (classification_request_.get()) { classification_request_->Cancel(); } CancelPendingRequests(); } void ClientSideDetectionHost::CancelPendingRequests() { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); weak_factory_.InvalidateWeakPtrs(); ClientSideDetectionHostBase::CancelPendingRequests(); } void ClientSideDetectionHost::GetInnerText(HostInnerTextCallback callback) { delegate_->GetInnerText(std::move(callback)); } bool ClientSideDetectionHost::IsAccountSignedIn() { return !account_signed_in_callback_.is_null() && account_signed_in_callback_.Run(); } bool ClientSideDetectionHost::IsErrorDocument() { return web_contents()->GetPrimaryMainFrame()->IsErrorDocument(); } ChromeUserPopulation ClientSideDetectionHost::GetUserPopulation() { return delegate_->GetUserPopulation(); } safe_browsing::credit_card_form::ReferringApp ClientSideDetectionHost::GetReferringApp() const { #if BUILDFLAG(IS_ANDROID) return safe_browsing::credit_card_form::FromReferringAppInfo( delegate_->GetReferringAppInfo(web_contents())); #else return safe_browsing::credit_card_form::kNoReferringApp; #endif } void ClientSideDetectionHost::RegisterPermissionRequestManager() { if (IsEnhancedProtectionEnabled()) { permission_request_observation_.Observe( permissions::PermissionRequestManager::FromWebContents(web_contents())); } } void ClientSideDetectionHost::RegisterAsyncCheckTracker() { if (IsEnhancedProtectionEnabled()) { AsyncCheckTracker* tracker = AsyncCheckTracker::FromWebContents(web_contents()); CHECK(tracker); async_check_observation_.Observe(tracker); } } void ClientSideDetectionHost::RegisterAutofillManager() { if (!IsEnhancedProtectionEnabled()) { return; } autofill_managers_observation_.Observe( autofill::ContentAutofillClient::FromWebContents(web_contents()), autofill::ScopedAutofillManagersObservation::InitializationPolicy:: kObservePreexistingManagers); } void ClientSideDetectionHost::MaybeRunUserReportCallback() { user_report_timeout_timer_.Stop(); if (user_report_callback_) { std::move(user_report_callback_).Run(); } } void ClientSideDetectionHost::ReportUnsafeSite(SkBitmap screenshot, base::OnceClosure callback) { if (!screenshot.drawsNothing() && screenshot.width() <= kMaxHighResScreenshotWidth && screenshot.height() <= kMaxHighResScreenshotHeight) { screenshot_ = screenshot; } MaybeRunUserReportCallback(); user_report_callback_ = std::move(callback); // Start a 30-second timer that will run the callback if it hasn't been run // yet. user_report_timeout_timer_.Start( FROM_HERE, base::Seconds(kUserReportCallbackTimer), base::BindOnce(&ClientSideDetectionHost::MaybeRunUserReportCallback, weak_factory_.GetWeakPtr())); MaybeStartPreClassification(ClientSideDetectionType::USER_REPORT); } void ClientSideDetectionHost::OnUnfamiliarLoginPageDetected() { if (base::FeatureList::IsEnabled(kProactivePasswordProtection) && IsEnhancedProtectionEnabled()) { MaybeStartPreClassification(ClientSideDetectionType::UNFAMILIAR_LOGIN_PAGE); } } void ClientSideDetectionHost::MaybeStartPreClassification( ClientSideDetectionType request_type) { if (base::FeatureList::IsEnabled(kClientSideDetectionKillswitch)) { MaybeRunUserReportCallback(); return; } // Cancel any pending classification request. // TODO(b/447359124): Support multiple classifications on the same page. if (classification_request_.get()) { // First check if there's an ongoing preclassification check. if (classification_request_->ShouldClassifyForPhishing() && base::FeatureList::IsEnabled(kClientSideDetectionTierSystem)) { if (NewRequestTypeTierHigher(request_type)) { classification_request_->Cancel(request_type); } else { base::UmaHistogramExactLinear( base::StrCat({"SBClientPhishing.BlockingRequestType.", GetRequestTypeName(request_type)}), last_request_type(), ClientSideDetectionType_MAX + 1); return; } } else { classification_request_->Cancel(request_type); } } // If there is a renderer classification going on and the incoming request // type is not higher, do not let that cancel pending classification. if (is_classifying() && base::FeatureList::IsEnabled(kClientSideDetectionTierSystem) && !NewRequestTypeTierHigher(request_type)) { base::UmaHistogramExactLinear( base::StrCat({"SBClientPhishing.BlockingRequestType.", GetRequestTypeName(request_type)}), last_request_type(), ClientSideDetectionType_MAX + 1); return; } if (!GetClientSideDetectionService()) { if (request_type == ClientSideDetectionType::USER_REPORT) { MaybeRunUserReportCallback(); } return; } if (!preclassification_started_cb_for_testing_.is_null()) { preclassification_started_cb_for_testing_.Run(request_type); } content::RenderFrameHost* rfh = web_contents()->GetPrimaryMainFrame(); set_current_url(rfh->GetLastCommittedURL()); set_last_committed_url(request_type, current_url()); current_outermost_main_frame_id_ = rfh->GetGlobalId(); set_last_request_type(request_type); LogClientSideDetectionEvent( ClientSideDetectionEvent::kTriggerStartsPreClassification, request_type); // Check whether we can cassify the current URL for phishing. classification_request_ = std::make_unique( rfh->GetLastCommittedURL(), rfh->GetLastResponseHead(), base::BindOnce(&ClientSideDetectionHost::OnPhishingPreClassificationDone, weak_factory_.GetWeakPtr(), request_type), web_contents(), GetClientSideDetectionService(), database_manager_.get(), request_type, weak_factory_.GetWeakPtr()); classification_request_->Start(); } void ClientSideDetectionHost::DidFinishNavigation( content::NavigationHandle* navigation_handle) { // `current_navigation_id_` will be set to UnsafeResource, and later in // `BaseUIManager::DisplayBlockingPage` we will check // `AsyncCheckTracker::IsMainPageResourceLoadPending`, and `AsyncCheckTracker` // tracks only committed not-same-document navigations, see // `AsyncCheckTracker::DidFinishNavigation`. So we should never set // `current_navigation_id_` to non-comitted or same-document navigations. if ((navigation_handle->HasCommitted() && !navigation_handle->IsSameDocument())) { current_navigation_id_ = navigation_handle->GetNavigationId(); } } void ClientSideDetectionHost::PrimaryPageChanged(content::Page& page) { // TODO(noelutz): move this DCHECK to WebContents and fix all the unit tests // that don't call this method on the UI thread. // DCHECK_CURRENTLY_ON(BrowserThread::UI); // If we navigate away and there currently is a pending phishing report // request we have to cancel it to make sure we don't display an // interstitial for the wrong page. Note that this won't cancel the server // ping back but only cancel the showing of the interstitial. CancelPendingRequests(); if (is_csd_running()) { base::UmaHistogramExactLinear( "SBClientPhishing.ClientSideDetection.InterruptedByNavigation", last_request_type(), ClientSideDetectionType_MAX + 1); } set_is_csd_running(false); set_is_classifying(false); set_last_request_type( ClientSideDetectionType::CLIENT_SIDE_DETECTION_TYPE_UNSPECIFIED); set_should_send_as_force_request(false); clear_clipboard_extracted_data(); MaybeRunUserReportCallback(); if (base::FeatureList::IsEnabled(kClientSideDetectionOnlyESBClassification) && !IsEnhancedProtectionEnabled()) { return; } if (base::FeatureList::IsEnabled(kClientSideDetectionNewObservers)) { if (did_first_visually_non_empty_paint_ ^ on_first_contentful_paint_) { auto value = did_first_visually_non_empty_paint_ ? CSDObserverCalled::kDidFirstVisuallyNonEmptyPaint : CSDObserverCalled::kOnFirstContentfulPaint; base::UmaHistogramEnumeration( "SBClientPhishing.SingleObserverCalledOnNewPage", value); } did_first_visually_non_empty_paint_ = false; on_first_contentful_paint_ = false; set_trigger_model_request_sent_as_force_request(false); // It is possible for the async check force request to complete before this, // and we should have the URL set in case it can match in the verdict cache // manager. content::RenderFrameHost* rfh = web_contents()->GetPrimaryMainFrame(); content::NavigationEntry* nav_entry = web_contents()->GetController().GetLastCommittedEntry(); bool is_reload = nav_entry && ui::PageTransitionCoreTypeIs( nav_entry->GetTransitionType(), ui::PAGE_TRANSITION_RELOAD); if (current_url() == rfh->GetLastCommittedURL() && !is_reload) { base::UmaHistogramBoolean("SBClientPhishing.SameURLAtPrimaryPageChanged", true); } set_current_url(rfh->GetLastCommittedURL()); return; } set_trigger_model_request_sent_as_force_request(false); MaybeStartPreClassification(ClientSideDetectionType::TRIGGER_MODELS); } void ClientSideDetectionHost::DidFirstVisuallyNonEmptyPaint() { if (base::FeatureList::IsEnabled(kClientSideDetectionOnlyESBClassification) && !IsEnhancedProtectionEnabled()) { return; } if (base::FeatureList::IsEnabled(kClientSideDetectionNewObservers)) { did_first_visually_non_empty_paint_ = true; if (on_first_contentful_paint_) { if (should_send_as_force_request() || HasForceRequestFromRtUrlLookup()) { base::UmaHistogramBoolean( "SBClientPhishing.TriggerModelsConvertedToForceRequestAtLoad", true); MaybeStartPreClassification(ClientSideDetectionType::FORCE_REQUEST); } else { MaybeStartPreClassification(ClientSideDetectionType::TRIGGER_MODELS); } } } } void ClientSideDetectionHost::OnFirstContentfulPaintInPrimaryMainFrame( base::TimeTicks presentation_time) { if (base::FeatureList::IsEnabled(kClientSideDetectionOnlyESBClassification) && !IsEnhancedProtectionEnabled()) { return; } if (base::FeatureList::IsEnabled(kClientSideDetectionNewObservers)) { on_first_contentful_paint_ = true; if (did_first_visually_non_empty_paint_) { if (should_send_as_force_request() || HasForceRequestFromRtUrlLookup()) { base::UmaHistogramBoolean( "SBClientPhishing.TriggerModelsConvertedToForceRequestAtLoad", true); MaybeStartPreClassification(ClientSideDetectionType::FORCE_REQUEST); } else { MaybeStartPreClassification(ClientSideDetectionType::TRIGGER_MODELS); } } } } void ClientSideDetectionHost::OnPromptAdded() { if (!IsEnhancedProtectionEnabled()) { return; } permissions::PermissionRequestManager* permission_request_manager = permissions::PermissionRequestManager::FromWebContents(web_contents()); CHECK(permission_request_manager); if (std::ranges::contains(permission_request_manager->Requests(), permissions::RequestType::kNotifications, &permissions::PermissionRequest::request_type)) { MaybeStartPreClassification( ClientSideDetectionType::NOTIFICATION_PERMISSION_PROMPT); } } void ClientSideDetectionHost::OnPermissionRequestManagerDestructed() { permission_request_observation_.Reset(); } void ClientSideDetectionHost::OnAsyncSafeBrowsingCheckCompleted() { ClientSideDetectionHostBase::OnAsyncSafeBrowsingCheckCompleted(); } void ClientSideDetectionHost::OnAsyncSafeBrowsingCheckTrackerDestructed() { async_check_observation_.Reset(); } void ClientSideDetectionHost::MaybeFillScreenshotData( ClientPhishingRequest* request) { if (request->client_side_detection_type() != ClientSideDetectionType::USER_REPORT) { return; } if (screenshot_) { visual_utils::EncodeScreenshot( *screenshot_, request->mutable_visual_features()->mutable_high_res_screenshot()); } screenshot_ = std::nullopt; } void ClientSideDetectionHost::KeyboardLockRequested() { if (!IsEnhancedProtectionEnabled()) { return; } if (!HasDonePreclassificationCheckOnSameURL( ClientSideDetectionType::KEYBOARD_LOCK_REQUESTED)) { MaybeStartPreClassification( ClientSideDetectionType::KEYBOARD_LOCK_REQUESTED); } } void ClientSideDetectionHost::VibrationRequested() { if (!IsEnhancedProtectionEnabled()) { return; } // Vibration API can be triggered on a page in intervals between 0 and 1 // seconds. Because of this, we want to only classify once per given URL since // a page can send a request multiple vibration at a time. if (!HasDonePreclassificationCheckOnSameURL( ClientSideDetectionType::VIBRATION_API)) { MaybeStartPreClassification(ClientSideDetectionType::VIBRATION_API); } } void ClientSideDetectionHost::OnTextCopiedToClipboard( content::RenderFrameHost* render_frame_host, const std::u16string& copied_text) { ClientSideDetectionHostBase::OnTextCopiedToClipboard(copied_text); } void ClientSideDetectionHost::OnPhishingPreClassificationDone( ClientSideDetectionType request_type, bool should_classify, bool is_sample_ping, std::optional did_match_high_confidence_allowlist, bool is_invalid_ip) { DCHECK_CURRENTLY_ON(BrowserThread::UI); LogClientSideDetectionEvent( ClientSideDetectionEvent::kPreClassificationCheckComplete, request_type); if (!preclassification_done_cb_for_testing_.is_null()) { preclassification_done_cb_for_testing_.Run(request_type); } if (!should_classify) { if (request_type == ClientSideDetectionType::USER_REPORT) { MaybeRunUserReportCallback(); } return; } set_is_csd_running(true); bool intelligent_scan_ongoing = GetIntelligentScanId().has_value(); base::UmaHistogramBoolean( "SBClientPhishing.IntelligentScanOngoingOnNewPreclassification", intelligent_scan_ongoing); base::UmaHistogramBoolean( base::StrCat( {"SBClientPhishing.IntelligentScanOngoingOnNewPreclassification.", GetRequestTypeName(request_type)}), intelligent_scan_ongoing); if (intelligent_scan_ongoing) { DCHECK(GetIntelligentScanDelegate()); GetIntelligentScanDelegate()->CancelIntelligentScan( *GetIntelligentScanId()); } content::RenderFrameHost* rfh = web_contents()->GetPrimaryMainFrame(); phishing_detector_.reset(); rfh->GetRemoteAssociatedInterfaces()->GetInterface(&phishing_detector_); if (!phishing_detector_.is_bound()) { if (request_type == ClientSideDetectionType::USER_REPORT) { MaybeRunUserReportCallback(); } return; } // For TRIGGER_MODELS and IMAGE_EMBEDDING_MATCH only, perform phishing // classification as the next step. // For all other triggers, if enabled, skip phishing detection. if (IsEnhancedProtectionEnabled() && request_type == ClientSideDetectionType::TRIGGER_MODELS && // Only ESB users should be in the study. base::FeatureList::IsEnabled(kClientSideDetectionImageEmbeddingMatch)) { LogClientSideDetectionEvent( ClientSideDetectionEvent::kImageClassificationBegin, request_type); set_is_classifying(true); phishing_detector_->StartPhishingDetection( current_url(), GetClientSideDetectionMojomType( ClientSideDetectionType::IMAGE_EMBEDDING_MATCH), base::BindOnce(&ClientSideDetectionHost::PhishingDetectionDone, weak_factory_.GetWeakPtr(), ClientSideDetectionType::IMAGE_EMBEDDING_MATCH, is_sample_ping, did_match_high_confidence_allowlist, is_invalid_ip, tick_clock()->NowTicks())); return; } if (request_type != ClientSideDetectionType::TRIGGER_MODELS && base::FeatureList::IsEnabled( kSkipImageClassificationScoringForNonPageLoadTriggers)) { ClientPhishingRequest verdict; verdict.set_url(current_url().spec()); verdict.set_client_score(0.0); PhishingDetectionDone(request_type, is_sample_ping, did_match_high_confidence_allowlist, is_invalid_ip, tick_clock()->NowTicks(), mojom::PhishingDetectorResult::CLASSIFICATION_SKIPPED, mojo_base::ProtoWrapper(verdict)); return; } LogClientSideDetectionEvent( ClientSideDetectionEvent::kImageClassificationBegin, request_type); set_is_classifying(true); phishing_detector_->StartPhishingDetection( current_url(), GetClientSideDetectionMojomType(request_type), base::BindOnce(&ClientSideDetectionHost::PhishingDetectionDone, weak_factory_.GetWeakPtr(), request_type, is_sample_ping, did_match_high_confidence_allowlist, is_invalid_ip, tick_clock()->NowTicks())); } void ClientSideDetectionHost::PhishingDetectionDone( ClientSideDetectionType request_type, bool is_sample_ping, std::optional did_match_high_confidence_allowlist, bool is_invalid_ip, base::TimeTicks start_time, mojom::PhishingDetectorResult result, std::optional wrapped_verdict) { DCHECK_CURRENTLY_ON(BrowserThread::UI); // There is something seriously wrong if there is no service class but // this method is called. The renderer should not start phishing detection // if there isn't any service class in the browser. DCHECK(GetClientSideDetectionService()); phishing_detector_.reset(); std::optional verdict; // There's no need to parse the wrapped verdict if the result is not SUCCESS // or CLASSIFICATION_SKIPPED. if (wrapped_verdict.has_value() && (result == mojom::PhishingDetectorResult::SUCCESS || result == mojom::PhishingDetectorResult::CLASSIFICATION_SKIPPED)) { verdict = wrapped_verdict->As(); } ClientSideDetectionHostBase::PhishingDetectionDone( request_type, is_sample_ping, did_match_high_confidence_allowlist, is_invalid_ip, start_time, GetPhishingDetectorResult(result), std::move(verdict)); } visual_utils::CanExtractVisualFeaturesResult ClientSideDetectionHost::DetermineVisualFeaturesExtraction() { int viewport_width = -1; int viewport_height = -1; visual_utils::CanExtractVisualFeaturesResult can_extract_visual_features_result; content::RenderWidgetHostView* view = web_contents()->GetRenderWidgetHostView(); #if BUILDFLAG(IS_ANDROID) gfx::Size size; // native view can be null in tests. if (view && view->GetNativeView()) { gfx::SizeF viewport = view->GetNativeView()->viewport_size(); viewport_width = static_cast(viewport.width()); viewport_height = static_cast(viewport.height()); size = gfx::Size(viewport_width, viewport_height); } can_extract_visual_features_result = visual_utils::CanExtractVisualFeatures( IsEnhancedProtectionEnabled(), web_contents()->GetBrowserContext()->IsOffTheRecord(), size); #else gfx::Size size; if (view) { size = view->GetVisibleViewportSize(); viewport_width = size.width(); viewport_height = size.height(); } can_extract_visual_features_result = visual_utils::CanExtractVisualFeatures( IsEnhancedProtectionEnabled(), web_contents()->GetBrowserContext()->IsOffTheRecord(), size, zoom::ZoomController::GetZoomLevelForWebContents(web_contents())); #endif base::UmaHistogramSparse("SBClientPhishing.Viewport.Width", viewport_width); base::UmaHistogramSparse("SBClientPhishing.Viewport.Height", viewport_height); float ppi = 0; if (view && view->GetNativeView() && display::Screen::Get()) { ppi = display::Screen::Get() ->GetDisplayNearestView(view->GetNativeView()) .GetPixelsPerInchX(); } base::UmaHistogramSparse("SBClientPhishing.Viewport.PixelsPerInch", static_cast(ppi)); if (viewport_width <= 0xFFFF && viewport_width >= 0 && viewport_height <= 0xFFFF && viewport_height >= 0) { int32_t encoded_resolution = (viewport_width << 16) | viewport_height; base::UmaHistogramSparse("SBClientPhishing.Viewport.EncodedResolution", encoded_resolution); } base::UmaHistogramEnumeration("SBClientPhishing.VisualFeaturesClearReason2", can_extract_visual_features_result); return can_extract_visual_features_result; } void ClientSideDetectionHost::PhishingImageEmbeddingDone( std::unique_ptr verdict, std::optional did_match_high_confidence_allowlist, bool is_invalid_ip, mojom::PhishingImageEmbeddingResult result, std::optional image_feature_embedding_wrapper, std::optional visual_features_wrapper) { std::optional image_feature_embedding; if (image_feature_embedding_wrapper.has_value()) { image_feature_embedding = image_feature_embedding_wrapper->As(); } std::optional visual_features; if (visual_features_wrapper.has_value()) { visual_features = visual_features_wrapper->As(); } ClientSideDetectionHostBase::PhishingImageEmbeddingDone( std::move(verdict), did_match_high_confidence_allowlist, is_invalid_ip, ToImageEmbeddingResult(result), std::move(image_feature_embedding), std::move(visual_features)); } void ClientSideDetectionHost::ShowBlockingPage( GURL phishing_url, ClientSideDetectionType request_type, std::optional intelligent_scan_verdict, bool should_show_scam_warning) { DCHECK_CURRENTLY_ON(BrowserThread::UI); if (ui_manager_.get()) { auto* primary_main_frame = web_contents()->GetPrimaryMainFrame(); const content::GlobalRenderFrameHostId primary_main_frame_id = primary_main_frame->GetGlobalId(); security_interstitials::UnsafeResource resource; resource.url = phishing_url; resource.original_url = phishing_url; resource.threat_type = SBThreatType::SB_THREAT_TYPE_URL_CLIENT_SIDE_PHISHING; resource.threat_source = safe_browsing::ThreatSource::CLIENT_SIDE_DETECTION; resource.navigation_id = current_navigation_id_; // When we present a scam warning, we want to add separate interstitial // metrics to track specifics. if (should_show_scam_warning) { resource.threat_subtype = GetThreatSubtype(*intelligent_scan_verdict); DCHECK(GetIntelligentScanDelegate()); GetIntelligentScanDelegate()->OnScamWarningShown(); } resource.rfh_locator = security_interstitials::UnsafeResourceLocator:: CreateForRenderFrameToken(primary_main_frame_id.child_id.value(), primary_main_frame->GetFrameToken().value()); if (!ui_manager_->IsAllowlisted( resource.url, resource.rfh_locator, resource.navigation_id, resource.threat_type, resource.threat_source)) { // We need to stop any pending navigations, otherwise the interstitial // might not get created properly. web_contents()->GetController().DiscardNonCommittedEntries(); } LogClientSideDetectionEvent(ClientSideDetectionEvent::kWarningShown, request_type); ui_manager_->DisplayBlockingPage(resource); } } void ClientSideDetectionHost::UpdateDebuggingMetadataWithNetworkResult( GURL phishing_url, net::HttpStatusCode response_code) { DCHECK_CURRENTLY_ON(BrowserThread::UI); ClientSideDetectionFeatureCache::CreateForWebContents(web_contents()); ClientSideDetectionFeatureCache* feature_cache_map = ClientSideDetectionFeatureCache::FromWebContents(web_contents()); feature_cache_map->GetOrCreateDebuggingMetadataForURL(phishing_url) ->set_network_result(response_code); } void ClientSideDetectionHost::set_ui_manager(BaseUIManager* ui_manager) { ui_manager_ = ui_manager; } void ClientSideDetectionHost::set_database_manager( SafeBrowsingDatabaseManager* database_manager) { database_manager_ = database_manager; } void ClientSideDetectionHost::AddMiscellaneousMetadataToClientPhishingRequest( ClientPhishingRequest* verdict, bool is_invalid_ip) { content::RenderFrameHost* rfh = web_contents()->GetPrimaryMainFrame(); // Check the frame id as a precaution against unexpected race conditions. if (rfh && rfh->GetGlobalId() == current_outermost_main_frame_id_) { const network::mojom::URLResponseHead* response_head = rfh->GetLastResponseHead(); if (response_head && response_head->headers) { verdict->set_http_response_code(response_head->headers->response_code()); } } ClientSideDetectionHostBase::AddMiscellaneousMetadataToClientPhishingRequest( verdict, is_invalid_ip); } void ClientSideDetectionHost::AddReferrerChain(ClientPhishingRequest* verdict) { if (IsEnhancedProtectionEnabled()) { delegate_->AddReferrerChain(verdict, current_url(), current_outermost_main_frame_id_); } } void ClientSideDetectionHost::MaybeStartGeminiAntiscamProtection( GURL url, ClientSideDetectionType request_type, std::optional did_match_high_confidence_allowlist) { delegate_->MaybeStartGeminiAntiscamProtection( url, request_type, did_match_high_confidence_allowlist); } ClientSideDetectionFeatureCacheBase* ClientSideDetectionHost::GetFeatureCache() { ClientSideDetectionFeatureCache::CreateForWebContents(web_contents()); return ClientSideDetectionFeatureCache::FromWebContents(web_contents()); } void ClientSideDetectionHost::MaybeStartImageEmbedding( std::unique_ptr verdict, std::optional did_match_high_confidence_allowlist, bool is_invalid_ip, PhishingDetectorResult result) { visual_utils::CanExtractVisualFeaturesResult can_extract_visual_features_result = DetermineVisualFeaturesExtraction(); // Clear the blurred image from the visual features if we should not extract // visual features. if (can_extract_visual_features_result != visual_utils::CanExtractVisualFeaturesResult::kCanExtractVisualFeatures) { verdict->mutable_visual_features()->clear_image(); } else { base::UmaHistogramBoolean("SBClientPhishing.HasVisualFeaturesImage2", verdict->has_visual_features() && verdict->visual_features().has_image()); } if (auto service = GetClientSideDetectionService(); IsEnhancedProtectionEnabled() && service && service->HasImageEmbeddingModel() && service->IsModelMetadataImageEmbeddingVersionMatching() && !verdict->has_image_feature_embedding()) { content::RenderFrameHost* rfh = web_contents()->GetPrimaryMainFrame(); phishing_image_embedder_.reset(); rfh->GetRemoteAssociatedInterfaces()->GetInterface( &phishing_image_embedder_); if (phishing_image_embedder_.is_bound()) { LogClientSideDetectionEvent( ClientSideDetectionEvent::kImageEmbeddingBegin, verdict->client_side_detection_type()); bool can_extract_visual_features = result == PhishingDetectorResult::CLASSIFICATION_SKIPPED || can_extract_visual_features_result == visual_utils::CanExtractVisualFeaturesResult:: kCanExtractVisualFeatures; set_image_embedding_start_time(tick_clock()->NowTicks()); phishing_image_embedder_->StartImageEmbedding( current_url(), can_extract_visual_features, base::BindOnce(&ClientSideDetectionHost::PhishingImageEmbeddingDone, weak_factory_.GetWeakPtr(), std::move(verdict), did_match_high_confidence_allowlist, is_invalid_ip)); } return; } MaybeStartIntelligentScanForScamDetection( std::move(verdict), did_match_high_confidence_allowlist, is_invalid_ip); } std::vector ClientSideDetectionHost::GetRedirectChain() { if (!web_contents() || !web_contents()->GetController().GetLastCommittedEntry()) { return std::vector(); } return web_contents() ->GetController() .GetLastCommittedEntry() ->GetRedirectChain(); } GURL ClientSideDetectionHost::GetCurrentUrl() const { if (!web_contents() || !web_contents()->GetPrimaryMainFrame()) { return GURL(); } return web_contents()->GetPrimaryMainFrame()->GetLastCommittedURL(); } } // namespace safe_browsing