Add a whitelist check for nacl-nonsfi mode

chrome/common/pepper_permission_util.cc

 // Copyright 2013 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/pepper_permission_util.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 
 using extensions::Extension;
 using extensions::Manifest;
+using extensions::SharedModuleInfo;
 
 namespace chrome {
 
 namespace {
 
 std::string HashHost(const std::string& host) {
   const std::string id_hash = base::SHA1HashString(host);
   DCHECK_EQ(id_hash.length(), base::kSHA1Length);
   return base::HexEncode(id_hash.c_str(), id_hash.length());
 }
@@ skipping 12 matching lines @@
     return false;
 
   const std::string host = url.host();
   if (HostIsInSet(host, whitelist))
     return true;
 
   // Check the modules that are imported by this extension to see if any of them
   // is whitelisted.
   const Extension* extension = extension_set ? extension_set->GetByID(host)
                                              : NULL;
-  if (extension) {
-    typedef std::vector<extensions::SharedModuleInfo::ImportInfo>
-        ImportInfoVector;
-    const ImportInfoVector& imports =
-        extensions::SharedModuleInfo::GetImports(extension);
-    for (ImportInfoVector::const_iterator it = imports.begin();
-         it != imports.end(); ++it) {
-      const Extension* imported_extension = extension_set->GetByID(
-          it->extension_id);
-      if (imported_extension &&
-          extensions::SharedModuleInfo::IsSharedModule(imported_extension) &&
-          HostIsInSet(it->extension_id, whitelist)) {
-        return true;
-      }
+  if (!extension)
+    return false;
+
+  typedef std::vector<SharedModuleInfo::ImportInfo> ImportInfoVector;
+  const ImportInfoVector& imports = SharedModuleInfo::GetImports(extension);
+  for (ImportInfoVector::const_iterator it = imports.begin();
+       it != imports.end(); ++it) {
+    const Extension* imported_extension = extension_set->GetByID(
+        it->extension_id);
+    if (imported_extension &&
+        SharedModuleInfo::IsSharedModule(imported_extension) &&
+        // We check the whitelist explicitly even though the extension should

[Mark Seaborn, 2014/05/09 02:12:31]

Could you possibly explain what this change does in the commit message, and
explain the reason?

i.e. Before the change, this implicitly whitelists extension A if it depends on
extension B which was explicitly whitelisted.  With this change, you're adding a
sanity check to ensure that B whitelisted A as being allowed to import B.

When you say "the extension should never have been allowed to be installed in
the first place", could you also say in the comment where the check for that is
implemented, for context?

[elijahtaylor1, 2014/05/09 05:37:58]

Done.  While adjusting this comment, I thought of another additional sanity
check to do for shared modules' whitelists, so I added that and a comment to
this CL.

+        // never have been allowed to be installed in the first place if this
+        // fails.
+        SharedModuleInfo::IsExportAllowedByWhitelist(imported_extension,
+                                                     host) &&
+        HostIsInSet(it->extension_id, whitelist)) {
+      return true;
     }
   }
 
   return false;
 }
 
 bool IsHostAllowedByCommandLine(const GURL& url,
                                 const extensions::ExtensionSet* extension_set,
                                 const char* command_line_switch) {
   if (!url.is_valid())
@@ skipping 20 matching lines @@
   base::StringTokenizer t(allowed_list, ",");
   while (t.GetNext()) {
     if (t.token() == host)
       return true;
   }
 
   return false;
 }
 
 }  // namespace chrome