Common Name Mismatch Handler For WWW Subdomain Mismatch case

chrome/browser/ssl/ssl_blocking_page.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/build_time.h"
 #include "base/callback_helpers.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/interstitials/chrome_metrics_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/ssl/cert_report_helper.h"
 #include "chrome/browser/ssl/certificate_error_report.h"
 #include "chrome/browser/ssl/ssl_cert_reporter.h"
 #include "chrome/browser/ssl/ssl_error_classification.h"
 #include "chrome/browser/ssl/ssl_error_info.h"
+#include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/google/core/browser/google_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cert_store.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/navigation_controller.h"
@@ skipping 185 matching lines @@
 
 // Note that we always create a navigation entry with SSL errors.
 // No error happening loading a sub-resource triggers an interstitial so far.
 SSLBlockingPage::SSLBlockingPage(content::WebContents* web_contents,
                                  int cert_error,
                                  const net::SSLInfo& ssl_info,
                                  const GURL& request_url,
                                  int options_mask,
                                  const base::Time& time_triggered,
                                  scoped_ptr<SSLCertReporter> ssl_cert_reporter,
-                                 const base::Callback<void(bool)>& callback)
+                                 const base::Callback<void(bool)>& callback,
+                                 const GURL& suggested_url)
     : SecurityInterstitialPage(web_contents, request_url),
       callback_(callback),
       cert_error_(cert_error),
       ssl_info_(ssl_info),
       overridable_(IsOverridable(
           options_mask,
           Profile::FromBrowserContext(web_contents->GetBrowserContext()))),
       danger_overridable_(DoesPolicyAllowDangerOverride(
           Profile::FromBrowserContext(web_contents->GetBrowserContext()))),
       strict_enforcement_((options_mask & STRICT_ENFORCEMENT) != 0),
       expired_but_previously_allowed_(
           (options_mask & EXPIRED_BUT_PREVIOUSLY_ALLOWED) != 0),
-      time_triggered_(time_triggered) {
+      time_triggered_(time_triggered),
+      suggested_url_(suggested_url) {
   interstitial_reason_ =
       IsErrorDueToBadClock(time_triggered_, cert_error_) ?
       SSL_REASON_BAD_CLOCK : SSL_REASON_SSL;
 
   // We collapse the Rappor metric name to just "ssl" so we don't leak
   // the "overridable" bit. We skip Rappor altogether for bad clocks.
   // This must be done after calculating |interstitial_reason_| above.
   security_interstitials::MetricsHelper::ReportDetails reporting_info;
   reporting_info.metric_prefix = GetUmaHistogramPrefix();
   reporting_info.rappor_prefix = kSSLRapporPrefix;
@@ skipping 112 matching lines @@
     load_time_data->SetBoolean("bad_clock", false);
 
     load_time_data->SetString(
         "tabTitle", l10n_util::GetStringUTF16(IDS_SSL_V2_TITLE));
     load_time_data->SetString(
         "heading", l10n_util::GetStringUTF16(IDS_SSL_V2_HEADING));
     load_time_data->SetString(
         "primaryParagraph",
         l10n_util::GetStringFUTF16(IDS_SSL_V2_PRIMARY_PARAGRAPH, url));
 
+    load_time_data->SetBoolean("common_name_mismatch", false);
+    // If suggested URL is not empty, display a modified message
+    // with a link to suggested_url.
+    if (!suggested_url_.is_empty()) {
+      load_time_data->SetBoolean("common_name_mismatch", true);
+      load_time_data->SetString(
+          "primaryParagraph",
+          l10n_util::GetStringFUTF16(
+              IDS_SSL_COMMON_NAME_MISMATCH_PRIMARY_PARAGRAPH,
+              base::UTF8ToUTF16(request_url().host()),
+              base::UTF8ToUTF16(suggested_url_.host())));
+    }
+
     if (overridable_) {
       load_time_data->SetBoolean("overridable", true);
 
       SSLErrorInfo error_info =
           SSLErrorInfo::CreateError(
               SSLErrorInfo::NetErrorToErrorType(cert_error_),
               ssl_info_.cert.get(),
               request_url());
+
       load_time_data->SetString("explanationParagraph", error_info.details());
       load_time_data->SetString(
           "primaryButtonText",
           l10n_util::GetStringUTF16(IDS_SSL_OVERRIDABLE_SAFETY_BUTTON));
       load_time_data->SetString(
           "finalParagraph",
           l10n_util::GetStringFUTF16(IDS_SSL_OVERRIDABLE_PROCEED_PARAGRAPH,
                                    url));
     } else {
       load_time_data->SetBoolean("overridable", false);
@@ skipping 129 matching lines @@
     case CMD_OPEN_DATE_SETTINGS: {
       metrics_helper()->RecordUserInteraction(
           security_interstitials::MetricsHelper::OPEN_TIME_SETTINGS);
       content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
                                        base::Bind(&LaunchDateAndTimeSettings));
       break;
     }
     case CMD_OPEN_REPORTING_PRIVACY:
       OpenExtendedReportingPrivacyPolicy();
       break;
+    case CMD_NAVIGATE_SUGGESTED_URL:
+      OpenSuggestedURL();
+      break;
     case CMD_OPEN_DIAGNOSTIC:
       // Google doesn't currently have a transparency report for SSL.
       NOTREACHED() << "Unexpected command: " << command;
   }
 }
 
 void SSLBlockingPage::OverrideRendererPrefs(
       content::RendererPreferences* prefs) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents()->GetBrowserContext());
@@ skipping 78 matching lines @@
 std::string SSLBlockingPage::GetSamplingEventName() const {
   std::string event_name(kEventNameBase);
   if (overridable_)
     event_name.append(kEventOverridable);
   else
     event_name.append(kEventNotOverridable);
   event_name.append(net::ErrorToString(cert_error_));
   return event_name;
 }
 
+void SSLBlockingPage::OpenSuggestedURL() const {
+  content::NavigationController::LoadURLParams load_params(suggested_url_);
+  load_params.transition_type = ui::PAGE_TRANSITION_LINK;
+  web_contents()->GetController().LoadURLWithParams(load_params);
+}
+
 // static
 bool SSLBlockingPage::IsOverridable(int options_mask,
                                     const Profile* const profile) {
   const bool is_overridable =
       (options_mask & SSLBlockingPage::OVERRIDABLE) &&
       !(options_mask & SSLBlockingPage::STRICT_ENFORCEMENT) &&
       profile->GetPrefs()->GetBoolean(prefs::kSSLErrorOverrideAllowed);
   return is_overridable;
 }
 
 // static
 bool SSLBlockingPage::DoesPolicyAllowDangerOverride(
     const Profile* const profile) {
   return profile->GetPrefs()->GetBoolean(prefs::kSSLErrorOverrideAllowed);
 }