Communicate ExtensionSettings policy to renderers

extensions/common/permissions/permissions_data.cc

 // Copyright (c) 2013 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 "extensions/common/permissions/permissions_data.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 69 matching lines @@
 bool PermissionsData::ShouldSkipPermissionWarnings(
     const std::string& extension_id) {
   // See http://b/4946060 for more details.
   return extension_id == extension_misc::kProdHangoutsExtensionId;
 }
 
 // static
 bool PermissionsData::IsRestrictedUrl(const GURL& document_url,
                                       const Extension* extension,
                                       std::string* error) {
+  if (extension &&
+      extension->permissions_data()->IsRuntimeBlockedHost(document_url)) {

[Devlin, 2016/11/23 17:22:56]

This isn't the same type of restricted url as the rest here, and this is
redundant with the check in CanRunOnPage.

[nrpeter, 2017/01/02 19:57:45]

The idea was to block any manipulation of a webpage protected by this policy in
a way similar to the webstore. I was thinking there are some situations where
this is called instead of CanRunOnPage.

+    *error = manifest_errors::kCannotAccessPage;
+    return true;
+  }
   if (extension && CanExecuteScriptEverywhere(extension))
     return false;
 
   // Check if the scheme is valid for extensions. If not, return.
   if (!URLPattern::IsValidSchemeForExtensions(document_url.scheme()) &&
       document_url.spec() != url::kAboutBlankURL) {
     if (error) {
       if (extension->permissions_data()->active_permissions().HasAPIPermission(
               APIPermission::kTab)) {
         *error = ErrorUtils::FormatErrorMessage(
@@ skipping 33 matching lines @@
 }
 
 void PermissionsData::SetPermissions(
     std::unique_ptr<const PermissionSet> active,
     std::unique_ptr<const PermissionSet> withheld) const {
   AutoLockOnValidThread lock(runtime_lock_, thread_checker_.get());
   active_permissions_unsafe_ = std::move(active);
   withheld_permissions_unsafe_ = std::move(withheld);
 }
 
+void PermissionsData::SetRuntimeBlockedAllowedHosts(
+    const URLPatternSet runtime_blocked_hosts,
+    const URLPatternSet runtime_allowed_hosts) const {
+  AutoLockOnValidThread lock(runtime_lock_, thread_checker_.get());
+  runtime_blocked_hosts_unsafe_ = runtime_blocked_hosts;
+  runtime_allowed_hosts_unsafe_ = runtime_allowed_hosts;
+}
+
 void PermissionsData::SetActivePermissions(
     std::unique_ptr<const PermissionSet> active) const {
   AutoLockOnValidThread lock(runtime_lock_, thread_checker_.get());
   active_permissions_unsafe_ = std::move(active);
 }
 
 void PermissionsData::UpdateTabSpecificPermissions(
     int tab_id,
     const PermissionSet& permissions) const {
   AutoLockOnValidThread lock(runtime_lock_, thread_checker_.get());
@@ skipping 48 matching lines @@
 URLPatternSet PermissionsData::GetEffectiveHostPermissions() const {
   base::AutoLock auto_lock(runtime_lock_);
   URLPatternSet effective_hosts = active_permissions_unsafe_->effective_hosts();
   for (const auto& val : tab_specific_permissions_)
     effective_hosts.AddPatterns(val.second->effective_hosts());
   return effective_hosts;
 }
 
 bool PermissionsData::HasHostPermission(const GURL& url) const {
   base::AutoLock auto_lock(runtime_lock_);
-  return active_permissions_unsafe_->HasExplicitAccessToOrigin(url);
+  return active_permissions_unsafe_->HasExplicitAccessToOrigin(url) &&
+         !IsRuntimeBlockedHost(url);
 }
 
 bool PermissionsData::HasEffectiveAccessToAllHosts() const {
   base::AutoLock auto_lock(runtime_lock_);
   return active_permissions_unsafe_->HasEffectiveAccessToAllHosts();
 }
 
 PermissionMessages PermissionsData::GetPermissionMessages() const {
   base::AutoLock auto_lock(runtime_lock_);
   return PermissionMessageProvider::Get()->GetPermissionMessages(
@@ skipping 98 matching lines @@
   if (tab_id >= 0) {
     const PermissionSet* tab_permissions = GetTabSpecificPermissions(tab_id);
     if (tab_permissions &&
         tab_permissions->explicit_hosts().MatchesSecurityOrigin(url)) {
       return true;
     }
   }
   return false;
 }
 
+bool PermissionsData::IsRuntimeBlockedHost(const GURL& url) const {
+  if (runtime_blocked_hosts_unsafe_.MatchesURL(url)) {

[asargent_no_longer_on_chrome, 2016/11/23 01:19:23]

It seems like one of 2 things should happen here:

a) runtime_lock_ is held

b) use untime_blocked_hosts() to test against (instead of
runtime_blocked_hosts_unsafe_)

(same thing below for runtime_allowed_hosts_unsafe)

[nrpeter, 2017/01/02 19:57:45]

I may need a little bit of help with this. I tried making sure runtime_lock_ is
held and it works in most every test except for when a new extension is added.
Would you have 15 minutes to look at the trace of the issue?

+    if (!runtime_allowed_hosts_unsafe_.MatchesURL(url))
+      return true;
+  }
+  return false;
+}
+
 PermissionsData::AccessType PermissionsData::CanRunOnPage(
     const Extension* extension,
     const GURL& document_url,
     int tab_id,
     const URLPatternSet& permitted_url_patterns,
     const URLPatternSet& withheld_url_patterns,
     std::string* error) const {
   runtime_lock_.AssertAcquired();
   if (g_policy_delegate &&
       !g_policy_delegate->CanExecuteScriptOnPage(extension, document_url,
-                                                 tab_id, error)) {
+                                                 tab_id, error))
+    return ACCESS_DENIED;
+
+  if (IsRuntimeBlockedHost(document_url)) {
+    if (error)
+      *error = manifest_errors::kCannotScriptPageByPolicy;
     return ACCESS_DENIED;
   }
 
   if (IsRestrictedUrl(document_url, extension, error))
     return ACCESS_DENIED;
 
   if (HasTabSpecificPermissionToExecuteScript(tab_id, document_url))
     return ACCESS_ALLOWED;
 
   if (permitted_url_patterns.MatchesURL(document_url))
     return ACCESS_ALLOWED;
 
   if (withheld_url_patterns.MatchesURL(document_url))
     return ACCESS_WITHHELD;
 
   if (error) {
     if (extension->permissions_data()->active_permissions().HasAPIPermission(
             APIPermission::kTab)) {
       *error = ErrorUtils::FormatErrorMessage(
           manifest_errors::kCannotAccessPageWithUrl, document_url.spec());
     } else {
       *error = manifest_errors::kCannotAccessPage;
     }
   }
 
   return ACCESS_DENIED;
 }
 
 }  // namespace extensions