src/chrome/browser/extensions/external_provider_impl.cc

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