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