extensions: Generate hash of extension ID at a higher level

extensions/common/features/simple_feature.cc

 // Copyright 2014 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 "extensions/common/features/simple_feature.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 17 matching lines @@
 namespace extensions {
 
 namespace {
 
 // A singleton copy of the --whitelisted-extension-id so that we don't need to
 // copy it from the CommandLine each time.
 std::string* g_whitelisted_extension_id = NULL;
 
 Feature::Availability IsAvailableToManifestForBind(
     const std::string& extension_id,
+    const std::string& hashed_id,
     Manifest::Type type,
     Manifest::Location location,
     int manifest_version,
     Feature::Platform platform,
     const Feature* feature) {
-  return feature->IsAvailableToManifest(
-      extension_id, type, location, manifest_version, platform);
+  return feature->IsAvailableToManifest(extension_id, hashed_id, type, location,
+                                        manifest_version, platform);
 }
 
 Feature::Availability IsAvailableToContextForBind(const Extension* extension,
                                                   Feature::Context context,
                                                   const GURL& url,
                                                   Feature::Platform platform,
                                                   const Feature* feature) {
   return feature->IsAvailableToContext(extension, context, url, platform);
 }
 
@@ skipping 301 matching lines @@
     result = filter->Parse(dictionary);
     if (!result.empty())
       break;
   }
 
   return result;
 }
 
 Feature::Availability SimpleFeature::IsAvailableToManifest(
     const std::string& extension_id,
+    const std::string& hashed_id,
     Manifest::Type type,
     Manifest::Location location,
     int manifest_version,
     Platform platform) const {
   // Check extension type first to avoid granting platform app permissions
   // to component extensions.
   // HACK(kalman): user script -> extension. Solve this in a more generic way
   // when we compile feature files.
   Manifest::Type type_to_check = (type == Manifest::TYPE_USER_SCRIPT) ?
       Manifest::TYPE_EXTENSION : type;
   if (!extension_types_.empty() &&
       !ContainsValue(extension_types_, type_to_check)) {
     return CreateAvailability(INVALID_TYPE, type);
   }
 
-  if (IsIdInBlacklist(extension_id))
+  if (IsIdInBlacklist(extension_id, hashed_id))
     return CreateAvailability(FOUND_IN_BLACKLIST, type);
 
   // TODO(benwells): don't grant all component extensions.
   // See http://crbug.com/370375 for more details.
   // Component extensions can access any feature.
   // NOTE: Deliberately does not match EXTERNAL_COMPONENT.
   if (component_extensions_auto_granted_ && location == Manifest::COMPONENT)
     return CreateAvailability(IS_AVAILABLE, type);
 
-  if (!whitelist_.empty() && !IsIdInWhitelist(extension_id) &&
-      !IsWhitelistedForTest(extension_id)) {
+  if (!whitelist_.empty() && !IsIdInWhitelist(extension_id, hashed_id) &&
+      !IsWhitelistedForTest(extension_id) && !IsWhitelistedForTest(hashed_id)) {
     return CreateAvailability(NOT_FOUND_IN_WHITELIST, type);
   }
 
   if (!MatchesManifestLocation(location))
     return CreateAvailability(INVALID_LOCATION, type);
 
   if (!platforms_.empty() && !ContainsValue(platforms_, platform))
     return CreateAvailability(INVALID_PLATFORM, type);
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return CreateAvailability(INVALID_MIN_MANIFEST_VERSION, type);
 
   if (max_manifest_version_ != 0 && manifest_version > max_manifest_version_)
     return CreateAvailability(INVALID_MAX_MANIFEST_VERSION, type);
 
   if (!command_line_switch_.empty() &&
       !IsCommandLineSwitchEnabled(command_line_switch_)) {
     return CreateAvailability(MISSING_COMMAND_LINE_SWITCH, type);
   }
 
   for (const auto& filter : filters_) {
     Availability availability = filter->IsAvailableToManifest(
         extension_id, type, location, manifest_version, platform);
     if (!availability.is_available())
       return availability;
   }
 
   return CheckDependencies(base::Bind(&IsAvailableToManifestForBind,
-                                      extension_id,
-                                      type,
-                                      location,
-                                      manifest_version,
-                                      platform));
+                                      extension_id, hashed_id, type, location,
+                                      manifest_version, platform));
 }
 
 Feature::Availability SimpleFeature::IsAvailableToContext(
     const Extension* extension,
     SimpleFeature::Context context,
     const GURL& url,
     SimpleFeature::Platform platform) const {
   if (extension) {
-    Availability result = IsAvailableToManifest(extension->id(),
-                                                extension->GetType(),
-                                                extension->location(),
-                                                extension->manifest_version(),
-                                                platform);
+    Availability result = IsAvailableToManifest(
+        extension->id(), HashedIdInHex(extension->id()), extension->GetType(),
+        extension->location(), extension->manifest_version(), platform);
     if (!result.is_available())
       return result;
   }
 
   // TODO(lazyboy): This isn't quite right for Extension Service Worker
   // extension API calls, since there's no guarantee that the extension is
   // "active" in current renderer process when the API permission check is
   // done.
   if (!contexts_.empty() && !ContainsValue(contexts_, context))
     return CreateAvailability(INVALID_CONTEXT, context);
@@ skipping 111 matching lines @@
     Context context) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
                                      context));
 }
 
 bool SimpleFeature::IsInternal() const {
   return false;
 }
 
