Verify signed .crx extension installations

chrome/common/extensions/extension.cc

 // Copyright (c) 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 "chrome/common/extensions/extension.h"
 
 #include "app/resource_bundle.h"
+#include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
+#include "base/third_party/nss/blapi.h"
+#include "base/third_party/nss/sha256.h"
+#include "net/base/base64.h"
 #include "net/base/net_util.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/base64.h"
 
 #if defined(OS_WIN)
 #include "base/registry.h"
 #endif
 
 namespace {
   const int kPEMOutputColumns = 65;
 
   // KEY MARKERS
   const char kKeyBeginHeaderMarker[] = "-----BEGIN";
   const char kKeyBeginFooterMarker[] = "-----END";
   const char kKeyInfoEndMarker[] = "KEY-----";
   const char kPublic[] = "PUBLIC";
   const char kPrivate[] = "PRIVATE";
 
   const int kRSAKeySize = 1024;
 };
 
+int Extension::id_counter_ = 0;
+
 const char Extension::kManifestFilename[] = "manifest.json";
 
 const wchar_t* Extension::kBackgroundKey = L"background_page";
 const wchar_t* Extension::kContentScriptsKey = L"content_scripts";
 const wchar_t* Extension::kCssKey = L"css";
 const wchar_t* Extension::kDescriptionKey = L"description";
 const wchar_t* Extension::kIconPathKey = L"icon";
-const wchar_t* Extension::kIdKey = L"id";
 const wchar_t* Extension::kJsKey = L"js";
 const wchar_t* Extension::kMatchesKey = L"matches";
 const wchar_t* Extension::kNameKey = L"name";
+const wchar_t* Extension::kPageActionIdKey = L"id";
 const wchar_t* Extension::kPageActionsKey = L"page_actions";
 const wchar_t* Extension::kPermissionsKey = L"permissions";
 const wchar_t* Extension::kPluginsKey = L"plugins";
 const wchar_t* Extension::kPluginsPathKey = L"path";
 const wchar_t* Extension::kPluginsPublicKey = L"public";
 const wchar_t* Extension::kPublicKeyKey = L"key";
 const wchar_t* Extension::kRunAtKey = L"run_at";
 const wchar_t* Extension::kSignatureKey = L"signature";
 const wchar_t* Extension::kThemeKey = L"theme";
 const wchar_t* Extension::kThemeImagesKey = L"images";
 const wchar_t* Extension::kThemeColorsKey = L"colors";
 const wchar_t* Extension::kThemeTintsKey = L"tints";
 const wchar_t* Extension::kThemeDisplayPropertiesKey = L"properties";
 const wchar_t* Extension::kToolstripsKey = L"toolstrips";
 const wchar_t* Extension::kTooltipKey = L"tooltip";
 const wchar_t* Extension::kTypeKey = L"type";
 const wchar_t* Extension::kVersionKey = L"version";
 
 const char* Extension::kRunAtDocumentStartValue = "document_start";
 const char* Extension::kRunAtDocumentEndValue = "document_end";
 const char* Extension::kPageActionTypeTab = "tab";
 const char* Extension::kPageActionTypePermanent = "permanent";
 
 // A list of all the keys allowed by themes.
 static const wchar_t* kValidThemeKeys[] = {
   Extension::kDescriptionKey,
   Extension::kIconPathKey,
-  Extension::kIdKey,
   Extension::kNameKey,
   Extension::kPublicKeyKey,
   Extension::kSignatureKey,
   Extension::kThemeKey,
   Extension::kVersionKey
 };
 
 // Extension-related error messages. Some of these are simple patterns, where a
 // '*' is replaced at runtime with a specific value. This is used instead of
 // printf because we want to unit test them and scanf is hard to make
 // cross-platform.
 const char* Extension::kInvalidContentScriptError =
     "Invalid value for 'content_scripts[*]'.";
 const char* Extension::kInvalidContentScriptsListError =
     "Invalid value for 'content_scripts'.";
 const char* Extension::kInvalidCssError =
     "Invalid value for 'content_scripts[*].css[*]'.";
 const char* Extension::kInvalidCssListError =
     "Required value 'content_scripts[*].css is invalid.";
 const char* Extension::kInvalidDescriptionError =
     "Invalid value for 'description'.";
-const char* Extension::kInvalidIdError =
-    "Required value 'id' is missing or invalid.";
 const char* Extension::kInvalidJsError =
     "Invalid value for 'content_scripts[*].js[*]'.";
 const char* Extension::kInvalidJsListError =
     "Required value 'content_scripts[*].js is invalid.";
