src/extensions/common/manifest_handlers/shared_module_info.cc

   1 // Copyright 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 "extensions/common/manifest_handlers/shared_module_info.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/version.h"
  13 #include "components/crx_file/id_util.h"
  14 #include "extensions/common/constants.h"
  15 #include "extensions/common/error_utils.h"
  16 #include "extensions/common/manifest_constants.h"
  17 #include "extensions/common/permissions/permission_set.h"
  18 #include "extensions/common/permissions/permissions_data.h"
  19
  20 namespace extensions {
  21
  22 namespace keys = manifest_keys;
  23 namespace values = manifest_values;
  24 namespace errors = manifest_errors;
  25
  26 namespace {
  27
  28 const char kSharedModule[] = "shared_module";
  29
  30 static base::LazyInstance<SharedModuleInfo> g_empty_shared_module_info =
  31     LAZY_INSTANCE_INITIALIZER;
  32
  33 const SharedModuleInfo& GetSharedModuleInfo(const Extension* extension) {
  34   SharedModuleInfo* info = static_cast<SharedModuleInfo*>(
  35       extension->GetManifestData(kSharedModule));
  36   if (!info)
  37     return g_empty_shared_module_info.Get();
  38   return *info;
  39 }
  40
  41 }  // namespace
  42
  43 SharedModuleInfo::SharedModuleInfo() {
  44 }
  45
  46 SharedModuleInfo::~SharedModuleInfo() {
  47 }
  48
  49 // static
  50 void SharedModuleInfo::ParseImportedPath(const std::string& path,
  51                                          std::string* import_id,
  52                                          std::string* import_relative_path) {
  53   std::vector<std::string> tokens;
  54   Tokenize(path, std::string("/"), &tokens);
  55   if (tokens.size() > 2 && tokens[0] == kModulesDir &&
  56       crx_file::id_util::IdIsValid(tokens[1])) {
  57     *import_id = tokens[1];
  58     *import_relative_path = tokens[2];
  59     for (size_t i = 3; i < tokens.size(); ++i)
  60       *import_relative_path += "/" + tokens[i];
  61   }
  62 }
  63
  64 // static
  65 bool SharedModuleInfo::IsImportedPath(const std::string& path) {
  66   std::vector<std::string> tokens;
  67   Tokenize(path, std::string("/"), &tokens);
  68   if (tokens.size() > 2 && tokens[0] == kModulesDir &&
  69       crx_file::id_util::IdIsValid(tokens[1])) {
  70     return true;
  71   }
  72   return false;
  73 }
  74
  75 // static
  76 bool SharedModuleInfo::IsSharedModule(const Extension* extension) {
  77   CHECK(extension);
  78   return extension->manifest()->is_shared_module();
  79 }
  80
  81 // static
  82 bool SharedModuleInfo::IsExportAllowed(const Extension* extension,
  83                                        const std::string& relative_path) {
  84   return GetSharedModuleInfo(extension).
  85       exported_set_.MatchesURL(extension->url().Resolve(relative_path));
  86 }
  87
  88 // static
  89 bool SharedModuleInfo::IsExportAllowedByWhitelist(const Extension* extension,
  90                                                   const std::string& other_id) {
  91   // Sanity check. In case the caller did not check |extension| to make sure it
  92   // is a shared module, we do not want it to appear that the extension with
  93   // |other_id| importing |extension| is valid.
  94   if (!SharedModuleInfo::IsSharedModule(extension))
  95     return false;
  96   const SharedModuleInfo& info = GetSharedModuleInfo(extension);
  97   if (info.export_whitelist_.empty())
  98     return true;
  99   if (info.export_whitelist_.find(other_id) != info.export_whitelist_.end())
 100     return true;
 101   return false;
 102 }
 103
 104 // static
 105 bool SharedModuleInfo::ImportsExtensionById(const Extension* extension,
 106                                             const std::string& other_id) {
 107   const SharedModuleInfo& info = GetSharedModuleInfo(extension);
 108   for (size_t i = 0; i < info.imports_.size(); i++) {
 109     if (info.imports_[i].extension_id == other_id)
 110       return true;
 111   }
 112   return false;
 113 }
 114
 115 // static
 116 bool SharedModuleInfo::ImportsModules(const Extension* extension) {
 117   return GetSharedModuleInfo(extension).imports_.size() > 0;
 118 }
 119
 120 // static
 121 const std::vector<SharedModuleInfo::ImportInfo>& SharedModuleInfo::GetImports(
 122     const Extension* extension) {
 123   return GetSharedModuleInfo(extension).imports_;
 124 }
 125
 126 bool SharedModuleInfo::Parse(const Extension* extension,
 127                              base::string16* error) {
 128   bool has_import = extension->manifest()->HasKey(keys::kImport);
 129   bool has_export = extension->manifest()->HasKey(keys::kExport);
 130   if (!has_import && !has_export)
 131     return true;
 132
 133   if (has_import && has_export) {
 134     *error = base::ASCIIToUTF16(errors::kInvalidImportAndExport);
 135     return false;
 136   }
 137
 138   if (has_export) {
 139     const base::DictionaryValue* export_value = NULL;
 140     if (!extension->manifest()->GetDictionary(keys::kExport, &export_value)) {
 141       *error = base::ASCIIToUTF16(errors::kInvalidExport);
 142       return false;
 143     }
 144     const base::ListValue* resources_list = NULL;
 145     if (!export_value->GetList(keys::kResources, &resources_list)) {
 146       *error = base::ASCIIToUTF16(errors::kInvalidExportResources);
 147       return false;
 148     }
 149     if (export_value->HasKey(keys::kWhitelist)) {
 150       const base::ListValue* whitelist = NULL;
 151       if (!export_value->GetList(keys::kWhitelist, &whitelist)) {
 152         *error = base::ASCIIToUTF16(errors::kInvalidExportWhitelist);
 153         return false;
 154       }
 155       for (size_t i = 0; i < whitelist->GetSize(); ++i) {
 156         std::string extension_id;
 157         if (!whitelist->GetString(i, &extension_id) ||
 158             !crx_file::id_util::IdIsValid(extension_id)) {
 159           *error = ErrorUtils::FormatErrorMessageUTF16(
 160               errors::kInvalidExportWhitelistString, base::IntToString(i));
 161           return false;
 162         }
 163         export_whitelist_.insert(extension_id);
 164       }
 165     }
 166     for (size_t i = 0; i < resources_list->GetSize(); ++i) {
 167       std::string resource_path;
 168       if (!resources_list->GetString(i, &resource_path)) {
 169         *error = ErrorUtils::FormatErrorMessageUTF16(
 170             errors::kInvalidExportResourcesString, base::IntToString(i));
 171         return false;
 172       }
 173       const GURL& resolved_path = extension->url().Resolve(resource_path);
 174       if (!resolved_path.is_valid()) {
 175         *error = ErrorUtils::FormatErrorMessageUTF16(
 176             errors::kInvalidExportResourcesString, base::IntToString(i));
 177         return false;
 178       }
 179       exported_set_.AddPattern(
 180           URLPattern(URLPattern::SCHEME_EXTENSION, resolved_path.spec()));
 181     }
 182   }
 183
 184   if (has_import) {
 185     const base::ListValue* import_list = NULL;
 186     if (!extension->manifest()->GetList(keys::kImport, &import_list)) {
 187       *error = base::ASCIIToUTF16(errors::kInvalidImport);
 188       return false;
 189     }
 190     for (size_t i = 0; i < import_list->GetSize(); ++i) {
 191       const base::DictionaryValue* import_entry = NULL;
 192       if (!import_list->GetDictionary(i, &import_entry)) {
 193         *error = base::ASCIIToUTF16(errors::kInvalidImport);
 194         return false;
 195       }
 196       std::string extension_id;
 197       imports_.push_back(ImportInfo());
 198       if (!import_entry->GetString(keys::kId, &extension_id) ||
 199           !crx_file::id_util::IdIsValid(extension_id)) {
 200         *error = ErrorUtils::FormatErrorMessageUTF16(
 201             errors::kInvalidImportId, base::IntToString(i));
 202         return false;
 203       }
 204       imports_.back().extension_id = extension_id;
 205       if (import_entry->HasKey(keys::kMinimumVersion)) {
 206         std::string min_version;
 207         if (!import_entry->GetString(keys::kMinimumVersion, &min_version)) {
 208           *error = ErrorUtils::FormatErrorMessageUTF16(
 209               errors::kInvalidImportVersion, base::IntToString(i));
 210           return false;
 211         }
 212         imports_.back().minimum_version = min_version;
 213         Version v(min_version);
 214         if (!v.IsValid()) {
 215           *error = ErrorUtils::FormatErrorMessageUTF16(
 216               errors::kInvalidImportVersion, base::IntToString(i));
 217           return false;
 218         }
 219       }
 220     }
 221   }
 222   return true;
 223 }
 224
 225
 226 SharedModuleHandler::SharedModuleHandler() {
 227 }
 228
 229 SharedModuleHandler::~SharedModuleHandler() {
 230 }
 231
 232 bool SharedModuleHandler::Parse(Extension* extension, base::string16* error) {
 233   scoped_ptr<SharedModuleInfo> info(new SharedModuleInfo);
 234   if (!info->Parse(extension, error))
 235     return false;
 236   extension->SetManifestData(kSharedModule, info.release());
 237   return true;
 238 }
 239
 240 bool SharedModuleHandler::Validate(
 241     const Extension* extension,
 242     std::string* error,
 243     std::vector<InstallWarning>* warnings) const {
 244   // Extensions that export resources should not have any permissions of their
 245   // own, instead they rely on the permissions of the extensions which import
 246   // them.
 247   if (SharedModuleInfo::IsSharedModule(extension) &&
 248       !extension->permissions_data()->active_permissions()->IsEmpty()) {
 249     *error = errors::kInvalidExportPermissions;
 250     return false;
 251   }
 252   return true;
 253 }
 254
 255 const std::vector<std::string> SharedModuleHandler::Keys() const {
 256   static const char* keys[] = {
 257     keys::kExport,
 258     keys::kImport
 259   };
 260   return std::vector<std::string>(keys, keys + arraysize(keys));
 261 }
 262
 263 }  // namespace extensions