-bool SimpleFeature::IsIdInBlacklist(const std::string& extension_id) const {
-  return IsIdInList(extension_id, blacklist_);
+bool SimpleFeature::IsIdInBlacklist(const std::string& extension_id,
+                                    const std::string& hashed_id) const {
+  return (IsIdInList(extension_id, blacklist_) ||
+          IsIdInList(hashed_id, blacklist_));
 }
 
-bool SimpleFeature::IsIdInWhitelist(const std::string& extension_id) const {
-  return IsIdInList(extension_id, whitelist_);
+bool SimpleFeature::IsIdInWhitelist(const std::string& extension_id,
+                                    const std::string& hashed_id) const {
+  return (IsIdInList(extension_id, whitelist_) ||
+          IsIdInList(hashed_id, whitelist_));
 }
 
 // static
 bool SimpleFeature::IsIdInArray(const std::string& extension_id,
                                 const char* const array[],
                                 size_t array_length) {
   if (!IsValidExtensionId(extension_id))
     return false;
 
   const char* const* start = array;
   const char* const* end = array + array_length;
 
-  return ((std::find(start, end, extension_id) != end) ||
-          (std::find(start, end, HashedIdInHex(extension_id)) != end));
+  return (std::find(start, end, extension_id) != end);
 }
 
 // static
 bool SimpleFeature::IsIdInList(const std::string& extension_id,
                                const std::vector<std::string>& list) {
   if (!IsValidExtensionId(extension_id))
     return false;
 
-  return (ContainsValue(list, extension_id) ||
-          ContainsValue(list, HashedIdInHex(extension_id)));
+  return ContainsValue(list, extension_id);
 }
 
 bool SimpleFeature::MatchesManifestLocation(
     Manifest::Location manifest_location) const {
   switch (location_) {
     case SimpleFeature::UNSPECIFIED_LOCATION:
       return true;
     case SimpleFeature::COMPONENT_LOCATION:
       return manifest_location == Manifest::COMPONENT;
     case SimpleFeature::EXTERNAL_COMPONENT_LOCATION:
@@ skipping 24 matching lines @@
 bool SimpleFeature::IsValidExtensionId(const std::string& extension_id) {
   // Belt-and-suspenders philosophy here. We should be pretty confident by this
   // point that we've validated the extension ID format, but in case something
   // slips through, we avoid a class of attack where creative ID manipulation
   // leads to hash collisions.
   // 128 bits / 4 = 32 mpdecimal characters
   return (extension_id.length() == 32);
 }
 
 }  // namespace extensions