Revert "BUG=12114"

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
 
-// first 20 bytes of SHA256 hashed public key.
-const size_t Extension::kIdSize = 20;
+const size_t Extension::kIdSize = 20;  // SHA1 (160 bits) == 20 bytes
 
 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(kPageActionIdKey, &id)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidPageActionIdError,
+  if (!page_action->GetString(kIdKey, &id)) {
+    *error = ExtensionErrorUtils::FormatErrorMessage(kInvalidIdError,
         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) {
-  DCHECK(output);
-  if (!output)
-    return false;
+  CHECK(output);
   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) {
-  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;
+  // 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;
     }
   } else if (require_id) {
-    *error = kInvalidKeyError;
+    *error = kInvalidIdError;
     return false;
   } else {
     // Generate a random ID
-    id_ = StringPrintf("%x", NextGeneratedId());
+    static int counter = 0;
+    id_ = StringPrintf("%x", counter);
+    ++counter;
 
-    // pad the string out to kIdSize*2 chars with zeroes.
-    id_.insert(0, Extension::kIdSize*2 - id_.length(), '0');
+    // pad the string out to 40 chars with zeroes.
+    id_.insert(0, 40 - 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;
 }