// Copyright 2012 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include #include #include #include #include #include "base/base64.h" #include "base/base_switches.h" #include "base/command_line.h" #include "base/containers/span.h" #include "base/feature_list.h" #include "base/files/file_util.h" #include "base/functional/bind.h" #include "base/functional/callback.h" #include "base/functional/callback_helpers.h" #include "base/json/json_reader.h" #include "base/location.h" #include "base/memory/raw_ptr.h" #include "base/metrics/field_trial.h" #include "base/run_loop.h" #include "base/strings/escape.h" #include "base/strings/pattern.h" #include "base/strings/string_number_conversions.h" #include "base/strings/string_split.h" #include "base/strings/string_util.h" #include "base/strings/stringprintf.h" #include "base/strings/utf_string_conversions.h" #include "base/task/current_thread.h" #include "base/task/single_thread_task_runner.h" #include "base/test/bind.h" #include "base/test/metrics/histogram_tester.h" #include "base/test/scoped_command_line.h" #include "base/test/scoped_feature_list.h" #include "base/test/simple_test_clock.h" #include "base/test/test_future.h" #include "base/threading/scoped_blocking_call.h" #include "base/threading/thread_restrictions.h" #include "base/time/default_clock.h" #include "base/time/default_tick_clock.h" #include "base/time/time.h" #include "build/build_config.h" #include "chrome/app/chrome_command_ids.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/chrome_content_browser_client.h" #include "chrome/browser/content_settings/host_content_settings_map_factory.h" #include "chrome/browser/interstitials/security_interstitial_idn_test.h" #include "chrome/browser/interstitials/security_interstitial_page_test_utils.h" #include "chrome/browser/net/profile_network_context_service.h" #include "chrome/browser/net/profile_network_context_service_factory.h" #include "chrome/browser/net/system_network_context_manager.h" #include "chrome/browser/policy/policy_test_utils.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/profiles/profile_manager.h" #include "chrome/browser/ssl/cert_verifier_browser_test.h" #include "chrome/browser/ssl/chrome_security_blocking_page_factory.h" #include "chrome/browser/ssl/chrome_security_state_util.h" #include "chrome/browser/ssl/https_upgrades_util.h" #include "chrome/browser/ssl/ssl_browsertest_base.h" #include "chrome/browser/ssl/ssl_browsertest_util.h" #include "chrome/browser/ssl/ssl_client_certificate_selector.h" #include "chrome/browser/ssl/ssl_error_controller_client.h" #include "chrome/browser/ui/browser_commands.h" #include "chrome/browser/ui/browser_tabstrip.h" #include "chrome/browser/ui/browser_window/public/browser_window_interface.h" #include "chrome/browser/ui/browser_window/public/profile_browser_collection.h" #include "chrome/browser/ui/navigator/browser_navigator.h" #include "chrome/browser/ui/navigator/browser_navigator_params.h" #include "chrome/browser/ui/tab_ui_helper.h" #include "chrome/browser/ui/tabs/tab_strip_model.h" #include "chrome/browser/ui/webui/certificate_viewer/certificate_viewer_webui.h" #include "chrome/common/chrome_features.h" #include "chrome/common/chrome_paths.h" #include "chrome/common/chrome_switches.h" #include "chrome/common/extensions/api/safe_browsing_private.h" #include "chrome/common/pref_names.h" #include "chrome/test/base/in_process_browser_test.h" #include "chrome/test/base/test_launcher_utils.h" #include "chrome/test/base/ui_test_utils.h" #include "components/content_settings/browser/page_specific_content_settings.h" #include "components/content_settings/common/content_settings_agent.mojom.h" #include "components/content_settings/core/browser/host_content_settings_map.h" #include "components/content_settings/core/common/content_settings_types.h" #include "components/error_page/content/browser/net_error_auto_reloader.h" #include "components/metrics/content/subprocess_metrics_provider.h" #include "components/network_session_configurator/common/network_switches.h" #include "components/network_time/network_time_test_utils.h" #include "components/network_time/network_time_tracker.h" #include "components/policy/core/browser/browser_policy_connector.h" #include "components/policy/core/common/mock_configuration_policy_provider.h" #include "components/policy/core/common/policy_map.h" #include "components/policy/core/common/policy_types.h" #include "components/policy/policy_constants.h" #include "components/prefs/testing_pref_service.h" #include "components/safe_browsing/core/common/features.h" #include "components/safe_browsing/core/common/safe_browsing_prefs.h" #include "components/security_interstitials/content/bad_clock_blocking_page.h" #include "components/security_interstitials/content/captive_portal_blocking_page.h" #include "components/security_interstitials/content/common_name_mismatch_handler.h" #include "components/security_interstitials/content/insecure_form_blocking_page.h" #include "components/security_interstitials/content/insecure_form_navigation_throttle.h" #include "components/security_interstitials/content/mitm_software_blocking_page.h" #include "components/security_interstitials/content/security_interstitial_controller_client.h" #include "components/security_interstitials/content/security_interstitial_page.h" #include "components/security_interstitials/content/security_interstitial_tab_helper.h" #include "components/security_interstitials/content/ssl_blocking_page.h" #include "components/security_interstitials/content/ssl_error_assistant.h" #include "components/security_interstitials/content/ssl_error_assistant.pb.h" #include "components/security_interstitials/content/ssl_error_handler.h" #include "components/security_interstitials/content/stateful_ssl_host_state_delegate.h" #include "components/security_interstitials/core/controller_client.h" #include "components/security_interstitials/core/https_only_mode_metrics.h" #include "components/security_interstitials/core/metrics_helper.h" #include "components/security_interstitials/core/pref_names.h" #include "components/security_state/core/security_state.h" #include "components/strings/grit/components_strings.h" #include "components/tabs/public/tab_interface.h" #include "components/web_modal/web_contents_modal_dialog_manager.h" #include "content/public/browser/back_forward_cache.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/client_certificate_delegate.h" #include "content/public/browser/navigation_controller.h" #include "content/public/browser/navigation_entry.h" #include "content/public/browser/navigation_entry_restore_context.h" #include "content/public/browser/navigation_handle.h" #include "content/public/browser/network_service_instance.h" #include "content/public/browser/network_service_util.h" #include "content/public/browser/render_frame_host.h" #include "content/public/browser/render_process_host.h" #include "content/public/browser/render_view_host.h" #include "content/public/browser/render_widget_host_view.h" #include "content/public/browser/restore_type.h" #include "content/public/browser/ssl_status.h" #include "content/public/browser/storage_partition.h" #include "content/public/browser/web_contents.h" #include "content/public/browser/web_contents_observer.h" #include "content/public/common/content_client.h" #include "content/public/common/content_features.h" #include "content/public/common/content_switches.h" #include "content/public/common/url_constants.h" #include "content/public/test/browser_test.h" #include "content/public/test/browser_test_utils.h" #include "content/public/test/content_mock_cert_verifier.h" #include "content/public/test/download_test_observer.h" #include "content/public/test/fenced_frame_test_util.h" #include "content/public/test/prerender_test_util.h" #include "content/public/test/test_navigation_observer.h" #include "content/public/test/test_renderer_host.h" #include "content/public/test/test_utils.h" #include "content/public/test/url_loader_interceptor.h" #include "crypto/hash.h" #include "extensions/browser/event_router.h" #include "google_apis/gaia/gaia_id.h" #include "mojo/public/cpp/bindings/associated_remote.h" #include "mojo/public/cpp/bindings/receiver.h" #include "mojo/public/cpp/bindings/remote.h" #include "mojo/public/cpp/bindings/sync_call_restrictions.h" #include "net/base/features.h" #include "net/base/host_port_pair.h" #include "net/base/io_buffer.h" #include "net/base/net_errors.h" #include "net/cert/asn1_util.h" #include "net/cert/cert_database.h" #include "net/cert/cert_status_flags.h" #include "net/cert/mock_cert_verifier.h" #include "net/cert/test_root_certs.h" #include "net/cert/x509_certificate.h" #include "net/cert/x509_util.h" #include "net/dns/mock_host_resolver.h" #include "net/http/http_response_headers.h" #include "net/http/http_status_code.h" #include "net/http/transport_security_state_test_util.h" #include "net/ssl/client_cert_identity_test_util.h" #include "net/ssl/client_cert_store.h" #include "net/ssl/ssl_config.h" #include "net/ssl/ssl_info.h" #include "net/ssl/ssl_private_key.h" #include "net/ssl/ssl_server_config.h" #include "net/test/cert_test_util.h" #include "net/test/embedded_test_server/controllable_http_response.h" #include "net/test/embedded_test_server/embedded_test_server.h" #include "net/test/embedded_test_server/http_request.h" #include "net/test/embedded_test_server/http_response.h" #include "net/test/embedded_test_server/install_default_websocket_handlers.h" #include "net/test/embedded_test_server/request_handler_util.h" #include "net/test/quic_simple_test_server.h" #include "net/test/test_certificate_data.h" #include "net/test/test_data_directory.h" #include "net/third_party/quiche/src/quiche/quic/platform/api/quic_flags.h" #include "services/network/public/cpp/features.h" #include "services/network/public/cpp/network_switches.h" #include "services/network/public/mojom/network_service.mojom.h" #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h" #include "third_party/blink/public/common/chrome_debug_urls.h" #include "third_party/blink/public/common/features.h" #include "third_party/blink/public/common/page_state/page_state.h" #include "third_party/blink/public/common/web_preferences/web_preferences.h" #include "third_party/blink/public/mojom/window_features/window_features.mojom.h" #include "ui/base/l10n/l10n_util.h" #if BUILDFLAG(ENABLE_EXTENSIONS) #include "chrome/browser/extensions/chrome_test_extension_loader.h" #include "chrome/browser/extensions/scoped_test_mv2_enabler.h" #include "extensions/browser/background_script_executor.h" #include "extensions/common/extension.h" #include "extensions/test/test_extension_dir.h" #endif // BUILDFLAG(ENABLE_EXTENSIONS) #if BUILDFLAG(USE_NSS_CERTS) #include "chrome/browser/net/nss_service.h" #include "chrome/browser/net/nss_service_factory.h" #include "crypto/scoped_test_nss_db.h" #include "net/cert/nss_cert_database.h" #include "net/cert/x509_util_nss.h" #endif // BUILDFLAG(USE_NSS_CERTS) #if BUILDFLAG(IS_CHROMEOS) #include "ash/constants/ash_switches.h" #include "base/path_service.h" #include "chrome/browser/ash/profiles/profile_helper.h" #include "chrome/browser/policy/profile_policy_connector.h" #include "chrome/browser/policy/profile_policy_connector_builder.h" #include "components/policy/core/common/policy_namespace.h" #include "components/policy/core/common/policy_service.h" #endif // BUILDFLAG(IS_CHROMEOS) using content::WebContents; namespace AuthState = ssl_test_util::AuthState; namespace CertError = ssl_test_util::CertError; namespace { const int kLargeVersionId = 0xFFFFFF; const char kHstsTestHostName[] = "hsts-example.test"; enum ProceedDecision { SSL_INTERSTITIAL_PROCEED, SSL_INTERSTITIAL_DO_NOT_PROCEED }; // A WebContentsObserver that allows observing when the page has set a // particular SSL content status flag. Assumes that the flag is not set when the // observer is created. class SSLContentStatusObserver : public content::WebContentsObserver { public: explicit SSLContentStatusObserver(content::WebContents* web_contents, content::SSLStatus::ContentStatusFlags flag) : content::WebContentsObserver(web_contents), flag_(flag) { content::NavigationEntry* entry = web_contents->GetController().GetVisibleEntry(); if (entry) { DCHECK(!(entry->GetSSL().content_status & flag_)); } } SSLContentStatusObserver(const SSLContentStatusObserver&) = delete; SSLContentStatusObserver& operator=(const SSLContentStatusObserver&) = delete; ~SSLContentStatusObserver() override = default; void DidChangeVisibleSecurityState() override { content::NavigationEntry* entry = web_contents()->GetController().GetVisibleEntry(); if (entry && (entry->GetSSL().content_status & flag_)) { run_loop_.Quit(); } } void WaitForSSLContentStatusFlag() { run_loop_.Run(); } private: // The content status flag of interest content::SSLStatus::ContentStatusFlags flag_; base::RunLoop run_loop_; }; // This observer waits for the SSLErrorHandler to start an interstitial timer // for the given web contents. class SSLInterstitialTimerObserver { public: explicit SSLInterstitialTimerObserver(WebContents* web_contents) : web_contents_(web_contents), message_loop_runner_(new base::RunLoop) { callback_ = base::BindRepeating( &SSLInterstitialTimerObserver::OnTimerStarted, base::Unretained(this)); SSLErrorHandler::SetInterstitialTimerStartedCallbackForTesting(&callback_); } SSLInterstitialTimerObserver(const SSLInterstitialTimerObserver&) = delete; SSLInterstitialTimerObserver& operator=(const SSLInterstitialTimerObserver&) = delete; ~SSLInterstitialTimerObserver() { SSLErrorHandler::SetInterstitialTimerStartedCallbackForTesting(nullptr); } // Waits until the interstitial delay timer in SSLErrorHandler is started. void WaitForTimerStarted() { message_loop_runner_->Run(); } // Returns true if the interstitial delay timer has been started. bool timer_started() const { return timer_started_; } private: void OnTimerStarted(WebContents* web_contents) { timer_started_ = true; if (web_contents_ == web_contents) { message_loop_runner_->Quit(); } } bool timer_started_ = false; raw_ptr web_contents_; SSLErrorHandler::TimerStartedCallback callback_; std::unique_ptr message_loop_runner_; }; class ChromeContentBrowserClientForMixedContentTest : public ChromeContentBrowserClient { public: ChromeContentBrowserClientForMixedContentTest() = default; ChromeContentBrowserClientForMixedContentTest( const ChromeContentBrowserClientForMixedContentTest&) = delete; ChromeContentBrowserClientForMixedContentTest& operator=( const ChromeContentBrowserClientForMixedContentTest&) = delete; void OverrideWebPreferences( content::WebContents* web_contents, content::SiteInstance& main_frame_site, blink::web_pref::WebPreferences* web_prefs) override { web_prefs->allow_running_insecure_content = allow_running_insecure_content_; web_prefs->strict_mixed_content_checking = strict_mixed_content_checking_; web_prefs->strictly_block_blockable_mixed_content = strictly_block_blockable_mixed_content_; } void SetMixedContentSettings(bool allow_running_insecure_content, bool strict_mixed_content_checking, bool strictly_block_blockable_mixed_content) { allow_running_insecure_content_ = allow_running_insecure_content; strict_mixed_content_checking_ = strict_mixed_content_checking; strictly_block_blockable_mixed_content_ = strictly_block_blockable_mixed_content; } private: bool allow_running_insecure_content_ = false; bool strict_mixed_content_checking_ = false; bool strictly_block_blockable_mixed_content_ = false; }; // Returns the Sha256 hash of the SPKI of |cert|. std::array GetSPKIHash( const CRYPTO_BUFFER* cert) { std::string_view spki_bytes; EXPECT_TRUE(net::asn1::ExtractSPKIFromDERCert( net::x509_util::CryptoBufferAsStringPiece(cert), &spki_bytes)); return crypto::hash::Sha256(base::as_byte_span(spki_bytes)); } // Compares two SSLStatuses to check if they match up before and after an // interstitial. To match up, they should have the same connection information // properties, such as certificate, connection status, connection security, // etc. Content status and user data are not compared. Returns true if the // statuses match and false otherwise. bool ComparePreAndPostInterstitialSSLStatuses(const content::SSLStatus& one, const content::SSLStatus& two) { // TODO(mattm): It feels like this should use // certificate->EqualsIncludingChain, but that fails on some platforms. Find // out why and document or fix. return one.initialized == two.initialized && !!one.certificate == !!two.certificate && (one.certificate ? one.certificate->EqualsExcludingChain(two.certificate.get()) : true) && one.cert_status == two.cert_status && one.key_exchange_group == two.key_exchange_group && // Skip comparing the peer_signature_algorithm, because it is not // filled in by the time of an interstitial. one.connection_status == two.connection_status && one.pkp_bypassed == two.pkp_bypassed; } void ExpectInterstitialElementHidden(WebContents* tab, const std::string& element_id, bool expect_hidden) { content::RenderFrameHost* frame = tab->GetPrimaryMainFrame(); // Send CMD_TEXT_FOUND to indicate that the 'hidden' class is found, and // CMD_TEXT_NOT_FOUND if not. std::string command = base::StringPrintf( "document.querySelector('#%s')" " .classList.contains('hidden')" " ? %d : %d;", element_id.c_str(), security_interstitials::CMD_TEXT_FOUND, security_interstitials::CMD_TEXT_NOT_FOUND); int result = content::EvalJs(frame, command).ExtractInt(); EXPECT_EQ(expect_hidden ? security_interstitials::CMD_TEXT_FOUND : security_interstitials::CMD_TEXT_NOT_FOUND, result); } } // namespace class SSLUITest : public SSLUITestBase { public: SSLUITest() : SSLUITestBase() { scoped_feature_list_.InitWithFeatures( /*enabled_features=*/{net::features::kVerifyQWACs}, GetDisabledFeatures()); } SSLUITest(const SSLUITest&) = delete; SSLUITest& operator=(const SSLUITest&) = delete; protected: void DontProceedThroughInterstitial(WebContents* tab) override { content::TestNavigationObserver nav_observer(tab, 1); SendInterstitialCommand(tab, security_interstitials::CMD_DONT_PROCEED); nav_observer.Wait(); } private: base::test::ScopedFeatureList scoped_feature_list_; }; class SSLUITestBlock : public SSLUITest { public: SSLUITestBlock() : SSLUITest() {} // Browser will not run insecure content. void SetUpCommandLine(base::CommandLine* command_line) override { // By overriding SSLUITest, we won't apply the flag that allows running // insecure content. } }; class SSLUITestIgnoreCertErrors : public SSLUITest { public: SSLUITestIgnoreCertErrors() : SSLUITest() {} void SetUpCommandLine(base::CommandLine* command_line) override { SSLUITest::SetUpCommandLine(command_line); // Browser will ignore certificate errors. command_line->AppendSwitch(switches::kIgnoreCertificateErrors); } }; static std::string MakeCertSPKIFingerprint(net::X509Certificate* cert) { return base::Base64Encode(GetSPKIHash(cert->cert_buffer())); } class SSLUITestIgnoreCertErrorsBySPKIHTTPS : public SSLUITest { protected: void SetUpCommandLine(base::CommandLine* command_line) override { SSLUITest::SetUpCommandLine(command_line); std::string whitelist_flag = MakeCertSPKIFingerprint( https_server_mismatched_.GetCertificate().get()); // Browser will ignore certificate errors for chains matching one of the // public keys from the list. command_line->AppendSwitchASCII( network::switches::kIgnoreCertificateErrorsSPKIList, whitelist_flag); } }; class SSLUITestIgnoreCertErrorsBySPKIWSS : public SSLUITest { public: SSLUITestIgnoreCertErrorsBySPKIWSS() : SSLUITest() {} void SetUpCommandLine(base::CommandLine* command_line) override { SSLUITest::SetUpCommandLine(command_line); std::string whitelist_flag = MakeCertSPKIFingerprint(wss_server_expired_.GetCertificate().get()); // Browser will ignore certificate errors for chains matching one of the // public keys from the list. command_line->AppendSwitchASCII( network::switches::kIgnoreCertificateErrorsSPKIList, whitelist_flag); } }; class SSLUITestIgnoreLocalhostCertErrors : public SSLUITest { public: SSLUITestIgnoreLocalhostCertErrors() : SSLUITest() {} void SetUpCommandLine(base::CommandLine* command_line) override { SSLUITest::SetUpCommandLine(command_line); // Browser will ignore certificate errors on localhost. command_line->AppendSwitch(switches::kAllowInsecureLocalhost); } }; class SSLUITestHSTS : public SSLUITest { public: void SetUpOnMainThread() override { SSLUITest::SetUpOnMainThread(); ssl_test_util::SetHSTSForHostName(browser()->GetProfile(), kHstsTestHostName); } }; class SSLUITestReduceSubresourceNotifications : public SSLUITestBase { public: SSLUITestReduceSubresourceNotifications() { scoped_feature_list_.InitWithFeatures( /*enabled_features=*/{features::kReduceSubresourceResponseStartedIPC}, GetDisabledFeatures()); } SSLUITestReduceSubresourceNotifications( const SSLUITestReduceSubresourceNotifications&) = delete; SSLUITestReduceSubresourceNotifications& operator=( const SSLUITestReduceSubresourceNotifications&) = delete; private: base::test::ScopedFeatureList scoped_feature_list_; }; // Visits a regular page over http. IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTP) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL("/ssl/google.html"))); ssl_test_util::CheckUnauthenticatedState( browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE); } // Visits a page over http which includes broken https resources (status should // be OK). // TODO(jcampan): test that bad HTTPS content is blocked (otherwise we'll give // the secure cookies away!). IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPWithBrokenHTTPSResource) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_with_unsafe_contents.html", https_server_expired_.host_port_pair()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL(replacement_path))); ssl_test_util::CheckUnauthenticatedState( browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE); } // Tests that after loading mixed content and then making a same-document // navigation, the mixed content security indicator remains. See // https://crbug.com/40094866. IN_PROC_BROWSER_TEST_F(SSLUITest, TestMixedContentWithSamePageNavigation) { ASSERT_TRUE(https_server_.Start()); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // Navigate to a secure page (no mixed content). ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Add a mixed form after a same-document navigation. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/google.html#foo"))); ssl_test_util::SecurityStateWebContentsObserver observer(tab); ASSERT_NE(false, content::EvalJs(tab, "var f = document.createElement('form');" "f.action = 'http://foo.test';" "document.body.appendChild(f)")); observer.WaitForDidChangeVisibleSecurityState(); // Since mixed forms trigger their own warning, we display the lock icon on // otherwise secure sites with an insecure form. security_state::SecurityLevel expected_level = security_state::SECURE; ssl_test_util::CheckSecurityState( tab, CertError::NONE, expected_level, AuthState::DISPLAYED_FORM_WITH_INSECURE_ACTION); // Go back (which should also be a same-document navigation) and test that the // security indicator is still downgraded because of the mixed form. chrome::GoBack(browser(), WindowOpenDisposition::CURRENT_TAB); EXPECT_TRUE(content::WaitForLoadStop(tab)); ssl_test_util::CheckSecurityState( tab, CertError::NONE, expected_level, AuthState::DISPLAYED_FORM_WITH_INSECURE_ACTION); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestBrokenHTTPSWithInsecureContent) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_displays_insecure_content.html", embedded_test_server()->host_port_pair()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL(replacement_path))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::DISPLAYED_INSECURE_CONTENT); } // Tests that the NavigationEntry gets marked as active mixed content, // even if there is a certificate error. Regression test for // https://crbug.com/41243626. IN_PROC_BROWSER_TEST_F(SSLUITest, TestBrokenHTTPSWithActiveInsecureContent) { ASSERT_TRUE(https_server_expired_.Start()); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(tab); // Navigate to a page with a certificate error and click through the // interstitial. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/title1.html"))); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); // Load an insecure (http://) script. When it is loaded, check that the page // is marked as having run insecure content. SSLContentStatusObserver observer(tab, content::SSLStatus::RAN_INSECURE_CONTENT); ASSERT_NE(false, content::EvalJs(tab, "var s = document.createElement('script');" "s.src = 'http://does-not-exist.test/foo.js';" "document.body.appendChild(s)")); observer.WaitForSSLContentStatusFlag(); // Now check that the page is marked as both having a cert error and having // run insecure content. ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::RAN_INSECURE_CONTENT); } // Tests that when a subframe commits a main resource with a certificate error, // the navigation entry is marked as insecure. IN_PROC_BROWSER_TEST_F(SSLUITestIgnoreCertErrors, SubframeHasCertError) { ASSERT_TRUE(https_server_mismatched_.Start()); // Load a page with a data: favicon URL to suppress a favicon request. A // favicon request can cause the navigation entry to get marked as having run // insecure content (favicons are treated as active content), which would // interfere with the test expectation below. GURL main_frame_url = https_server_mismatched_.GetURL("a.test", "/data_favicon.html"); EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(tab); EXPECT_FALSE( tab->GetController().GetLastCommittedEntry()->GetSSL().content_status & content::SSLStatus::RAN_CONTENT_WITH_CERT_ERRORS); GURL subframe_url = https_server_mismatched_.GetURL("b.test", "/data_favicon.html"); content::TestNavigationObserver iframe_observer(tab); EXPECT_TRUE(content::ExecJs( tab, content::JsReplace("var i = document.createElement('iframe');" "i.src = $1;" "document.body.appendChild(i);", subframe_url.spec()))); iframe_observer.Wait(); EXPECT_TRUE( tab->GetController().GetLastCommittedEntry()->GetSSL().content_status & content::SSLStatus::RAN_CONTENT_WITH_CERT_ERRORS); } namespace { // A WebContentsObserver that allows the user to wait for a same-document // navigation. Tests using this observer will fail if a non-same-document // navigation completes after calling WaitForSameDocumentNavigation. class SameDocumentNavigationObserver : public content::WebContentsObserver { public: explicit SameDocumentNavigationObserver(WebContents* web_contents) : WebContentsObserver(web_contents) {} ~SameDocumentNavigationObserver() override = default; void WaitForSameDocumentNavigation() { run_loop_.Run(); } // WebContentsObserver: void DidFinishNavigation( content::NavigationHandle* navigation_handle) override { ASSERT_TRUE(navigation_handle->IsSameDocument()); run_loop_.Quit(); } private: base::RunLoop run_loop_; }; } // namespace // Tests that the mixed content flags are reset when going back to an existing // navigation entry that had mixed content. Regression test for // https://crbug.com/41336817. IN_PROC_BROWSER_TEST_F(SSLUITest, GoBackToMixedContent) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); // Navigate to a URL and dynamically load mixed content. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); ssl_test_util::SecurityStateWebContentsObserver observer(tab); ASSERT_TRUE(content::ExecJs(tab, "var i = document.createElement('img');" "i.src = 'http://example.test';" "document.body.appendChild(i);")); observer.WaitForDidChangeVisibleSecurityState(); ssl_test_util::CheckSecurityState(tab, CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); // Now navigate somewhere else, and then back to the page that dynamically // loaded mixed content. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL("/ssl/google.html"))); ssl_test_util::CheckUnauthenticatedState( browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE); chrome::GoBack(browser(), WindowOpenDisposition::CURRENT_TAB); EXPECT_TRUE(content::WaitForLoadStop(tab)); // After going back, the mixed content indicator should no longer be present. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); } // Tests that the mixed content flags are not reset for an in-page navigation. IN_PROC_BROWSER_TEST_F(SSLUITest, MixedContentWithSameDocumentNavigation) { ASSERT_TRUE(https_server_.Start()); // Navigate to a URL and dynamically load mixed content. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); ssl_test_util::SecurityStateWebContentsObserver security_state_observer(tab); ASSERT_TRUE(content::ExecJs(tab, "var i = document.createElement('img');" "i.src = 'http://example.test';" "document.body.appendChild(i);")); security_state_observer.WaitForDidChangeVisibleSecurityState(); ssl_test_util::CheckSecurityState(tab, CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); // Initiate a same-document navigation and check that the page is still // marked as having displayed mixed content. SameDocumentNavigationObserver navigation_observer(tab); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/google.html#foo"))); navigation_observer.WaitForSameDocumentNavigation(); ssl_test_util::CheckSecurityState(tab, CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); } // Tests that the WebContents's flag for displaying content with cert // errors get cleared upon navigation. IN_PROC_BROWSER_TEST_F(SSLUITest, DisplayedContentWithCertErrorsClearedOnNavigation) { ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(tab); // Navigate to a page with a certificate error and click through the // interstitial. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/title1.html"))); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); // Add a subresource with a certificate error and check that it's recorded // correctly. We wait specifically for the DidDisplayContentWithCertErrors // event (rather than a DidChangeVisibleSecurityState event) because the // page's favicon is loaded as active content and the notification about that // can interfere with the visible security state change that we're observing // here. SSLContentStatusObserver observer( tab, content::SSLStatus::DISPLAYED_CONTENT_WITH_CERT_ERRORS); ASSERT_NE(false, content::EvalJs(tab, "var i = document.createElement('img');" "i.src = 'ssl/google_files/logo.gif';" "document.body.appendChild(i)")); observer.WaitForSSLContentStatusFlag(); // Navigate away to a different page, and check that the flag gets cleared. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/google.html"))); content::NavigationEntry* entry = tab->GetController().GetVisibleEntry(); ASSERT_TRUE(entry); EXPECT_FALSE(entry->GetSSL().content_status & content::SSLStatus::DISPLAYED_CONTENT_WITH_CERT_ERRORS); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestBrokenHTTPSMetricsReporting_Proceed) { ASSERT_TRUE(https_server_expired_.Start()); base::HistogramTester histograms; const std::string decision_histogram = "interstitial.ssl_overridable.decision"; const std::string interaction_histogram = "interstitial.ssl_overridable.interaction"; // Histograms should start off empty. histograms.ExpectTotalCount(decision_histogram, 0); histograms.ExpectTotalCount(interaction_histogram, 0); // After navigating to the page, the totals should be set. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/title1.html"))); ASSERT_TRUE(chrome_browser_interstitials::IsShowingInterstitial( browser()->tab_strip_model()->GetActiveWebContents())); histograms.ExpectTotalCount(decision_histogram, 1); histograms.ExpectBucketCount(decision_histogram, security_interstitials::MetricsHelper::SHOW, 1); histograms.ExpectTotalCount(interaction_histogram, 2); histograms.ExpectBucketCount( interaction_histogram, security_interstitials::MetricsHelper::TOTAL_VISITS, 1); histograms.ExpectBucketCount( interaction_histogram, security_interstitials::MetricsHelper::SHOW_ENHANCED_PROTECTION, 1); // Decision should be recorded. SendInterstitialCommand(browser()->tab_strip_model()->GetActiveWebContents(), security_interstitials::CMD_PROCEED); histograms.ExpectTotalCount(decision_histogram, 2); histograms.ExpectBucketCount( decision_histogram, security_interstitials::MetricsHelper::PROCEED, 1); histograms.ExpectTotalCount(interaction_histogram, 2); histograms.ExpectBucketCount( interaction_histogram, security_interstitials::MetricsHelper::TOTAL_VISITS, 1); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestBrokenHTTPSMetricsReporting_DontProceed) { ASSERT_TRUE(https_server_expired_.Start()); base::HistogramTester histograms; const std::string decision_histogram = "interstitial.ssl_overridable.decision"; const std::string interaction_histogram = "interstitial.ssl_overridable.interaction"; // Histograms should start off empty. histograms.ExpectTotalCount(decision_histogram, 0); histograms.ExpectTotalCount(interaction_histogram, 0); // After navigating to the page, the totals should be set. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/title1.html"))); ASSERT_TRUE(chrome_browser_interstitials::IsShowingInterstitial( browser()->tab_strip_model()->GetActiveWebContents())); histograms.ExpectTotalCount(decision_histogram, 1); histograms.ExpectBucketCount(decision_histogram, security_interstitials::MetricsHelper::SHOW, 1); histograms.ExpectTotalCount(interaction_histogram, 2); histograms.ExpectBucketCount( interaction_histogram, security_interstitials::MetricsHelper::TOTAL_VISITS, 1); histograms.ExpectBucketCount( interaction_histogram, security_interstitials::MetricsHelper::SHOW_ENHANCED_PROTECTION, 1); // Decision should be recorded. SendInterstitialCommand(browser()->tab_strip_model()->GetActiveWebContents(), security_interstitials::CMD_DONT_PROCEED); histograms.ExpectTotalCount(decision_histogram, 2); histograms.ExpectBucketCount( decision_histogram, security_interstitials::MetricsHelper::DONT_PROCEED, 1); histograms.ExpectTotalCount(interaction_histogram, 2); histograms.ExpectBucketCount( interaction_histogram, security_interstitials::MetricsHelper::TOTAL_VISITS, 1); } // Visits a page over OK https: IN_PROC_BROWSER_TEST_F(SSLUITest, TestOKHTTPS) { ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticatedState( browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE); } // Visits a page with https error and proceed: IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSExpiredCertAndProceed) { ASSERT_TRUE(https_server_expired_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/ssl/google.html"))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(chrome_browser_interstitials::IsShowingInterstitial(tab)); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::NONE); EXPECT_EQ(https_server_expired_.GetURL("/ssl/google.html"), tab->GetVisibleURL()); } // Visits a page with https error and checks favicon is not displayed: IN_PROC_BROWSER_TEST_F(SSLUITest, TestNoFaviconOnInterstitial) { ASSERT_TRUE(https_server_expired_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/ssl/google.html"))); tabs::TabInterface* const tab_interface = browser()->tab_strip_model()->GetActiveTab(); ASSERT_TRUE(chrome_browser_interstitials::IsShowingInterstitial( tab_interface->GetContents())); EXPECT_FALSE(TabUIHelper::From(tab_interface)->ShouldDisplayFavicon()); } // Visits a page with https error and don't proceed (and ensure we can still // navigate at that point): IN_PROC_BROWSER_TEST_F(SSLUITest, TestInterstitialCrossSiteNavigation) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_mismatched_.Start()); // First navigate to an OK page. GURL initial_url = https_server_.GetURL("/ssl/google.html"); ASSERT_EQ("127.0.0.1", initial_url.GetHost()); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), initial_url)); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // Navigate from 127.0.0.1 to localhost so it triggers a // cross-site navigation to make sure http://crbug.com/41235852 is gone. GURL cross_site_url = https_server_mismatched_.GetURL("/ssl/google.html"); ASSERT_EQ("localhost", cross_site_url.GetHost()); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), cross_site_url)); // An SSL interstitial should be showing. ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_COMMON_NAME_INVALID, AuthState::SHOWING_INTERSTITIAL); ASSERT_TRUE(chrome_browser_interstitials::IsShowingSSLInterstitial(tab)); // Simulate user clicking "Take me back". DontProceedThroughInterstitial(tab); // We should be back to the original good page. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Navigate to a new page to make sure bug 5800 is fixed. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL("/ssl/google.html"))); ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); } // Test that localhost pages don't show an interstitial. IN_PROC_BROWSER_TEST_F(SSLUITestIgnoreLocalhostCertErrors, TestNoInterstitialOnLocalhost) { ASSERT_TRUE(https_server_.Start()); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // Navigate to a localhost page. GURL url = https_server_.GetURL("/ssl/page_with_subresource.html"); GURL::Replacements replacements; std::string new_host("localhost"); replacements.SetHostStr(new_host); url = url.ReplaceComponents(replacements); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url)); // We should see no interstitial, but we should have an error // (red-crossed-out-https) in the URL bar. ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_COMMON_NAME_INVALID, AuthState::NONE); // We should see that the script tag in the page loaded and ran (and // wasn't blocked by the certificate error). std::u16string title; std::u16string expected_title = u"This script has loaded"; ui_test_utils::GetCurrentTabTitle(browser(), &title); EXPECT_EQ(title, expected_title); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSErrorCausedByClockUsingBuildTime) { ASSERT_TRUE(https_server_expired_.Start()); // Set up the build and current clock times to be more than a year apart. std::unique_ptr mock_clock( new base::SimpleTestClock()); mock_clock->SetNow(base::Time::NowFromSystemTime()); mock_clock->Advance(base::Days(367)); SSLErrorHandler::SetClockForTesting(mock_clock.get()); ssl_errors::SetBuildTimeForTesting(base::Time::NowFromSystemTime()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/title1.html"))); WebContents* clock_tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE( chrome_browser_interstitials::IsShowingBadClockInterstitial(clock_tab)); ssl_test_util::CheckSecurityState(clock_tab, net::CERT_STATUS_DATE_INVALID, security_state::DANGEROUS, AuthState::SHOWING_INTERSTITIAL); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSErrorCausedByClockUsingNetwork) { ASSERT_TRUE(https_server_expired_.Start()); // Set network forward ten minutes, which is sufficient to trigger // the interstitial. g_browser_process->network_time_tracker()->UpdateNetworkTime( base::Time::Now() + base::Minutes(10), base::Milliseconds(1), /* resolution */ base::Milliseconds(500), /* latency */ base::TimeTicks::Now() /* posting time of this update */); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/title1.html"))); WebContents* clock_tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE( chrome_browser_interstitials::IsShowingBadClockInterstitial(clock_tab)); ssl_test_util::CheckSecurityState(clock_tab, net::CERT_STATUS_DATE_INVALID, security_state::DANGEROUS, AuthState::SHOWING_INTERSTITIAL); } // Visits a page with https error and then goes back using Browser::GoBack. IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSExpiredCertAndGoBackViaButton) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); // First navigate to an HTTP page. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL("/ssl/google.html"))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // Now go to a bad HTTPS page that shows an interstitial. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); // Simulate user clicking on back button (crbug.com/40373975). chrome::GoBack(browser(), WindowOpenDisposition::CURRENT_TAB); EXPECT_TRUE(content::WaitForLoadStop(tab)); // We should be back at the original good page. EXPECT_FALSE(chrome_browser_interstitials::IsShowingInterstitial(tab)); ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); } // Visits a page with https error and then goes back using GoToOffset. IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSExpiredCertAndGoBackViaMenu) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); // First navigate to an HTTP page. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL("/ssl/google.html"))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // Now go to a bad HTTPS page that shows an interstitial. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); // Simulate user clicking and holding on back button (crbug.com/41106657). // With committed interstitials enabled, this triggers a navigation. content::TestNavigationObserver nav_observer(tab); tab->GetController().GoToOffset(-1); nav_observer.Wait(); // We should be back at the original good page. EXPECT_FALSE(chrome_browser_interstitials::IsShowingInterstitial(tab)); ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); } // Visits a page with https error and then goes back using the DONT_PROCEED // interstitial command. IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSExpiredCertGoBackUsingCommand) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); // First navigate to an HTTP page. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL("/ssl/google.html"))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // Now go to a bad HTTPS page that shows an interstitial. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); content::LoadStopObserver observer(tab); SendInterstitialCommand(tab, security_interstitials::CMD_DONT_PROCEED); observer.Wait(); // We should be back at the original good page. ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); } // Visits a page that uses a SHA-1 leaf certificate, which should be rejected. IN_PROC_BROWSER_TEST_F(SSLUITest, SHA1IsNotAllowed) { ASSERT_TRUE(https_server_sha1_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_sha1_.GetURL("/ssl/google.html"))); ssl_test_util::CheckAuthenticationBrokenState( browser()->tab_strip_model()->GetActiveWebContents(), net::CERT_STATUS_INVALID, AuthState::SHOWING_INTERSTITIAL); } // Visit a HTTP page which request WSS connection to a server providing invalid // certificate. Close the page while WSS connection waits for SSLManager's // response from UI thread. IN_PROC_BROWSER_TEST_F(SSLUITest, TestWSSInvalidCertAndClose) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(wss_server_expired_.Start()); // Setup page title observer. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); content::TitleWatcher watcher(tab, u"PASS"); watcher.AlsoWaitForTitle(u"FAIL"); // Create GURLs to test pages. std::string wss_close_url_path = base::StringPrintf( "%s?%d", embedded_test_server()->GetURL("/ssl/wss_close.html").spec().c_str(), wss_server_expired_.port()); GURL wss_close_url(wss_close_url_path); std::string wss_loop_url_path = base::StringPrintf( "%s?%d", embedded_test_server()->GetURL("/ssl/wss_close_loop.html").spec().c_str(), wss_server_expired_.port()); GURL wss_loop_url(wss_loop_url_path); // Create tabs and visit pages which keep on creating wss connections. std::array tabs; for (int i = 0; i < 16; ++i) { tabs[i] = chrome::AddSelectedTabWithURL(browser(), wss_loop_url, ui::PAGE_TRANSITION_LINK); } chrome::SelectNextTab(browser()); // Visit a page which waits for one TLS handshake failure. // The title will be changed to 'PASS'. ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), wss_close_url)); const std::u16string result = watcher.WaitAndGetTitle(); EXPECT_TRUE(base::EqualsCaseInsensitiveASCII(result, "pass")); // Close tabs which contains the test page. for (int i = 0; i < 16; ++i) { chrome::CloseWebContents(browser(), tabs[i], false); } chrome::CloseWebContents(browser(), tab, false); } // Visit a HTTPS page and proceeds despite an invalid certificate. The page // requests WSS connection to the same origin host to check if WSS connection // share certificates policy with HTTPS correcly. IN_PROC_BROWSER_TEST_F(SSLUITest, TestWSSInvalidCert) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(wss_server_expired_.Start()); // Setup page title observer. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); content::TitleWatcher watcher(tab, u"PASS"); watcher.AlsoWaitForTitle(u"FAIL"); // Visit bad HTTPS page. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), wss_server_expired_.GetURL("/websocket/connect_check.html"))); ASSERT_TRUE(chrome_browser_interstitials::IsShowingInterstitial(tab)); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); // Proceed anyway. ProceedThroughInterstitial(tab); // Test page run a WebSocket wss connection test. The result will be shown // as page title. const std::u16string result = watcher.WaitAndGetTitle(); EXPECT_TRUE(base::EqualsCaseInsensitiveASCII(result, "pass")); } // Data URLs should always be marked as non-secure. IN_PROC_BROWSER_TEST_F(SSLUITest, MarkDataAsNonSecure) { WebContents* contents = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(contents); ASSERT_TRUE( ui_test_utils::NavigateToURL(browser(), GURL("data:text/plain,hello"))); EXPECT_EQ(security_state::WARNING, chrome_security_state::GetSecurityLevel(contents)); } #if BUILDFLAG(USE_NSS_CERTS) class SSLUITestWithClientCert : public SSLUITestBase { public: SSLUITestWithClientCert() : cert_db_(nullptr) {} void SetUpOnMainThread() override { SSLUITestBase::SetUpOnMainThread(); base::RunLoop loop; NssServiceFactory::GetForContext(browser()->GetProfile()) ->UnsafelyGetNSSCertDatabaseForTesting( base::BindOnce(&SSLUITestWithClientCert::DidGetCertDatabase, base::Unretained(this), &loop)); loop.Run(); } protected: void DidGetCertDatabase(base::RunLoop* loop, net::NSSCertDatabase* cert_db) { cert_db_ = cert_db; loop->Quit(); } raw_ptr cert_db_; }; // SSL client certificate tests are only enabled when using NSS for private key // storage, as only NSS can avoid modifying global machine state when testing. // See http://crbug.com/41189152 // Visit a HTTPS page which requires client cert authentication. The client // cert will be selected automatically, then a test which uses WebSocket runs. // // TODO(crbug.com/40811167): disabled because of race in when certs // are incorporated. IN_PROC_BROWSER_TEST_F(SSLUITestWithClientCert, DISABLED_TestWSSClientCert) { // Import a client cert for test. crypto::ScopedPK11Slot public_slot = cert_db_->GetPublicSlot(); std::string pkcs12_data; base::FilePath cert_path = net::GetTestCertsDirectory().Append( FILE_PATH_LITERAL("websocket_client_cert.p12")); { base::ScopedAllowBlockingForTesting allow_blocking; EXPECT_TRUE(base::ReadFileToString(cert_path, &pkcs12_data)); } EXPECT_EQ(net::OK, cert_db_->ImportFromPKCS12(public_slot.get(), pkcs12_data, std::u16string(), true, nullptr)); // Start WebSocket test server with TLS and client cert authentication. net::EmbeddedTestServer wss_server(net::EmbeddedTestServer::Type::TYPE_HTTP); { net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT; wss_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config); } net::test_server::InstallDefaultWebSocketHandlers(&wss_server); wss_server.AddDefaultHandlers(GetChromeTestDataDir()); ASSERT_TRUE(wss_server.Start()); GURL url = wss_server.GetURL("/websocket/connect_check.html"); // Setup page title observer. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); content::TitleWatcher watcher(tab, u"PASS"); watcher.AlsoWaitForTitle(u"FAIL"); // Add an entry into AutoSelectCertificateForUrls policy for automatic client // cert selection. Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext()); DCHECK(profile); base::DictValue filter; filter.SetByDottedPath("ISSUER.CN", "Test Root CA"); base::ListValue filters; filters.Append(std::move(filter)); base::DictValue setting; setting.Set("filters", std::move(filters)); HostContentSettingsMapFactory::GetForProfile(profile) ->SetWebsiteSettingDefaultScope( url, GURL(), ContentSettingsType::AUTO_SELECT_CERTIFICATE, base::Value(std::move(setting))); // Visit a HTTPS page which requires client certs. ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url)); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Test page runs a WebSocket wss connection test. The result will be shown // as page title. const std::u16string result = watcher.WaitAndGetTitle(); EXPECT_TRUE(base::EqualsCaseInsensitiveASCII(result, "pass")); } #endif // BUILDFLAG(USE_NSS_CERTS) // A stub ClientCertStore that returns a FakeClientCertIdentity. class ClientCertStoreStub : public net::ClientCertStore { public: explicit ClientCertStoreStub(net::ClientCertIdentityList list) : list_(std::move(list)) {} ~ClientCertStoreStub() override = default; // net::ClientCertStore: void GetClientCerts( scoped_refptr cert_request_info, ClientCertListCallback callback) override { std::move(callback).Run(std::move(list_)); } private: net::ClientCertIdentityList list_; }; std::unique_ptr CreateCertStore() { base::FilePath certs_dir = net::GetTestCertsDirectory(); net::ClientCertIdentityList cert_identity_list; { base::ScopedAllowBlockingForTesting allow_blocking; std::unique_ptr cert_identity = net::FakeClientCertIdentity::CreateFromCertAndKeyFiles( certs_dir, "client_1.pem", "client_1.pk8"); EXPECT_TRUE(cert_identity.get()); if (cert_identity) { cert_identity_list.push_back(std::move(cert_identity)); } } return std::unique_ptr( new ClientCertStoreStub(std::move(cert_identity_list))); } std::unique_ptr CreateFailSigningCertStore() { base::FilePath certs_dir = net::GetTestCertsDirectory(); net::ClientCertIdentityList cert_identity_list; { base::ScopedAllowBlockingForTesting allow_blocking; std::unique_ptr cert_identity = net::FakeClientCertIdentity::CreateFromCertAndFailSigning( certs_dir, "client_1.pem"); EXPECT_TRUE(cert_identity.get()); if (cert_identity) { cert_identity_list.push_back(std::move(cert_identity)); } } return std::unique_ptr( new ClientCertStoreStub(std::move(cert_identity_list))); } std::unique_ptr CreateEmptyCertStore() { return std::unique_ptr(new ClientCertStoreStub({})); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestBrowserUseClientCertStore) { // Make the browser use the ClientCertStoreStub instead of the regular one. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateCertStore)); net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS); net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT; https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config); https_server.ServeFilesFromSourceDirectory("chrome/test/data"); ASSERT_TRUE(https_server.Start()); GURL https_url = https_server.GetURL("/ssl/browser_use_client_cert_store.html"); // Add an entry into AutoSelectCertificateForUrls policy for automatic client // cert selection. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext()); DCHECK(profile); // This reproduces the AutoSelectCertificateForUrls policy payload: an array // of JSON dictionaries, each containing optional filters. An empty filter // dictionary means “allow any matching certificate”, which is enough for the // test to auto-select the single certificate offered by the stub store. base::ListValue filters; filters.Append(base::DictValue()); base::DictValue setting; setting.Set("filters", std::move(filters)); HostContentSettingsMapFactory::GetForProfile(profile) ->SetWebsiteSettingDefaultScope( https_url, GURL(), ContentSettingsType::AUTO_SELECT_CERTIFICATE, base::Value(std::move(setting))); // Visit a HTTPS page which requires client certs. ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); EXPECT_EQ("pass", tab->GetLastCommittedURL().GetRef()); } // Tests that dynamically updating AutoSelectCertificateForUrls content setting // triggers the network service to pick up the change and allows automatic // client cert selection without requiring a browser restart. IN_PROC_BROWSER_TEST_F(SSLUITest, TestBrowserUseClientCertStoreDynamicUpdate) { // 1. Setup: Full Cert Store. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateCertStore)); net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS); net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT; https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config); https_server.ServeFilesFromSourceDirectory("chrome/test/data"); ASSERT_TRUE(https_server.Start()); GURL https_url = https_server.GetURL("/ssl/browser_use_client_cert_store.html"); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext()); DCHECK(profile); // 2. Initial Navigation (No Policy) -> Fail. // Install a hook to auto-cancel the certificate selector prompt. SetShowSSLClientCertificateSelectorHookForTest(base::BindRepeating( [](content::WebContents* contents, net::SSLCertRequestInfo* cert_request_info, net::ClientCertIdentityList client_certs, std::unique_ptr delegate) { delegate->ContinueWithCertificate(nullptr, nullptr); return base::OnceClosure(); })); ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); // Expect failure (did not reach "pass"). EXPECT_NE("pass", tab->GetLastCommittedURL().GetRef()); // 3. Set AutoSelect Policy. base::ListValue filters; filters.Append(base::DictValue()); base::DictValue setting; setting.Set("filters", std::move(filters)); HostContentSettingsMapFactory::GetForProfile(profile) ->SetWebsiteSettingDefaultScope( https_url, GURL(), ContentSettingsType::AUTO_SELECT_CERTIFICATE, base::Value(std::move(setting))); // 4. Retry Navigation -> Expect Success. // The policy should cause auto-selection, bypassing the selector hook. ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); EXPECT_EQ("pass", tab->GetLastCommittedURL().GetRef()); // Cleanup hook. SetShowSSLClientCertificateSelectorHookForTest( ShowSSLClientCertificateSelectorTestingHook()); } // Tests that requests from service workers can also use certificates // auto-selected by policy. // https://crbug.com/40894162. IN_PROC_BROWSER_TEST_F(SSLUITest, TestServiceWorkerRequestsUseClientCertStore) { // Make the browser use the ClientCertStoreStub instead of the regular one. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateCertStore)); net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS); { net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT; https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_TEST_NAMES, ssl_config); } https_server.ServeFilesFromSourceDirectory("chrome/test/data"); ASSERT_TRUE(https_server.Start()); // We set up a page that installs a service worker to perform a fetch to // a separate, cross-origin resource. We need this to be a cross-origin // because visiting the first site (to install the service worker) requires // a cert to be present, so subsequent fetches to that site will succeed // without a separate certificate prompt. // Note: These domain names need to match those in // //net/data/ssl/certificates/test_names.pem. GURL requestor_url = https_server.GetURL("a.test", "/ssl/service_worker_fetch/page.html"); GURL target_url = https_server.GetURL("b.test", "/ssl/service_worker_fetch/target.txt"); // Add an entry into AutoSelectCertificateForUrls policy for automatic client // cert selection for both the requestor and target URLs. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext()); DCHECK(profile); base::ListValue filters; filters.Append(base::DictValue()); base::DictValue setting; setting.Set("filters", std::move(filters)); HostContentSettingsMapFactory::GetForProfile(profile) ->SetWebsiteSettingDefaultScope( requestor_url, GURL(), ContentSettingsType::AUTO_SELECT_CERTIFICATE, base::Value(setting.Clone())); HostContentSettingsMapFactory::GetForProfile(profile) ->SetWebsiteSettingDefaultScope( target_url, GURL(), ContentSettingsType::AUTO_SELECT_CERTIFICATE, base::Value(std::move(setting))); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), requestor_url)); content::WebContents* web_contents = browser()->tab_strip_model()->GetActiveWebContents(); // Check the navigation succeeded. The title check verifies we didn't e.g. // get a privacy error. EXPECT_EQ(requestor_url, web_contents->GetLastCommittedURL()); EXPECT_EQ(u"My Title", web_contents->GetTitle()); // Perform a fetch from a worker and validate that it succeeds. EXPECT_EQ( "text content\n", content::EvalJs(web_contents, content::JsReplace("doFetchInWorker($1);", target_url))); } // Tests that if an extension service worker requests a resource where a // client cert is optional (not required) and there are no client certs, the // request will continue without a certificate (as opposed to abort). #if BUILDFLAG(ENABLE_EXTENSIONS) && !BUILDFLAG(IS_ANDROID) IN_PROC_BROWSER_TEST_F( SSLUITest, TestExtensionServiceWorkerCanContinueWithoutACertificate) { // TODO(https://crbug.com/40804030): Remove this when updated to use MV3. extensions::ScopedTestMV2Enabler mv2_enabler; // Make the browser use the ClientCertStoreStub instead of the regular one. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateEmptyCertStore)); // Set up an HTTPS server with optional client certs. net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS); { net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::OPTIONAL_CLIENT_CERT; https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_TEST_NAMES, ssl_config); } https_server.ServeFilesFromSourceDirectory("chrome/test/data"); ASSERT_TRUE(https_server.Start()); // Load a test extension that will try to fetch the cross-origin resource. static constexpr char kManifest[] = R"({ "name": "Fetching Extension", "manifest_version": 2, "version": "0.1", "background": {"service_worker": "background.js"} })"; static constexpr char kBackgroundJs[] = R"(async function doFetchAndReply(url) { try { let response = await fetch(url); result = await response.text(); } catch (e) { result = `Fetch error: ${e.toString()}`; } chrome.test.sendScriptResult(result); })"; extensions::TestExtensionDir test_dir; test_dir.WriteManifest(kManifest); test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); Profile* const profile = browser()->GetProfile(); extensions::ChromeTestExtensionLoader extension_loader(profile); scoped_refptr extension = extension_loader.LoadExtension(test_dir.UnpackedPath()); ASSERT_TRUE(extension); // Path to the cross-origin resource to fetch. // Note: This domain name matches one in // //net/data/ssl/certificates/test_names.pem. GURL target_url = https_server.GetURL("b.test", "/ssl/service_worker_fetch/target.txt"); // Try to fetch the resource from the extension. We have no client certs // (we're using an empty cert store), so no certificates will be selected. // Even so, the fetch should succeed. It continues without a certificate, and // the certificate is optional. base::Value fetch_result = extensions::BackgroundScriptExecutor::ExecuteScript( profile, extension->id(), base::StringPrintf("doFetchAndReply('%s');", target_url.spec().c_str()), extensions::BackgroundScriptExecutor::ResultCapture:: kSendScriptResult); EXPECT_EQ(fetch_result, "text content\n"); } #endif // BUILDFLAG(ENABLE_EXTENSIONS) IN_PROC_BROWSER_TEST_F(SSLUITest, TestClientAuthSigningFails) { // Make the browser use the ClientCertStoreStub instead of the regular one. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateFailSigningCertStore)); net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS); net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT; https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config); https_server.ServeFilesFromSourceDirectory("chrome/test/data"); ASSERT_TRUE(https_server.Start()); GURL https_url = https_server.GetURL("/ssl/browser_use_client_cert_store.html"); // Add an entry into AutoSelectCertificateForUrls policy for automatic client // cert selection. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext()); DCHECK(profile); base::ListValue filters; filters.Append(base::DictValue()); base::DictValue setting; setting.Set("filters", std::move(filters)); HostContentSettingsMapFactory::GetForProfile(profile) ->SetWebsiteSettingDefaultScope( https_url, GURL(), ContentSettingsType::AUTO_SELECT_CERTIFICATE, base::Value(std::move(setting))); // Visit a HTTPS page which requires client certs. ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); // Page should not load successfully. EXPECT_EQ("", tab->GetLastCommittedURL().GetRef()); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestClientAuthContinueWithoutCert) { // Make the browser use a ClientCertStoreStub that returns no certs. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateEmptyCertStore)); net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS); net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT; https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config); https_server.ServeFilesFromSourceDirectory("chrome/test/data"); ASSERT_TRUE(https_server.Start()); GURL https_url = https_server.GetURL("/ssl/browser_use_client_cert_store.html"); // Visit a HTTPS page which requires client certs. // The browser should automatically continue to the site without a client // cert, since the ClientCertStore returns no certs. ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // Page should not load successfully. EXPECT_EQ("", tab->GetLastCommittedURL().GetRef()); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestCertDBChangedFlushesClientAuthCache) { // Make the browser use the ClientCertStoreStub instead of the regular one. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateCertStore)); net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS); net::SSLServerConfig ssl_config; ssl_config.client_cert_type = net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT; https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config); https_server.ServeFilesFromSourceDirectory("chrome/test/data"); ASSERT_TRUE(https_server.Start()); GURL https_url = https_server.GetURL("/ssl/browser_use_client_cert_store.html"); // Add an entry into AutoSelectCertificateForUrls policy for automatic client // cert selection. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext()); DCHECK(profile); base::ListValue filters; filters.Append(base::DictValue()); base::DictValue setting; setting.Set("filters", std::move(filters)); HostContentSettingsMapFactory::GetForProfile(profile) ->SetWebsiteSettingDefaultScope( https_url, GURL(), ContentSettingsType::AUTO_SELECT_CERTIFICATE, base::Value(std::move(setting))); // Visit a HTTPS page which requires client certs. ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); EXPECT_EQ("pass", tab->GetLastCommittedURL().GetRef()); ui_test_utils::NavigateToURLBlockUntilNavigationsComplete( browser(), GURL("about:blank"), 1); EXPECT_EQ("", tab->GetLastCommittedURL().GetRef()); // Now use a ClientCertStoreStub that always returns an empty list. ProfileNetworkContextServiceFactory::GetForContext(browser()->GetProfile()) ->set_client_cert_store_factory_for_testing( base::BindRepeating(&CreateEmptyCertStore)); // Visiting the page which requires client certs should still work (either // due to the socket still being open, or due to the SSL client auth cache). ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); EXPECT_EQ("pass", tab->GetLastCommittedURL().GetRef()); ui_test_utils::NavigateToURLBlockUntilNavigationsComplete( browser(), GURL("about:blank"), 1); EXPECT_EQ("", tab->GetLastCommittedURL().GetRef()); // Send an OnClientCertStoreChanged notification. net::CertDatabase::GetInstance()->NotifyObserversClientCertStoreChanged(); content::FlushNetworkServiceInstanceForTesting(); // Visiting the page which requires client certs should fail, as the socket // pool has been flushed and SSL client auth cache has been cleared due to // the CertDBChanged observer. ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), https_url, 1); EXPECT_EQ("", tab->GetLastCommittedURL().GetRef()); } // Open a page with a HTTPS error in a tab with no prior navigation (through a // link with a blank target). This is to test that the lack of navigation entry // does not cause any problems (it was causing a crasher, see // http://crbug.com/40981931). IN_PROC_BROWSER_TEST_F(SSLUITest, TestHTTPSErrorWithNoNavEntry) { ASSERT_TRUE(https_server_expired_.Start()); const GURL url = https_server_expired_.GetURL("/ssl/google.htm"); WebContents* tab2 = chrome::AddSelectedTabWithURL(browser(), url, ui::PAGE_TRANSITION_TYPED); content::WaitForLoadStop(tab2); // Verify our assumption that there was no prior navigation. EXPECT_FALSE(chrome::CanGoBack(browser())); // We should have an interstitial page showing. ASSERT_TRUE(chrome_browser_interstitials::IsShowingSSLInterstitial(tab2)); } IN_PROC_BROWSER_TEST_F(SSLUITest, TestBadHTTPSDownload) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); GURL url_non_dangerous = embedded_test_server()->GetURL("/title1.html"); GURL url_dangerous = https_server_expired_.GetURL("/downloads/dangerous/dangerous.exe"); // Visit a non-dangerous page. ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url_non_dangerous)); // Now, start a transition to dangerous download. { WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); content::LoadStopObserver observer(tab); NavigateParams navigate_params(browser(), url_dangerous, ui::PAGE_TRANSITION_TYPED); Navigate(&navigate_params); observer.Wait(); } // Proceed through the SSL interstitial. This doesn't use // ProceedThroughInterstitial() since no page load will commit. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(tab); ASSERT_TRUE(chrome_browser_interstitials::IsShowingSSLInterstitial(tab)); { // Wait for the download to complete after proceeding with the download. // This serves to verify the download was initiated, and to let the // test successfully shut down and cleanup. Exiting the browser with a // download still in-progress can lead to test failues. content::DownloadTestObserverTerminal dangerous_download_observer( browser()->GetProfile()->GetDownloadManager(), 1, content::DownloadTestObserver::ON_DANGEROUS_DOWNLOAD_ACCEPT); SendInterstitialCommand(tab, security_interstitials::CMD_PROCEED); dangerous_download_observer.WaitForFinished(); } // There should still be an interstitial at this point. Press the // back button on the browser. Note that this doesn't wait for a // NAV_ENTRY_COMMITTED notification because going back with an // active interstitial simply hides the interstitial. ASSERT_TRUE(chrome_browser_interstitials::IsShowingSSLInterstitial(tab)); EXPECT_TRUE(chrome::CanGoBack(browser())); chrome::GoBack(browser(), WindowOpenDisposition::CURRENT_TAB); } // // Insecure content // // Visits a page that displays insecure content. IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysInsecureContent) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_displays_insecure_content.html", embedded_test_server()->host_port_pair()); // Load a page that displays insecure content. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL(replacement_path))); ssl_test_util::CheckSecurityState( browser()->tab_strip_model()->GetActiveWebContents(), CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); } // Visits a page that displays an insecure form. IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysInsecureForm) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_displays_insecure_form.html", embedded_test_server()->host_port_pair()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL(replacement_path))); // Since mixed forms trigger their own warning, we display the lock icon on // otherwise secure sites with an insecure form. security_state::SecurityLevel expected_level = security_state::SECURE; ssl_test_util::CheckSecurityState( browser()->tab_strip_model()->GetActiveWebContents(), CertError::NONE, expected_level, AuthState::DISPLAYED_FORM_WITH_INSECURE_ACTION); } // Verifies that an SSL interstitial generates SafeBrowsing extension api // events. IN_PROC_BROWSER_TEST_F(SSLUITest, TestExtensionEvents) { class ExtensionEventObserver : public extensions::EventRouter::TestObserver { public: ExtensionEventObserver() = default; ExtensionEventObserver(const ExtensionEventObserver&) = delete; ExtensionEventObserver& operator=(const ExtensionEventObserver&) = delete; ~ExtensionEventObserver() override = default; // extensions::EventRouter::TestObserver: void OnWillDispatchEvent(const extensions::Event& event) override { event_names_.push_back(event.event_name); } void OnDidDispatchEventToProcess(const extensions::Event& event, int process_id) override {} const std::vector& event_names() const { return event_names_; } private: std::vector event_names_; }; ExtensionEventObserver observer; extensions::EventRouter::Get(browser()->GetProfile()) ->AddObserverForTesting(&observer); ASSERT_TRUE(https_server_expired_.Start()); GURL request_url = https_server_expired_.GetURL("/title1.html"); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), request_url)); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(tab != nullptr); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); // Verifies that security interstitial shown event is observed. EXPECT_TRUE(std::ranges::contains( observer.event_names(), extensions::api::safe_browsing_private:: OnSecurityInterstitialShown::kEventName)); ProceedThroughInterstitial(tab); // Verifies that security interstitial proceeded event is observed. EXPECT_TRUE(std::ranges::contains( observer.event_names(), extensions::api::safe_browsing_private:: OnSecurityInterstitialProceeded::kEventName)); extensions::EventRouter::Get(browser()->GetProfile()) ->RemoveObserverForTesting(&observer); } // Visits a page that runs insecure content and tries to suppress the insecure // content warnings by randomizing location.hash. // Based on http://crbug.com/40092102 IN_PROC_BROWSER_TEST_F(SSLUITest, TestRunsInsecuredContentRandomizeHash) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/page_runs_insecure_content.html"))); ssl_test_util::CheckAuthenticationBrokenState( browser()->tab_strip_model()->GetActiveWebContents(), CertError::NONE, AuthState::RAN_INSECURE_CONTENT); } // Visits an SSL page twice, once with subresources served over good SSL and // once over bad SSL. // - For the good SSL case, the iframe and images should be properly displayed. // - For the bad SSL case, the iframe contents shouldn't be displayed and images // and scripts should be filtered out entirely. IN_PROC_BROWSER_TEST_F(SSLUITest, TestUnsafeContents) { ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); // Enable popups without user gesture. HostContentSettingsMapFactory::GetForProfile(browser()->GetProfile()) ->SetDefaultContentSetting(ContentSettingsType::POPUPS, CONTENT_SETTING_ALLOW); { // First visit the page with its iframe and subresources served over good // SSL. This is a sanity check to make sure these resources aren't already // broken in the good case. std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_with_unsafe_contents.html", https_server_.host_port_pair()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL(replacement_path))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // The state is expected to be authenticated. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // The iframe should be able to open a popup. EXPECT_EQ(2u, ProfileBrowserCollection::GetForProfile(browser()->GetProfile()) ->GetSize()); // In order to check that the image was loaded, check its width. // The actual image (Google logo) is 276 pixels wide. EXPECT_EQ(276, content::EvalJs(tab, "ImageWidth();")); // Check that variable |foo| is set. EXPECT_EQ(true, content::EvalJs(tab, "IsFooSet();")); } { // Now visit the page with its iframe and subresources served over bad // SSL. Iframes, images, and scripts should all be blocked. std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_with_unsafe_contents.html", https_server_expired_.host_port_pair()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL(replacement_path))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // When the bad content is filtered, the state is expected to be // authenticated. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // The iframe attempts to open a popup window, but it shouldn't be able to. // Previous popup is still open. EXPECT_EQ(2u, ProfileBrowserCollection::GetForProfile(browser()->GetProfile()) ->GetSize()); // The broken image width is zero. EXPECT_EQ(16, content::EvalJs(tab, "ImageWidth();")); // Check that variable |foo| is not set. EXPECT_EQ(false, content::EvalJs(tab, "IsFooSet();")); } } // Visits a page with insecure content loaded by JS (after the initial page // load). #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) // flaky http://crbug.com/40375913 #define MAYBE_TestDisplaysInsecureContentLoadedFromJS \ DISABLED_TestDisplaysInsecureContentLoadedFromJS #else #define MAYBE_TestDisplaysInsecureContentLoadedFromJS \ TestDisplaysInsecureContentLoadedFromJS #endif IN_PROC_BROWSER_TEST_F(SSLUITest, MAYBE_TestDisplaysInsecureContentLoadedFromJS) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); net::HostPortPair replacement_pair = embedded_test_server()->host_port_pair(); replacement_pair.set_host("example.test"); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_with_dynamic_insecure_content.html", replacement_pair); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL(replacement_path))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Load the insecure image. EXPECT_EQ(true, content::EvalJs(tab, "loadBadImage();")); // We should now have insecure content. ssl_test_util::CheckSecurityState(tab, CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); } // Visits two pages from the same origin: one that displays insecure content and // one that doesn't. The test checks that we do not propagate the insecure // content state from one to the other. IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysInsecureContentTwoTabs) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/blank_page.html"))); WebContents* tab1 = browser()->tab_strip_model()->GetActiveWebContents(); // This tab should be fine. ssl_test_util::CheckAuthenticatedState(tab1, AuthState::NONE); // Create a new tab. std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_displays_insecure_content.html", embedded_test_server()->host_port_pair()); GURL url = https_server_.GetURL(replacement_path); NavigateParams params(browser(), url, ui::PAGE_TRANSITION_TYPED); params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB; params.tabstrip_index = 0; params.source_contents = tab1; Navigate(¶ms); WebContents* tab2 = params.navigated_or_inserted_contents; EXPECT_TRUE(content::WaitForLoadStop(tab2)); // The new tab has insecure content. ssl_test_util::CheckSecurityState(tab2, CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); // The original tab should not be contaminated. ssl_test_util::CheckAuthenticatedState(tab1, AuthState::NONE); } // Visits two pages from the same origin: one that runs insecure content and one // that doesn't. The test checks that we propagate the insecure content state // from one to the other. // TODO(crbug.com/40709634): Flaky IN_PROC_BROWSER_TEST_F(SSLUITest, DISABLED_TestRunsInsecureContentTwoTabs) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/blank_page.html"))); WebContents* tab1 = browser()->tab_strip_model()->GetActiveWebContents(); // This tab should be fine. ssl_test_util::CheckAuthenticatedState(tab1, AuthState::NONE); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_runs_insecure_content.html", embedded_test_server()->host_port_pair()); // Create a new tab in the same process. Using a NEW_FOREGROUND_TAB // disposition won't usually stay in the same process, but this works // because we are using process-per-site in SetUpCommandLine. GURL url = https_server_.GetURL(replacement_path); NavigateParams params(browser(), url, ui::PAGE_TRANSITION_TYPED); params.disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB; params.source_contents = tab1; Navigate(¶ms); WebContents* tab2 = params.navigated_or_inserted_contents; EXPECT_TRUE(content::WaitForLoadStop(tab2)); // Both tabs should have the same process. EXPECT_EQ(tab1->GetPrimaryMainFrame()->GetProcess(), tab2->GetPrimaryMainFrame()->GetProcess()); // The new tab has insecure content. ssl_test_util::CheckAuthenticationBrokenState( tab2, CertError::NONE, AuthState::RAN_INSECURE_CONTENT); // Which means the origin for the first tab has also been contaminated with // insecure content. ssl_test_util::CheckAuthenticationBrokenState( tab1, CertError::NONE, AuthState::RAN_INSECURE_CONTENT); } // Visits a page with an image over http. Visits another page over https // referencing that same image over http (hoping it is coming from the webcore // memory cache). IN_PROC_BROWSER_TEST_F(SSLUITest, TestDisplaysCachedInsecureContent) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_displays_insecure_content.html", embedded_test_server()->host_port_pair()); // Load original page over HTTP. const GURL url_http = embedded_test_server()->GetURL(replacement_path); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url_http)); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); // Load again but over SSL. It should be marked as displaying insecure // content (even though the image comes from the WebCore memory cache). const GURL url_https = https_server_.GetURL(replacement_path); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url_https)); ssl_test_util::CheckSecurityState(tab, CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); } // Visits a page with script over http. Visits another page over https // referencing that same script over http (hoping it is coming from the webcore // memory cache). IN_PROC_BROWSER_TEST_F(SSLUITest, TestRunsCachedInsecureContent) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_runs_insecure_content.html", embedded_test_server()->host_port_pair()); // Load original page over HTTP. const GURL url_http = embedded_test_server()->GetURL(replacement_path); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url_http)); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); // Load again but over SSL. It should be marked as displaying insecure // content (even though the image comes from the WebCore memory cache). const GURL url_https = https_server_.GetURL(replacement_path); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url_https)); ssl_test_util::CheckAuthenticationBrokenState( tab, CertError::NONE, AuthState::RAN_INSECURE_CONTENT); } // This test ensures the CN invalid status does not 'stick' to a certificate // (see bug #1044942) and that it depends on the host-name. // Test if disabled due to flakiness http://crbug.com/41104365 . IN_PROC_BROWSER_TEST_F(SSLUITest, DISABLED_TestCNInvalidStickiness) { ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_mismatched_.Start()); // First we hit the server with hostname, this generates an invalid policy // error. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_mismatched_.GetURL("/ssl/google.html"))); // We get an interstitial page as a result. WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_COMMON_NAME_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_COMMON_NAME_INVALID, AuthState::NONE); // Now we try again with the right host name this time. GURL url(https_server_.GetURL("/ssl/google.html")); ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url)); // Security state should be OK. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Now try again the broken one to make sure it is still broken. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_mismatched_.GetURL("/ssl/google.html"))); // Since we OKed the interstitial last time, we get right to the page. ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_COMMON_NAME_INVALID, AuthState::NONE); } // Test that navigating to a #ref does not change a bad security state. IN_PROC_BROWSER_TEST_F(SSLUITest, TestRefNavigation) { ASSERT_TRUE(https_server_expired_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/ssl/page_with_refs.html"))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::NONE); // Now navigate to a ref in the page, the security state should not have // changed. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL("/ssl/page_with_refs.html#jp"))); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::NONE); } // Tests that closing a page that opened a pop-up with an interstitial does not // crash the browser (crbug.com/40979342). // TODO(crbug.com/40714131, crbug.com/40848837): Test is flaky on Linux and // Chrome OS. #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) #define MAYBE_TestCloseTabWithUnsafePopup DISABLED_TestCloseTabWithUnsafePopup #else #define MAYBE_TestCloseTabWithUnsafePopup TestCloseTabWithUnsafePopup #endif IN_PROC_BROWSER_TEST_F(SSLUITest, MAYBE_TestCloseTabWithUnsafePopup) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); // Enable popups without user gesture. HostContentSettingsMapFactory::GetForProfile(browser()->GetProfile()) ->SetDefaultContentSetting(ContentSettingsType::POPUPS, CONTENT_SETTING_ALLOW); std::string replacement_path = GetFilePathWithHostAndPortReplacement( "/ssl/page_with_unsafe_popup.html", https_server_expired_.host_port_pair()); WebContents* tab1 = browser()->tab_strip_model()->GetActiveWebContents(); content::TestNavigationObserver nav_observer( https_server_expired_.GetURL("/ssl/bad_iframe.html")); nav_observer.StartWatchingNewWebContents(); ASSERT_EQ(1u, ProfileBrowserCollection::GetForProfile(browser()->GetProfile()) ->GetSize()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL(replacement_path))); ASSERT_EQ(2u, ProfileBrowserCollection::GetForProfile(browser()->GetProfile()) ->GetSize()); // Last activated browser should be the popup. BrowserWindowInterface* popup_browser = ProfileBrowserCollection::GetForProfile(browser()->GetProfile()) ->GetLastActiveBrowser(); WebContents* popup = popup_browser->GetTabStripModel()->GetActiveWebContents(); EXPECT_NE(popup, tab1); nav_observer.Wait(); ASSERT_TRUE(popup->GetController().GetVisibleEntry()); EXPECT_EQ(https_server_expired_.GetURL("/ssl/bad_iframe.html"), popup->GetController().GetVisibleEntry()->GetURL()); // The interstitial showing is posted to the message loop and this happens // after the navigation, so we need to additionally wait for that to be // processed. base::RunLoop().RunUntilIdle(); EXPECT_TRUE(chrome_browser_interstitials::IsShowingInterstitial(popup)); // Add another tab to make sure the browser does not exit when we close // the first tab. GURL url = embedded_test_server()->GetURL("/ssl/google.html"); auto* contents = chrome::AddSelectedTabWithURL(browser(), url, ui::PAGE_TRANSITION_TYPED); EXPECT_TRUE(content::WaitForLoadStop(contents)); // Close the first tab. chrome::CloseWebContents(browser(), tab1, false); } // Visit a page over bad https that is a redirect to a page with good https. IN_PROC_BROWSER_TEST_F(SSLUITest, TestRedirectBadToGoodHTTPS) { ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); GURL url1 = https_server_expired_.GetURL("/server-redirect?"); GURL url2 = https_server_.GetURL("/ssl/google.html"); ASSERT_TRUE( ui_test_utils::NavigateToURL(browser(), GURL(url1.spec() + url2.spec()))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); // We have been redirected to the good page. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); } // Visit a page over good https that is a redirect to a page with bad https. IN_PROC_BROWSER_TEST_F(SSLUITest, TestRedirectGoodToBadHTTPS) { ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); GURL url1 = https_server_.GetURL("/server-redirect?"); GURL url2 = https_server_expired_.GetURL("/ssl/google.html"); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE( ui_test_utils::NavigateToURL(browser(), GURL(url1.spec() + url2.spec()))); ASSERT_TRUE(chrome_browser_interstitials::IsShowingInterstitial(tab)); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::NONE); } // Visit a page over http that is a redirect to a page with good HTTPS. IN_PROC_BROWSER_TEST_F(SSLUITest, TestRedirectHTTPToGoodHTTPS) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); // HTTP redirects to good HTTPS. GURL http_url = embedded_test_server()->GetURL("/server-redirect?"); GURL good_https_url = https_server_.GetURL("/ssl/google.html"); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), GURL(http_url.spec() + good_https_url.spec()))); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); } // Visit a page over http that is a redirect to a page with bad HTTPS. IN_PROC_BROWSER_TEST_F(SSLUITest, TestRedirectHTTPToBadHTTPS) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_expired_.Start()); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); const GURL http_url = embedded_test_server()->GetURL("/server-redirect?"); const GURL bad_https_url = https_server_expired_.GetURL("/ssl/google.html"); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), GURL(http_url.spec() + bad_https_url.spec()))); ASSERT_TRUE(chrome_browser_interstitials::IsShowingInterstitial(tab)); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::NONE); } // Visit a page over https that is a redirect to a page with http (to make sure // we don't keep the secure state). IN_PROC_BROWSER_TEST_F(SSLUITest, TestRedirectHTTPSToHTTP) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); GURL https_url = https_server_.GetURL("/server-redirect?"); GURL http_url = embedded_test_server()->GetURL("/ssl/google.html"); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), GURL(https_url.spec() + http_url.spec()))); ssl_test_util::CheckUnauthenticatedState( browser()->tab_strip_model()->GetActiveWebContents(), AuthState::NONE); } // Visit a page over https that is a redirect to a non-existent page with http // (to make sure we don't keep the secure state when redirecting to an error). // Regression test for crbug.com/40735055. IN_PROC_BROWSER_TEST_F(SSLUITest, TestRedirectHTTPSToInvalidHTTP) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); GURL https_url = https_server_.GetURL("/server-redirect?"); // Test runners might have servers listening in localhost, and the test // constructor routes all URLs to localhost, so use close-socket to make // sure we always get an error page. GURL invalid_url = embedded_test_server()->GetURL("/close-socket"); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), GURL(https_url.spec() + invalid_url.spec()))); // Check we don't keep the previous certificate state around. EXPECT_FALSE(chrome_security_state::GetVisibleSecurityState( browser()->tab_strip_model()->GetActiveWebContents()) ->certificate); EXPECT_EQ(chrome_security_state::GetSecurityLevel( browser()->tab_strip_model()->GetActiveWebContents()), security_state::SecurityLevel::NONE); } class SSLUITestWaitForDOMNotification : public SSLUITestIgnoreCertErrors, public content::WebContentsObserver { public: SSLUITestWaitForDOMNotification() : SSLUITestIgnoreCertErrors(), run_loop_(nullptr) {} SSLUITestWaitForDOMNotification(const SSLUITestWaitForDOMNotification&) = delete; SSLUITestWaitForDOMNotification& operator=( const SSLUITestWaitForDOMNotification&) = delete; ~SSLUITestWaitForDOMNotification() override = default; void SetUpOnMainThread() override { SSLUITestIgnoreCertErrors::SetUpOnMainThread(); } void set_expected_notification(const std::string& expected_notification) { expected_notification_ = expected_notification; } void set_run_loop(base::RunLoop* run_loop) { run_loop_ = run_loop; } void observe(content::WebContents* web_contents) { content::WebContentsObserver::Observe(web_contents); } // content::WebContentsObserver void DomOperationResponse(content::RenderFrameHost* render_frame_host, const std::string& json_string) override { DCHECK(run_loop_); if (json_string == expected_notification_) { run_loop_->Quit(); } } private: std::string expected_notification_; raw_ptr run_loop_; }; // Tests that a mixed resource which includes HTTP in the redirect chain // is marked as mixed content, even if the end result is HTTPS. IN_PROC_BROWSER_TEST_F(SSLUITestWaitForDOMNotification, TestMixedContentWithHTTPInRedirectChain) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/ssl/blank_page.html"))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Construct a URL which will be dynamically added to the page as an // image. The URL redirects through HTTP, though it ends up at an // HTTPS resource. GURL http_url = embedded_test_server()->GetURL("/server-redirect?"); GURL::Replacements http_url_replacements; // Be sure to use a non-localhost name for the mixed content request, // since local hostnames are not considered mixed content. http_url_replacements.SetHostStr("example.test"); url::UriComponentEncoder http_url_query( https_server_.GetURL("/ssl/google_files/logo.gif").spec()); http_url_replacements.SetQueryStr(http_url_query.view()); http_url = http_url.ReplaceComponents(http_url_replacements); GURL https_url = https_server_.GetURL("/server-redirect?"); GURL::Replacements https_url_replacements; url::UriComponentEncoder https_url_query(http_url.spec()); https_url_replacements.SetQueryStr(https_url_query.view()); https_url = https_url.ReplaceComponents(https_url_replacements); base::RunLoop run_loop; // Load the image. It starts at |https_server_|, which redirects to an // embedded_test_server() HTTP URL, which redirects back to // |https_server_| for the final HTTPS image. Because the redirect // chain passes through HTTP, the page should be marked as mixed // content. set_expected_notification("\"mixed-image-loaded\""); observe(tab); set_run_loop(&run_loop); ASSERT_TRUE(content::ExecJs( tab, "var loaded = function () {" " window.domAutomationController.send('mixed-image-loaded');" "};" "var img = document.createElement('img');" "img.onload = loaded;" "img.src = '" + https_url.spec() + "';" "document.body.appendChild(img);")); run_loop.Run(); ssl_test_util::CheckSecurityState(tab, CertError::NONE, security_state::WARNING, AuthState::DISPLAYED_INSECURE_CONTENT); } // Visits a page to which we could not connect (bad port) over http and https // and make sure the security style is correct. IN_PROC_BROWSER_TEST_F(SSLUITest, TestConnectToBadPort) { ASSERT_TRUE( ui_test_utils::NavigateToURL(browser(), GURL("http://localhost:17"))); ssl_test_util::CheckUnauthenticatedState( browser()->tab_strip_model()->GetActiveWebContents(), AuthState::SHOWING_ERROR); // Same thing over HTTPS. ASSERT_TRUE( ui_test_utils::NavigateToURL(browser(), GURL("https://localhost:17"))); ssl_test_util::CheckUnauthenticatedState( browser()->tab_strip_model()->GetActiveWebContents(), AuthState::SHOWING_ERROR); } // // Frame navigation // // From a good HTTPS top frame: // - navigate to an OK HTTPS frame // - navigate to a bad HTTPS (expect unsafe content and filtered frame), then // back // - navigate to HTTP (expect insecure content), then back IN_PROC_BROWSER_TEST_F(SSLUITest, TestGoodFrameNavigation) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); // SetUpOnMainThread adds this hostname to the resolver so that it's not // blocked (browser_test_base.cc has a resolver that blocks all non-local // hostnames by default to ensure tests don't hit the network). This is // critical to do because the request would otherwise get cancelled in the // browser before the renderer sees it. std::string top_frame_path = GetTopFramePath( *embedded_test_server(), https_server_, https_server_expired_); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL(top_frame_path))); ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Now navigate inside the frame. { content::LoadStopObserver observer(tab); ASSERT_EQ(true, content::EvalJs(tab, "clickLink('goodHTTPSLink');")); observer.Wait(); } // We should still be fine. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Now let's hit a bad page. { content::LoadStopObserver observer(tab); ASSERT_EQ(true, content::EvalJs(tab, "clickLink('badHTTPSLink');")); observer.Wait(); } // The security style should still be secure. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // And the frame should be blocked. content::RenderFrameHost* content_frame = content::FrameMatchingPredicate( tab->GetPrimaryPage(), base::BindRepeating(&content::FrameMatchesName, "contentFrame")); std::string is_evil_js("document.getElementById('evilDiv') != null;"); EXPECT_EQ(false, content::EvalJs(content_frame, is_evil_js)); // Now go back, our state should still be OK. { content::LoadStopObserver observer(tab); tab->GetController().GoBack(); observer.Wait(); } ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); // Navigate to a page served over HTTP. { content::LoadStopObserver observer(tab); ASSERT_EQ(true, content::EvalJs(tab, "clickLink('HTTPLink');")); observer.Wait(); } // Our state should be unauthenticated (in the ran mixed script sense). Note // this also displays images from the http page (google.com). ssl_test_util::CheckAuthenticationBrokenState( tab, CertError::NONE, AuthState::RAN_INSECURE_CONTENT | AuthState::DISPLAYED_INSECURE_CONTENT | AuthState::DISPLAYED_FORM_WITH_INSECURE_ACTION); // Go back, our state should be unchanged. { content::LoadStopObserver observer(tab); tab->GetController().GoBack(); observer.Wait(); } ssl_test_util::CheckAuthenticationBrokenState( tab, CertError::NONE, AuthState::RAN_INSECURE_CONTENT | AuthState::DISPLAYED_INSECURE_CONTENT | AuthState::DISPLAYED_FORM_WITH_INSECURE_ACTION); } // From a bad HTTPS top frame: // - navigate to an OK HTTPS frame (expected to be still authentication broken). IN_PROC_BROWSER_TEST_F(SSLUITest, TestBadFrameNavigation) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); std::string top_frame_path = GetTopFramePath( *embedded_test_server(), https_server_, https_server_expired_); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_expired_.GetURL(top_frame_path))); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::SHOWING_INTERSTITIAL); ProceedThroughInterstitial(tab); // Navigate to a good frame. content::LoadStopObserver observer(tab); ASSERT_EQ(true, content::EvalJs(tab, "clickLink('goodHTTPSLink');")); observer.Wait(); // We should still be authentication broken. ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_DATE_INVALID, AuthState::NONE); } // From an HTTP top frame, navigate to good and bad HTTPS (security state should // stay unauthenticated). IN_PROC_BROWSER_TEST_F(SSLUITest, TestUnauthenticatedFrameNavigation) { ASSERT_TRUE(embedded_test_server()->Start()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); std::string top_frame_path = GetTopFramePath( *embedded_test_server(), https_server_, https_server_expired_); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), embedded_test_server()->GetURL(top_frame_path))); ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); // Now navigate inside the frame to a secure HTTPS frame. { content::LoadStopObserver observer(tab); ASSERT_EQ(true, content::EvalJs(tab, "clickLink('goodHTTPSLink');")); observer.Wait(); } // We should still be unauthenticated. ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); // Now navigate to a bad HTTPS frame. { content::LoadStopObserver observer(tab); ASSERT_EQ(true, content::EvalJs(tab, "clickLink('badHTTPSLink');")); observer.Wait(); } // State should not have changed. ssl_test_util::CheckUnauthenticatedState(tab, AuthState::NONE); // And the frame should have been blocked (see bug #2316). content::RenderFrameHost* content_frame = content::FrameMatchingPredicate( tab->GetPrimaryPage(), base::BindRepeating(&content::FrameMatchesName, "contentFrame")); std::string is_evil_js("document.getElementById('evilDiv') != null;"); EXPECT_EQ(false, content::EvalJs(content_frame, is_evil_js)); } enum class OffMainThreadFetchMode { kEnabled, kDisabled }; enum class SSLUIWorkerFetchTestType { kUseFetch, kUseImportScripts }; class SSLUIWorkerFetchTest : public testing::WithParamInterface, public SSLUITestBase { public: SSLUIWorkerFetchTest() { EXPECT_TRUE(tmp_dir_.CreateUniqueTempDir()); } SSLUIWorkerFetchTest(const SSLUIWorkerFetchTest&) = delete; SSLUIWorkerFetchTest& operator=(const SSLUIWorkerFetchTest&) = delete; ~SSLUIWorkerFetchTest() override = default; void SetUpOnMainThread() override { SSLUITestBase::SetUpOnMainThread(); } void SetUpCommandLine(base::CommandLine* command_line) override { SSLUITestBase::SetUpCommandLine(command_line); scoped_feature_list_.InitWithFeatures({}, GetDisabledFeatures()); } protected: void WriteFile(const base::FilePath::StringType& filename, std::string_view contents) { base::ScopedAllowBlockingForTesting allow_blocking; EXPECT_TRUE(base::WriteFile(tmp_dir_.GetPath().Append(filename), contents)); } void WriteTestFiles(const net::EmbeddedTestServer& remote_server, const std::string& hostname) { WriteFile(FILE_PATH_LITERAL("worker_test.html"), ""); switch (GetParam()) { case SSLUIWorkerFetchTestType::kUseFetch: WriteFile(FILE_PATH_LITERAL("worker_test_data.txt.mock-http-headers"), "HTTP/1.1 200 OK\n" "Content-Type: text/plain\n" "Access-Control-Allow-Origin: *"); WriteFile(FILE_PATH_LITERAL("worker_test_data.txt"), "LOADED"); WriteFile(FILE_PATH_LITERAL("worker.js"), base::StringPrintf( "fetch('%s')" " .then(res => res.text())" " .then(text => postMessage(text))" " .catch(_ => postMessage('FAILED'))", remote_server.GetURL(hostname, "/worker_test_data.txt") .spec() .c_str())); break; case SSLUIWorkerFetchTestType::kUseImportScripts: { WriteFile(FILE_PATH_LITERAL("imported.js"), "data = 'LOADED';"); WriteFile( FILE_PATH_LITERAL("worker.js"), base::StringPrintf( "var data = 'FAILED';" "try {" " importScripts('%s')" "} catch(e) {}" "postMessage(data);", remote_server.GetURL(hostname, "/imported.js").spec().c_str())); } break; } } void RunMixedContentSettingsTest( ChromeContentBrowserClientForMixedContentTest* browser_client, bool allow_running_insecure_content, bool strict_mixed_content_checking, bool strictly_block_blockable_mixed_content, bool expected_load, bool expected_show_blocked, bool expected_show_dangerous, bool expected_load_after_allow, bool expected_show_blocked_after_allow, bool expected_show_dangerous_after_allow) { SCOPED_TRACE( ::testing::Message() << "RunMixedContentSettingsTest :" << "allow_running_insecure_content=" << (allow_running_insecure_content ? "true " : "false ") << "strict_mixed_content_checking=" << (strict_mixed_content_checking ? "true " : "false ") << "strictly_block_blockable_mixed_content=" << (strictly_block_blockable_mixed_content ? "true " : "false ")); // Run the tests in a new tab. This forces each call of // RunMixedContentSettingsTest in a single test case to use different tabs // and thus different processes, bypassing a subtle race condition where // processes can get re-used under Site Isolation and retain their mixed // content status (see crbug.com/41417895). This ensures all error state is // cleared. chrome::NewTab(browser(), NewTabTypes::kNoUserAction); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); EXPECT_TRUE(content::WaitForLoadStop(tab)); CheckErrorStateIsCleared(); browser_client->SetMixedContentSettings( allow_running_insecure_content, strict_mixed_content_checking, strictly_block_blockable_mixed_content); tab->OnWebPreferencesChanged(); CheckMixedContentSettings(allow_running_insecure_content, strict_mixed_content_checking, strictly_block_blockable_mixed_content); const std::u16string loaded_title = u"LOADED"; const std::u16string failed_title = u"FAILED"; { // First load. content::TitleWatcher watcher(tab, loaded_title); watcher.AlsoWaitForTitle(failed_title); ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/worker_test.html"))); EXPECT_EQ(expected_load ? loaded_title : failed_title, watcher.WaitAndGetTitle()); } EXPECT_EQ(expected_show_blocked, content_settings::PageSpecificContentSettings::GetForFrame( tab->GetPrimaryMainFrame()) ->IsContentBlocked(ContentSettingsType::MIXEDSCRIPT)); ssl_test_util::CheckSecurityState( tab, CertError::NONE, expected_show_dangerous ? security_state::DANGEROUS : security_state::SECURE, expected_show_dangerous ? AuthState::RAN_INSECURE_CONTENT : AuthState::NONE); // Clears title. ASSERT_TRUE( content::ExecJs(tab->GetPrimaryMainFrame(), "document.title = \"\";")); { // SetAllowRunningInsecureContent will reload the page. content::TitleWatcher watcher(tab, loaded_title); watcher.AlsoWaitForTitle(failed_title); SetAllowRunningInsecureContent(); tab->OnWebPreferencesChanged(); EXPECT_EQ(expected_load_after_allow ? loaded_title : failed_title, watcher.WaitAndGetTitle()); } EXPECT_EQ(expected_show_blocked_after_allow, content_settings::PageSpecificContentSettings::GetForFrame( tab->GetPrimaryMainFrame()) ->IsContentBlocked(ContentSettingsType::MIXEDSCRIPT)); ssl_test_util::CheckSecurityState( tab, CertError::NONE, expected_show_dangerous_after_allow ? security_state::DANGEROUS : security_state::SECURE, expected_show_dangerous_after_allow ? AuthState::RAN_INSECURE_CONTENT : AuthState::NONE); chrome::CloseTab(browser()); } base::ScopedTempDir tmp_dir_; private: void SetAllowRunningInsecureContent() { content::RenderFrameHost* render_frame_host = browser() ->tab_strip_model() ->GetActiveWebContents() ->GetPrimaryMainFrame(); mojo::AssociatedRemote agent; render_frame_host->GetRemoteAssociatedInterfaces()->GetInterface(&agent); agent->SetAllowRunningInsecureContent(); } void CheckErrorStateIsCleared() { WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); EXPECT_FALSE(content_settings::PageSpecificContentSettings::GetForFrame( tab->GetPrimaryMainFrame()) ->IsContentBlocked(ContentSettingsType::MIXEDSCRIPT)); ssl_test_util::CheckSecurityState(tab, CertError::NONE, security_state::NONE, AuthState::NONE); EXPECT_FALSE( chrome_security_state::GetVisibleSecurityState(tab)->ran_mixed_content); } void CheckMixedContentSettings(bool allow_running_insecure_content, bool strict_mixed_content_checking, bool strictly_block_blockable_mixed_content) { WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); const blink::web_pref::WebPreferences& prefs = tab->GetOrCreateWebPreferences(); ASSERT_EQ(prefs.strictly_block_blockable_mixed_content, strictly_block_blockable_mixed_content); ASSERT_EQ(prefs.allow_running_insecure_content, allow_running_insecure_content); ASSERT_EQ(prefs.strict_mixed_content_checking, strict_mixed_content_checking); } base::test::ScopedFeatureList scoped_feature_list_; }; IN_PROC_BROWSER_TEST_P(SSLUIWorkerFetchTest, TestUnsafeContentsInWorkerFiltered) { https_server_.ServeFilesFromDirectory(tmp_dir_.GetPath()); https_server_expired_.ServeFilesFromDirectory(tmp_dir_.GetPath()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(https_server_expired_.Start()); WriteTestFiles(https_server_expired_, "localhost"); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); const std::u16string loaded_title = u"LOADED"; const std::u16string failed_title = u"FAILED"; content::TitleWatcher watcher(tab, loaded_title); watcher.AlsoWaitForTitle(failed_title); // This page will spawn a Worker which will try to load content from // BadCertServer. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/worker_test.html"))); // Expect Worker not to load insecure content. EXPECT_EQ(failed_title, watcher.WaitAndGetTitle()); // The bad content is filtered, expect the state to be authenticated. ssl_test_util::CheckAuthenticatedState(tab, AuthState::NONE); } // This test, and the related test TestUnsafeContentsWithUserException, verify // that if unsafe content is loaded but the host of that unsafe content has a // user exception, the content runs and the security style is downgraded. // TODO(crbug.com/40707016): Disabled due to flakiness. IN_PROC_BROWSER_TEST_P(SSLUIWorkerFetchTest, DISABLED_TestUnsafeContentsInWorkerWithUserException) { https_server_.ServeFilesFromDirectory(tmp_dir_.GetPath()); https_server_mismatched_.ServeFilesFromDirectory(tmp_dir_.GetPath()); ASSERT_TRUE(https_server_.Start()); // Note that it is necessary to user https_server_mismatched_ here over the // other invalid cert servers. This is because the test relies on the two // servers having different hosts since SSL exceptions are per-host, not per // origin, and https_server_mismatched_ uses 'localhost' rather than // '127.0.0.1'. ASSERT_TRUE(https_server_mismatched_.Start()); WriteTestFiles(https_server_mismatched_, "localhost"); // Navigate to an unsafe site. Proceed with interstitial page to indicate // the user approves the bad certificate. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_mismatched_.GetURL("/ssl/blank_page.html"))); WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents(); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_COMMON_NAME_INVALID, AuthState::SHOWING_INTERSTITIAL); content::TestNavigationObserver nav_observer(tab, 1); security_interstitials::SecurityInterstitialTabHelper* helper = security_interstitials::SecurityInterstitialTabHelper::FromWebContents( tab); helper->GetBlockingPageForCurrentlyCommittedNavigationForTesting() ->CommandReceived( base::NumberToString(security_interstitials::CMD_PROCEED)); nav_observer.Wait(); ssl_test_util::CheckAuthenticationBrokenState( tab, net::CERT_STATUS_COMMON_NAME_INVALID, AuthState::NONE); std::unique_ptr visible_security_state = chrome_security_state::GetVisibleSecurityState(tab); EXPECT_FALSE(visible_security_state->ran_mixed_content); EXPECT_FALSE(visible_security_state->displayed_mixed_content); EXPECT_FALSE(visible_security_state->ran_content_with_cert_errors); EXPECT_FALSE(visible_security_state->displayed_content_with_cert_errors); const std::u16string loaded_title = u"LOADED"; const std::u16string failed_title = u"FAILED"; content::TitleWatcher watcher(tab, loaded_title); watcher.AlsoWaitForTitle(failed_title); // Navigate to safe page that has Worker loading unsafe content. // Expect content to load but be marked as auth broken due to running insecure // content. ASSERT_TRUE(ui_test_utils::NavigateToURL( browser(), https_server_.GetURL("/worker_test.html"))); // Worker loads insecure content EXPECT_EQ(loaded_title, watcher.WaitAndGetTitle()); ssl_test_util::CheckAuthenticationBrokenState(tab, CertError::NONE, AuthState::NONE); visible_security_state = chrome_security_state::GetVisibleSecurityState(tab); EXPECT_FALSE(visible_security_state->ran_mixed_content); EXPECT_FALSE(visible_security_state->displayed_mixed_content); EXPECT_TRUE(visible_security_state->ran_content_with_cert_errors); EXPECT_FALSE(visible_security_state->displayed_content_with_cert_errors); } // This test checks the behavior of mixed content blocking for the requests // from a dedicated worker by changing the settings in WebPreferences // with allow_running_insecure_content = true. // Flaky. See https://crbug.com/40729606. IN_PROC_BROWSER_TEST_P( SSLUIWorkerFetchTest, DISABLED_MixedContentSettings_AllowRunningInsecureContent) { ChromeContentBrowserClientForMixedContentTest browser_client; content::ScopedContentBrowserClientSetting setting(&browser_client); https_server_.ServeFilesFromDirectory(tmp_dir_.GetPath()); embedded_test_server()->ServeFilesFromDirectory(tmp_dir_.GetPath()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(embedded_test_server()->Start()); WriteTestFiles(*embedded_test_server(), "example.com"); for (bool strict_mixed_content_checking : {true, false}) { for (bool strictly_block_blockable_mixed_content : {true, false}) { if (strict_mixed_content_checking) { RunMixedContentSettingsTest( &browser_client, true /* allow_running_insecure_content */, strict_mixed_content_checking, strictly_block_blockable_mixed_content, false /* expected_load */, false /* expected_show_blocked */, false /* expected_show_dangerous */, false /* expected_load_after_allow */, false /* expected_show_blocked_after_allow */, false /* expected_show_dangerous_after_allow */); } else { RunMixedContentSettingsTest( &browser_client, true /* allow_running_insecure_content */, strict_mixed_content_checking, strictly_block_blockable_mixed_content, true /* expected_load */, false /* expected_show_blocked */, true /* expected_show_dangerous */, true /* expected_load_after_allow */, false /* expected_show_blocked_after_allow */, true /* expected_show_dangerous_after_allow */); } } } } // This test checks the behavior of mixed content blocking for the requests // from a dedicated worker by changing the settings in WebPreferences // with allow_running_insecure_content = false. // Disabled due to being flaky. crbug.com/40712072 IN_PROC_BROWSER_TEST_P( SSLUIWorkerFetchTest, DISABLED_MixedContentSettings_DisallowRunningInsecureContent) { ChromeContentBrowserClientForMixedContentTest browser_client; content::ScopedContentBrowserClientSetting setting(&browser_client); https_server_.ServeFilesFromDirectory(tmp_dir_.GetPath()); embedded_test_server()->ServeFilesFromDirectory(tmp_dir_.GetPath()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(embedded_test_server()->Start()); WriteTestFiles(*embedded_test_server(), "example.com"); for (bool strict_mixed_content_checking : {true, false}) { for (bool strictly_block_blockable_mixed_content : {true, false}) { if (strict_mixed_content_checking) { RunMixedContentSettingsTest( &browser_client, false /* allow_running_insecure_content */, strict_mixed_content_checking, strictly_block_blockable_mixed_content, false /* expected_load */, false /* expected_show_blocked */, false /* expected_show_dangerous */, false /* expected_load_after_allow */, false /* expected_show_blocked_after_allow */, false /* expected_show_dangerous_after_allow */); } else if (strictly_block_blockable_mixed_content) { RunMixedContentSettingsTest( &browser_client, false /* allow_running_insecure_content */, strict_mixed_content_checking, strictly_block_blockable_mixed_content, false /* expected_load */, false /* expected_show_blocked */, false /* expected_show_dangerous */, false /* expected_load_after_allow */, false /* expected_show_blocked_after_allow */, false /* expected_show_dangerous_after_allow */); } else { RunMixedContentSettingsTest( &browser_client, false /* allow_running_insecure_content */, strict_mixed_content_checking, strictly_block_blockable_mixed_content, false /* expected_load */, true /* expected_show_blocked */, false /* expected_show_dangerous */, true /* expected_load_after_allow */, false /* expected_show_blocked_after_allow */, true /* expected_show_dangerous_after_allow */); } } } } // This test checks that all mixed content requests from a dedicated worker are // blocked regardless of the settings in WebPreferences when // block-all-mixed-content CSP is set with allow_running_insecure_content=true. // TODO(crbug.com/429204994): Disabled due to flakiness. IN_PROC_BROWSER_TEST_P( SSLUIWorkerFetchTest, DISABLED_MixedContentSettingsWithBlockingCSP_AllowRunningInsecureContent) { ChromeContentBrowserClientForMixedContentTest browser_client; content::ScopedContentBrowserClientSetting setting(&browser_client); https_server_.ServeFilesFromDirectory(tmp_dir_.GetPath()); embedded_test_server()->ServeFilesFromDirectory(tmp_dir_.GetPath()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(embedded_test_server()->Start()); WriteTestFiles(*embedded_test_server(), "example.com"); WriteFile(FILE_PATH_LITERAL("worker.js.mock-http-headers"), "HTTP/1.1 200 OK\n" "Content-Type: application/javascript\n" "Content-Security-Policy: block-all-mixed-content;"); for (bool strict_mixed_content_checking : {true, false}) { for (bool strictly_block_blockable_mixed_content : {true, false}) { RunMixedContentSettingsTest( &browser_client, true /* allow_running_insecure_content */, strict_mixed_content_checking, strictly_block_blockable_mixed_content, false /* expected_load */, false /* expected_show_blocked */, false /* expected_show_dangerous */, false /* expected_load_after_allow */, false /* expected_show_blocked_after_allow */, false /* expected_show_dangerous_after_allow */); } } } // This test checks that all mixed content requests from a dedicated worker are // blocked regardless of the settings in WebPreferences when // block-all-mixed-content CSP is set with allow_running_insecure_content=false. IN_PROC_BROWSER_TEST_P( SSLUIWorkerFetchTest, MixedContentSettingsWithBlockingCSP_DisallowRunningInsecureContent) { ChromeContentBrowserClientForMixedContentTest browser_client; content::ScopedContentBrowserClientSetting setting(&browser_client); https_server_.ServeFilesFromDirectory(tmp_dir_.GetPath()); embedded_test_server()->ServeFilesFromDirectory(tmp_dir_.GetPath()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(embedded_test_server()->Start()); WriteTestFiles(*embedded_test_server(), "example.com"); WriteFile(FILE_PATH_LITERAL("worker.js.mock-http-headers"), "HTTP/1.1 200 OK\n" "Content-Type: application/javascript\n" "Content-Security-Policy: block-all-mixed-content;"); for (bool strict_mixed_content_checking : {true, false}) { for (bool strictly_block_blockable_mixed_content : {true, false}) { RunMixedContentSettingsTest( &browser_client, false /* allow_running_insecure_content */, strict_mixed_content_checking, strictly_block_blockable_mixed_content, false /* expected_load */, false /* expected_show_blocked */, false /* expected_show_dangerous */, false /* expected_load_after_allow */, false /* expected_show_blocked_after_allow */, false /* expected_show_dangerous_after_allow */); } } } // This test checks that all mixed content requests from a dedicated worker // which is started from a subframe are blocked if // allow_running_insecure_content setting is false or // strict_mixed_content_checking setting is true. // TODO(carlosil): Re-enable to check if this triggers flakiness due to // committed interstitials. IN_PROC_BROWSER_TEST_P(SSLUIWorkerFetchTest, DISABLED_MixedContentSubFrame) { ChromeContentBrowserClientForMixedContentTest browser_client; content::ScopedContentBrowserClientSetting setting(&browser_client); https_server_.ServeFilesFromDirectory(tmp_dir_.GetPath()); embedded_test_server()->ServeFilesFromDirectory(tmp_dir_.GetPath()); ASSERT_TRUE(https_server_.Start()); ASSERT_TRUE(embedded_test_server()->Start()); WriteTestFiles(*embedded_test_server(), "example.com"); WriteFile(FILE_PATH_LITERAL("worker_iframe.html"), ""); WriteFile(FILE_PATH_LITERAL("worker_test.html"), "" "