Change ChildProcessSecurityPolicy to store a list of allowed flags for...

chrome/browser/child_process_security_policy.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/browser/child_process_security_policy.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
+#include "base/platform_file.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/common/bindings_policy.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request.h"
 
+const int kReadFilePermissions =

[darin (slow to review), 2010/09/28 06:18:27]

nit: mark this as 'static'

+    base::PLATFORM_FILE_OPEN |
+    base::PLATFORM_FILE_READ |
+    base::PLATFORM_FILE_EXCLUSIVE_READ |
+    base::PLATFORM_FILE_ASYNC;
+
 // The SecurityState class is used to maintain per-renderer security state
 // information.
 class ChildProcessSecurityPolicy::SecurityState {
  public:
   SecurityState()
     : enabled_bindings_(0),
       can_read_raw_cookies_(false) { }
   ~SecurityState() {
     scheme_policy_.clear();
   }
 
   // Grant permission to request URLs with the specified scheme.
   void GrantScheme(const std::string& scheme) {
     scheme_policy_[scheme] = true;
   }
 
   // Revoke permission to request URLs with the specified scheme.
   void RevokeScheme(const std::string& scheme) {
     scheme_policy_[scheme] = false;
   }
 
-  // Grant permission to upload the specified file to the web.
-  void GrantUploadFile(const FilePath& file) {
-    uploadable_files_.insert(file);
+  // Grant certain permissions to a file.
+  void GrantPermissionsForFile(const FilePath& file, int permissions) {
+    file_permissions_[file.StripTrailingSeparators()] |= permissions;
   }
 
   void GrantBindings(int bindings) {
     enabled_bindings_ |= bindings;
   }
 
   void GrantReadRawCookies() {
     can_read_raw_cookies_ = true;
   }
 
   void RevokeReadRawCookies() {
     can_read_raw_cookies_ = false;
   }
 
   // Determine whether permission has been granted to request url.
   // Schemes that have not been granted default to being denied.
   bool CanRequestURL(const GURL& url) {
     SchemeMap::const_iterator judgment(scheme_policy_.find(url.scheme()));
 
     if (judgment == scheme_policy_.end())
       return false;  // Unmentioned schemes are disallowed.
 
     return judgment->second;
   }
 
-  // Determine whether permission has been granted to upload file.
-  // Files that have not been granted default to being denied.
-  bool CanUploadFile(const FilePath& file) {
-    return uploadable_files_.find(file) != uploadable_files_.end();
+  // Determine if the certain permissions have been granted to a file.
+  bool HasPermissionsForFile(const FilePath& file, int permissions) {
+    FilePath current_path = file.StripTrailingSeparators();
+    FilePath last_path;
+    while (current_path != last_path) {
+      if (file_permissions_.find(current_path) != file_permissions_.end())
+        return (file_permissions_[current_path] & permissions) == permissions;
+      last_path = current_path;
+      current_path = current_path.DirName();
+    }
+
+    return false;
   }
 
   bool has_dom_ui_bindings() const {
     return BindingsPolicy::is_dom_ui_enabled(enabled_bindings_);
   }
 
   bool has_extension_bindings() const {
     return BindingsPolicy::is_extension_enabled(enabled_bindings_);
   }
 
   bool can_read_raw_cookies() const {
     return can_read_raw_cookies_;
   }
 
  private:
   typedef std::map<std::string, bool> SchemeMap;
-  typedef std::set<FilePath> FileSet;
+  typedef std::map<FilePath, int> FileMap; // bit-set of PlatformFileFlags

[darin (slow to review), 2010/09/28 06:18:27]

nit: two spaces before the '//'

 
   // Maps URL schemes to whether permission has been granted or revoked:
   //   |true| means the scheme has been granted.
   //   |false| means the scheme has been revoked.
   // If a scheme is not present in the map, then it has never been granted
   // or revoked.
   SchemeMap scheme_policy_;
 
   // The set of files the renderer is permited to upload to the web.
-  FileSet uploadable_files_;
+  FileMap file_permissions_;
 
   int enabled_bindings_;
 
   bool can_read_raw_cookies_;
 
   DISALLOW_COPY_AND_ASSIGN(SecurityState);
 };
 
 ChildProcessSecurityPolicy::ChildProcessSecurityPolicy() {
   // We know about these schemes and believe them to be safe.
@@ skipping 102 matching lines @@
     SecurityStateMap::iterator state = security_state_.find(renderer_id);
     if (state == security_state_.end())
       return;
 
     // If the renderer has been commanded to request a scheme, then we grant
     // it the capability to request URLs of that scheme.
     state->second->GrantScheme(url.scheme());
   }
 }
 
-void ChildProcessSecurityPolicy::GrantUploadFile(int renderer_id,
-                                             const FilePath& file) {
+void ChildProcessSecurityPolicy::GrantReadFile(int renderer_id,
+                                               const FilePath& file) {
+  GrantPermissionsForFile(renderer_id, file, kReadFilePermissions);
+}
+
+void ChildProcessSecurityPolicy::GrantPermissionsForFile(
+    int renderer_id, const FilePath& file, int permissions) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return;
 
-  state->second->GrantUploadFile(file);
+  state->second->GrantPermissionsForFile(file, permissions);
 }
 
 void ChildProcessSecurityPolicy::GrantScheme(int renderer_id,
                                              const std::string& scheme) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return;
 
@@ skipping 92 matching lines @@
     SecurityStateMap::iterator state = security_state_.find(renderer_id);
     if (state == security_state_.end())
       return false;
 
     // Otherwise, we consult the renderer's security state to see if it is
     // allowed to request the URL.
     return state->second->CanRequestURL(url);
   }
 }
 
-bool ChildProcessSecurityPolicy::CanUploadFile(int renderer_id,
-                                               const FilePath& file) {
+bool ChildProcessSecurityPolicy::CanReadFile(int renderer_id,
+                                             const FilePath& file) {
+  return HasPermissionsForFile(renderer_id, file, kReadFilePermissions);
+}
+
+bool ChildProcessSecurityPolicy::HasPermissionsForFile(
+    int renderer_id, const FilePath& file, int permissions) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return false;
 
-  return state->second->CanUploadFile(file);
+  return state->second->HasPermissionsForFile(file, permissions);
 }
 
 bool ChildProcessSecurityPolicy::HasDOMUIBindings(int renderer_id) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->has_dom_ui_bindings();
@@ skipping 11 matching lines @@
 
 bool ChildProcessSecurityPolicy::CanReadRawCookies(int renderer_id) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->can_read_raw_cookies();
 }