Verify signed .crx extension installations

chrome/browser/extensions/extensions_service_unittest.cc

 // Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json_reader.h"
@@ skipping 18 matching lines @@
 
 #if defined(OS_WIN)
 #include "base/registry.h"
 #endif
 
 namespace {
 
 // Extension ids used during testing.
 const char* const all_zero = "0000000000000000000000000000000000000000";
 const char* const zero_n_one = "0000000000000000000000000000000000000001";
-const char* const good0 = "00123456789abcdef0123456789abcdef0123456";
-const char* const good1 = "10123456789abcdef0123456789abcdef0123456";
-const char* const good2 = "20123456789abcdef0123456789abcdef0123456";
-const char* const good_crx = "00123456789abcdef0123456789abcdef0123456";
-const char* const page_action = "8a5e4cb023c61b431e9b603a97c293429ce057c8";
-const char* const theme_crx = "f0123456789abcdef0123456789abcdef0126456";
-const char* const theme2_crx = "f0123456789adddef0123456789abcdef0126456";
+const char* const good0 = "fc6f6ba6693faf6773c13701019f2e7a12f0febe";
+const char* const good1 = "e5ead92b2c6795c1d2b92df9c5cb37de5582471a";
+const char* const good2 = "a37fed892f622823f4daaec4426a32fc7f6147dc";
+const char* const good_crx = "b3dd733cd71a98fa83f387455e12f5c5501c519e";
+const char* const page_action = "a4ca7d01469a010acb200568a0b8f4d9b3ac1f91";
+const char* const theme_crx = "80c45f5ae9e0f839d105c6a6d2461a036bc40a04";
+const char* const theme2_crx = "f9f6c52c01efdd5edd7c396b5f995a15fc7ad6d1";
 
 struct ExtensionsOrder {
   bool operator()(const Extension* a, const Extension* b) {
     return a->name() < b->name();
   }
 };
 
 static std::vector<std::string> GetErrors() {
   const std::vector<std::string>* errors =
       ExtensionErrorReporter::GetInstance()->GetErrors();
@@ skipping 172 matching lines @@
   ASSERT_TRUE(service_->Init());
   loop_.RunAllPending();
 
   std::vector<std::string> errors = GetErrors();
   for (std::vector<std::string>::iterator err = errors.begin();
     err != errors.end(); ++err) {
     LOG(ERROR) << *err;
   }
   ASSERT_EQ(3u, loaded_.size());
 
-  EXPECT_EQ(std::string(good_crx), loaded_[0]->id());
+  EXPECT_EQ(std::string(good0), loaded_[0]->id());
   EXPECT_EQ(std::string("My extension 1"),
             loaded_[0]->name());
   EXPECT_EQ(std::string("The first extension that I made."),
             loaded_[0]->description());
   EXPECT_EQ(Extension::INTERNAL, loaded_[0]->location());
   EXPECT_TRUE(service_->GetExtensionByID(loaded_[0]->id()));
   EXPECT_EQ(3u, service_->extensions()->size());
 
   ValidatePrefKeyCount(3);
-  ValidatePref(good_crx, L"state", Extension::ENABLED);
-  ValidatePref(good_crx, L"location", Extension::INTERNAL);
+  ValidatePref(good0, L"state", Extension::ENABLED);
+  ValidatePref(good0, L"location", Extension::INTERNAL);
   ValidatePref(good1, L"state", Extension::ENABLED);
   ValidatePref(good1, L"location", Extension::INTERNAL);
   ValidatePref(good2, L"state", Extension::ENABLED);
   ValidatePref(good2, L"location", Extension::INTERNAL);
 
   Extension* extension = loaded_[0];
   const UserScriptList& scripts = extension->content_scripts();
   const std::vector<std::string>& toolstrips = extension->toolstrips();
   ASSERT_EQ(2u, scripts.size());
   EXPECT_EQ(2u, scripts[0].url_patterns().size());
@@ skipping 131 matching lines @@
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::INTERNAL);
 
   // An extension with page actions.
   path = extensions_path.AppendASCII("page_action.crx");
   InstallExtension(path, true);
   ValidatePrefKeyCount(++pref_count);
   ValidatePref(page_action, L"state", Extension::ENABLED);
   ValidatePref(page_action, L"location", Extension::INTERNAL);
 
+  // Bad signature. 
+  path = extensions_path.AppendASCII("bad_signature.crx");
+  InstallExtension(path, false);
+
   // 0-length extension file.
   path = extensions_path.AppendASCII("not_an_extension.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 
   // Bad magic number.
   path = extensions_path.AppendASCII("bad_magic.crx");
   InstallExtension(path, false);
   ValidatePrefKeyCount(pref_count);
 
-  // Poorly formed JSON.
-  path = extensions_path.AppendASCII("bad_json.crx");
-  InstallExtension(path, false);
-  ValidatePrefKeyCount(pref_count);
-
-  // Incorrect zip hash.
-  path = extensions_path.AppendASCII("bad_hash.crx");
-  InstallExtension(path, false);
-  ValidatePrefKeyCount(pref_count);
-
   // TODO(erikkay): add more tests for many of the failure cases.
   // TODO(erikkay): add tests for upgrade cases.
 }
 
 #if defined(OS_WIN)  // TODO(port)
 // Test Packaging and installing an extension.
 // TODO(aa): add a test that uses an openssl-generate private key.
 // TODO(rafaelw): add more tests for failure cases.
 TEST_F(ExtensionsServiceTest, PackExtension) {
   SetExtensionsEnabled(true);
@@ skipping 121 matching lines @@
   loop_.RunAllPending();
 
   ASSERT_FALSE(installed_);
   ASSERT_EQ(0u, loaded_.size());
   ASSERT_EQ(0u, GetErrors().size());
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::ENABLED);
   ValidatePref(good_crx, L"location", Extension::INTERNAL);
 }
 
