components/security_interstitials/content/ssl_error_handler.cc - chromium/src - Git at Google

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "components/security_interstitials/content/ssl_error_handler.h"

 #include <stdint.h>

 #include <memory>
 #include <unordered_set>
 #include <utility>

 #include "base/bind.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/network_time/network_time_tracker.h"
 #include "components/prefs/pref_service.h"
 #include "components/security_interstitials/content/bad_clock_blocking_page.h"
 #include "components/security_interstitials/content/blocked_interception_blocking_page.h"
 #include "components/security_interstitials/content/captive_portal_blocking_page.h"
 #include "components/security_interstitials/content/captive_portal_helper.h"
 #include "components/security_interstitials/content/legacy_tls_blocking_page.h"
 #include "components/security_interstitials/content/mitm_software_blocking_page.h"
 #include "components/security_interstitials/content/security_blocking_page_factory.h"
 #include "components/security_interstitials/content/security_interstitial_page.h"
 #include "components/security_interstitials/content/ssl_blocking_page.h"
 #include "components/security_interstitials/content/ssl_cert_reporter.h"
 #include "components/security_interstitials/content/ssl_error_assistant.h"
 #include "components/security_interstitials/core/ssl_error_options_mask.h"
 #include "components/security_interstitials/core/ssl_error_ui.h"
 #include "components/ssl_errors/error_classification.h"
 #include "components/ssl_errors/error_info.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/net_errors.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"

 #if BUILDFLAG(ENABLE_CAPTIVE_PORTAL_DETECTION)
 #include "components/captive_portal/content/captive_portal_tab_helper.h"
 #endif

 #if defined(OS_ANDROID)
 #include "base/android/jni_android.h"
 #include "components/security_interstitials/content/captive_portal_helper_android.h"
 #endif

 const base::Feature kMITMSoftwareInterstitial{"MITMSoftwareInterstitial",
                                               base::FEATURE_ENABLED_BY_DEFAULT};

 const base::Feature kCaptivePortalInterstitial{
     "CaptivePortalInterstitial", base::FEATURE_ENABLED_BY_DEFAULT};

 const base::Feature kCaptivePortalCertificateList{
     "CaptivePortalCertificateList", base::FEATURE_ENABLED_BY_DEFAULT};

 namespace {

 const base::Feature kSSLCommonNameMismatchHandling{
     "SSLCommonNameMismatchHandling", base::FEATURE_ENABLED_BY_DEFAULT};

 // Default delay in milliseconds before displaying the SSL interstitial.
 // This can be changed in tests.
 // - If there is a name mismatch and a suggested URL available result arrives
 //   during this time, the user is redirected to the suggester URL.
 // - If a "captive portal detected" result arrives during this time,
 //   a captive portal interstitial is displayed.
 // - Otherwise, an SSL interstitial is displayed.
 const int64_t kInterstitialDelayInMilliseconds = 3000;

 const char kHistogram[] = "interstitial.ssl_error_handler";

 // Adds a message to console after navigation commits and then, deletes itself.
 // Also deletes itself if the navigation is stopped.
 class CommonNameMismatchRedirectObserver
     : public content::WebContentsObserver,
       public content::WebContentsUserData<CommonNameMismatchRedirectObserver> {
  public:
   CommonNameMismatchRedirectObserver(
       const CommonNameMismatchRedirectObserver&) = delete;
   CommonNameMismatchRedirectObserver& operator=(
       const CommonNameMismatchRedirectObserver&) = delete;

   ~CommonNameMismatchRedirectObserver() override {}

   static void AddToConsoleAfterNavigation(
       content::WebContents* web_contents,
       const std::string& request_url_hostname,
       const std::string& suggested_url_hostname) {
     web_contents->SetUserData(
         UserDataKey(),
         base::WrapUnique(new CommonNameMismatchRedirectObserver(
             web_contents, request_url_hostname, suggested_url_hostname)));
   }

  private:
   friend class content::WebContentsUserData<CommonNameMismatchRedirectObserver>;
   CommonNameMismatchRedirectObserver(content::WebContents* web_contents,
                                      const std::string& request_url_hostname,
                                      const std::string& suggested_url_hostname)
       : WebContentsObserver(web_contents),
         web_contents_(web_contents),
         request_url_hostname_(request_url_hostname),
         suggested_url_hostname_(suggested_url_hostname) {}

   // WebContentsObserver:
   void NavigationStopped() override {
     // Deletes |this|.
     web_contents_->RemoveUserData(UserDataKey());
   }

   void NavigationEntryCommitted(
       const content::LoadCommittedDetails& /* load_details */) override {
     web_contents_->GetMainFrame()->AddMessageToConsole(
         blink::mojom::ConsoleMessageLevel::kInfo,
         base::StringPrintf(
             "Redirecting navigation %s -> %s because the server presented a "
             "certificate valid for %s but not for %s. To disable such "
             "redirects launch Chrome with the following flag: "
             "--disable-features=SSLCommonNameMismatchHandling",
             request_url_hostname_.c_str(), suggested_url_hostname_.c_str(),
             suggested_url_hostname_.c_str(), request_url_hostname_.c_str()));
     web_contents_->RemoveUserData(UserDataKey());
   }

   void WebContentsDestroyed() override {
     web_contents_->RemoveUserData(UserDataKey());
   }

   content::WebContents* web_contents_;
   const std::string request_url_hostname_;
   const std::string suggested_url_hostname_;

   WEB_CONTENTS_USER_DATA_KEY_DECL();
 };

 WEB_CONTENTS_USER_DATA_KEY_IMPL(CommonNameMismatchRedirectObserver);

 void RecordUMA(SSLErrorHandler::UMAEvent event) {
   UMA_HISTOGRAM_ENUMERATION(kHistogram, event,
                             SSLErrorHandler::SSL_ERROR_HANDLER_EVENT_COUNT);
 }

 bool IsCaptivePortalInterstitialEnabled() {
   return base::FeatureList::IsEnabled(kCaptivePortalInterstitial);
 }

 bool IsMITMSoftwareInterstitialEnabled() {
   return base::FeatureList::IsEnabled(kMITMSoftwareInterstitial);
 }

 bool IsSSLCommonNameMismatchHandlingEnabled() {
   return base::FeatureList::IsEnabled(kSSLCommonNameMismatchHandling);
 }

 // Configuration for SSLErrorHandler.
 class ConfigSingleton {
  public:
   ConfigSingleton();

   base::TimeDelta interstitial_delay() const;
   SSLErrorHandler::TimerStartedCallback* timer_started_callback() const;
   base::Clock* clock() const;
   SSLErrorHandler::OnBlockingPageShownCallback on_blocking_page_shown_callback()
       const;

   bool IsKnownCaptivePortalCertificate(const net::SSLInfo& ssl_info);

   // Returns the name of a known MITM software provider that matches the
   // certificate passed in as the |cert| parameter. Returns empty string if
   // there is no match.
   const std::string MatchKnownMITMSoftware(
       const scoped_refptr<net::X509Certificate> cert);

   // Returns a DynamicInterstitialInfo that matches with |ssl_info|. If is no
   // match, return null.
   absl::optional<DynamicInterstitialInfo> MatchDynamicInterstitial(
       const net::SSLInfo& ssl_info,
       bool is_overridable);

   // Testing methods:
   void ResetForTesting();
   void SetInterstitialDelayForTesting(const base::TimeDelta& delay);
   void SetTimerStartedCallbackForTesting(
       SSLErrorHandler::TimerStartedCallback* callback);
   void SetClockForTesting(base::Clock* clock);
   void SetReportNetworkConnectivityCallbackForTesting(
       base::OnceClosure callback);

   void SetErrorAssistantProto(
       std::unique_ptr<chrome_browser_ssl::SSLErrorAssistantConfig>
           error_assistant_proto);

   void SetClientCallbackOnInterstitialsShown(
       SSLErrorHandler::OnBlockingPageShownCallback callback);

   int GetErrorAssistantProtoVersionIdForTesting() const;

   void SetOSReportsCaptivePortalForTesting(bool os_reports_captive_portal);
   bool DoesOSReportCaptivePortalForTesting() const;

   base::OnceClosure report_network_connectivity_callback() {
     return std::move(report_network_connectivity_callback_);
   }

  private:
   base::TimeDelta interstitial_delay_;

   // Callback to call when the interstitial timer is started. Used for
   // testing.
   SSLErrorHandler::TimerStartedCallback* timer_started_callback_ = nullptr;

   // The clock to use when deciding which error type to display. Used for
   // testing.
   base::Clock* testing_clock_ = nullptr;

   base::OnceClosure report_network_connectivity_callback_;

   SSLErrorHandler::OnBlockingPageShownCallback on_blocking_page_shown_callback_;

   enum OSCaptivePortalStatus {
     OS_CAPTIVE_PORTAL_STATUS_NOT_SET,
     OS_CAPTIVE_PORTAL_STATUS_BEHIND_PORTAL,
     OS_CAPTIVE_PORTAL_STATUS_NOT_BEHIND_PORTAL,
   };
   OSCaptivePortalStatus os_captive_portal_status_for_testing_;

   std::unique_ptr<SSLErrorAssistant> ssl_error_assistant_;
 };

 ConfigSingleton::ConfigSingleton()
     : interstitial_delay_(base::Milliseconds(kInterstitialDelayInMilliseconds)),
       os_captive_portal_status_for_testing_(OS_CAPTIVE_PORTAL_STATUS_NOT_SET),
       ssl_error_assistant_(std::make_unique<SSLErrorAssistant>()) {}

 base::TimeDelta ConfigSingleton::interstitial_delay() const {
   return interstitial_delay_;
 }

 SSLErrorHandler::TimerStartedCallback* ConfigSingleton::timer_started_callback()
     const {
   return timer_started_callback_;
 }

 base::Clock* ConfigSingleton::clock() const {
   return testing_clock_;
 }

 SSLErrorHandler::OnBlockingPageShownCallback
 ConfigSingleton::on_blocking_page_shown_callback() const {
   return on_blocking_page_shown_callback_;
 }

 void ConfigSingleton::ResetForTesting() {
   interstitial_delay_ = base::Milliseconds(kInterstitialDelayInMilliseconds);
   timer_started_callback_ = nullptr;
   on_blocking_page_shown_callback_ =
       SSLErrorHandler::OnBlockingPageShownCallback();
   testing_clock_ = nullptr;
   ssl_error_assistant_->ResetForTesting();
   os_captive_portal_status_for_testing_ = OS_CAPTIVE_PORTAL_STATUS_NOT_SET;
 }

 void ConfigSingleton::SetInterstitialDelayForTesting(
     const base::TimeDelta& delay) {
   interstitial_delay_ = delay;
 }

 void ConfigSingleton::SetTimerStartedCallbackForTesting(
     SSLErrorHandler::TimerStartedCallback* callback) {
   DCHECK(!callback || !callback->is_null());
   timer_started_callback_ = callback;
 }

 void ConfigSingleton::SetClockForTesting(base::Clock* clock) {
   testing_clock_ = clock;
 }

 void ConfigSingleton::SetReportNetworkConnectivityCallbackForTesting(
     base::OnceClosure closure) {
   report_network_connectivity_callback_ = std::move(closure);
 }

 int ConfigSingleton::GetErrorAssistantProtoVersionIdForTesting() const {
   return ssl_error_assistant_->GetErrorAssistantProtoVersionIdForTesting();
 }

 void ConfigSingleton::SetOSReportsCaptivePortalForTesting(
     bool os_reports_captive_portal) {
   os_captive_portal_status_for_testing_ =
       os_reports_captive_portal ? OS_CAPTIVE_PORTAL_STATUS_BEHIND_PORTAL
                                 : OS_CAPTIVE_PORTAL_STATUS_NOT_BEHIND_PORTAL;
 }

 bool ConfigSingleton::DoesOSReportCaptivePortalForTesting() const {
   return os_captive_portal_status_for_testing_ ==
          OS_CAPTIVE_PORTAL_STATUS_BEHIND_PORTAL;
 }

 void ConfigSingleton::SetErrorAssistantProto(
     std::unique_ptr<chrome_browser_ssl::SSLErrorAssistantConfig> proto) {
   ssl_error_assistant_->SetErrorAssistantProto(std::move(proto));
 }

 void ConfigSingleton::SetClientCallbackOnInterstitialsShown(
     SSLErrorHandler::OnBlockingPageShownCallback callback) {
   on_blocking_page_shown_callback_ = callback;
 }

 bool ConfigSingleton::IsKnownCaptivePortalCertificate(
     const net::SSLInfo& ssl_info) {
   return ssl_error_assistant_->IsKnownCaptivePortalCertificate(ssl_info);
 }

 const std::string ConfigSingleton::MatchKnownMITMSoftware(
     const scoped_refptr<net::X509Certificate> cert) {
   return ssl_error_assistant_->MatchKnownMITMSoftware(cert);
 }

 absl::optional<DynamicInterstitialInfo>
 ConfigSingleton::MatchDynamicInterstitial(const net::SSLInfo& ssl_info,
                                           bool is_overridable) {
   return ssl_error_assistant_->MatchDynamicInterstitial(ssl_info,
                                                         is_overridable);
 }

 class SSLErrorHandlerDelegateImpl : public SSLErrorHandler::Delegate {
  public:
   SSLErrorHandlerDelegateImpl(
       content::WebContents* web_contents,
       const net::SSLInfo& ssl_info,
       content::BrowserContext* const browser_context,
       int cert_error,
       int options_mask,
       const GURL& request_url,
       std::unique_ptr<SSLCertReporter> ssl_cert_reporter,
       captive_portal::CaptivePortalService* captive_portal_service,
       std::unique_ptr<SecurityBlockingPageFactory> blocking_page_factory,
       SSLErrorHandler::OnBlockingPageShownCallback
           on_blocking_page_shown_callback,
       SSLErrorHandler::BlockingPageReadyCallback blocking_page_ready_callback)
       : web_contents_(web_contents),
         ssl_info_(ssl_info),
         browser_context_(browser_context),
         cert_error_(cert_error),
         options_mask_(options_mask),
         request_url_(request_url),
         ssl_cert_reporter_(std::move(ssl_cert_reporter)),
 #if BUILDFLAG(ENABLE_CAPTIVE_PORTAL_DETECTION)
         captive_portal_service_(captive_portal_service),
 #endif
         blocking_page_factory_(std::move(blocking_page_factory)),
         on_blocking_page_shown_callback_(on_blocking_page_shown_callback),
         blocking_page_ready_callback_(std::move(blocking_page_ready_callback)) {
     DCHECK(!blocking_page_ready_callback_.is_null());
   }
   ~SSLErrorHandlerDelegateImpl() override;

   // SSLErrorHandler::Delegate methods:
   void CheckForCaptivePortal() override;
   bool DoesOSReportCaptivePortal() override;
   bool GetSuggestedUrl(const std::vector<std::string>& dns_names,
                        GURL* suggested_url) const override;
   void CheckSuggestedUrl(
       const GURL& suggested_url,
       CommonNameMismatchHandler::CheckUrlCallback callback) override;
   void NavigateToSuggestedURL(const GURL& suggested_url) override;
   bool IsErrorOverridable() const override;
   void ShowCaptivePortalInterstitial(const GURL& landing_url) override;
   void ShowMITMSoftwareInterstitial(
       const std::string& mitm_software_name) override;
   void ShowSSLInterstitial(const GURL& support_url) override;
   void ShowBadClockInterstitial(const base::Time& now,
                                 ssl_errors::ClockState clock_state) override;
   void ShowBlockedInterceptionInterstitial() override;
   void ReportNetworkConnectivity(base::OnceClosure callback) override;
   bool HasBlockedInterception() const override;
   void ShowLegacyTLSInterstitial() override;
   bool HasLegacyTLS() const override;

  private:
   // Calls the |blocking_page_ready_callback_| if it's not null, else calls
   // Show() on the given interstitial.
   void OnBlockingPageReady(
       std::unique_ptr<security_interstitials::SecurityInterstitialPage>
           interstitial_page);

   content::WebContents* web_contents_;
   const net::SSLInfo ssl_info_;
   content::BrowserContext* const browser_context_;
   const int cert_error_;
   const int options_mask_;
   const GURL request_url_;
   std::unique_ptr<CommonNameMismatchHandler> common_name_mismatch_handler_;
   std::unique_ptr<SSLCertReporter> ssl_cert_reporter_;
 #if BUILDFLAG(ENABLE_CAPTIVE_PORTAL_DETECTION)
   captive_portal::CaptivePortalService* captive_portal_service_;
 #endif
   std::unique_ptr<SecurityBlockingPageFactory> blocking_page_factory_;
   SSLErrorHandler::OnBlockingPageShownCallback on_blocking_page_shown_callback_;
   SSLErrorHandler::BlockingPageReadyCallback blocking_page_ready_callback_;
 };

 SSLErrorHandlerDelegateImpl::~SSLErrorHandlerDelegateImpl() {
   if (common_name_mismatch_handler_) {
     common_name_mismatch_handler_->Cancel();
     common_name_mismatch_handler_.reset();
   }
 }

 void SSLErrorHandlerDelegateImpl::CheckForCaptivePortal() {
 #if BUILDFLAG(ENABLE_CAPTIVE_PORTAL_DETECTION)
   captive_portal_service_->DetectCaptivePortal();
 #else
   NOTREACHED();
 #endif
 }

 bool SSLErrorHandlerDelegateImpl::DoesOSReportCaptivePortal() {
 #if defined(OS_ANDROID) || defined(OS_WIN)
   return security_interstitials::IsBehindCaptivePortal();
 #else
   return false;
 #endif
 }

 bool SSLErrorHandlerDelegateImpl::GetSuggestedUrl(
     const std::vector<std::string>& dns_names,
     GURL* suggested_url) const {
   return CommonNameMismatchHandler::GetSuggestedUrl(request_url_, dns_names,
                                                     suggested_url);
 }

 void SSLErrorHandlerDelegateImpl::CheckSuggestedUrl(
     const GURL& suggested_url,
     CommonNameMismatchHandler::CheckUrlCallback callback) {
   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory(
       browser_context_->GetDefaultStoragePartition()
           ->GetURLLoaderFactoryForBrowserProcess());
   common_name_mismatch_handler_ = std::make_unique<CommonNameMismatchHandler>(
       request_url_, url_loader_factory);

   common_name_mismatch_handler_->CheckSuggestedUrl(suggested_url,
                                                    std::move(callback));
 }

 void SSLErrorHandlerDelegateImpl::NavigateToSuggestedURL(
     const GURL& suggested_url) {
   content::NavigationController::LoadURLParams load_params(suggested_url);
   load_params.transition_type = ui::PAGE_TRANSITION_TYPED;
   web_contents_->GetController().LoadURLWithParams(load_params);
 }

 bool SSLErrorHandlerDelegateImpl::IsErrorOverridable() const {
   return SSLBlockingPage::IsOverridable(options_mask_);
 }

 void SSLErrorHandlerDelegateImpl::ShowCaptivePortalInterstitial(
     const GURL& landing_url) {
   // Show captive portal blocking page. The interstitial owns the blocking page.
   OnBlockingPageReady(blocking_page_factory_->CreateCaptivePortalBlockingPage(
       web_contents_, request_url_, landing_url, std::move(ssl_cert_reporter_),
       ssl_info_, cert_error_));
 }

 void SSLErrorHandlerDelegateImpl::ShowMITMSoftwareInterstitial(
     const std::string& mitm_software_name) {
   // Show MITM software blocking page. The interstitial owns the blocking page.
   OnBlockingPageReady(blocking_page_factory_->CreateMITMSoftwareBlockingPage(
       web_contents_, cert_error_, request_url_, std::move(ssl_cert_reporter_),
       ssl_info_, mitm_software_name));
 }

 void SSLErrorHandlerDelegateImpl::ShowSSLInterstitial(const GURL& support_url) {
   // Show SSL blocking page. The interstitial owns the blocking page.
   OnBlockingPageReady(blocking_page_factory_->CreateSSLPage(
       web_contents_, cert_error_, ssl_info_, request_url_, options_mask_,
       base::Time::NowFromSystemTime(), support_url,
       std::move(ssl_cert_reporter_)));
 }

 void SSLErrorHandlerDelegateImpl::ShowBadClockInterstitial(
     const base::Time& now,
     ssl_errors::ClockState clock_state) {
   // Show bad clock page. The interstitial owns the blocking page.
   OnBlockingPageReady(blocking_page_factory_->CreateBadClockBlockingPage(
       web_contents_, cert_error_, ssl_info_, request_url_, now, clock_state,
       std::move(ssl_cert_reporter_)));
 }

 void SSLErrorHandlerDelegateImpl::ShowBlockedInterceptionInterstitial() {
   // Show interception blocking page. The interstitial owns the blocking page.
   OnBlockingPageReady(
       blocking_page_factory_->CreateBlockedInterceptionBlockingPage(
           web_contents_, cert_error_, request_url_,
           std::move(ssl_cert_reporter_), ssl_info_));
 }

 void SSLErrorHandlerDelegateImpl::ShowLegacyTLSInterstitial() {
   // Show legacy TLS blocking page. The interstitial owns the blocking page.
   OnBlockingPageReady(blocking_page_factory_->CreateLegacyTLSBlockingPage(
       web_contents_, cert_error_, request_url_, std::move(ssl_cert_reporter_),
       ssl_info_));
 }

 void SSLErrorHandlerDelegateImpl::ReportNetworkConnectivity(
     base::OnceClosure callback) {
 #if defined(OS_ANDROID)
   security_interstitials::ReportNetworkConnectivity(
       base::android::AttachCurrentThread());
 #else
 // Nothing to do on other platforms.
 #endif
   if (callback)
     std::move(callback).Run();
 }

 bool SSLErrorHandlerDelegateImpl::HasBlockedInterception() const {
   return ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_) ==
          ssl_errors::ErrorInfo::CERT_KNOWN_INTERCEPTION_BLOCKED;
 }

 bool SSLErrorHandlerDelegateImpl::HasLegacyTLS() const {
   return ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_) ==
          ssl_errors::ErrorInfo::LEGACY_TLS;
 }

 void SSLErrorHandlerDelegateImpl::OnBlockingPageReady(
     std::unique_ptr<security_interstitials::SecurityInterstitialPage>
         interstitial_page) {
   if (on_blocking_page_shown_callback_) {
     on_blocking_page_shown_callback_.Run(web_contents_, request_url_,
                                          "SSL_ERROR", cert_error_);
   }

   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(std::move(blocking_page_ready_callback_),
                                 std::move(interstitial_page)));
 }

 }  // namespace

 static base::LazyInstance<ConfigSingleton>::Leaky g_config =
     LAZY_INSTANCE_INITIALIZER;

 void SSLErrorHandler::HandleSSLError(
     content::WebContents* web_contents,
     int cert_error,
     const net::SSLInfo& ssl_info,
     const GURL& request_url,
     std::unique_ptr<SSLCertReporter> ssl_cert_reporter,
     base::OnceCallback<
         void(std::unique_ptr<security_interstitials::SecurityInterstitialPage>)>
         blocking_page_ready_callback,
     network_time::NetworkTimeTracker* network_time_tracker,
     captive_portal::CaptivePortalService* captive_portal_service,
     std::unique_ptr<SecurityBlockingPageFactory> blocking_page_factory,
     bool user_can_proceed_past_interstitial /*=true*/) {
   DCHECK(!FromWebContents(web_contents));

   bool hard_override_disabled = !user_can_proceed_past_interstitial;

   int options_mask = security_interstitials::CalculateSSLErrorOptionsMask(
       cert_error, hard_override_disabled, ssl_info.is_fatal_cert_error);

   SSLErrorHandler* error_handler = new SSLErrorHandler(
       std::unique_ptr<SSLErrorHandler::Delegate>(
           new SSLErrorHandlerDelegateImpl(
               web_contents, ssl_info, web_contents->GetBrowserContext(),
               cert_error, options_mask, request_url,
               std::move(ssl_cert_reporter), captive_portal_service,
               std::move(blocking_page_factory),
               g_config.Pointer()->on_blocking_page_shown_callback(),
               std::move(blocking_page_ready_callback))),
       web_contents, cert_error, ssl_info, network_time_tracker,
       captive_portal_service, request_url);
   web_contents->SetUserData(UserDataKey(), base::WrapUnique(error_handler));
   error_handler->StartHandlingError();
 }

 // static
 void SSLErrorHandler::ResetConfigForTesting() {
   g_config.Pointer()->ResetForTesting();
 }

 // static
 void SSLErrorHandler::SetInterstitialDelayForTesting(
     const base::TimeDelta& delay) {
   g_config.Pointer()->SetInterstitialDelayForTesting(delay);
 }

 // static
 void SSLErrorHandler::SetInterstitialTimerStartedCallbackForTesting(
     TimerStartedCallback* callback) {
   g_config.Pointer()->SetTimerStartedCallbackForTesting(callback);
 }

 // static
 void SSLErrorHandler::SetClockForTesting(base::Clock* testing_clock) {
   g_config.Pointer()->SetClockForTesting(testing_clock);
 }

 // static
 void SSLErrorHandler::SetReportNetworkConnectivityCallbackForTesting(
     base::OnceClosure closure) {
   g_config.Pointer()->SetReportNetworkConnectivityCallbackForTesting(
       std::move(closure));
 }

 // static
 std::string SSLErrorHandler::GetHistogramNameForTesting() {
   return kHistogram;
 }

 // static
 int SSLErrorHandler::GetErrorAssistantProtoVersionIdForTesting() {
   return g_config.Pointer()->GetErrorAssistantProtoVersionIdForTesting();
 }

 // static
 void SSLErrorHandler::SetOSReportsCaptivePortalForTesting(
     bool os_reports_captive_portal) {
   g_config.Pointer()->SetOSReportsCaptivePortalForTesting(
       os_reports_captive_portal);
 }

 bool SSLErrorHandler::IsTimerRunningForTesting() const {
   return timer_.IsRunning();
 }

 // static
 void SSLErrorHandler::SetErrorAssistantProto(
     std::unique_ptr<chrome_browser_ssl::SSLErrorAssistantConfig> config_proto) {
   g_config.Pointer()->SetErrorAssistantProto(std::move(config_proto));
 }

 // static
 void SSLErrorHandler::SetClientCallbackOnInterstitialsShown(
     OnBlockingPageShownCallback callback) {
   g_config.Pointer()->SetClientCallbackOnInterstitialsShown(callback);
 }

 SSLErrorHandler::SSLErrorHandler(
     std::unique_ptr<Delegate> delegate,
     content::WebContents* web_contents,
     int cert_error,
     const net::SSLInfo& ssl_info,
     network_time::NetworkTimeTracker* network_time_tracker,
     captive_portal::CaptivePortalService* captive_portal_service,
     const GURL& request_url)
     : content::WebContentsObserver(web_contents),
       delegate_(std::move(delegate)),
       web_contents_(web_contents),
       cert_error_(cert_error),
       ssl_info_(ssl_info),
       request_url_(request_url),
       network_time_tracker_(network_time_tracker)
 #if BUILDFLAG(ENABLE_CAPTIVE_PORTAL_DETECTION)
       ,
       captive_portal_service_(captive_portal_service)
 #endif
 {
 }

 SSLErrorHandler::~SSLErrorHandler() = default;

 void SSLErrorHandler::StartHandlingError() {
   RecordUMA(HANDLE_ALL);

   if (delegate_->HasBlockedInterception()) {
     return ShowBlockedInterceptionInterstitial();
   }

   // The legacy TLS interstitial is only shown if no other errors were found.
   if (ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_) ==
       ssl_errors::ErrorInfo::LEGACY_TLS) {
     return ShowLegacyTLSInterstitial();
   }

   if (ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_) ==
       ssl_errors::ErrorInfo::CERT_DATE_INVALID) {
     HandleCertDateInvalidError();
     return;
   }

   absl::optional<DynamicInterstitialInfo> dynamic_interstitial =
       g_config.Pointer()->MatchDynamicInterstitial(
           ssl_info_, delegate_->IsErrorOverridable());
   if (dynamic_interstitial) {
     ShowDynamicInterstitial(dynamic_interstitial.value());
     return;
   }

   // Ideally, a captive portal interstitial should only be displayed if the only
   // SSL error is a name mismatch error. However, captive portal detector always
   // opens a new tab if it detects a portal ignoring the types of SSL errors. To
   // be consistent with captive portal detector, use the result of OS detection
   // without checking only_error_is_name_mismatch.
   if (IsCaptivePortalInterstitialEnabled() &&
       (g_config.Pointer()->DoesOSReportCaptivePortalForTesting() ||
        delegate_->DoesOSReportCaptivePortal())) {
     delegate_->ReportNetworkConnectivity(
         g_config.Pointer()->report_network_connectivity_callback());
     RecordUMA(OS_REPORTS_CAPTIVE_PORTAL);
     ShowCaptivePortalInterstitial(GURL());
     return;
   }

   const bool only_error_is_name_mismatch =
       IsOnlyCertError(net::CERT_STATUS_COMMON_NAME_INVALID);

   // Check known captive portal certificate list if the only error is
   // name-mismatch. If there are multiple errors, it indicates that the captive
   // portal landing page itself will have SSL errors, and so it's not a very
   // helpful place to direct the user to go.
   if (only_error_is_name_mismatch) {
     delegate_->ReportNetworkConnectivity(
         g_config.Pointer()->report_network_connectivity_callback());

     if (base::FeatureList::IsEnabled(kCaptivePortalCertificateList) &&
         g_config.Pointer()->IsKnownCaptivePortalCertificate(ssl_info_)) {
       RecordUMA(CAPTIVE_PORTAL_CERT_FOUND);
       ShowCaptivePortalInterstitial(GURL());
       return;
     }
   }

   // The MITM software interstitial is displayed if and only if:
   // - the error thrown is not overridable
   // - the only certificate error is CERT_STATUS_AUTHORITY_INVALID
   // - the certificate contains a string that indicates it was issued by a
   //   MITM software
   if (IsMITMSoftwareInterstitialEnabled() && !delegate_->IsErrorOverridable() &&
       IsOnlyCertError(net::CERT_STATUS_AUTHORITY_INVALID)) {
     const std::string found_mitm_software =
         g_config.Pointer()->MatchKnownMITMSoftware(ssl_info_.cert);
     if (!found_mitm_software.empty()) {
       ShowMITMSoftwareInterstitial(found_mitm_software);
       return;
     }
   }

   if (IsSSLCommonNameMismatchHandlingEnabled() &&
       cert_error_ == net::ERR_CERT_COMMON_NAME_INVALID &&
       delegate_->IsErrorOverridable()) {
     std::vector<std::string> dns_names;
     ssl_info_.cert->GetSubjectAltName(&dns_names, nullptr);
     GURL suggested_url;
     if (!dns_names.empty() &&
         delegate_->GetSuggestedUrl(dns_names, &suggested_url)) {
       RecordUMA(WWW_MISMATCH_FOUND_IN_SAN);

       // Show the SSL interstitial if |CERT_STATUS_COMMON_NAME_INVALID| is not
       // the only error. Need not check for captive portal in this case.
       // (See the comment below).
       if (!only_error_is_name_mismatch) {
         ShowSSLInterstitial();
         return;
       }
       delegate_->CheckSuggestedUrl(
           suggested_url,
           base::BindOnce(&SSLErrorHandler::CommonNameMismatchHandlerCallback,
                          weak_ptr_factory_.GetWeakPtr()));
       timer_.Start(FROM_HERE, g_config.Pointer()->interstitial_delay(), this,
                    &SSLErrorHandler::ShowSSLInterstitial);

       if (g_config.Pointer()->timer_started_callback())
         g_config.Pointer()->timer_started_callback()->Run(web_contents_);

       // Do not check for a captive portal in this case, because a captive
       // portal most likely cannot serve a valid certificate which passes the
       // similarity check.
       return;
     }
   }

 #if BUILDFLAG(ENABLE_CAPTIVE_PORTAL_DETECTION)
   subscription_ = captive_portal_service_->RegisterCallback(
       base::BindRepeating(&SSLErrorHandler::Observe, base::Unretained(this)));

   captive_portal::CaptivePortalTabHelper* captive_portal_tab_helper =
       captive_portal::CaptivePortalTabHelper::FromWebContents(web_contents_);
   if (captive_portal_tab_helper) {
     captive_portal_tab_helper->OnSSLCertError(ssl_info_);
   }

   if (IsCaptivePortalInterstitialEnabled()) {
     delegate_->CheckForCaptivePortal();
     timer_.Start(FROM_HERE, g_config.Pointer()->interstitial_delay(), this,
                  &SSLErrorHandler::ShowSSLInterstitial);
     if (g_config.Pointer()->timer_started_callback())
       g_config.Pointer()->timer_started_callback()->Run(web_contents_);
     return;
   }
 #endif
   // Display an SSL interstitial.
   ShowSSLInterstitial();
 }

 void SSLErrorHandler::ShowCaptivePortalInterstitial(const GURL& landing_url) {
   // Show captive portal blocking page. The interstitial owns the blocking page.
   RecordUMA(delegate_->IsErrorOverridable()
                 ? SHOW_CAPTIVE_PORTAL_INTERSTITIAL_OVERRIDABLE
                 : SHOW_CAPTIVE_PORTAL_INTERSTITIAL_NONOVERRIDABLE);
   delegate_->ShowCaptivePortalInterstitial(landing_url);

   // Once an interstitial is displayed, no need to keep the handler around.
   // This is the equivalent of "delete this". It also destroys the timer.
   web_contents_->RemoveUserData(UserDataKey());
 }

 void SSLErrorHandler::ShowMITMSoftwareInterstitial(
     const std::string& mitm_software_name) {
   // Show SSL blocking page. The interstitial owns the blocking page.
   RecordUMA(SHOW_MITM_SOFTWARE_INTERSTITIAL);
   delegate_->ShowMITMSoftwareInterstitial(mitm_software_name);
   // Once an interstitial is displayed, no need to keep the handler around.
   // This is the equivalent of "delete this".
   web_contents_->RemoveUserData(UserDataKey());
 }

 void SSLErrorHandler::ShowSSLInterstitial() {
   GURL support_url = (cert_error_ == net::ERR_CERT_SYMANTEC_LEGACY)
                          ? GURL(kSymantecSupportUrl)
                          : GURL();

   // Show SSL blocking page. The interstitial owns the blocking page.
   RecordUMA(delegate_->IsErrorOverridable()
                 ? SHOW_SSL_INTERSTITIAL_OVERRIDABLE
                 : SHOW_SSL_INTERSTITIAL_NONOVERRIDABLE);
   delegate_->ShowSSLInterstitial(support_url);
   // Once an interstitial is displayed, no need to keep the handler around.
   // This is the equivalent of "delete this".
   web_contents_->RemoveUserData(UserDataKey());
 }

 void SSLErrorHandler::ShowBadClockInterstitial(
     const base::Time& now,
     ssl_errors::ClockState clock_state) {
   RecordUMA(SHOW_BAD_CLOCK);
   delegate_->ShowBadClockInterstitial(now, clock_state);
   // Once an interstitial is displayed, no need to keep the handler around.
   // This is the equivalent of "delete this".
   web_contents_->RemoveUserData(UserDataKey());
 }

 void SSLErrorHandler::ShowDynamicInterstitial(
     const DynamicInterstitialInfo dynamic_interstitial) {
   switch (dynamic_interstitial.interstitial_type) {
     case chrome_browser_ssl::DynamicInterstitial::INTERSTITIAL_PAGE_NONE:
       NOTREACHED();
       return;
     case chrome_browser_ssl::DynamicInterstitial::INTERSTITIAL_PAGE_SSL:
       delegate_->ShowSSLInterstitial(dynamic_interstitial.support_url);
       return;
     case chrome_browser_ssl::DynamicInterstitial::
         INTERSTITIAL_PAGE_CAPTIVE_PORTAL:
       delegate_->ShowCaptivePortalInterstitial(GURL());
       return;
     case chrome_browser_ssl::DynamicInterstitial::
         INTERSTITIAL_PAGE_MITM_SOFTWARE:
       DCHECK(!dynamic_interstitial.mitm_software_name.empty());
       delegate_->ShowMITMSoftwareInterstitial(
           dynamic_interstitial.mitm_software_name);
       return;
   }
 }

 void SSLErrorHandler::ShowBlockedInterceptionInterstitial() {
   // Show a blocking page. The interstitial owns the blocking page.
   RecordUMA(SHOW_BLOCKED_INTERCEPTION_INTERSTITIAL);
   delegate_->ShowBlockedInterceptionInterstitial();
   // Once an interstitial is displayed, no need to keep the handler around.
   // This is the equivalent of "delete this".
   web_contents_->RemoveUserData(UserDataKey());
 }

 void SSLErrorHandler::ShowLegacyTLSInterstitial() {
   // Show a blocking page. The interstitial owns the blocking page.
   RecordUMA(SHOW_LEGACY_TLS_INTERSTITIAL);
   delegate_->ShowLegacyTLSInterstitial();
   // Once an interstitial is displayed, no need to keep the handler around.
   // This is the equivalent of "delete this".
   web_contents_->RemoveUserData(UserDataKey());
 }

 void SSLErrorHandler::CommonNameMismatchHandlerCallback(
     CommonNameMismatchHandler::SuggestedUrlCheckResult result,
     const GURL& suggested_url) {
   timer_.Stop();
   if (result == CommonNameMismatchHandler::SuggestedUrlCheckResult::
                     SUGGESTED_URL_AVAILABLE) {
     RecordUMA(WWW_MISMATCH_URL_AVAILABLE);
     CommonNameMismatchRedirectObserver::AddToConsoleAfterNavigation(
         web_contents(), request_url_.host(), suggested_url.host());
     delegate_->NavigateToSuggestedURL(suggested_url);
   } else {
     RecordUMA(WWW_MISMATCH_URL_NOT_AVAILABLE);
     ShowSSLInterstitial();
   }
 }

 void SSLErrorHandler::Observe(
     const captive_portal::CaptivePortalService::Results& results) {
 #if BUILDFLAG(ENABLE_CAPTIVE_PORTAL_DETECTION)
   timer_.Stop();
   if (results.result == captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL)
     ShowCaptivePortalInterstitial(results.landing_url);
   else
     ShowSSLInterstitial();
 #else
   NOTREACHED();
 #endif
 }

 void SSLErrorHandler::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInPrimaryMainFrame() ||
       navigation_handle->IsSameDocument()) {
     return;
   }

   // Destroy the error handler on all new navigations. This ensures that the
   // handler is properly recreated when a hanging page is navigated to an SSL
   // error, even when the tab's WebContents doesn't change.
   DeleteSSLErrorHandler();
 }

 void SSLErrorHandler::NavigationStopped() {
   // Destroy the error handler when the page load is stopped.
   DeleteSSLErrorHandler();
 }

 void SSLErrorHandler::DeleteSSLErrorHandler() {
   delegate_.reset();
   // Deletes |this| and also destroys the timer.
   web_contents_->RemoveUserData(UserDataKey());
 }

 void SSLErrorHandler::HandleCertDateInvalidError() {
   const base::TimeTicks now = base::TimeTicks::Now();
   timer_.Start(FROM_HERE, g_config.Pointer()->interstitial_delay(),
                base::BindOnce(&SSLErrorHandler::HandleCertDateInvalidErrorImpl,
                               base::Unretained(this), now));
   // Try kicking off a time fetch to get an up-to-date estimate of the
   // true time. This will only have an effect if network time is
   // unavailable or if there is not already a query in progress.
   //
   // Pass a weak pointer as the callback; if the timer fires before the
   // fetch completes and shows an interstitial, this SSLErrorHandler
   // will be deleted.
   if (!network_time_tracker_->StartTimeFetch(
           base::BindOnce(&SSLErrorHandler::HandleCertDateInvalidErrorImpl,
                          weak_ptr_factory_.GetWeakPtr(), now))) {
     HandleCertDateInvalidErrorImpl(now);
     return;
   }

   if (g_config.Pointer()->timer_started_callback())
     g_config.Pointer()->timer_started_callback()->Run(web_contents_);
 }

 void SSLErrorHandler::HandleCertDateInvalidErrorImpl(
     base::TimeTicks started_handling_error) {
   UMA_HISTOGRAM_CUSTOM_TIMES(
       "interstitial.ssl_error_handler.cert_date_error_delay",
       base::TimeTicks::Now() - started_handling_error, base::Milliseconds(1),
       base::Seconds(4), 50);

   timer_.Stop();
   base::Clock* testing_clock = g_config.Pointer()->clock();
   const base::Time now =
       testing_clock ? testing_clock->Now() : base::Time::NowFromSystemTime();

   ssl_errors::ClockState clock_state =
       ssl_errors::GetClockState(now, network_time_tracker_);
   if (clock_state == ssl_errors::CLOCK_STATE_FUTURE ||
       clock_state == ssl_errors::CLOCK_STATE_PAST) {
     ShowBadClockInterstitial(now, clock_state);
     return;  // |this| is deleted after showing the interstitial.
   }
   ShowSSLInterstitial();
 }

 // Returns true if |only_cert_error_expected| is the only error code present in
 // the certificate. The parameter |only_cert_error_expected| is a
 // net::CertStatus code representing the most serious error identified on the
 // certificate. For example, this could be net::CERT_STATUS_COMMON_NAME_INVALID.
 // This function is useful for rendering interstitials that are triggered by one
 // specific error code only.
 bool SSLErrorHandler::IsOnlyCertError(
     net::CertStatus only_cert_error_expected) const {
   const net::CertStatus other_errors =
       ssl_info_.cert_status ^ only_cert_error_expected;

   return cert_error_ ==
              net::MapCertStatusToNetError(only_cert_error_expected) &&
          !net::IsCertStatusError(other_errors);
 }

 WEB_CONTENTS_USER_DATA_KEY_IMPL(SSLErrorHandler);