src/chrome/common/extensions/manifest_handlers/content_scripts_handler.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/string_util.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/values.h"
  14 #include "chrome/grit/generated_resources.h"
  15 #include "content/public/common/url_constants.h"
  16 #include "extensions/common/error_utils.h"
  17 #include "extensions/common/extension.h"
  18 #include "extensions/common/extension_resource.h"
  19 #include "extensions/common/manifest_constants.h"
  20 #include "extensions/common/manifest_handlers/permissions_parser.h"
  21 #include "extensions/common/permissions/permissions_data.h"
  22 #include "extensions/common/url_pattern.h"
  23 #include "extensions/common/url_pattern_set.h"
  24 #include "ui/base/l10n/l10n_util.h"
  25 #include "url/gurl.h"
  26
  27 namespace extensions {
  28
  29 namespace keys = extensions::manifest_keys;
  30 namespace values = manifest_values;
  31 namespace errors = manifest_errors;
  32
  33 namespace {
  34
  35 // The globally-unique id for a user script.
  36 int64 g_next_user_script_id = 0;
  37
  38 // Helper method that loads either the include_globs or exclude_globs list
  39 // from an entry in the content_script lists of the manifest.
  40 bool LoadGlobsHelper(const base::DictionaryValue* content_script,
  41                      int content_script_index,
  42                      const char* globs_property_name,
  43                      base::string16* error,
  44                      void(UserScript::*add_method)(const std::string& glob),
  45                      UserScript* instance) {
  46   if (!content_script->HasKey(globs_property_name))
  47     return true;  // they are optional
  48
  49   const base::ListValue* list = NULL;
  50   if (!content_script->GetList(globs_property_name, &list)) {
  51     *error = ErrorUtils::FormatErrorMessageUTF16(
  52         errors::kInvalidGlobList,
  53         base::IntToString(content_script_index),
  54         globs_property_name);
  55     return false;
  56   }
  57
  58   for (size_t i = 0; i < list->GetSize(); ++i) {
  59     std::string glob;
  60     if (!list->GetString(i, &glob)) {
  61       *error = ErrorUtils::FormatErrorMessageUTF16(
  62           errors::kInvalidGlob,
  63           base::IntToString(content_script_index),
  64           globs_property_name,
  65           base::IntToString(i));
  66       return false;
  67     }
  68
  69     (instance->*add_method)(glob);
  70   }
  71
  72   return true;
  73 }
  74
  75 // Helper method that loads a UserScript object from a dictionary in the
  76 // content_script list of the manifest.
  77 bool LoadUserScriptFromDictionary(const base::DictionaryValue* content_script,
  78                                   int definition_index,
  79                                   Extension* extension,
  80                                   base::string16* error,
  81                                   UserScript* result) {
  82   // run_at
  83   if (content_script->HasKey(keys::kRunAt)) {
  84     std::string run_location;
  85     if (!content_script->GetString(keys::kRunAt, &run_location)) {
  86       *error = ErrorUtils::FormatErrorMessageUTF16(
  87           errors::kInvalidRunAt,
  88           base::IntToString(definition_index));
  89       return false;
  90     }
  91
  92     if (run_location == values::kRunAtDocumentStart) {
  93       result->set_run_location(UserScript::DOCUMENT_START);
  94     } else if (run_location == values::kRunAtDocumentEnd) {
  95       result->set_run_location(UserScript::DOCUMENT_END);
  96     } else if (run_location == values::kRunAtDocumentIdle) {
  97       result->set_run_location(UserScript::DOCUMENT_IDLE);
  98     } else {
  99       *error = ErrorUtils::FormatErrorMessageUTF16(
 100           errors::kInvalidRunAt,
 101           base::IntToString(definition_index));
 102       return false;
 103     }
 104   }
 105
 106   // all frames
 107   if (content_script->HasKey(keys::kAllFrames)) {
 108     bool all_frames = false;
 109     if (!content_script->GetBoolean(keys::kAllFrames, &all_frames)) {
 110       *error = ErrorUtils::FormatErrorMessageUTF16(
 111             errors::kInvalidAllFrames, base::IntToString(definition_index));
 112       return false;
 113     }
 114     result->set_match_all_frames(all_frames);
 115   }
 116
 117   // match about blank
 118   if (content_script->HasKey(keys::kMatchAboutBlank)) {
 119     bool match_about_blank = false;
 120     if (!content_script->GetBoolean(keys::kMatchAboutBlank,
 121                                     &match_about_blank)) {
 122       *error = ErrorUtils::FormatErrorMessageUTF16(
 123           errors::kInvalidMatchAboutBlank, base::IntToString(definition_index));
 124       return false;
 125     }
 126     result->set_match_about_blank(match_about_blank);
 127   }
 128
 129   // matches (required)
 130   const base::ListValue* matches = NULL;
 131   if (!content_script->GetList(keys::kMatches, &matches)) {
 132     *error = ErrorUtils::FormatErrorMessageUTF16(
 133         errors::kInvalidMatches,
 134         base::IntToString(definition_index));
 135     return false;
 136   }
 137
 138   if (matches->GetSize() == 0) {
 139     *error = ErrorUtils::FormatErrorMessageUTF16(
 140         errors::kInvalidMatchCount,
 141         base::IntToString(definition_index));
 142     return false;
 143   }
 144   for (size_t j = 0; j < matches->GetSize(); ++j) {
 145     std::string match_str;
 146     if (!matches->GetString(j, &match_str)) {
 147       *error = ErrorUtils::FormatErrorMessageUTF16(
 148           errors::kInvalidMatch,
 149           base::IntToString(definition_index),
 150           base::IntToString(j),
 151           errors::kExpectString);
 152       return false;
 153     }
 154
 155     URLPattern pattern(UserScript::ValidUserScriptSchemes(
 156         PermissionsData::CanExecuteScriptEverywhere(extension)));
 157
 158     URLPattern::ParseResult parse_result = pattern.Parse(match_str);
 159     if (parse_result != URLPattern::PARSE_SUCCESS) {
 160       *error = ErrorUtils::FormatErrorMessageUTF16(
 161           errors::kInvalidMatch,
 162           base::IntToString(definition_index),
 163           base::IntToString(j),
 164           URLPattern::GetParseResultString(parse_result));
 165       return false;
 166     }
 167
 168     // TODO(aboxhall): check for webstore
 169     if (!PermissionsData::CanExecuteScriptEverywhere(extension) &&
 170         pattern.scheme() != content::kChromeUIScheme) {
 171       // Exclude SCHEME_CHROMEUI unless it's been explicitly requested.
 172       // If the --extensions-on-chrome-urls flag has not been passed, requesting
 173       // a chrome:// url will cause a parse failure above, so there's no need to
 174       // check the flag here.
 175       pattern.SetValidSchemes(
 176           pattern.valid_schemes() & ~URLPattern::SCHEME_CHROMEUI);
 177     }
 178
 179     if (pattern.MatchesScheme(url::kFileScheme) &&
 180         !PermissionsData::CanExecuteScriptEverywhere(extension)) {
 181       extension->set_wants_file_access(true);
 182       if (!(extension->creation_flags() & Extension::ALLOW_FILE_ACCESS)) {
 183         pattern.SetValidSchemes(
 184             pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
 185       }
 186     }
 187
 188     result->add_url_pattern(pattern);
 189   }
 190
 191   // exclude_matches
 192   if (content_script->HasKey(keys::kExcludeMatches)) {  // optional
 193     const base::ListValue* exclude_matches = NULL;
 194     if (!content_script->GetList(keys::kExcludeMatches, &exclude_matches)) {
 195       *error = ErrorUtils::FormatErrorMessageUTF16(
 196           errors::kInvalidExcludeMatches,
 197           base::IntToString(definition_index));
 198       return false;
 199     }
 200
 201     for (size_t j = 0; j < exclude_matches->GetSize(); ++j) {
 202       std::string match_str;
 203       if (!exclude_matches->GetString(j, &match_str)) {
 204         *error = ErrorUtils::FormatErrorMessageUTF16(
 205             errors::kInvalidExcludeMatch,
 206             base::IntToString(definition_index),
 207             base::IntToString(j),
 208             errors::kExpectString);
 209         return false;
 210       }
 211
 212       int valid_schemes = UserScript::ValidUserScriptSchemes(
 213           PermissionsData::CanExecuteScriptEverywhere(extension));
 214       URLPattern pattern(valid_schemes);
 215
 216       URLPattern::ParseResult parse_result = pattern.Parse(match_str);
 217       if (parse_result != URLPattern::PARSE_SUCCESS) {
 218         *error = ErrorUtils::FormatErrorMessageUTF16(
 219             errors::kInvalidExcludeMatch,
 220             base::IntToString(definition_index), base::IntToString(j),
 221             URLPattern::GetParseResultString(parse_result));
 222         return false;
 223       }
 224
 225       result->add_exclude_url_pattern(pattern);
 226     }
 227   }
 228
 229   // include/exclude globs (mostly for Greasemonkey compatibility)
 230   if (!LoadGlobsHelper(content_script, definition_index, keys::kIncludeGlobs,
 231                        error, &UserScript::add_glob, result)) {
 232       return false;
 233   }
 234
 235   if (!LoadGlobsHelper(content_script, definition_index, keys::kExcludeGlobs,
 236                        error, &UserScript::add_exclude_glob, result)) {
 237       return false;
 238   }
 239
 240   // js and css keys
 241   const base::ListValue* js = NULL;
 242   if (content_script->HasKey(keys::kJs) &&
 243       !content_script->GetList(keys::kJs, &js)) {
 244     *error = ErrorUtils::FormatErrorMessageUTF16(
 245         errors::kInvalidJsList,
 246         base::IntToString(definition_index));
 247     return false;
 248   }
 249
 250   const base::ListValue* css = NULL;
 251   if (content_script->HasKey(keys::kCss) &&
 252       !content_script->GetList(keys::kCss, &css)) {
 253     *error = ErrorUtils::
 254         FormatErrorMessageUTF16(errors::kInvalidCssList,
 255         base::IntToString(definition_index));
 256     return false;
 257   }
 258
 259   // The manifest needs to have at least one js or css user script definition.
 260   if (((js ? js->GetSize() : 0) + (css ? css->GetSize() : 0)) == 0) {
 261     *error = ErrorUtils::FormatErrorMessageUTF16(
 262         errors::kMissingFile,
 263         base::IntToString(definition_index));
 264     return false;
 265   }
 266
 267   if (js) {
 268     for (size_t script_index = 0; script_index < js->GetSize();
 269          ++script_index) {
 270       const base::Value* value;
 271       std::string relative;
 272       if (!js->Get(script_index, &value) || !value->GetAsString(&relative)) {
 273         *error = ErrorUtils::FormatErrorMessageUTF16(
 274             errors::kInvalidJs,
 275             base::IntToString(definition_index),
 276             base::IntToString(script_index));
 277         return false;
 278       }
 279       GURL url = extension->GetResourceURL(relative);
 280       ExtensionResource resource = extension->GetResource(relative);
 281       result->js_scripts().push_back(UserScript::File(
 282           resource.extension_root(), resource.relative_path(), url));
 283     }
 284   }
 285
 286   if (css) {
 287     for (size_t script_index = 0; script_index < css->GetSize();
 288          ++script_index) {
 289       const base::Value* value;
 290       std::string relative;
 291       if (!css->Get(script_index, &value) || !value->GetAsString(&relative)) {
 292         *error = ErrorUtils::FormatErrorMessageUTF16(
 293             errors::kInvalidCss,
 294             base::IntToString(definition_index),
 295             base::IntToString(script_index));
 296         return false;
 297       }
 298       GURL url = extension->GetResourceURL(relative);
 299       ExtensionResource resource = extension->GetResource(relative);
 300       result->css_scripts().push_back(UserScript::File(
 301           resource.extension_root(), resource.relative_path(), url));
 302     }
 303   }
 304
 305   return true;
 306 }
 307
 308 // Returns false and sets the error if script file can't be loaded,
 309 // or if it's not UTF-8 encoded.
 310 static bool IsScriptValid(const base::FilePath& path,
 311                           const base::FilePath& relative_path,
 312                           int message_id,
 313                           std::string* error) {
 314   std::string content;
 315   if (!base::PathExists(path) ||
 316       !base::ReadFileToString(path, &content)) {
 317     *error = l10n_util::GetStringFUTF8(
 318         message_id,
 319         relative_path.LossyDisplayName());
 320     return false;
 321   }
 322
 323   if (!base::IsStringUTF8(content)) {
 324     *error = l10n_util::GetStringFUTF8(
 325         IDS_EXTENSION_BAD_FILE_ENCODING,
 326         relative_path.LossyDisplayName());
 327     return false;
 328   }
 329
 330   return true;
 331 }
 332
 333 struct EmptyUserScriptList {
 334   UserScriptList user_script_list;
 335 };
 336
 337 static base::LazyInstance<EmptyUserScriptList> g_empty_script_list =
 338     LAZY_INSTANCE_INITIALIZER;
 339
 340 }  // namespace
 341
 342 ContentScriptsInfo::ContentScriptsInfo() {
 343 }
 344
 345 ContentScriptsInfo::~ContentScriptsInfo() {
 346 }
 347
 348 // static
 349 const UserScriptList& ContentScriptsInfo::GetContentScripts(
 350     const Extension* extension) {
 351   ContentScriptsInfo* info = static_cast<ContentScriptsInfo*>(
 352       extension->GetManifestData(keys::kContentScripts));
 353   return info ? info->content_scripts
 354               : g_empty_script_list.Get().user_script_list;
 355 }
 356
 357 // static
 358 bool ContentScriptsInfo::ExtensionHasScriptAtURL(const Extension* extension,
 359                                                  const GURL& url) {
 360   const UserScriptList& content_scripts = GetContentScripts(extension);
 361   for (UserScriptList::const_iterator iter = content_scripts.begin();
 362       iter != content_scripts.end(); ++iter) {
 363     if (iter->MatchesURL(url))
 364       return true;
 365   }
 366   return false;
 367 }
 368
 369 // static
 370 URLPatternSet ContentScriptsInfo::GetScriptableHosts(
 371     const Extension* extension) {
 372   const UserScriptList& content_scripts = GetContentScripts(extension);
 373   URLPatternSet scriptable_hosts;
 374   for (UserScriptList::const_iterator content_script =
 375            content_scripts.begin();
 376        content_script != content_scripts.end();
 377        ++content_script) {
 378     URLPatternSet::const_iterator pattern =
 379         content_script->url_patterns().begin();
 380     for (; pattern != content_script->url_patterns().end(); ++pattern)
 381       scriptable_hosts.AddPattern(*pattern);
 382   }
 383   return scriptable_hosts;
 384 }
 385
 386 ContentScriptsHandler::ContentScriptsHandler() {
 387 }
 388
 389 ContentScriptsHandler::~ContentScriptsHandler() {
 390 }
 391
 392 const std::vector<std::string> ContentScriptsHandler::Keys() const {
 393   static const char* keys[] = {
 394     keys::kContentScripts
 395   };
 396   return std::vector<std::string>(keys, keys + arraysize(keys));
 397 }
 398
 399 bool ContentScriptsHandler::Parse(Extension* extension, base::string16* error) {
 400   scoped_ptr<ContentScriptsInfo> content_scripts_info(new ContentScriptsInfo);
 401   const base::ListValue* scripts_list = NULL;
 402   if (!extension->manifest()->GetList(keys::kContentScripts, &scripts_list)) {
 403     *error = base::ASCIIToUTF16(errors::kInvalidContentScriptsList);
 404     return false;
 405   }
 406
 407   for (size_t i = 0; i < scripts_list->GetSize(); ++i) {
 408     const base::DictionaryValue* script_dict = NULL;
 409     if (!scripts_list->GetDictionary(i, &script_dict)) {
 410       *error = ErrorUtils::FormatErrorMessageUTF16(
 411           errors::kInvalidContentScript,
 412           base::IntToString(i));
 413       return false;
 414     }
 415
 416     UserScript user_script;
 417     if (!LoadUserScriptFromDictionary(script_dict,
 418                                       i,
 419                                       extension,
 420                                       error,
 421                                       &user_script)) {
 422       return false;  // Failed to parse script context definition.
 423     }
 424
 425     user_script.set_extension_id(extension->id());
 426     if (extension->converted_from_user_script()) {
 427       user_script.set_emulate_greasemonkey(true);
 428       // Greasemonkey matches all frames.
 429       user_script.set_match_all_frames(true);
 430     }
 431     user_script.set_id(g_next_user_script_id++);
 432     content_scripts_info->content_scripts.push_back(user_script);
 433   }
 434   extension->SetManifestData(keys::kContentScripts,
 435                              content_scripts_info.release());
 436   PermissionsParser::SetScriptableHosts(
 437       extension, ContentScriptsInfo::GetScriptableHosts(extension));
 438   return true;
 439 }
 440
 441 bool ContentScriptsHandler::Validate(
 442     const Extension* extension,
 443     std::string* error,
 444     std::vector<InstallWarning>* warnings) const {
 445   // Validate that claimed script resources actually exist,
 446   // and are UTF-8 encoded.
 447   ExtensionResource::SymlinkPolicy symlink_policy;
 448   if ((extension->creation_flags() &
 449        Extension::FOLLOW_SYMLINKS_ANYWHERE) != 0) {
 450     symlink_policy = ExtensionResource::FOLLOW_SYMLINKS_ANYWHERE;
 451   } else {
 452     symlink_policy = ExtensionResource::SYMLINKS_MUST_RESOLVE_WITHIN_ROOT;
 453   }
 454
 455   const UserScriptList& content_scripts =
 456       ContentScriptsInfo::GetContentScripts(extension);
 457   for (size_t i = 0; i < content_scripts.size(); ++i) {
 458     const UserScript& script = content_scripts[i];
 459
 460     for (size_t j = 0; j < script.js_scripts().size(); j++) {
 461       const UserScript::File& js_script = script.js_scripts()[j];
 462       const base::FilePath& path = ExtensionResource::GetFilePath(
 463           js_script.extension_root(), js_script.relative_path(),
 464           symlink_policy);
 465       if (!IsScriptValid(path, js_script.relative_path(),
 466                          IDS_EXTENSION_LOAD_JAVASCRIPT_FAILED, error))
 467         return false;
 468     }
 469
 470     for (size_t j = 0; j < script.css_scripts().size(); j++) {
 471       const UserScript::File& css_script = script.css_scripts()[j];
 472       const base::FilePath& path = ExtensionResource::GetFilePath(
 473           css_script.extension_root(), css_script.relative_path(),
 474           symlink_policy);
 475       if (!IsScriptValid(path, css_script.relative_path(),
 476                          IDS_EXTENSION_LOAD_CSS_FAILED, error))
 477         return false;
 478     }
 479   }
 480
 481   return true;
 482 }
 483
 484 }  // namespace extensions