webkit/fileapi/sandbox_mount_point_provider_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "webkit/fileapi/sandbox_mount_point_provider.h"
   6
   7 #include <set>
   8
   9 #include "base/basictypes.h"
  10 #include "base/file_util.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/message_loop.h"
  14 #include "base/message_loop_proxy.h"
  15 #include "googleurl/src/gurl.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17 #include "webkit/fileapi/file_system_mount_point_provider.h"
  18 #include "webkit/fileapi/file_system_url.h"
  19 #include "webkit/fileapi/file_system_util.h"
  20 #include "webkit/fileapi/mock_file_system_options.h"
  21
  22 namespace fileapi {
  23
  24 namespace {
  25
  26 FileSystemURL CreateFileSystemURL(const char* path) {
  27   const GURL kOrigin("http://foo/");
  28   return FileSystemURL::CreateForTest(
  29       kOrigin, kFileSystemTypeTemporary, base::FilePath::FromUTF8Unsafe(path));
  30 }
  31
  32 }  // namespace
  33
  34 class SandboxMountPointProviderOriginEnumeratorTest : public testing::Test {
  35  public:
  36   virtual void SetUp() {
  37     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
  38     sandbox_provider_.reset(
  39         new SandboxMountPointProvider(
  40             NULL,
  41             base::MessageLoopProxy::current(),
  42             data_dir_.path(),
  43             CreateAllowFileAccessOptions()));
  44   }
  45
  46   SandboxMountPointProvider::OriginEnumerator* CreateEnumerator() const {
  47     return sandbox_provider_->CreateOriginEnumerator();
  48   }
  49
  50  protected:
  51   void CreateOriginTypeDirectory(const GURL& origin,
  52                                  fileapi::FileSystemType type) {
  53     base::FilePath target = sandbox_provider_->
  54         GetBaseDirectoryForOriginAndType(origin, type, true);
  55     ASSERT_TRUE(!target.empty());
  56     ASSERT_TRUE(file_util::DirectoryExists(target));
  57   }
  58
  59   base::ScopedTempDir data_dir_;
  60   MessageLoop message_loop_;
  61   scoped_ptr<SandboxMountPointProvider> sandbox_provider_;
  62 };
  63
  64 TEST_F(SandboxMountPointProviderOriginEnumeratorTest, Empty) {
  65   scoped_ptr<SandboxMountPointProvider::OriginEnumerator> enumerator(
  66       CreateEnumerator());
  67   ASSERT_TRUE(enumerator->Next().is_empty());
  68 }
  69
  70 TEST_F(SandboxMountPointProviderOriginEnumeratorTest, EnumerateOrigins) {
  71   const char* temporary_origins[] = {
  72     "http://www.bar.com/",
  73     "http://www.foo.com/",
  74     "http://www.foo.com:1/",
  75     "http://www.example.com:8080/",
  76     "http://www.google.com:80/",
  77   };
  78   const char* persistent_origins[] = {
  79     "http://www.bar.com/",
  80     "http://www.foo.com:8080/",
  81     "http://www.foo.com:80/",
  82   };
  83   size_t temporary_size = ARRAYSIZE_UNSAFE(temporary_origins);
  84   size_t persistent_size = ARRAYSIZE_UNSAFE(persistent_origins);
  85   std::set<GURL> temporary_set, persistent_set;
  86   for (size_t i = 0; i < temporary_size; ++i) {
  87     CreateOriginTypeDirectory(GURL(temporary_origins[i]),
  88         fileapi::kFileSystemTypeTemporary);
  89     temporary_set.insert(GURL(temporary_origins[i]));
  90   }
  91   for (size_t i = 0; i < persistent_size; ++i) {
  92     CreateOriginTypeDirectory(GURL(persistent_origins[i]),
  93         kFileSystemTypePersistent);
  94     persistent_set.insert(GURL(persistent_origins[i]));
  95   }
  96
  97   scoped_ptr<SandboxMountPointProvider::OriginEnumerator> enumerator(
  98       CreateEnumerator());
  99   size_t temporary_actual_size = 0;
 100   size_t persistent_actual_size = 0;
 101   GURL current;
 102   while (!(current = enumerator->Next()).is_empty()) {
 103     SCOPED_TRACE(testing::Message() << "EnumerateOrigin " << current.spec());
 104     if (enumerator->HasFileSystemType(kFileSystemTypeTemporary)) {
 105       ASSERT_TRUE(temporary_set.find(current) != temporary_set.end());
 106       ++temporary_actual_size;
 107     }
 108     if (enumerator->HasFileSystemType(kFileSystemTypePersistent)) {
 109       ASSERT_TRUE(persistent_set.find(current) != persistent_set.end());
 110       ++persistent_actual_size;
 111     }
 112   }
 113
 114   EXPECT_EQ(temporary_size, temporary_actual_size);
 115   EXPECT_EQ(persistent_size, persistent_actual_size);
 116 }
 117
 118 TEST(SandboxMountPointProviderTest, AccessPermissions) {
 119   MessageLoop message_loop_;
 120   SandboxMountPointProvider provider(
 121       NULL, base::MessageLoopProxy::current(), base::FilePath(),
 122       CreateAllowFileAccessOptions());
 123
 124   // Any access should be allowed in sandbox directory.
 125   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 126             provider.GetPermissionPolicy(CreateFileSystemURL("foo"),
 127                                          kReadFilePermissions));
 128   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 129             provider.GetPermissionPolicy(CreateFileSystemURL("foo"),
 130                                          kWriteFilePermissions));
 131   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 132             provider.GetPermissionPolicy(CreateFileSystemURL("foo"),
 133                                          kCreateFilePermissions));
 134
 135   // Access to a path with parent references ('..') should be disallowed.
 136   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 137             provider.GetPermissionPolicy(CreateFileSystemURL("a/../b"),
 138                                          kReadFilePermissions));
 139
 140   // Access from non-allowed scheme should be disallowed.
 141   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 142             provider.GetPermissionPolicy(
 143                 FileSystemURL::CreateForTest(
 144                     GURL("unknown://bar"), kFileSystemTypeTemporary,
 145                     base::FilePath::FromUTF8Unsafe("foo")),
 146                 kReadFilePermissions));
 147
 148   // Access for non-sandbox type should be disallowed.
 149   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 150             provider.GetPermissionPolicy(
 151                 FileSystemURL::CreateForTest(
 152                     GURL("http://foo/"), kFileSystemTypeTest,
 153                     base::FilePath::FromUTF8Unsafe("foo")),
 154                 kReadFilePermissions));
 155
 156   // Write access to the root folder should be restricted.
 157   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 158             provider.GetPermissionPolicy(CreateFileSystemURL(""),
 159                                          kWriteFilePermissions));
 160   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 161             provider.GetPermissionPolicy(CreateFileSystemURL("/"),
 162                                          kWriteFilePermissions));
 163   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 164             provider.GetPermissionPolicy(CreateFileSystemURL("/"),
 165                                          kCreateFilePermissions));
 166
 167   // Create access with restricted name should be disallowed.
 168   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 169             provider.GetPermissionPolicy(CreateFileSystemURL(".."),
 170                                          kCreateFilePermissions));
 171   EXPECT_EQ(FILE_PERMISSION_ALWAYS_DENY,
 172             provider.GetPermissionPolicy(CreateFileSystemURL("."),
 173                                          kCreateFilePermissions));
 174
 175   // Similar but safe cases.
 176   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 177             provider.GetPermissionPolicy(CreateFileSystemURL(" ."),
 178                                          kCreateFilePermissions));
 179   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 180             provider.GetPermissionPolicy(CreateFileSystemURL(". "),
 181                                          kCreateFilePermissions));
 182   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 183             provider.GetPermissionPolicy(CreateFileSystemURL(" .."),
 184                                          kCreateFilePermissions));
 185   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 186             provider.GetPermissionPolicy(CreateFileSystemURL(".. "),
 187                                          kCreateFilePermissions));
 188   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 189             provider.GetPermissionPolicy(CreateFileSystemURL("b."),
 190                                          kCreateFilePermissions));
 191   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 192             provider.GetPermissionPolicy(CreateFileSystemURL(".b"),
 193                                          kCreateFilePermissions));
 194
 195   // A path that looks like a drive letter.
 196   EXPECT_EQ(FILE_PERMISSION_ALWAYS_ALLOW,
 197             provider.GetPermissionPolicy(CreateFileSystemURL("c:"),
 198                                          kCreateFilePermissions));
 199 }
 200
 201 }  // namespace fileapi