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
53 using content::BrowserThread;
54
55 namespace extensions {
56
57 // Constants for keeping track of extension preferences in a dictionary.
58 const char ExternalProviderImpl::kInstallParam[] = "install_parameter";
59 const char ExternalProviderImpl::kExternalCrx[] = "external_crx";
60 const char ExternalProviderImpl::kExternalVersion[] = "external_version";
61 const char ExternalProviderImpl::kExternalUpdateUrl[] = "external_update_url";
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 const char ExternalProviderImpl::kWasInstalledByOem[] = "was_installed_by_oem";
66 const char ExternalProviderImpl::kSupportedLocales[] = "supported_locales";
67
ExternalProviderImpl(VisitorInterface * service,const scoped_refptr<ExternalLoader> & loader,Profile * profile,Manifest::Location crx_location,Manifest::Location download_location,int creation_flags)68 ExternalProviderImpl::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
~ExternalProviderImpl()86 ExternalProviderImpl::~ExternalProviderImpl() {
87 CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
88 loader_->OwnerShutdown();
89 }
90
VisitRegisteredExtension()91 void ExternalProviderImpl::VisitRegisteredExtension() {
92 // The loader will call back to SetPrefs.
93 loader_->StartLoading();
94 }
95
SetPrefs(base::DictionaryValue * prefs)96 void 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, ¤t_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
ServiceShutdown()303 void ExternalProviderImpl::ServiceShutdown() {
304 service_ = NULL;
305 }
306
IsReady() const307 bool ExternalProviderImpl::IsReady() const {
308 return ready_;
309 }
310
HasExtension(const std::string & id) const311 bool 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
GetExtensionDetails(const std::string & id,Manifest::Location * location,scoped_ptr<Version> * version) const319 bool 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
CreateExternalProviders(VisitorInterface * service,Profile * profile,ProviderCollection * provider_list)355 void 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->IsSupervised()) {
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->IsSupervised() ?
450 chrome::DIR_SUPERVISED_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->IsSupervised() && !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::INTERNAL,
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