+// Test upgrading a signed extension.
+TEST_F(ExtensionsServiceTest, UpgradeSignedGood) {
+  FilePath extensions_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
+  extensions_path = extensions_path.AppendASCII("extensions");
+
+  FilePath path = extensions_path.AppendASCII("good.crx");
+  service_->InstallExtension(path);
+  loop_.RunAllPending();
+
+  ASSERT_TRUE(installed_);
+  ASSERT_EQ(1u, loaded_.size());
+  ASSERT_EQ(0u, GetErrors().size());
+
+  // Upgrade to version 2.0
+  path = extensions_path.AppendASCII("good2.crx");
+  service_->InstallExtension(path);
+  loop_.RunAllPending();
+
+  ASSERT_TRUE(installed_);
+  ASSERT_EQ(2u, loaded_.size());
+  ASSERT_EQ(0u, GetErrors().size());
+}
+
+// Test upgrading a signed extension with a bad signature.
+TEST_F(ExtensionsServiceTest, UpgradeSignedBad) {
+  FilePath extensions_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
+  extensions_path = extensions_path.AppendASCII("extensions");
+
+  FilePath path = extensions_path.AppendASCII("good.crx");
+  service_->InstallExtension(path);
+  loop_.RunAllPending();
+
+  ASSERT_TRUE(installed_);
+  ASSERT_EQ(1u, loaded_.size());
+  ASSERT_EQ(0u, GetErrors().size());
+  installed_ = NULL;
+
+  // Try upgrading with a bad signature. This should fail during the unpack,
+  // because the key will not match the signature.
+  path = extensions_path.AppendASCII("good2_bad_signature.crx");
+  service_->InstallExtension(path);
+  loop_.RunAllPending();
+
+  ASSERT_FALSE(installed_);
+  ASSERT_EQ(1u, loaded_.size());
+  ASSERT_EQ(1u, GetErrors().size());
+}
+
 // Tests uninstalling normal extensions
 TEST_F(ExtensionsServiceTest, UninstallExtension) {
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   // A simple extension that should install without error.
   FilePath path = extensions_path.AppendASCII("good.crx");
   InstallExtension(path, true);
 
@@ skipping 77 matching lines @@
   EXPECT_EQ(id, unloaded_id_);
 
   ValidatePrefKeyCount(1);
   ValidatePref(good0, L"state", Extension::DISABLED);
   ValidatePref(good0, L"location", Extension::INTERNAL);
 }
 
 // Tests that we generate IDs when they are not specified in the manifest for
 // --load-extension.
 TEST_F(ExtensionsServiceTest, GenerateID) {
+  Extension::ResetGeneratedIdCounter();
+
   FilePath extensions_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &extensions_path));
   extensions_path = extensions_path.AppendASCII("extensions");
 
   FilePath no_id_ext = extensions_path.AppendASCII("no_id");
   service_->LoadExtension(no_id_ext);
   loop_.RunAllPending();
   EXPECT_EQ(0u, GetErrors().size());
   ASSERT_EQ(1u, loaded_.size());
   std::string id1 = loaded_[0]->id();
@@ skipping 21 matching lines @@
 #if defined(OS_WIN)
 
 TEST_F(ExtensionsServiceTest, ExternalInstallRegistry) {
   // Register a test extension externally using the registry.
   FilePath source_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &source_path));
   source_path = source_path.AppendASCII("extensions").AppendASCII("good.crx");
 
   RegKey key;
   std::wstring reg_path = ASCIIToWide(registry_path_);
-  reg_path += L"\\00123456789ABCDEF0123456789ABCDEF0123456";
+  reg_path += L"\\b3dd733cd71a98fa83f387455e12f5c5501c519e";
   ASSERT_TRUE(key.Create(HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_WRITE));
   ASSERT_TRUE(key.WriteValue(L"path", source_path.ToWStringHack().c_str()));
   ASSERT_TRUE(key.WriteValue(L"version", L"1.0.0.0"));
 
   // Start up the service, it should find our externally registered extension
   // and install it.
   service_->Init();
   loop_.RunAllPending();
 
   ASSERT_EQ(0u, GetErrors().size());
@@ skipping 183 matching lines @@
   ValidatePrefKeyCount(1);
   ValidatePref(good_crx, L"state", Extension::KILLBIT);
   ValidatePref(good_crx, L"location", Extension::EXTERNAL_PREF);
 
   // The extension should also be gone from disk.
   FilePath extension_path = install_path.DirName();
   extension_path = extension_path.AppendASCII(good_crx);
   EXPECT_FALSE(file_util::PathExists(extension_path)) <<
       extension_path.ToWStringHack();
 }