Adding <keygen> Content Setting (core)

components/content_settings/core/browser/content_settings_policy_provider.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 "components/content_settings/core/browser/content_settings_policy_provider.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
         {prefs::kManagedCookiesSessionOnlyForUrls,
          CONTENT_SETTINGS_TYPE_COOKIES, CONTENT_SETTING_SESSION_ONLY},
         {prefs::kManagedImagesAllowedForUrls, CONTENT_SETTINGS_TYPE_IMAGES,
          CONTENT_SETTING_ALLOW},
         {prefs::kManagedImagesBlockedForUrls, CONTENT_SETTINGS_TYPE_IMAGES,
          CONTENT_SETTING_BLOCK},
         {prefs::kManagedJavaScriptAllowedForUrls,
          CONTENT_SETTINGS_TYPE_JAVASCRIPT, CONTENT_SETTING_ALLOW},
         {prefs::kManagedJavaScriptBlockedForUrls,
          CONTENT_SETTINGS_TYPE_JAVASCRIPT, CONTENT_SETTING_BLOCK},
+        {prefs::kManagedKeygenAllowedForUrls,
+         CONTENT_SETTINGS_TYPE_KEYGEN, CONTENT_SETTING_ALLOW},

[raymes, 2015/11/05 03:15:47]

Do we really want to add enterprise management for this setting?

[Ryan Sleevi, 2015/11/05 03:27:47]

Forwarded thread. Internal enterprise use is the key use case, so yeah.

Note that <keygen> is a special snowflake. It's not a JS feature - it's
something that goes in the form submission. It's done as a blocking call from
Blink renderer to the browser process, due to WebKit awfulness related to forms
processing that would have been even more painful. So we can't just treat it
like, say, window.alert - with a discrete intent on a current page - since the
actual 'scary' part of <keygen> always happens as part of a navigation (form
submission).

So instead, when a <keygen> tag is encountered, it surfaces the UI that says
"Hey, this is going to break", and if the user doesn't accept it before they
attempt to navigate, then it breaks, just like it indicated.

However, this requiring user interaction breaks the enterprise use case, which
often do a multi-phase navigation where they bounce w/ an autosubmitting form to
a processing page, which then does further stuff. A concrete example would be
some of the stuff that Google has deployed inhouse, and which relies on that
transparency (if you've used a Chromebook at all at Google, you've run in to
this use case).

Hence the Enterprise escape clause until the Enterprise systems (including a
number of whitebox solutions offered by CA vendors and Microsoft) can adapt or
until the full *removal* of the <keygen> tag happens.

+        {prefs::kManagedKeygenBlockedForUrls,
+         CONTENT_SETTINGS_TYPE_KEYGEN, CONTENT_SETTING_BLOCK},
         {prefs::kManagedNotificationsAllowedForUrls,
          CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_ALLOW},
         {prefs::kManagedNotificationsBlockedForUrls,
          CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_BLOCK},
         {prefs::kManagedPluginsAllowedForUrls, CONTENT_SETTINGS_TYPE_PLUGINS,
          CONTENT_SETTING_ALLOW},
         {prefs::kManagedPluginsBlockedForUrls, CONTENT_SETTINGS_TYPE_PLUGINS,
          CONTENT_SETTING_BLOCK},
         {prefs::kManagedPopupsAllowedForUrls, CONTENT_SETTINGS_TYPE_POPUPS,
          CONTENT_SETTING_ALLOW},
@@ skipping 13 matching lines @@
 
 // static
 const PolicyProvider::PrefsForManagedDefaultMapEntry
     PolicyProvider::kPrefsForManagedDefault[] = {
         {CONTENT_SETTINGS_TYPE_COOKIES, prefs::kManagedDefaultCookiesSetting},
         {CONTENT_SETTINGS_TYPE_IMAGES, prefs::kManagedDefaultImagesSetting},
         {CONTENT_SETTINGS_TYPE_GEOLOCATION,
          prefs::kManagedDefaultGeolocationSetting},
         {CONTENT_SETTINGS_TYPE_JAVASCRIPT,
          prefs::kManagedDefaultJavaScriptSetting},
+        {CONTENT_SETTINGS_TYPE_KEYGEN,
+         prefs::kManagedDefaultKeygenSetting},
         {CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
          prefs::kManagedDefaultMediaStreamSetting},
         {CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
          prefs::kManagedDefaultMediaStreamSetting},
         {CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
          prefs::kManagedDefaultNotificationsSetting},
         {CONTENT_SETTINGS_TYPE_PLUGINS, prefs::kManagedDefaultPluginsSetting},
         {CONTENT_SETTINGS_TYPE_POPUPS, prefs::kManagedDefaultPopupsSetting},
 };
 
 // static
 void PolicyProvider::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(prefs::kManagedAutoSelectCertificateForUrls);
   registry->RegisterListPref(prefs::kManagedCookiesAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedCookiesBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedCookiesSessionOnlyForUrls);
   registry->RegisterListPref(prefs::kManagedImagesAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedImagesBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedJavaScriptAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedJavaScriptBlockedForUrls);
