1 // Copyright (c) 2012 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/browser/extensions/external_provider_impl.h" 6 7 #include <set> 8 #include <vector> 9 10 #include "base/command_line.h" 11 #include "base/files/file_path.h" 12 #include "base/logging.h" 13 #include "base/memory/linked_ptr.h" 14 #include "base/metrics/field_trial.h" 15 #include "base/path_service.h" 16 #include "base/strings/string_util.h" 17 #include "base/values.h" 18 #include "base/version.h" 19 #include "chrome/browser/app_mode/app_mode_utils.h" 20 #include "chrome/browser/browser_process.h" 21 #include "chrome/browser/extensions/extension_service.h" 22 #include "chrome/browser/extensions/extension_system.h" 23 #include "chrome/browser/extensions/external_component_loader.h" 24 #include "chrome/browser/extensions/external_policy_loader.h" 25 #include "chrome/browser/extensions/external_pref_loader.h" 26 #include "chrome/browser/extensions/external_provider_interface.h" 27 #include "chrome/browser/profiles/profile.h" 28 #include "chrome/common/chrome_paths.h" 29 #include "chrome/common/chrome_switches.h" 30 #include "chrome/common/extensions/extension.h" 31 #include "chrome/common/extensions/manifest.h" 32 #include "chrome/common/pref_names.h" 33 #include "content/public/browser/browser_thread.h" 34 #include "ui/base/l10n/l10n_util.h" 35 36 #if defined(OS_CHROMEOS) 37 #include "chrome/browser/chromeos/extensions/external_pref_cache_loader.h" 38 #include "chrome/browser/chromeos/login/user_manager.h" 39 #include "chrome/browser/chromeos/policy/app_pack_updater.h" 40 #include "chrome/browser/policy/browser_policy_connector.h" 41 #else 42 #include "chrome/browser/extensions/default_apps.h" 43 #endif 44 45 #if defined(OS_WIN) 46 #include "chrome/browser/extensions/external_registry_loader_win.h" 47 #endif 48 49 using content::BrowserThread; 50 51 namespace extensions { 52 53 // Constants for keeping track of extension preferences in a dictionary. 54 const char ExternalProviderImpl::kExternalCrx[] = "external_crx"; 55 const char ExternalProviderImpl::kExternalVersion[] = "external_version"; 56 const char ExternalProviderImpl::kExternalUpdateUrl[] = "external_update_url"; 57 const char ExternalProviderImpl::kSupportedLocales[] = "supported_locales"; 58 const char ExternalProviderImpl::kIsBookmarkApp[] = "is_bookmark_app"; 59 const char ExternalProviderImpl::kIsFromWebstore[] = "is_from_webstore"; 60 const char ExternalProviderImpl::kKeepIfPresent[] = "keep_if_present"; 61 62 ExternalProviderImpl::ExternalProviderImpl(VisitorInterface* service, 63 ExternalLoader* loader, 64 Profile* profile, 65 Manifest::Location crx_location, 66 Manifest::Location download_location, 67 int creation_flags) 68 : crx_location_(crx_location), 69 download_location_(download_location), 70 service_(service), 71 ready_(false), 72 loader_(loader), 73 profile_(profile), 74 creation_flags_(creation_flags), 75 auto_acknowledge_(false) { 76 loader_->Init(this); 77 } 78 79 ExternalProviderImpl::~ExternalProviderImpl() { 80 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 81 loader_->OwnerShutdown(); 82 } 83 84 void ExternalProviderImpl::VisitRegisteredExtension() { 85 // The loader will call back to SetPrefs. 86 loader_->StartLoading(); 87 } 88 89 void ExternalProviderImpl::SetPrefs(base::DictionaryValue* prefs) { 90 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 91 92 // Check if the service is still alive. It is possible that it went 93 // away while |loader_| was working on the FILE thread. 94 if (!service_) return; 95 96 prefs_.reset(prefs); 97 ready_ = true; // Queries for extensions are allowed from this point. 98 99 // Set of unsupported extensions that need to be deleted from prefs_. 100 std::set<std::string> unsupported_extensions; 101 102 // Notify ExtensionService about all the extensions this provider has. 103 for (base::DictionaryValue::Iterator i(*prefs_); !i.IsAtEnd(); i.Advance()) { 104 const std::string& extension_id = i.key(); 105 const base::DictionaryValue* extension = NULL; 106 107 if (!Extension::IdIsValid(extension_id)) { 108 LOG(WARNING) << "Malformed extension dictionary: key " 109 << extension_id.c_str() << " is not a valid id."; 110 continue; 111 } 112 113 if (!i.value().GetAsDictionary(&extension)) { 114 LOG(WARNING) << "Malformed extension dictionary: key " 115 << extension_id.c_str() 116 << " has a value that is not a dictionary."; 117 continue; 118 } 119 120 base::FilePath::StringType external_crx; 121 const Value* external_version_value = NULL; 122 std::string external_version; 123 std::string external_update_url; 124 125 bool has_external_crx = extension->GetString(kExternalCrx, &external_crx); 126 127 bool has_external_version = false; 128 if (extension->Get(kExternalVersion, &external_version_value)) { 129 if (external_version_value->IsType(Value::TYPE_STRING)) { 130 external_version_value->GetAsString(&external_version); 131 has_external_version = true; 132 } else { 133 LOG(WARNING) << "Malformed extension dictionary for extension: " 134 << extension_id.c_str() << ". " << kExternalVersion 135 << " value must be a string."; 136 continue; 137 } 138 } 139 140 bool has_external_update_url = extension->GetString(kExternalUpdateUrl, 141 &external_update_url); 142 if (has_external_crx != has_external_version) { 143 LOG(WARNING) << "Malformed extension dictionary for extension: " 144 << extension_id.c_str() << ". " << kExternalCrx 145 << " and " << kExternalVersion << " must be used together."; 146 continue; 147 } 148 149 if (has_external_crx == has_external_update_url) { 150 LOG(WARNING) << "Malformed extension dictionary for extension: " 151 << extension_id.c_str() << ". Exactly one of the " 152 << "followng keys should be used: " << kExternalCrx 153 << ", " << kExternalUpdateUrl << "."; 154 continue; 155 } 156 157 // Check that extension supports current browser locale. 158 const base::ListValue* supported_locales = NULL; 159 if (extension->GetList(kSupportedLocales, &supported_locales)) { 160 std::vector<std::string> browser_locales; 161 l10n_util::GetParentLocales(g_browser_process->GetApplicationLocale(), 162 &browser_locales); 163 164 size_t num_locales = supported_locales->GetSize(); 165 bool locale_supported = false; 166 for (size_t j = 0; j < num_locales; j++) { 167 std::string current_locale; 168 if (supported_locales->GetString(j, ¤t_locale) && 169 l10n_util::IsValidLocaleSyntax(current_locale)) { 170 current_locale = l10n_util::NormalizeLocale(current_locale); 171 if (std::find(browser_locales.begin(), browser_locales.end(), 172 current_locale) != browser_locales.end()) { 173 locale_supported = true; 174 break; 175 } 176 } else { 177 LOG(WARNING) << "Unrecognized locale '" << current_locale 178 << "' found as supported locale for extension: " 179 << extension_id; 180 } 181 } 182 183 if (!locale_supported) { 184 unsupported_extensions.insert(extension_id); 185 VLOG(1) << "Skip installing (or uninstall) external extension: " 186 << extension_id << " because the extension doesn't support " 187 << "the browser locale."; 188 continue; 189 } 190 } 191 192 int creation_flags = creation_flags_; 193 bool is_bookmark_app; 194 if (extension->GetBoolean(kIsBookmarkApp, &is_bookmark_app) && 195 is_bookmark_app) { 196 creation_flags |= Extension::FROM_BOOKMARK; 197 } 198 bool is_from_webstore; 199 if (extension->GetBoolean(kIsFromWebstore, &is_from_webstore) && 200 is_from_webstore) { 201 creation_flags |= Extension::FROM_WEBSTORE; 202 } 203 bool keep_if_present; 204 if (extension->GetBoolean(kKeepIfPresent, &keep_if_present) && 205 keep_if_present && profile_) { 206 ExtensionServiceInterface* extension_service = 207 ExtensionSystem::Get(profile_)->extension_service(); 208 const Extension* extension = extension_service ? 209 extension_service->GetExtensionById(extension_id, true) : NULL; 210 if (!extension) { 211 VLOG(1) << "Skip installing (or uninstall) external extension: " 212 << extension_id << " because the extension should be kept " 213 << "only if it is already installed."; 214 continue; 215 } 216 } 217 218 if (has_external_crx) { 219 if (crx_location_ == Manifest::INVALID_LOCATION) { 220 LOG(WARNING) << "This provider does not support installing external " 221 << "extensions from crx files."; 222 continue; 223 } 224 if (external_crx.find(base::FilePath::kParentDirectory) != 225 base::StringPiece::npos) { 226 LOG(WARNING) << "Path traversal not allowed in path: " 227 << external_crx.c_str(); 228 continue; 229 } 230 231 // If the path is relative, and the provider has a base path, 232 // build the absolute path to the crx file. 233 base::FilePath path(external_crx); 234 if (!path.IsAbsolute()) { 235 base::FilePath base_path = loader_->GetBaseCrxFilePath(); 236 if (base_path.empty()) { 237 LOG(WARNING) << "File path " << external_crx.c_str() 238 << " is relative. An absolute path is required."; 239 continue; 240 } 241 path = base_path.Append(external_crx); 242 } 243 244 Version version(external_version); 245 if (!version.IsValid()) { 246 LOG(WARNING) << "Malformed extension dictionary for extension: " 247 << extension_id.c_str() << ". Invalid version string \"" 248 << external_version << "\"."; 249 continue; 250 } 251 service_->OnExternalExtensionFileFound(extension_id, &version, path, 252 crx_location_, creation_flags, 253 auto_acknowledge_); 254 } else { // if (has_external_update_url) 255 CHECK(has_external_update_url); // Checking of keys above ensures this. 256 if (download_location_ == Manifest::INVALID_LOCATION) { 257 LOG(WARNING) << "This provider does not support installing external " 258 << "extensions from update URLs."; 259 continue; 260 } 261 GURL update_url(external_update_url); 262 if (!update_url.is_valid()) { 263 LOG(WARNING) << "Malformed extension dictionary for extension: " 264 << extension_id.c_str() << ". Key " << kExternalUpdateUrl 265 << " has value \"" << external_update_url 266 << "\", which is not a valid URL."; 267 continue; 268 } 269 service_->OnExternalExtensionUpdateUrlFound( 270 extension_id, update_url, download_location_); 271 } 272 } 273 274 for (std::set<std::string>::iterator it = unsupported_extensions.begin(); 275 it != unsupported_extensions.end(); ++it) { 276 // Remove extension for the list of know external extensions. The extension 277 // will be uninstalled later because provider doesn't provide it anymore. 278 prefs_->Remove(*it, NULL); 279 } 280 281 service_->OnExternalProviderReady(this); 282 } 283 284 void ExternalProviderImpl::ServiceShutdown() { 285 service_ = NULL; 286 } 287 288 bool ExternalProviderImpl::IsReady() const { 289 return ready_; 290 } 291 292 bool ExternalProviderImpl::HasExtension( 293 const std::string& id) const { 294 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 295 CHECK(prefs_.get()); 296 CHECK(ready_); 297 return prefs_->HasKey(id); 298 } 299 300 bool ExternalProviderImpl::GetExtensionDetails( 301 const std::string& id, Manifest::Location* location, 302 scoped_ptr<Version>* version) const { 303 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 304 CHECK(prefs_.get()); 305 CHECK(ready_); 306 base::DictionaryValue* extension = NULL; 307 if (!prefs_->GetDictionary(id, &extension)) 308 return false; 309 310 Manifest::Location loc = Manifest::INVALID_LOCATION; 311 if (extension->HasKey(kExternalUpdateUrl)) { 312 loc = download_location_; 313 314 } else if (extension->HasKey(kExternalCrx)) { 315 loc = crx_location_; 316 317 std::string external_version; 318 if (!extension->GetString(kExternalVersion, &external_version)) 319 return false; 320 321 if (version) 322 version->reset(new Version(external_version)); 323 324 } else { 325 NOTREACHED(); // Chrome should not allow prefs to get into this state. 326 return false; 327 } 328 329 if (location) 330 *location = loc; 331 332 return true; 333 } 334 335 // static 336 void ExternalProviderImpl::CreateExternalProviders( 337 VisitorInterface* service, 338 Profile* profile, 339 ProviderCollection* provider_list) { 340 // Policies are mandatory so they can't be skipped with command line flag. 341 provider_list->push_back( 342 linked_ptr<ExternalProviderInterface>( 343 new ExternalProviderImpl( 344 service, 345 new ExternalPolicyLoader(profile), 346 profile, 347 Manifest::INVALID_LOCATION, 348 Manifest::EXTERNAL_POLICY_DOWNLOAD, 349 Extension::NO_FLAGS))); 350 351 // In tests don't install extensions from default external sources. 352 // It would only slowdown tests and make them flaky. 353 if (CommandLine::ForCurrentProcess()->HasSwitch( 354 switches::kDisableDefaultApps)) 355 return; 356 357 // No external app install in app mode. 358 if (chrome::IsRunningInForcedAppMode()) 359 return; 360 361 // On Mac OS, items in /Library/... should be written by the superuser. 362 // Check that all components of the path are writable by root only. 363 ExternalPrefLoader::Options check_admin_permissions_on_mac; 364 #if defined(OS_MACOSX) 365 check_admin_permissions_on_mac = 366 ExternalPrefLoader::ENSURE_PATH_CONTROLLED_BY_ADMIN; 367 #else 368 check_admin_permissions_on_mac = ExternalPrefLoader::NONE; 369 #endif 370 371 bool is_chromeos_demo_session = false; 372 int bundled_extension_creation_flags = Extension::NO_FLAGS; 373 #if defined(OS_CHROMEOS) 374 chromeos::UserManager* user_manager = chromeos::UserManager::Get(); 375 is_chromeos_demo_session = 376 user_manager && user_manager->IsLoggedInAsDemoUser() && 377 g_browser_process->browser_policy_connector()->GetDeviceMode() == 378 policy::DEVICE_MODE_RETAIL_KIOSK; 379 bundled_extension_creation_flags = Extension::FROM_WEBSTORE | 380 Extension::WAS_INSTALLED_BY_DEFAULT; 381 #endif 382 383 bool is_managed_profile = profile->IsManaged(); 384 int external_apps_path_id = chrome::DIR_EXTERNAL_EXTENSIONS; 385 if (is_managed_profile) 386 external_apps_path_id = chrome::DIR_MANAGED_USERS_DEFAULT_APPS; 387 388 #if defined(OS_CHROMEOS) 389 typedef chromeos::ExternalPrefCacheLoader PrefLoader; 390 #else 391 typedef ExternalPrefLoader PrefLoader; 392 #endif 393 394 if (!is_chromeos_demo_session) { 395 provider_list->push_back( 396 linked_ptr<ExternalProviderInterface>( 397 new ExternalProviderImpl( 398 service, 399 new PrefLoader(external_apps_path_id, 400 check_admin_permissions_on_mac), 401 profile, 402 Manifest::EXTERNAL_PREF, 403 Manifest::EXTERNAL_PREF_DOWNLOAD, 404 bundled_extension_creation_flags))); 405 } 406 407 if (!is_managed_profile) { 408 #if defined(OS_CHROMEOS) || defined (OS_MACOSX) 409 // Define a per-user source of external extensions. 410 // On Chrome OS, this serves as a source for OEM customization. 411 provider_list->push_back( 412 linked_ptr<ExternalProviderInterface>( 413 new ExternalProviderImpl( 414 service, 415 new ExternalPrefLoader(chrome::DIR_USER_EXTERNAL_EXTENSIONS, 416 ExternalPrefLoader::NONE), 417 profile, 418 Manifest::EXTERNAL_PREF, 419 Manifest::EXTERNAL_PREF_DOWNLOAD, 420 Extension::NO_FLAGS))); 421 #endif 422 423 #if defined(OS_WIN) 424 provider_list->push_back( 425 linked_ptr<ExternalProviderInterface>( 426 new ExternalProviderImpl( 427 service, 428 new ExternalRegistryLoader, 429 profile, 430 Manifest::EXTERNAL_REGISTRY, 431 Manifest::INVALID_LOCATION, 432 Extension::NO_FLAGS))); 433 #endif 434 435 #if defined(OS_LINUX) 436 provider_list->push_back( 437 linked_ptr<ExternalProviderInterface>( 438 new ExternalProviderImpl( 439 service, 440 new ExternalPrefLoader( 441 chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS, 442 ExternalPrefLoader::NONE), 443 profile, 444 Manifest::EXTERNAL_PREF, 445 Manifest::EXTERNAL_PREF_DOWNLOAD, 446 bundled_extension_creation_flags))); 447 #endif 448 449 #if !defined(OS_CHROMEOS) 450 // The default apps are installed as INTERNAL but use the external 451 // extension installer codeflow. 452 provider_list->push_back( 453 linked_ptr<ExternalProviderInterface>( 454 new default_apps::Provider( 455 profile, 456 service, 457 new ExternalPrefLoader(chrome::DIR_DEFAULT_APPS, 458 ExternalPrefLoader::NONE), 459 Manifest::INTERNAL, 460 Manifest::INVALID_LOCATION, 461 Extension::FROM_WEBSTORE | 462 Extension::WAS_INSTALLED_BY_DEFAULT))); 463 #endif 464 465 #if defined(OS_CHROMEOS) 466 policy::AppPackUpdater* app_pack_updater = 467 g_browser_process->browser_policy_connector()->GetAppPackUpdater(); 468 if (is_chromeos_demo_session && app_pack_updater && 469 !app_pack_updater->created_external_loader()) { 470 provider_list->push_back( 471 linked_ptr<ExternalProviderInterface>( 472 new ExternalProviderImpl( 473 service, 474 app_pack_updater->CreateExternalLoader(), 475 profile, 476 Manifest::EXTERNAL_PREF, 477 Manifest::INVALID_LOCATION, 478 Extension::NO_FLAGS))); 479 } 480 #endif 481 } 482 483 provider_list->push_back( 484 linked_ptr<ExternalProviderInterface>( 485 new ExternalProviderImpl( 486 service, 487 new ExternalComponentLoader(), 488 profile, 489 Manifest::INVALID_LOCATION, 490 Manifest::EXTERNAL_POLICY_DOWNLOAD, 491 Extension::FROM_WEBSTORE | Extension::WAS_INSTALLED_BY_DEFAULT))); 492 } 493 494 } // namespace extensions 495