chrome/common/extensions/extension_unittest.cc

   1 // Copyright (c) 2013 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 "base/files/file_util.h"
   6 #include "base/format_macros.h"
   7 #include "base/path_service.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "chrome/common/chrome_paths.h"
  11 #include "chrome/common/extensions/command.h"
  12 #include "chrome/common/extensions/extension_test_util.h"
  13 #include "chrome/common/extensions/manifest_handlers/content_scripts_handler.h"
  14 #include "chrome/common/url_constants.h"
  15 #include "components/crx_file/id_util.h"
  16 #include "extensions/common/extension.h"
  17 #include "extensions/common/extension_resource.h"
  18 #include "extensions/common/file_util.h"
  19 #include "extensions/common/manifest.h"
  20 #include "extensions/common/permissions/permissions_data.h"
  21 #include "net/base/mime_sniffer.h"
  22 #include "net/dns/mock_host_resolver.h"
  23 #include "skia/ext/image_operations.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "third_party/skia/include/core/SkBitmap.h"
  26 #include "ui/gfx/codec/png_codec.h"
  27 #include "url/gurl.h"
  28
  29 using extension_test_util::LoadManifest;
  30 using extension_test_util::LoadManifestStrict;
  31 using base::FilePath;
  32
  33 namespace extensions {
  34
  35 // We persist location values in the preferences, so this is a sanity test that
  36 // someone doesn't accidentally change them.
  37 TEST(ExtensionTest, LocationValuesTest) {
  38   ASSERT_EQ(0, Manifest::INVALID_LOCATION);
  39   ASSERT_EQ(1, Manifest::INTERNAL);
  40   ASSERT_EQ(2, Manifest::EXTERNAL_PREF);
  41   ASSERT_EQ(3, Manifest::EXTERNAL_REGISTRY);
  42   ASSERT_EQ(4, Manifest::UNPACKED);
  43   ASSERT_EQ(5, Manifest::COMPONENT);
  44   ASSERT_EQ(6, Manifest::EXTERNAL_PREF_DOWNLOAD);
  45   ASSERT_EQ(7, Manifest::EXTERNAL_POLICY_DOWNLOAD);
  46   ASSERT_EQ(8, Manifest::COMMAND_LINE);
  47   ASSERT_EQ(9, Manifest::EXTERNAL_POLICY);
  48 }
  49
  50 TEST(ExtensionTest, LocationPriorityTest) {
  51   for (int i = 0; i < Manifest::NUM_LOCATIONS; i++) {
  52     Manifest::Location loc = static_cast<Manifest::Location>(i);
  53
  54     // INVALID is not a valid location.
  55     if (loc == Manifest::INVALID_LOCATION)
  56       continue;
  57
  58     // Comparing a location that has no rank will hit a CHECK. Do a
  59     // compare with every valid location, to be sure each one is covered.
  60
  61     // Check that no install source can override a componenet extension.
  62     ASSERT_EQ(Manifest::COMPONENT,
  63               Manifest::GetHigherPriorityLocation(Manifest::COMPONENT, loc));
  64     ASSERT_EQ(Manifest::COMPONENT,
  65               Manifest::GetHigherPriorityLocation(loc, Manifest::COMPONENT));
  66
  67     // Check that any source can override a user install. This might change
  68     // in the future, in which case this test should be updated.
  69     ASSERT_EQ(loc,
  70               Manifest::GetHigherPriorityLocation(Manifest::INTERNAL, loc));
  71     ASSERT_EQ(loc,
  72               Manifest::GetHigherPriorityLocation(loc, Manifest::INTERNAL));
  73   }
  74
  75   // Check a few interesting cases that we know can happen:
  76   ASSERT_EQ(Manifest::EXTERNAL_POLICY_DOWNLOAD,
  77             Manifest::GetHigherPriorityLocation(
  78                 Manifest::EXTERNAL_POLICY_DOWNLOAD,
  79                 Manifest::EXTERNAL_PREF));
  80
  81   ASSERT_EQ(Manifest::EXTERNAL_PREF,
  82             Manifest::GetHigherPriorityLocation(
  83                 Manifest::INTERNAL,
  84                 Manifest::EXTERNAL_PREF));
  85 }
  86
  87 TEST(ExtensionTest, GetResourceURLAndPath) {
  88   scoped_refptr<Extension> extension = LoadManifestStrict("empty_manifest",
  89       "empty.json");
  90   EXPECT_TRUE(extension.get());
  91
  92   EXPECT_EQ(extension->url().spec() + "bar/baz.js",
  93             Extension::GetResourceURL(extension->url(), "bar/baz.js").spec());
  94   EXPECT_EQ(extension->url().spec() + "baz.js",
  95             Extension::GetResourceURL(extension->url(),
  96                                       "bar/../baz.js").spec());
  97   EXPECT_EQ(extension->url().spec() + "baz.js",
  98             Extension::GetResourceURL(extension->url(), "../baz.js").spec());
  99
 100   // Test that absolute-looking paths ("/"-prefixed) are pasted correctly.
 101   EXPECT_EQ(extension->url().spec() + "test.html",
 102             extension->GetResourceURL("/test.html").spec());
 103 }
 104
 105 TEST(ExtensionTest, GetResource) {
 106   const FilePath valid_path_test_cases[] = {
 107     FilePath(FILE_PATH_LITERAL("manifest.json")),
 108     FilePath(FILE_PATH_LITERAL("a/b/c/manifest.json")),
 109     FilePath(FILE_PATH_LITERAL("com/manifest.json")),
 110     FilePath(FILE_PATH_LITERAL("lpt/manifest.json")),
 111   };
 112   const FilePath invalid_path_test_cases[] = {
 113     // Directory name
 114     FilePath(FILE_PATH_LITERAL("src/")),
 115     // Contains a drive letter specification.
 116     FilePath(FILE_PATH_LITERAL("C:\\manifest.json")),
 117     // Use backslash '\\' as separator.
 118     FilePath(FILE_PATH_LITERAL("a\\b\\c\\manifest.json")),
 119     // Reserved Characters with extension
 120     FilePath(FILE_PATH_LITERAL("mani>fest.json")),
 121     FilePath(FILE_PATH_LITERAL("mani<fest.json")),
 122     FilePath(FILE_PATH_LITERAL("mani*fest.json")),
 123     FilePath(FILE_PATH_LITERAL("mani:fest.json")),
 124     FilePath(FILE_PATH_LITERAL("mani?fest.json")),
 125     FilePath(FILE_PATH_LITERAL("mani|fest.json")),
 126     // Reserved Characters without extension
 127     FilePath(FILE_PATH_LITERAL("mani>fest")),
 128     FilePath(FILE_PATH_LITERAL("mani<fest")),
 129     FilePath(FILE_PATH_LITERAL("mani*fest")),
 130     FilePath(FILE_PATH_LITERAL("mani:fest")),
 131     FilePath(FILE_PATH_LITERAL("mani?fest")),
 132     FilePath(FILE_PATH_LITERAL("mani|fest")),
 133     // Reserved Names with extension.
 134     FilePath(FILE_PATH_LITERAL("com1.json")),
 135     FilePath(FILE_PATH_LITERAL("com9.json")),
 136     FilePath(FILE_PATH_LITERAL("LPT1.json")),
 137     FilePath(FILE_PATH_LITERAL("LPT9.json")),
 138     FilePath(FILE_PATH_LITERAL("CON.json")),
 139     FilePath(FILE_PATH_LITERAL("PRN.json")),
 140     FilePath(FILE_PATH_LITERAL("AUX.json")),
 141     FilePath(FILE_PATH_LITERAL("NUL.json")),
 142     // Reserved Names without extension.
 143     FilePath(FILE_PATH_LITERAL("com1")),
 144     FilePath(FILE_PATH_LITERAL("com9")),
 145     FilePath(FILE_PATH_LITERAL("LPT1")),
 146     FilePath(FILE_PATH_LITERAL("LPT9")),
 147     FilePath(FILE_PATH_LITERAL("CON")),
 148     FilePath(FILE_PATH_LITERAL("PRN")),
 149     FilePath(FILE_PATH_LITERAL("AUX")),
 150     FilePath(FILE_PATH_LITERAL("NUL")),
 151     // Reserved Names as directory.
 152     FilePath(FILE_PATH_LITERAL("com1/manifest.json")),
 153     FilePath(FILE_PATH_LITERAL("com9/manifest.json")),
 154     FilePath(FILE_PATH_LITERAL("LPT1/manifest.json")),
 155     FilePath(FILE_PATH_LITERAL("LPT9/manifest.json")),
 156     FilePath(FILE_PATH_LITERAL("CON/manifest.json")),
 157     FilePath(FILE_PATH_LITERAL("PRN/manifest.json")),
 158     FilePath(FILE_PATH_LITERAL("AUX/manifest.json")),
 159     FilePath(FILE_PATH_LITERAL("NUL/manifest.json")),
 160   };
 161
 162   scoped_refptr<Extension> extension = LoadManifestStrict("empty_manifest",
 163       "empty.json");
 164   EXPECT_TRUE(extension.get());
 165   for (size_t i = 0; i < arraysize(valid_path_test_cases); ++i)
 166     EXPECT_TRUE(!extension->GetResource(valid_path_test_cases[i]).empty());
 167   for (size_t i = 0; i < arraysize(invalid_path_test_cases); ++i)
 168     EXPECT_TRUE(extension->GetResource(invalid_path_test_cases[i]).empty());
 169 }
 170
 171 TEST(ExtensionTest, GetAbsolutePathNoError) {
 172   scoped_refptr<Extension> extension = LoadManifestStrict("absolute_path",
 173       "absolute.json");
 174   EXPECT_TRUE(extension.get());
 175   std::string err;
 176   std::vector<InstallWarning> warnings;
 177   EXPECT_TRUE(file_util::ValidateExtension(extension.get(), &err, &warnings));
 178   EXPECT_EQ(0U, warnings.size());
 179
 180   EXPECT_EQ(extension->path().AppendASCII("test.html").value(),
 181             extension->GetResource("test.html").GetFilePath().value());
 182   EXPECT_EQ(extension->path().AppendASCII("test.js").value(),
 183             extension->GetResource("test.js").GetFilePath().value());
 184 }
 185
 186
 187 TEST(ExtensionTest, IdIsValid) {
 188   EXPECT_TRUE(crx_file::id_util::IdIsValid("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
 189   EXPECT_TRUE(crx_file::id_util::IdIsValid("pppppppppppppppppppppppppppppppp"));
 190   EXPECT_TRUE(crx_file::id_util::IdIsValid("abcdefghijklmnopabcdefghijklmnop"));
 191   EXPECT_TRUE(crx_file::id_util::IdIsValid("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"));
 192   EXPECT_FALSE(crx_file::id_util::IdIsValid("abcdefghijklmnopabcdefghijklmno"));
 193   EXPECT_FALSE(
 194       crx_file::id_util::IdIsValid("abcdefghijklmnopabcdefghijklmnopa"));
 195   EXPECT_FALSE(
 196       crx_file::id_util::IdIsValid("0123456789abcdef0123456789abcdef"));
 197   EXPECT_FALSE(
 198       crx_file::id_util::IdIsValid("abcdefghijklmnopabcdefghijklmnoq"));
 199   EXPECT_FALSE(
 200       crx_file::id_util::IdIsValid("abcdefghijklmnopabcdefghijklmno0"));
 201 }
 202
 203
 204 // This test ensures that the mimetype sniffing code stays in sync with the
 205 // actual crx files that we test other parts of the system with.
 206 TEST(ExtensionTest, MimeTypeSniffing) {
 207   base::FilePath path;
 208   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
 209   path = path.AppendASCII("extensions").AppendASCII("good.crx");
 210
 211   std::string data;
 212   ASSERT_TRUE(base::ReadFileToString(path, &data));
 213
 214   std::string result;
 215   EXPECT_TRUE(net::SniffMimeType(data.c_str(),
 216                                  data.size(),
 217                                  GURL("http://www.example.com/foo.crx"),
 218                                  std::string(),
 219                                  &result));
 220   EXPECT_EQ(std::string(Extension::kMimeType), result);
 221
 222   data.clear();
 223   result.clear();
 224   path = path.DirName().AppendASCII("bad_magic.crx");
 225   ASSERT_TRUE(base::ReadFileToString(path, &data));
 226   EXPECT_TRUE(net::SniffMimeType(data.c_str(),
 227                                  data.size(),
 228                                  GURL("http://www.example.com/foo.crx"),
 229                                  std::string(),
 230                                  &result));
 231   EXPECT_EQ("application/octet-stream", result);
 232 }
 233
 234 TEST(ExtensionTest, WantsFileAccess) {
 235   scoped_refptr<Extension> extension;
 236   GURL file_url("file:///etc/passwd");
 237
 238   // Ignore the policy delegate for this test.
 239   PermissionsData::SetPolicyDelegate(NULL);
 240
 241   // <all_urls> permission
 242   extension = LoadManifest("permissions", "permissions_all_urls.json");
 243   EXPECT_TRUE(extension->wants_file_access());
 244   EXPECT_FALSE(extension->permissions_data()->CanAccessPage(
 245       extension.get(), file_url, -1, -1, NULL));
 246   extension = LoadManifest(
 247       "permissions", "permissions_all_urls.json", Extension::ALLOW_FILE_ACCESS);
 248   EXPECT_TRUE(extension->wants_file_access());
 249   EXPECT_TRUE(extension->permissions_data()->CanAccessPage(
 250       extension.get(), file_url, -1, -1, NULL));
 251
 252   // file:///* permission
 253   extension = LoadManifest("permissions", "permissions_file_scheme.json");
 254   EXPECT_TRUE(extension->wants_file_access());
 255   EXPECT_FALSE(extension->permissions_data()->CanAccessPage(
 256       extension.get(), file_url, -1, -1, NULL));
 257   extension = LoadManifest("permissions",
 258                            "permissions_file_scheme.json",
 259                            Extension::ALLOW_FILE_ACCESS);
 260   EXPECT_TRUE(extension->wants_file_access());
 261   EXPECT_TRUE(extension->permissions_data()->CanAccessPage(
 262       extension.get(), file_url, -1, -1, NULL));
 263
 264   // http://* permission
 265   extension = LoadManifest("permissions", "permissions_http_scheme.json");
 266   EXPECT_FALSE(extension->wants_file_access());
 267   EXPECT_FALSE(extension->permissions_data()->CanAccessPage(
 268       extension.get(), file_url, -1, -1, NULL));
 269   extension = LoadManifest("permissions",
 270                            "permissions_http_scheme.json",
 271                            Extension::ALLOW_FILE_ACCESS);
 272   EXPECT_FALSE(extension->wants_file_access());
 273   EXPECT_FALSE(extension->permissions_data()->CanAccessPage(
 274       extension.get(), file_url, -1, -1, NULL));
 275
 276   // <all_urls> content script match
 277   extension = LoadManifest("permissions", "content_script_all_urls.json");
 278   EXPECT_TRUE(extension->wants_file_access());
 279   EXPECT_FALSE(extension->permissions_data()->CanRunContentScriptOnPage(
 280       extension.get(), file_url, -1, -1, NULL));
 281   extension = LoadManifest("permissions", "content_script_all_urls.json",
 282       Extension::ALLOW_FILE_ACCESS);
 283   EXPECT_TRUE(extension->wants_file_access());
 284   EXPECT_TRUE(extension->permissions_data()->CanRunContentScriptOnPage(
 285       extension.get(), file_url, -1, -1, NULL));
 286
 287   // file:///* content script match
 288   extension = LoadManifest("permissions", "content_script_file_scheme.json");
 289   EXPECT_TRUE(extension->wants_file_access());
 290   EXPECT_FALSE(extension->permissions_data()->CanRunContentScriptOnPage(
 291       extension.get(), file_url, -1, -1, NULL));
 292   extension = LoadManifest("permissions", "content_script_file_scheme.json",
 293       Extension::ALLOW_FILE_ACCESS);
 294   EXPECT_TRUE(extension->wants_file_access());
 295   EXPECT_TRUE(extension->permissions_data()->CanRunContentScriptOnPage(
 296       extension.get(), file_url, -1, -1, NULL));
 297
 298   // http://* content script match
 299   extension = LoadManifest("permissions", "content_script_http_scheme.json");
 300   EXPECT_FALSE(extension->wants_file_access());
 301   EXPECT_FALSE(extension->permissions_data()->CanRunContentScriptOnPage(
 302       extension.get(), file_url, -1, -1, NULL));
 303   extension = LoadManifest("permissions", "content_script_http_scheme.json",
 304       Extension::ALLOW_FILE_ACCESS);
 305   EXPECT_FALSE(extension->wants_file_access());
 306   EXPECT_FALSE(extension->permissions_data()->CanRunContentScriptOnPage(
 307       extension.get(), file_url, -1, -1, NULL));
 308 }
 309
 310 TEST(ExtensionTest, ExtraFlags) {
 311   scoped_refptr<Extension> extension;
 312   extension = LoadManifest("app", "manifest.json", Extension::FROM_WEBSTORE);
 313   EXPECT_TRUE(extension->from_webstore());
 314
 315   extension = LoadManifest("app", "manifest.json", Extension::FROM_BOOKMARK);
 316   EXPECT_TRUE(extension->from_bookmark());
 317
 318   extension = LoadManifest("app", "manifest.json", Extension::NO_FLAGS);
 319   EXPECT_FALSE(extension->from_bookmark());
 320   EXPECT_FALSE(extension->from_webstore());
 321 }
 322
 323 }  // namespace extensions