Implementation of the full clock interstitial.

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/build_time.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 222 matching lines @@
       "'com.android.settings/.Settings$DateTimeSettingsActivity'");
 #elif defined(OS_IOS)
   // iOS does not have a way to launch the date and time settings.
   return;
 #elif defined(OS_LINUX)
   struct ClockCommand {
     const char* pathname;
     const char* argument;
   };
   static const ClockCommand kClockCommands[] = {
+    // Unity
+    { "/usr/bin/unity-control-center", "datetime" },
     // GNOME
     //
     // NOTE: On old Ubuntu, naming control panels doesn't work, so it
     // opens the overview. This will have to be good enough.
     { "/usr/bin/gnome-control-center", "datetime" },
     { "/usr/local/bin/gnome-control-center", "datetime" },
     { "/opt/bin/gnome-control-center", "datetime" },
     // KDE
     { "/usr/bin/kcmshell4", "clock" },
     { "/usr/local/bin/kcmshell4", "clock" },
@@ skipping 158 matching lines @@
   interstitial_page_->Show();
 }
 
 std::string SSLBlockingPage::GetHTMLContents() {
   base::DictionaryValue load_time_data;
   base::string16 url(ASCIIToUTF16(request_url_.host()));
   if (base::i18n::IsRTL())
     base::i18n::WrapStringWithLTRFormatting(&url);
   webui::SetFontAndTextDirection(&load_time_data);
 
-  // Shared values for both the overridable and non-overridable versions.
   load_time_data.SetString("type", "SSL");
-  load_time_data.SetBoolean("overridable", overridable_);
-  load_time_data.SetString(
-      "tabTitle", l10n_util::GetStringUTF16(IDS_SSL_V2_TITLE));
-  load_time_data.SetString(
-      "heading", l10n_util::GetStringUTF16(IDS_SSL_V2_HEADING));
 
   base::Time now = base::Time::NowFromSystemTime();
   bool bad_clock = IsErrorDueToBadClock(now, cert_error_);
+
+  load_time_data.SetString("errorCode", net::ErrorToString(cert_error_));
+
   if (bad_clock) {
+    load_time_data.SetBoolean("bad_clock", true);
+    load_time_data.SetBoolean("overridable", false);
+
+    base::string16 headingString;
+    if (SSLErrorClassification::IsUserClockInTheFuture(now)) {
+      headingString = l10n_util::GetStringUTF16(
+                          IDS_SSL_V2_CLOCK_AHEAD_HEADING);
+    } else {
+      headingString = l10n_util::GetStringUTF16(
+                          IDS_SSL_V2_CLOCK_BEHIND_HEADING);
+    }
+
+    load_time_data.SetString("tabTitle",
+        l10n_util::GetStringUTF16(IDS_SSL_V2_CLOCK_TITLE));
+    load_time_data.SetString("heading", headingString);
     load_time_data.SetString("primaryParagraph",
                              l10n_util::GetStringFUTF16(
-                                 IDS_SSL_CLOCK_ERROR,
+                                 IDS_SSL_V2_CLOCK_PRIMARY_PARAGRAPH ,
                                  url,
-                                 base::TimeFormatShortDate(now)));
+                                 base::TimeFormatFriendlyDateAndTime(now)));
+
+    load_time_data.SetString(
+        "primaryButtonText",
+        l10n_util::GetStringUTF16(IDS_SSL_V2_CLOCK_UPDATE_DATE_AND_TIME));
+    load_time_data.SetString(
+       "openDetails",
+       l10n_util::GetStringUTF16(IDS_SSL_V2_CLOCK_RELOAD));
+
+    // The interstitial template expects these strings,
+    // but we're not using them. So we send blank strings for now.
+    load_time_data.SetString("explanationParagraph", "");
+    load_time_data.SetString("finalParagraph", "");
   } else {
+    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.SetString(
+       "openDetails",
+       l10n_util::GetStringUTF16(IDS_SSL_V2_OPEN_DETAILS_BUTTON));
+    load_time_data.SetString(
+       "closeDetails",
+       l10n_util::GetStringUTF16(IDS_SSL_V2_CLOSE_DETAILS_BUTTON));
 
-  load_time_data.SetString(
-     "openDetails",
-     l10n_util::GetStringUTF16(IDS_SSL_V2_OPEN_DETAILS_BUTTON));
-  load_time_data.SetString(
-     "closeDetails",
-     l10n_util::GetStringUTF16(IDS_SSL_V2_CLOSE_DETAILS_BUTTON));
-  load_time_data.SetString("errorCode", net::ErrorToString(cert_error_));
+    if (overridable_) {
+      load_time_data.SetBoolean("overridable", true);
 
-  if (overridable_) {
-    SSLErrorInfo error_info =
-        SSLErrorInfo::CreateError(
-            SSLErrorInfo::NetErrorToErrorType(cert_error_),
-            ssl_info_.cert.get(),
-            request_url_);
-    if (bad_clock) {
-      load_time_data.SetString("explanationParagraph",
-                               l10n_util::GetStringFUTF16(
-                                   IDS_SSL_CLOCK_ERROR_EXPLANATION, url));
+      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.SetString("explanationParagraph", error_info.details());
+      load_time_data.SetBoolean("overridable", false);
+
+      SSLErrorInfo::ErrorType type =
+          SSLErrorInfo::NetErrorToErrorType(cert_error_);
+      if (type == SSLErrorInfo::CERT_INVALID && SSLErrorClassification::
+          MaybeWindowsLacksSHA256Support()) {
+        load_time_data.SetString(
+            "explanationParagraph",
+            l10n_util::GetStringFUTF16(
+                IDS_SSL_NONOVERRIDABLE_MORE_INVALID_SP3, url));
+      } else {
+        load_time_data.SetString("explanationParagraph",
+                                 l10n_util::GetStringFUTF16(
+                                     IDS_SSL_NONOVERRIDABLE_MORE, url));
+      }
+      load_time_data.SetString(
+          "primaryButtonText",
+          l10n_util::GetStringUTF16(IDS_SSL_NONOVERRIDABLE_RELOAD_BUTTON));
+      // Customize the help link depending on the specific error type.
+      // Only mark as HSTS if none of the more specific error types apply,
+      // and use INVALID as a fallback if no other string is appropriate.
+      load_time_data.SetInteger("errorType", type);
+      int help_string = IDS_SSL_NONOVERRIDABLE_INVALID;
+      switch (type) {
+        case SSLErrorInfo::CERT_REVOKED:
+          help_string = IDS_SSL_NONOVERRIDABLE_REVOKED;
+          break;
+        case SSLErrorInfo::CERT_PINNED_KEY_MISSING:
+          help_string = IDS_SSL_NONOVERRIDABLE_PINNED;
+          break;
+        case SSLErrorInfo::CERT_INVALID:
+          help_string = IDS_SSL_NONOVERRIDABLE_INVALID;
+          break;
+        default:
+          if (strict_enforcement_)
+            help_string = IDS_SSL_NONOVERRIDABLE_HSTS;
+      }
+      load_time_data.SetString(
+          "finalParagraph", l10n_util::GetStringFUTF16(help_string, url));
     }
-    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 {
-    SSLErrorInfo::ErrorType type =
-        SSLErrorInfo::NetErrorToErrorType(cert_error_);
-    if (type == SSLErrorInfo::CERT_INVALID && SSLErrorClassification::
-        MaybeWindowsLacksSHA256Support()) {
-      load_time_data.SetString(
-          "explanationParagraph",
-          l10n_util::GetStringFUTF16(
-              IDS_SSL_NONOVERRIDABLE_MORE_INVALID_SP3, url));
-    } else if (bad_clock) {
-      load_time_data.SetString("explanationParagraph",
-                               l10n_util::GetStringFUTF16(
-                                   IDS_SSL_CLOCK_ERROR_EXPLANATION, url));
-    } else {
-      load_time_data.SetString("explanationParagraph",
-                               l10n_util::GetStringFUTF16(
-                                   IDS_SSL_NONOVERRIDABLE_MORE, url));
-    }
-    load_time_data.SetString(
-        "primaryButtonText",
-        l10n_util::GetStringUTF16(IDS_SSL_NONOVERRIDABLE_RELOAD_BUTTON));
-    // Customize the help link depending on the specific error type.
-    // Only mark as HSTS if none of the more specific error types apply, and use
-    // INVALID as a fallback if no other string is appropriate.
-    load_time_data.SetInteger("errorType", type);
-    int help_string = IDS_SSL_NONOVERRIDABLE_INVALID;
-    switch (type) {
-      case SSLErrorInfo::CERT_REVOKED:
-        help_string = IDS_SSL_NONOVERRIDABLE_REVOKED;
-        break;
-      case SSLErrorInfo::CERT_PINNED_KEY_MISSING:
-        help_string = IDS_SSL_NONOVERRIDABLE_PINNED;
-        break;
-      case SSLErrorInfo::CERT_INVALID:
-        help_string = IDS_SSL_NONOVERRIDABLE_INVALID;
-        break;
-      default:
-        if (strict_enforcement_)
-          help_string = IDS_SSL_NONOVERRIDABLE_HSTS;
-    }
-    load_time_data.SetString(
-        "finalParagraph", l10n_util::GetStringFUTF16(help_string, url));
   }
 
   // Set debugging information at the bottom of the warning.
   load_time_data.SetString(
       "subject", ssl_info_.cert->subject().GetDisplayName());
   load_time_data.SetString(
       "issuer", ssl_info_.cert->issuer().GetDisplayName());
   load_time_data.SetString(
       "expirationDate",
       base::TimeFormatShortDate(ssl_info_.cert->valid_expiry()));
@@ skipping 26 matching lines @@
 // DO NOT reorder or change this logic without also changing the JavaScript!
 void SSLBlockingPage::CommandReceived(const std::string& command) {
   int cmd = 0;
   bool retval = base::StringToInt(command, &cmd);
   DCHECK(retval);
   switch (cmd) {
     case CMD_DONT_PROCEED: {
       interstitial_page_->DontProceed();
       break;
     }
     case CMD_PROCEED: {

[felt, 2014/10/23 01:54:11]

I don't want people to be able to type danger and "proceed". Can you make sure
that this just returns if it's showing the clock interstitial? (Or make sure to
disable that JS in the interstitial. Either way works.)

[lgarron, 2014/10/23 03:02:04]

The interstitial JS can't call "proceed". There are a few steps in the way, so
it's unlikely to happen by accident:

- The `proceed-link` is added by a string for overridable SSL interstitial, and
is placed inside the paragraph that shows up when you click "Advanced". The SSL
clock interstitial creates a "Reload" link instead of "Advanced".
- In addition, the click listener for `proceed-link` that sends SSL_CMD_PROCEED
is also only add if the interstitial is "overridable" (but I explicitly set the
"override" variable to false for SSL clock interstitials.)

I wouldn't mind creating an instance variable to keep track of which
interstitial we're in (we've talked about an enum for the different types of
interstitials, anyhow), but it would only guard against a little bit of
developer ignorance/refactoring accidents.

[felt, 2014/10/23 05:26:22]

handleKeypress is registered, which means that you can type "danger" and it will
send the CMD_PROCEED, right?

[lgarron, 2014/10/23 19:37:44]

I didn't know about typing "danger". I can look into how to prevent it here.

Any reason you should be able to type "danger" for regular nonoverridable SSL
errors, but not for this?
Is it because the cert might still be incorrect after the clock is fixed, and we
don't want those users to make a dangerous override decision based on only
seeing the more innocent-sounding error?

[felt, 2014/10/23 20:48:57]

It's because the normal error warns the user. This doesn't really say much about
security, just that your clock is wrong. So since we haven't warned about the
risks I don't want it to be overridable.

       interstitial_page_->Proceed();
       break;
     }
     case CMD_MORE: {
       RecordSSLBlockingPageEventStats(MORE);
 #if defined(ENABLE_EXTENSIONS)
       if (sampling_event_.get())
         sampling_event_->set_has_viewed_details(true);
 #endif
       break;
@@ skipping 98 matching lines @@
   for (; i < 5; i++) {
     strings->SetString(keys[i], std::string());
   }
 }
 
 void SSLBlockingPage::OnGotHistoryCount(bool success,
                                         int num_visits,
                                         base::Time first_visit) {
   num_visits_ = num_visits;
 }