+const char* Extension::kInvalidKeyError =
+    "Value 'key' is missing or invalid.";
 const char* Extension::kInvalidManifestError =
     "Manifest is missing or invalid.";
 const char* Extension::kInvalidMatchCountError =
     "Invalid value for 'content_scripts[*].matches. There must be at least one "
     "match specified.";
 const char* Extension::kInvalidMatchError =
     "Invalid value for 'content_scripts[*].matches[*]'.";
 const char* Extension::kInvalidMatchesError =
     "Required value 'content_scripts[*].matches' is missing or invalid.";
 const char* Extension::kInvalidNameError =
     "Required value 'name' is missing or invalid.";
 const char* Extension::kInvalidPageActionError =
     "Invalid value for 'page_actions[*]'.";
 const char* Extension::kInvalidPageActionsListError =
     "Invalid value for 'page_actions'.";
 const char* Extension::kInvalidPageActionIconPathError =
     "Invalid value for 'page_actions[*].icon'.";
+const char* Extension::kInvalidPageActionIdError =
+    "Required value 'id' is missing or invalid.";
 const char* Extension::kInvalidPageActionTooltipError =
     "Invalid value for 'page_actions[*].tooltip'.";
 const char* Extension::kInvalidPageActionTypeValueError =
     "Invalid value for 'page_actions[*].type', expected 'tab' or 'permanent'.";
 const char* Extension::kInvalidPermissionsError =
     "Required value 'permissions' is missing or invalid.";
 const char* Extension::kInvalidPermissionCountWarning =
     "Warning, 'permissions' key found, but array is empty.";
 const char* Extension::kInvalidPermissionError =
     "Invalid value for 'permissions[*]'.";
 const char* Extension::kInvalidPermissionSchemeError =
     "Invalid scheme for 'permissions[*]'. Only 'http' and 'https' are "
     "allowed.";
 const char* Extension::kInvalidPluginsError =
     "Invalid value for 'plugins'.";
 const char* Extension::kInvalidPluginsPathError =
     "Invalid value for 'plugins[*].path'.";
 const char* Extension::kInvalidPluginsPublicError =
     "Invalid value for 'plugins[*].public'.";
 const char* Extension::kInvalidBackgroundError =
     "Invalid value for 'background'.";
 const char* Extension::kInvalidRunAtError =
     "Invalid value for 'content_scripts[*].run_at'.";
+const char* Extension::kInvalidSignatureError =
+    "Value 'signature' is missing or invalid.";
 const char* Extension::kInvalidToolstripError =
     "Invalid value for 'toolstrips[*]'";
 const char* Extension::kInvalidToolstripsError =
     "Invalid value for 'toolstrips'.";
 const char* Extension::kInvalidVersionError =
     "Required value 'version' is missing or invalid.";
 const char* Extension::kInvalidZipHashError =
     "Required key 'zip_hash' is missing or invalid.";
 const char* Extension::kMissingFileError =
     "At least one js or css file is required for 'content_scripts[*]'.";
 const char* Extension::kInvalidThemeError =
     "Invalid value for 'theme'.";
 const char* Extension::kInvalidThemeImagesError =
     "Invalid value for theme images - images must be strings.";
 const char* Extension::kInvalidThemeImagesMissingError =
     "Am image specified in the theme is missing.";
 const char* Extension::kInvalidThemeColorsError =
     "Invalid value for theme colors - colors must be integers";
 const char* Extension::kInvalidThemeTintsError =
     "Invalid value for theme images - tints must be decimal numbers.";
 const char* Extension::kThemesCannotContainExtensionsError =
     "A theme cannot contain extensions code.";
 
 #if defined(OS_WIN)
 const char* Extension::kExtensionRegistryPath =
     "Software\\Google\\Chrome\\Extensions";
 #endif
 
-const size_t Extension::kIdSize = 20;  // SHA1 (160 bits) == 20 bytes
+// first 20 bytes of SHA256 hashed public key.
+const size_t Extension::kIdSize = 20;
 
 Extension::~Extension() {
   for (PageActionMap::iterator i = page_actions_.begin();
        i != page_actions_.end(); ++i)
     delete i->second;
 }
 
 const std::string Extension::VersionString() const {
   return version_->GetString();
 }
@@ skipping 42 matching lines @@
   HKEY reg_root = HKEY_LOCAL_MACHINE;
   RegKey key;
   registry_path.append("\\");
   registry_path.append(id_);
   if (key.Open(reg_root, ASCIIToWide(registry_path).c_str()))
     return Extension::EXTERNAL_REGISTRY;
 #endif
   return Extension::EXTERNAL_PREF;
 }
 
