Change extension id format back to mp-decimal, and change the

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"
@@ skipping 17 matching lines @@
   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;
+
+  // Converts a normal hexadecimal string into the alphabet used by extensions.
+  // We use the characters 'a'-'p' instead of '0'-'f' to avoid ever having a
+  // completely numeric host, since some software interprets that as an IP
+  // address.
+  static void ConvertHexadecimalToIDAlphabet(std::string* id) {
+    for (size_t i = 0; i < id->size(); ++i)
+      (*id)[i] = HexStringToInt(id->substr(i, 1)) + 'a';
+  }
 };
 
 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";
@@ skipping 121 matching lines @@
 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;
+// first 16 bytes of SHA256 hashed public key.
+const size_t Extension::kIdSize = 16;
 
 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();
 }
 
 // static
 bool Extension::IdIsValid(const std::string& id) {
-  // Verify that the id is legal.  The id is a hex string of the SHA-1 hash of
-  // the public key.
-  std::vector<uint8> id_bytes;
-  if (!HexStringToBytes(id, &id_bytes) || id_bytes.size() != kIdSize)
+  // Verify that the id is legal.
+  if (id.size() != (kIdSize * 2))
     return false;
 
   // We only support lowercase IDs, because IDs can be used as URL components
   // (where GURL will lowercase it).
-  std::string temp = id;
-  StringToLowerASCII(temp);
-  if (temp != id)
-    return false;
+  std::string temp = StringToLowerASCII(id);
+  for (size_t i = 0; i < temp.size(); i++)
+    if (temp[i] < 'a' || temp[i] > 'p')
+      return false;
 
   return true;
 }
 
 // static
 GURL Extension::GetResourceURL(const GURL& extension_url,
                                const std::string& relative_path) {
   DCHECK(extension_url.SchemeIs(chrome::kExtensionScheme));
   DCHECK(extension_url.path() == "/");
 
@@ skipping 30 matching lines @@
   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)));
+  ConvertHexadecimalToIDAlphabet(output);
 
   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
@@ skipping 336 matching lines @@
     }
   } else if (require_id) {
     *error = kInvalidKeyError;
     return false;
   } else {
     // Generate a random ID
     id_ = StringPrintf("%x", NextGeneratedId());
 
     // pad the string out to kIdSize*2 chars with zeroes.
     id_.insert(0, Extension::kIdSize*2 - id_.length(), '0');
+
+    // Convert to our mp-decimal.
+    ConvertHexadecimalToIDAlphabet(&id_);
   }
 
   // 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;
 }