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