+  registry->RegisterListPref(prefs::kManagedKeygenAllowedForUrls);
+  registry->RegisterListPref(prefs::kManagedKeygenBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedNotificationsAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedNotificationsBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedPluginsAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedPluginsBlockedForUrls);
   registry->RegisterListPref(prefs::kManagedPopupsAllowedForUrls);
   registry->RegisterListPref(prefs::kManagedPopupsBlockedForUrls);
   // Preferences for default content setting policies. If a policy is not set of
   // the corresponding preferences below is set to CONTENT_SETTING_DEFAULT.
   registry->RegisterIntegerPref(prefs::kManagedDefaultCookiesSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultGeolocationSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultImagesSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultJavaScriptSetting,
                                 CONTENT_SETTING_DEFAULT);
+  registry->RegisterIntegerPref(prefs::kManagedDefaultKeygenSetting,
+                                CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultNotificationsSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultMediaStreamSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultPluginsSetting,
                                 CONTENT_SETTING_DEFAULT);
   registry->RegisterIntegerPref(prefs::kManagedDefaultPopupsSetting,
                                 CONTENT_SETTING_DEFAULT);
 }
 
 PolicyProvider::PolicyProvider(PrefService* prefs) : prefs_(prefs) {
   ReadManagedDefaultSettings();
   ReadManagedContentSettings(false);
 
   pref_change_registrar_.Init(prefs_);
   PrefChangeRegistrar::NamedChangeCallback callback =
       base::Bind(&PolicyProvider::OnPreferenceChanged, base::Unretained(this));
   pref_change_registrar_.Add(
       prefs::kManagedAutoSelectCertificateForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedCookiesAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedCookiesBlockedForUrls, callback);
   pref_change_registrar_.Add(
       prefs::kManagedCookiesSessionOnlyForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedImagesAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedImagesBlockedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedJavaScriptBlockedForUrls, callback);
+  pref_change_registrar_.Add(prefs::kManagedKeygenAllowedForUrls, callback);
+  pref_change_registrar_.Add(prefs::kManagedKeygenBlockedForUrls, callback);
 
   pref_change_registrar_.Add(
       prefs::kManagedNotificationsAllowedForUrls, callback);
   pref_change_registrar_.Add(
       prefs::kManagedNotificationsBlockedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedPluginsAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedPluginsBlockedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedPopupsAllowedForUrls, callback);
   pref_change_registrar_.Add(prefs::kManagedPopupsBlockedForUrls, callback);
   // The following preferences are only used to indicate if a default content
   // setting is managed and to hold the managed default setting value. If the
   // value for any of the following preferences is set then the corresponding
   // default content setting is managed. These preferences exist in parallel to
   // the preference default content settings. If a default content settings type
   // is managed any user defined exceptions (patterns) for this type are
   // ignored.
   pref_change_registrar_.Add(prefs::kManagedDefaultCookiesSetting, callback);
   pref_change_registrar_.Add(
       prefs::kManagedDefaultGeolocationSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultImagesSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultJavaScriptSetting, callback);
+  pref_change_registrar_.Add(prefs::kManagedDefaultKeygenSetting, callback);
   pref_change_registrar_.Add(
       prefs::kManagedDefaultNotificationsSetting, callback);
   pref_change_registrar_.Add(
       prefs::kManagedDefaultMediaStreamSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultPluginsSetting, callback);
   pref_change_registrar_.Add(prefs::kManagedDefaultPopupsSetting, callback);
 }
 
 PolicyProvider::~PolicyProvider() {
   DCHECK(!prefs_);
@@ skipping 211 matching lines @@
   }
 
   if (name == prefs::kManagedAutoSelectCertificateForUrls ||
       name == prefs::kManagedCookiesAllowedForUrls ||
       name == prefs::kManagedCookiesBlockedForUrls ||
       name == prefs::kManagedCookiesSessionOnlyForUrls ||
       name == prefs::kManagedImagesAllowedForUrls ||
       name == prefs::kManagedImagesBlockedForUrls ||
       name == prefs::kManagedJavaScriptAllowedForUrls ||
       name == prefs::kManagedJavaScriptBlockedForUrls ||
+      name == prefs::kManagedKeygenAllowedForUrls ||
+      name == prefs::kManagedKeygenBlockedForUrls ||
       name == prefs::kManagedNotificationsAllowedForUrls ||
       name == prefs::kManagedNotificationsBlockedForUrls ||
       name == prefs::kManagedPluginsAllowedForUrls ||
       name == prefs::kManagedPluginsBlockedForUrls ||
       name == prefs::kManagedPopupsAllowedForUrls ||
       name == prefs::kManagedPopupsBlockedForUrls) {
     ReadManagedContentSettings(true);
     ReadManagedDefaultSettings();
   }
 
   NotifyObservers(ContentSettingsPattern(),
                   ContentSettingsPattern(),
                   CONTENT_SETTINGS_TYPE_DEFAULT,
                   std::string());
 }
 
 }  // namespace content_settings