Add sanbdoxed_pages to allow extension/app pages to be served in a sandboxed, unique origin

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 43 matching lines @@
 #include "base/win/metro.h"
 #endif
 
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 namespace errors = extension_manifest_errors;
 namespace info_keys = extension_info_keys;
 namespace switch_utils = extensions::switch_utils;
 
 using extensions::csp_validator::ContentSecurityPolicyIsLegal;
+using extensions::csp_validator::ContentSecurityPolicyIsSandboxed;
 using extensions::csp_validator::ContentSecurityPolicyIsSecure;
 
 namespace extensions {
 
 namespace {
 
 const int kModernManifestVersion = 1;
 const int kPEMOutputColumns = 65;
 
 const char kOverrideExtentUrlPatternFormat[] = "chrome://%s/*";
@@ skipping 21 matching lines @@
    "default-src 'self' chrome-extension-resource:;"
    // For remote resources, they can fetch them via XMLHttpRequest.
    "connect-src *;"
    // And serve them via blob:, data: or filesystem: URLs
    "style-src " PLATFORM_APP_LOCAL_CSP_SOURCES " 'unsafe-inline';"
    "img-src " PLATFORM_APP_LOCAL_CSP_SOURCES ";"
    "media-src " PLATFORM_APP_LOCAL_CSP_SOURCES ";"
    "frame-src " PLATFORM_APP_LOCAL_CSP_SOURCES ";"
    "font-src " PLATFORM_APP_LOCAL_CSP_SOURCES ";";
 
+const char kDefaultSandboxedPageContentSecurityPolicy[] =
+    "sandbox allow-scripts allow-forms";
+
 // Converts a normal hexadecimal string into the alphabet used by extensions.
 // We use the characters 'a'-'p' instead of '0'-'f' to avoid ever having a
 // completely numeric host, since some software interprets that as an IP
 // address.
 static void ConvertHexadecimalToIDAlphabet(std::string* id) {
   for (size_t i = 0; i < id->size(); ++i) {
     int val;
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
                                                id->begin() + i + 1),
                              &val)) {
@@ skipping 404 matching lines @@
   return false;
 }
 
 bool Extension::HasWebAccessibleResources() const {
   if (web_accessible_resources_.size())
     return true;
 
   return false;
 }
 
+bool Extension::IsSandboxedPage(const std::string& relative_path) const {
+  return sandboxed_pages_.find(relative_path) != sandboxed_pages_.end();
+}
+
+
+std::string Extension::GetResourceContentSecurityPolicy(
+    const std::string& relative_path) const {
+  return IsSandboxedPage(relative_path) ?
+      sandboxed_pages_content_security_policy_ : content_security_policy_;
+}
+
 bool Extension::GenerateId(const std::string& input, std::string* output) {
   DCHECK(output);
   uint8 hash[Extension::kIdSize];
   crypto::SHA256HashString(input, hash, sizeof(hash));
   *output = StringToLowerASCII(base::HexEncode(hash, sizeof(hash)));
   ConvertHexadecimalToIDAlphabet(output);
 
   return true;
 }
 
@@ skipping 734 matching lines @@
     const ExtensionAPIPermissionSet& api_permissions,
     string16* error) {
   if (!LoadDescription(error) ||
       !LoadHomepageURL(error) ||
       !LoadUpdateURL(error) ||
       !LoadIcons(error) ||
       !LoadCommands(error) ||
       !LoadPlugins(error) ||
       !LoadNaClModules(error) ||
       !LoadWebAccessibleResources(error) ||
+      !LoadSandboxedPages(error) ||
       !CheckRequirements(error) ||
       !LoadDefaultLocale(error) ||
       !LoadOfflineEnabled(error) ||
       !LoadOptionsPage(error) ||
       // LoadBackgroundScripts() must be called before LoadBackgroundPage().
       !LoadBackgroundScripts(error) ||
       !LoadBackgroundPage(api_permissions, error) ||
       !LoadBackgroundPersistent(api_permissions, error) ||
       !LoadBackgroundAllowJSAccess(api_permissions, error) ||
       !LoadWebIntentServices(error))
@@ skipping 251 matching lines @@
     nacl_modules_.back().url = GetResourceURL(path_str);
     nacl_modules_.back().mime_type = mime_type;
   }
 
   return true;
 }
 
 bool Extension::LoadWebAccessibleResources(string16* error) {
   if (!manifest_->HasKey(keys::kWebAccessibleResources))
     return true;
-  ListValue* list_value;
+  ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kWebAccessibleResources, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidWebAccessibleResourcesList);
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string relative_path;
     if (!list_value->GetString(i, &relative_path)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidWebAccessibleResource, base::IntToString(i));
       return false;
     }
     if (relative_path[0] != '/')
       relative_path = '/' + relative_path;
     web_accessible_resources_.insert(relative_path);
   }
 
   return true;
 }
 
+bool Extension::LoadSandboxedPages(string16* error) {
+  // Can't use HasKey, since it doesn't do path expansion.
+  Value* ignored = NULL;
+  if (!manifest_->Get(keys::kSandboxedPages, &ignored))
+    return true;
+
+  ListValue* list_value = NULL;
+  if (!manifest_->GetList(keys::kSandboxedPages, &list_value)) {
+    *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesList);
+    return false;
+  }
+  for (size_t i = 0; i < list_value->GetSize(); ++i) {
+    std::string relative_path;
+    if (!list_value->GetString(i, &relative_path)) {
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidSandboxedPage, base::IntToString(i));
+      return false;
+    }
+    if (relative_path[0] != '/')
+      relative_path = '/' + relative_path;
+    sandboxed_pages_.insert(relative_path);
+  }
+
+  if (manifest_->Get(keys::kSandboxedPagesCSP, &ignored)) {
+    if (!manifest_->GetString(
+        keys::kSandboxedPagesCSP, &sandboxed_pages_content_security_policy_)) {
+      *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesCSP);
+      return false;
+    }
+
+    if (!ContentSecurityPolicyIsLegal(
+            sandboxed_pages_content_security_policy_) ||
+        !ContentSecurityPolicyIsSandboxed(
+            sandboxed_pages_content_security_policy_, GetType())) {
+      *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesCSP);
+      return false;
+    }
+  } else {
+    sandboxed_pages_content_security_policy_ =
+        kDefaultSandboxedPageContentSecurityPolicy;
+    CHECK(ContentSecurityPolicyIsSandboxed(
+        sandboxed_pages_content_security_policy_, GetType()));
+  }
+
+  return true;
+}
+
 // These are not actually persisted (they're only used by the store), but
 // still validated.
 bool Extension::CheckRequirements(string16* error) {
   if (!manifest_->HasKey(keys::kRequirements))
     return true;
   DictionaryValue* requirements_value = NULL;
   if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
     *error = ASCIIToUTF16(errors::kInvalidRequirements);
     return false;
   }
@@ skipping 2050 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions