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/common/extensions/extension_file_util.h"
6
7 #include "base/file_util.h"
8 #include "base/files/scoped_temp_dir.h"
9 #include "base/json/json_string_value_serializer.h"
10 #include "base/path_service.h"
11 #include "base/strings/stringprintf.h"
12 #include "base/strings/utf_string_conversions.h"
13 #include "chrome/common/chrome_paths.h"
14 #include "extensions/common/constants.h"
15 #include "extensions/common/extension.h"
16 #include "extensions/common/manifest.h"
17 #include "extensions/common/manifest_constants.h"
18 #include "grit/generated_resources.h"
19 #include "testing/gmock/include/gmock/gmock.h"
20 #include "testing/gtest/include/gtest/gtest.h"
21 #include "ui/base/l10n/l10n_util.h"
22
23 using extensions::Extension;
24 using extensions::Manifest;
25
26 namespace keys = extensions::manifest_keys;
27
28 class ExtensionFileUtilTest : public testing::Test {
29 };
30
TEST_F(ExtensionFileUtilTest,InstallUninstallGarbageCollect)31 TEST_F(ExtensionFileUtilTest, InstallUninstallGarbageCollect) {
32 base::ScopedTempDir temp;
33 ASSERT_TRUE(temp.CreateUniqueTempDir());
34
35 // Create a source extension.
36 std::string extension_id("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
37 std::string version("1.0");
38 base::FilePath src = temp.path().AppendASCII(extension_id);
39 ASSERT_TRUE(base::CreateDirectory(src));
40
41 // Create a extensions tree.
42 base::FilePath all_extensions = temp.path().AppendASCII("extensions");
43 ASSERT_TRUE(base::CreateDirectory(all_extensions));
44
45 // Install in empty directory. Should create parent directories as needed.
46 base::FilePath version_1 = extension_file_util::InstallExtension(
47 src,
48 extension_id,
49 version,
50 all_extensions);
51 ASSERT_EQ(version_1.value(),
52 all_extensions.AppendASCII(extension_id).AppendASCII("1.0_0")
53 .value());
54 ASSERT_TRUE(base::DirectoryExists(version_1));
55
56 // Should have moved the source.
57 ASSERT_FALSE(base::DirectoryExists(src));
58
59 // Install again. Should create a new one with different name.
60 ASSERT_TRUE(base::CreateDirectory(src));
61 base::FilePath version_2 = extension_file_util::InstallExtension(
62 src,
63 extension_id,
64 version,
65 all_extensions);
66 ASSERT_EQ(version_2.value(),
67 all_extensions.AppendASCII(extension_id).AppendASCII("1.0_1")
68 .value());
69 ASSERT_TRUE(base::DirectoryExists(version_2));
70
71 // Should have moved the source.
72 ASSERT_FALSE(base::DirectoryExists(src));
73
74 // Install yet again. Should create a new one with a different name.
75 ASSERT_TRUE(base::CreateDirectory(src));
76 base::FilePath version_3 = extension_file_util::InstallExtension(
77 src,
78 extension_id,
79 version,
80 all_extensions);
81 ASSERT_EQ(version_3.value(),
82 all_extensions.AppendASCII(extension_id).AppendASCII("1.0_2")
83 .value());
84 ASSERT_TRUE(base::DirectoryExists(version_3));
85
86 // Collect garbage. Should remove first one.
87 std::multimap<std::string, base::FilePath> extension_paths;
88 extension_paths.insert(std::make_pair(extension_id,
89 base::FilePath().AppendASCII(extension_id).Append(version_2.BaseName())));
90 extension_paths.insert(std::make_pair(extension_id,
91 base::FilePath().AppendASCII(extension_id).Append(version_3.BaseName())));
92 extension_file_util::GarbageCollectExtensions(all_extensions,
93 extension_paths);
94 ASSERT_FALSE(base::DirectoryExists(version_1));
95 ASSERT_TRUE(base::DirectoryExists(version_2));
96 ASSERT_TRUE(base::DirectoryExists(version_3));
97
98 // Uninstall. Should remove entire extension subtree.
99 extension_file_util::UninstallExtension(all_extensions, extension_id);
100 ASSERT_FALSE(base::DirectoryExists(version_2.DirName()));
101 ASSERT_FALSE(base::DirectoryExists(version_3.DirName()));
102 ASSERT_TRUE(base::DirectoryExists(all_extensions));
103 }
104
TEST_F(ExtensionFileUtilTest,LoadExtensionWithValidLocales)105 TEST_F(ExtensionFileUtilTest, LoadExtensionWithValidLocales) {
106 base::FilePath install_dir;
107 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
108 install_dir = install_dir.AppendASCII("extensions")
109 .AppendASCII("good")
110 .AppendASCII("Extensions")
111 .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
112 .AppendASCII("1.0.0.0");
113
114 std::string error;
115 scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
116 install_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
117 ASSERT_TRUE(extension.get() != NULL);
118 EXPECT_EQ("The first extension that I made.", extension->description());
119 }
120
TEST_F(ExtensionFileUtilTest,LoadExtensionWithoutLocalesFolder)121 TEST_F(ExtensionFileUtilTest, LoadExtensionWithoutLocalesFolder) {
122 base::FilePath install_dir;
123 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
124 install_dir = install_dir.AppendASCII("extensions")
125 .AppendASCII("good")
126 .AppendASCII("Extensions")
127 .AppendASCII("bjafgdebaacbbbecmhlhpofkepfkgcpa")
128 .AppendASCII("1.0");
129
130 std::string error;
131 scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
132 install_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
133 ASSERT_FALSE(extension.get() == NULL);
134 EXPECT_TRUE(error.empty());
135 }
136
TEST_F(ExtensionFileUtilTest,CheckIllegalFilenamesNoUnderscores)137 TEST_F(ExtensionFileUtilTest, CheckIllegalFilenamesNoUnderscores) {
138 base::ScopedTempDir temp;
139 ASSERT_TRUE(temp.CreateUniqueTempDir());
140
141 base::FilePath src_path = temp.path().AppendASCII("some_dir");
142 ASSERT_TRUE(base::CreateDirectory(src_path));
143
144 std::string data = "{ \"name\": { \"message\": \"foobar\" } }";
145 ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("some_file.txt"),
146 data.c_str(), data.length()));
147 std::string error;
148 EXPECT_TRUE(extension_file_util::CheckForIllegalFilenames(temp.path(),
149 &error));
150 }
151
TEST_F(ExtensionFileUtilTest,CheckIllegalFilenamesOnlyReserved)152 TEST_F(ExtensionFileUtilTest, CheckIllegalFilenamesOnlyReserved) {
153 base::ScopedTempDir temp;
154 ASSERT_TRUE(temp.CreateUniqueTempDir());
155
156 const base::FilePath::CharType* folders[] =
157 { extensions::kLocaleFolder, extensions::kPlatformSpecificFolder };
158
159 for (size_t i = 0; i < arraysize(folders); i++) {
160 base::FilePath src_path = temp.path().Append(folders[i]);
161 ASSERT_TRUE(base::CreateDirectory(src_path));
162 }
163
164 std::string error;
165 EXPECT_TRUE(extension_file_util::CheckForIllegalFilenames(temp.path(),
166 &error));
167 }
168
TEST_F(ExtensionFileUtilTest,CheckIllegalFilenamesReservedAndIllegal)169 TEST_F(ExtensionFileUtilTest, CheckIllegalFilenamesReservedAndIllegal) {
170 base::ScopedTempDir temp;
171 ASSERT_TRUE(temp.CreateUniqueTempDir());
172
173 base::FilePath src_path = temp.path().Append(extensions::kLocaleFolder);
174 ASSERT_TRUE(base::CreateDirectory(src_path));
175
176 src_path = temp.path().AppendASCII("_some_dir");
177 ASSERT_TRUE(base::CreateDirectory(src_path));
178
179 std::string error;
180 EXPECT_FALSE(extension_file_util::CheckForIllegalFilenames(temp.path(),
181 &error));
182 }
183
TEST_F(ExtensionFileUtilTest,LoadExtensionGivesHelpfullErrorOnMissingManifest)184 TEST_F(ExtensionFileUtilTest,
185 LoadExtensionGivesHelpfullErrorOnMissingManifest) {
186 base::FilePath install_dir;
187 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
188 install_dir = install_dir.AppendASCII("extensions")
189 .AppendASCII("bad")
190 .AppendASCII("Extensions")
191 .AppendASCII("dddddddddddddddddddddddddddddddd")
192 .AppendASCII("1.0");
193
194 std::string error;
195 scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
196 install_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
197 ASSERT_TRUE(extension.get() == NULL);
198 ASSERT_FALSE(error.empty());
199 ASSERT_STREQ("Manifest file is missing or unreadable.", error.c_str());
200 }
201
TEST_F(ExtensionFileUtilTest,LoadExtensionGivesHelpfullErrorOnBadManifest)202 TEST_F(ExtensionFileUtilTest, LoadExtensionGivesHelpfullErrorOnBadManifest) {
203 base::FilePath install_dir;
204 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
205 install_dir = install_dir.AppendASCII("extensions")
206 .AppendASCII("bad")
207 .AppendASCII("Extensions")
208 .AppendASCII("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")
209 .AppendASCII("1.0");
210
211 std::string error;
212 scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
213 install_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
214 ASSERT_TRUE(extension.get() == NULL);
215 ASSERT_FALSE(error.empty());
216 ASSERT_STREQ("Manifest is not valid JSON. "
217 "Line: 2, column: 16, Syntax error.", error.c_str());
218 }
219
TEST_F(ExtensionFileUtilTest,FailLoadingNonUTF8Scripts)220 TEST_F(ExtensionFileUtilTest, FailLoadingNonUTF8Scripts) {
221 base::FilePath install_dir;
222 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
223 install_dir = install_dir.AppendASCII("extensions")
224 .AppendASCII("bad")
225 .AppendASCII("bad_encoding");
226
227 std::string error;
228 scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
229 install_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
230 ASSERT_TRUE(extension.get() == NULL);
231 ASSERT_STREQ("Could not load file 'bad_encoding.js' for content script. "
232 "It isn't UTF-8 encoded.",
233 error.c_str());
234 }
235
LoadExtensionManifest(base::DictionaryValue * manifest,const base::FilePath & manifest_dir,Manifest::Location location,int extra_flags,std::string * error)236 static scoped_refptr<Extension> LoadExtensionManifest(
237 base::DictionaryValue* manifest,
238 const base::FilePath& manifest_dir,
239 Manifest::Location location,
240 int extra_flags,
241 std::string* error) {
242 scoped_refptr<Extension> extension = Extension::Create(
243 manifest_dir, location, *manifest, extra_flags, error);
244 return extension;
245 }
246
LoadExtensionManifest(const std::string & manifest_value,const base::FilePath & manifest_dir,Manifest::Location location,int extra_flags,std::string * error)247 static scoped_refptr<Extension> LoadExtensionManifest(
248 const std::string& manifest_value,
249 const base::FilePath& manifest_dir,
250 Manifest::Location location,
251 int extra_flags,
252 std::string* error) {
253 JSONStringValueSerializer serializer(manifest_value);
254 scoped_ptr<base::Value> result(serializer.Deserialize(NULL, error));
255 if (!result.get())
256 return NULL;
257 CHECK_EQ(base::Value::TYPE_DICTIONARY, result->GetType());
258 return LoadExtensionManifest(
259 static_cast<base::DictionaryValue*>(result.get()),
260 manifest_dir,
261 location,
262 extra_flags,
263 error);
264 }
265
TEST_F(ExtensionFileUtilTest,ValidateThemeUTF8)266 TEST_F(ExtensionFileUtilTest, ValidateThemeUTF8) {
267 base::ScopedTempDir temp;
268 ASSERT_TRUE(temp.CreateUniqueTempDir());
269
270 // "aeo" with accents. Use http://0xcc.net/jsescape/ to decode them.
271 std::string non_ascii_file = "\xC3\xA0\xC3\xA8\xC3\xB2.png";
272 base::FilePath non_ascii_path =
273 temp.path().Append(base::FilePath::FromUTF8Unsafe(non_ascii_file));
274 file_util::WriteFile(non_ascii_path, "", 0);
275
276 std::string kManifest =
277 base::StringPrintf(
278 "{ \"name\": \"Test\", \"version\": \"1.0\", "
279 " \"theme\": { \"images\": { \"theme_frame\": \"%s\" } }"
280 "}", non_ascii_file.c_str());
281 std::string error;
282 scoped_refptr<Extension> extension = LoadExtensionManifest(
283 kManifest, temp.path(), Manifest::UNPACKED, 0, &error);
284 ASSERT_TRUE(extension.get()) << error;
285
286 std::vector<extensions::InstallWarning> warnings;
287 EXPECT_TRUE(extension_file_util::ValidateExtension(
288 extension.get(), &error, &warnings)) << error;
289 EXPECT_EQ(0U, warnings.size());
290 }
291
TEST_F(ExtensionFileUtilTest,BackgroundScriptsMustExist)292 TEST_F(ExtensionFileUtilTest, BackgroundScriptsMustExist) {
293 base::ScopedTempDir temp;
294 ASSERT_TRUE(temp.CreateUniqueTempDir());
295
296 scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
297 value->SetString("name", "test");
298 value->SetString("version", "1");
299 value->SetInteger("manifest_version", 1);
300
301 base::ListValue* scripts = new base::ListValue();
302 scripts->Append(new base::StringValue("foo.js"));
303 value->Set("background.scripts", scripts);
304
305 std::string error;
306 std::vector<extensions::InstallWarning> warnings;
307 scoped_refptr<Extension> extension = LoadExtensionManifest(
308 value.get(), temp.path(), Manifest::UNPACKED, 0, &error);
309 ASSERT_TRUE(extension.get()) << error;
310
311 EXPECT_FALSE(extension_file_util::ValidateExtension(
312 extension.get(), &error, &warnings));
313 EXPECT_EQ(l10n_util::GetStringFUTF8(
314 IDS_EXTENSION_LOAD_BACKGROUND_SCRIPT_FAILED, ASCIIToUTF16("foo.js")),
315 error);
316 EXPECT_EQ(0U, warnings.size());
317
318 scripts->Clear();
319 scripts->Append(new base::StringValue("http://google.com/foo.js"));
320
321 extension = LoadExtensionManifest(value.get(), temp.path(),
322 Manifest::UNPACKED, 0, &error);
323 ASSERT_TRUE(extension.get()) << error;
324
325 warnings.clear();
326 EXPECT_FALSE(extension_file_util::ValidateExtension(
327 extension.get(), &error, &warnings));
328 EXPECT_EQ(l10n_util::GetStringFUTF8(
329 IDS_EXTENSION_LOAD_BACKGROUND_SCRIPT_FAILED,
330 ASCIIToUTF16("http://google.com/foo.js")),
331 error);
332 EXPECT_EQ(0U, warnings.size());
333 }
334
335 // Private key, generated by Chrome specifically for this test, and
336 // never used elsewhere.
337 const char private_key[] =
338 "-----BEGIN PRIVATE KEY-----\n"
339 "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKt02SR0FYaYy6fpW\n"
340 "MAA+kU1BgK3d+OmmWfdr+JATIjhRkyeSF4lTd/71JQsyKqPzYkQPi3EeROWM+goTv\n"
341 "EhJqq07q63BolpsFmlV+S4ny+sBA2B4aWwRYXlBWikdrQSA0mJMzvEHc6nKzBgXik\n"
342 "QSVbyyBNAsxlDB9WaCxRVOpK3AgMBAAECgYBGvSPlrVtAOAQ2V8j9FqorKZA8SLPX\n"
343 "IeJC/yzU3RB2nPMjI17aMOvrUHxJUhzMeh4jwabVvSzzDtKFozPGupW3xaI8sQdi2\n"
344 "WWMTQIk/Q9HHDWoQ9qA6SwX2qWCc5SyjCKqVp78ye+000kqTJYjBsDgXeAlzKcx2B\n"
345 "4GAAeWonDdkQJBANNb8wrqNWFn7DqyQTfELzcRTRnqQ/r1pdeJo6obzbnwGnlqe3t\n"
346 "KhLjtJNIGrQg5iC0OVLWFuvPJs0t3z62A1ckCQQDPq2JZuwTwu5Pl4DJ0r9O1FdqN\n"
347 "JgqPZyMptokCDQ3khLLGakIu+TqB9YtrzI69rJMSG2Egb+6McaDX+dh3XmR/AkB9t\n"
348 "xJf6qDnmA2td/tMtTc0NOk8Qdg/fD8xbZ/YfYMnVoYYs9pQoilBaWRePDRNURMLYZ\n"
349 "vHAI0Llmw7tj7jv17pAkEAz44uXRpjRKtllUIvi5pUENAHwDz+HvdpGH68jpU3hmb\n"
350 "uOwrmnQYxaMReFV68Z2w9DcLZn07f7/R9Wn72z89CxwJAFsDoNaDes4h48bX7plct\n"
351 "s9ACjmTwcCigZjN2K7AGv7ntCLF3DnV5dK0dTHNaAdD3SbY3jl29Rk2CwiURSX6Ee\n"
352 "g==\n"
353 "-----END PRIVATE KEY-----\n";
354
TEST_F(ExtensionFileUtilTest,FindPrivateKeyFiles)355 TEST_F(ExtensionFileUtilTest, FindPrivateKeyFiles) {
356 base::ScopedTempDir temp;
357 ASSERT_TRUE(temp.CreateUniqueTempDir());
358
359 base::FilePath src_path = temp.path().AppendASCII("some_dir");
360 ASSERT_TRUE(base::CreateDirectory(src_path));
361
362 ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("a_key.pem"),
363 private_key, arraysize(private_key)));
364 ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("second_key.pem"),
365 private_key, arraysize(private_key)));
366 // Shouldn't find a key with a different extension.
367 ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("key.diff_ext"),
368 private_key, arraysize(private_key)));
369 // Shouldn't find a key that isn't parsable.
370 ASSERT_TRUE(file_util::WriteFile(src_path.AppendASCII("unparsable_key.pem"),
371 private_key, arraysize(private_key) - 30));
372 std::vector<base::FilePath> private_keys =
373 extension_file_util::FindPrivateKeyFiles(temp.path());
374 EXPECT_EQ(2U, private_keys.size());
375 EXPECT_THAT(private_keys,
376 testing::Contains(src_path.AppendASCII("a_key.pem")));
377 EXPECT_THAT(private_keys,
378 testing::Contains(src_path.AppendASCII("second_key.pem")));
379 }
380
TEST_F(ExtensionFileUtilTest,WarnOnPrivateKey)381 TEST_F(ExtensionFileUtilTest, WarnOnPrivateKey) {
382 base::ScopedTempDir temp;
383 ASSERT_TRUE(temp.CreateUniqueTempDir());
384
385 base::FilePath ext_path = temp.path().AppendASCII("ext_root");
386 ASSERT_TRUE(base::CreateDirectory(ext_path));
387
388 const char manifest[] =
389 "{\n"
390 " \"name\": \"Test Extension\",\n"
391 " \"version\": \"1.0\",\n"
392 " \"manifest_version\": 2,\n"
393 " \"description\": \"The first extension that I made.\"\n"
394 "}\n";
395 ASSERT_TRUE(file_util::WriteFile(ext_path.AppendASCII("manifest.json"),
396 manifest, strlen(manifest)));
397 ASSERT_TRUE(file_util::WriteFile(ext_path.AppendASCII("a_key.pem"),
398 private_key, strlen(private_key)));
399
400 std::string error;
401 scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
402 ext_path, "the_id", Manifest::EXTERNAL_PREF,
403 Extension::NO_FLAGS, &error));
404 ASSERT_TRUE(extension.get()) << error;
405 ASSERT_EQ(1u, extension->install_warnings().size());
406 EXPECT_THAT(
407 extension->install_warnings(),
408 testing::ElementsAre(
409 testing::Field(
410 &extensions::InstallWarning::message,
411 testing::ContainsRegex(
412 "extension includes the key file.*ext_root.a_key.pem"))));
413
414 // Turn the warning into an error with ERROR_ON_PRIVATE_KEY.
415 extension = extension_file_util::LoadExtension(
416 ext_path, "the_id", Manifest::EXTERNAL_PREF,
417 Extension::ERROR_ON_PRIVATE_KEY, &error);
418 EXPECT_FALSE(extension.get());
419 EXPECT_THAT(error,
420 testing::ContainsRegex(
421 "extension includes the key file.*ext_root.a_key.pem"));
422 }
423
TEST_F(ExtensionFileUtilTest,CheckZeroLengthImageFile)424 TEST_F(ExtensionFileUtilTest, CheckZeroLengthImageFile) {
425 base::FilePath install_dir;
426 ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
427
428 // Try to install an extension with a zero-length icon file.
429 base::FilePath ext_dir = install_dir.AppendASCII("extensions")
430 .AppendASCII("bad")
431 .AppendASCII("Extensions")
432 .AppendASCII("ffffffffffffffffffffffffffffffff");
433
434 std::string error;
435 scoped_refptr<Extension> extension(extension_file_util::LoadExtension(
436 ext_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
437 EXPECT_TRUE(extension.get() == NULL);
438 EXPECT_STREQ("Could not load extension icon 'icon.png'.", error.c_str());
439
440 // Try to install an extension with a zero-length browser action icon file.
441 ext_dir = install_dir.AppendASCII("extensions")
442 .AppendASCII("bad")
443 .AppendASCII("Extensions")
444 .AppendASCII("gggggggggggggggggggggggggggggggg");
445
446 scoped_refptr<Extension> extension2(extension_file_util::LoadExtension(
447 ext_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
448 EXPECT_TRUE(extension2.get() == NULL);
449 EXPECT_STREQ("Could not load icon 'icon.png' for browser action.",
450 error.c_str());
451
452 // Try to install an extension with a zero-length page action icon file.
453 ext_dir = install_dir.AppendASCII("extensions")
454 .AppendASCII("bad")
455 .AppendASCII("Extensions")
456 .AppendASCII("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh");
457
458 scoped_refptr<Extension> extension3(extension_file_util::LoadExtension(
459 ext_dir, Manifest::UNPACKED, Extension::NO_FLAGS, &error));
460 EXPECT_TRUE(extension3.get() == NULL);
461 EXPECT_STREQ("Could not load icon 'icon.png' for page action.",
462 error.c_str());
463 }
464
465 // TODO(aa): More tests as motivation allows. Maybe steal some from
466 // ExtensionService? Many of them could probably be tested here without the
467 // MessageLoop shenanigans.
468