+bool Extension::GenerateIdFromPublicKey(const std::string& input,
+                                        std::string* output) {
+  CHECK(output);
+  if (input.length() == 0)
+    return false;
+
+  const uint8* ubuf = reinterpret_cast<const unsigned char*>(input.data());
+  SHA256Context ctx;
+  SHA256_Begin(&ctx);
+  SHA256_Update(&ctx, ubuf, input.length());
+  uint8 hash[Extension::kIdSize];
+  SHA256_End(&ctx, hash, NULL, sizeof(hash));
+  *output = StringToLowerASCII(HexEncode(hash, sizeof(hash)));
+
+  return true;
+}
+
 // Helper method that loads a UserScript object from a dictionary in the
 // content_script list of the manifest.
 bool Extension::LoadUserScriptHelper(const DictionaryValue* content_script,
                                      int definition_index, std::string* error,
                                      UserScript* result) {
   // run_at
   if (content_script->HasKey(kRunAtKey)) {
     std::string run_location;
     if (!content_script->GetString(kRunAtKey, &run_location)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidRunAtError,
@@ skipping 117 matching lines @@
   if (!page_action->GetString(kIconPathKey, &icon)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(
         kInvalidPageActionIconPathError, IntToString(definition_index));
     return NULL;
   }
   FilePath icon_path = path_.AppendASCII(icon);
   result->set_icon_path(icon_path);
 
   // Read the page action |id|.
   std::string id;
-  if (!page_action->GetString(kIdKey, &id)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidIdError,
+  if (!page_action->GetString(kPageActionIdKey, &id)) {
+    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidPageActionIdError,
         IntToString(definition_index));
     return NULL;
   }
   result->set_id(id);
 
   // Read the page action |name|.
   std::string name;
   if (!page_action->GetString(kNameKey, &name)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidNameError,
         IntToString(definition_index));
@@ skipping 103 matching lines @@
   if (path_str.size() >= 2 && path_str[0] >= L'a' && path_str[0] <= L'z' &&
       path_str[1] == ':')
     path_str[0] += ('A' - 'a');
 
   path_ = FilePath(path_str);
 #else
   path_ = path;
 #endif
 }
 
-
 // TODO(rafaelw): Move ParsePEMKeyBytes, ProducePEM & FormatPEMForOutput to a
 // util class in base:
 // http://code.google.com/p/chromium/issues/detail?id=13572
 bool Extension::ParsePEMKeyBytes(const std::string& input,
                                         std::string* output) {
-  CHECK(output);
+  DCHECK(output);
+  if (!output)
+    return false;
   if (input.length() == 0)
     return false;
 
   std::string working = input;
   if (StartsWithASCII(working, kKeyBeginHeaderMarker, true)) {
     working = CollapseWhitespaceASCII(working, true);
     size_t header_pos = working.find(kKeyInfoEndMarker,
       sizeof(kKeyBeginHeaderMarker) - 1);
     if (header_pos == std::string::npos)
       return false;
@@ skipping 45 matching lines @@
   output->append(is_public ? kPublic : kPrivate);
   output->append(" ");
   output->append(kKeyInfoEndMarker);
   output->append("\n");
 
   return true;
 }
 
 bool Extension::InitFromValue(const DictionaryValue& source, bool require_id,
                               std::string* error) {
-  // Initialize id.
-  if (source.HasKey(kIdKey)) {
-    if (!source.GetString(kIdKey, &id_)) {
-      *error = kInvalidIdError;
-      return false;
-    }
-
-    // Normalize the string to lowercase, so it can be used as an URL component
-    // (where GURL will lowercase it).
-    StringToLowerASCII(&id_);
-
-    // Verify that the id is legal.
-    if (!IdIsValid(id_)) {
-      *error = kInvalidIdError;
-      return false;
+  if (source.HasKey(kPublicKeyKey)) {
+    std::string public_key_bytes;
+    if (!source.GetString(kPublicKeyKey, &public_key_) ||
+      !ParsePEMKeyBytes(public_key_, &public_key_bytes) ||
+      !GenerateIdFromPublicKey(public_key_bytes, &id_)) {
+        *error = kInvalidKeyError;
+        return false;
     }
   } else if (require_id) {
-    *error = kInvalidIdError;
+    *error = kInvalidKeyError;
     return false;
   } else {
     // Generate a random ID
-    static int counter = 0;
-    id_ = StringPrintf("%x", counter);
-    ++counter;
+    id_ = StringPrintf("%x", NextGeneratedId());
 
-    // pad the string out to 40 chars with zeroes.
-    id_.insert(0, 40 - id_.length(), '0');
+    // pad the string out to kIdSize*2 chars with zeroes.
+    id_.insert(0, Extension::kIdSize*2 - id_.length(), '0');
   }
 
   // Initialize the URL.
   extension_url_ = GURL(std::string(chrome::kExtensionScheme) +
                         chrome::kStandardSchemeSeparator + id_ + "/");
 
   // Initialize version.
   std::string version_str;
   if (!source.GetString(kVersionKey, &version_str)) {
     *error = kInvalidVersionError;
@@ skipping 292 matching lines @@
     }
   }
 
   for (PageActionMap::const_iterator it = page_actions().begin();
        it != page_actions().end(); ++it) {
     image_paths.insert(it->second->icon_path());
   }
 
   return image_paths;
 }