| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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 "base/stringprintf.h" | |
| 6 #include "base/win/scoped_handle.h" | |
| 7 #include "sandbox/src/handle_closer_agent.h" | |
| 8 #include "sandbox/src/sandbox.h" | |
| 9 #include "sandbox/src/sandbox_factory.h" | |
| 10 #include "sandbox/src/target_services.h" | |
| 11 #include "sandbox/tests/common/controller.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 namespace { | |
| 15 | |
| 16 const wchar_t *kFileExtensions[] = { L".1", L".2", L".3", L".4" }; | |
| 17 | |
| 18 // Returns a handle to a unique marker file that can be retrieved between runs. | |
| 19 HANDLE GetMarkerFile(const wchar_t *extension) { | |
| 20 wchar_t path_buffer[MAX_PATH + 1]; | |
| 21 CHECK(::GetTempPath(MAX_PATH, path_buffer)); | |
| 22 string16 marker_path = path_buffer; | |
| 23 marker_path += L"\\sbox_marker_"; | |
| 24 | |
| 25 // Generate a unique value from the exe's size and timestamp. | |
| 26 CHECK(::GetModuleFileName(NULL, path_buffer, MAX_PATH)); | |
| 27 base::win::ScopedHandle module(::CreateFile(path_buffer, | |
| 28 FILE_READ_ATTRIBUTES, FILE_SHARE_READ, NULL, | |
| 29 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)); | |
| 30 CHECK(module.IsValid()); | |
| 31 FILETIME timestamp; | |
| 32 CHECK(::GetFileTime(module, ×tamp, NULL, NULL)); | |
| 33 marker_path += base::StringPrintf(L"%08x%08x%08x", | |
| 34 ::GetFileSize(module, NULL), | |
| 35 timestamp.dwLowDateTime, | |
| 36 timestamp.dwHighDateTime); | |
| 37 marker_path += extension; | |
| 38 | |
| 39 // Make the file delete-on-close so cleanup is automatic. | |
| 40 return CreateFile(marker_path.c_str(), FILE_ALL_ACCESS, | |
| 41 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, | |
| 42 NULL, OPEN_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL); | |
| 43 } | |
| 44 | |
| 45 // Used by the thread pool tests. | |
| 46 HANDLE finish_event; | |
| 47 const int kWaitCount = 20; | |
| 48 | |
| 49 } // namespace | |
| 50 | |
| 51 namespace sandbox { | |
| 52 | |
| 53 // Checks for the presence of a list of files (in object path form). | |
| 54 // Format: CheckForFileHandle (Y|N) \path\to\file1 [\path\to\file2 ...] | |
| 55 // - Y or N depending if the file should exist or not. | |
| 56 SBOX_TESTS_COMMAND int CheckForFileHandles(int argc, wchar_t **argv) { | |
| 57 if (argc < 2) | |
| 58 return SBOX_TEST_FAILED_TO_RUN_TEST; | |
| 59 bool should_find = argv[0][0] == L'Y'; | |
| 60 if (argv[0][1] != L'\0' || !should_find && argv[0][0] != L'N') | |
| 61 return SBOX_TEST_FAILED_TO_RUN_TEST; | |
| 62 | |
| 63 static int state = BEFORE_INIT; | |
| 64 switch (state++) { | |
| 65 case BEFORE_INIT: | |
| 66 // Create a unique marker file that is open while the test is running. | |
| 67 // The handles leak, but it will be closed by the test or on exit. | |
| 68 for (int i = 0; i < arraysize(kFileExtensions); ++i) | |
| 69 EXPECT_NE(GetMarkerFile(kFileExtensions[i]), INVALID_HANDLE_VALUE); | |
| 70 return SBOX_TEST_SUCCEEDED; | |
| 71 | |
| 72 case AFTER_REVERT: { | |
| 73 // Brute force the handle table to find what we're looking for. | |
| 74 DWORD handle_count = UINT_MAX; | |
| 75 const int kInvalidHandleThreshold = 100; | |
| 76 const size_t kHandleOffset = sizeof(HANDLE); | |
| 77 HANDLE handle = NULL; | |
| 78 int invalid_count = 0; | |
| 79 string16 handle_name; | |
| 80 | |
| 81 if (!::GetProcessHandleCount(::GetCurrentProcess(), &handle_count)) | |
| 82 return SBOX_TEST_FAILED_TO_RUN_TEST; | |
| 83 | |
| 84 while (handle_count && invalid_count < kInvalidHandleThreshold) { | |
| 85 reinterpret_cast<size_t&>(handle) += kHandleOffset; | |
| 86 if (GetHandleName(handle, &handle_name)) { | |
| 87 for (int i = 1; i < argc; ++i) { | |
| 88 if (handle_name == argv[i]) | |
| 89 return should_find ? SBOX_TEST_SUCCEEDED : SBOX_TEST_FAILED; | |
| 90 } | |
| 91 --handle_count; | |
| 92 } else { | |
| 93 ++invalid_count; | |
| 94 } | |
| 95 } | |
| 96 | |
| 97 return should_find ? SBOX_TEST_FAILED : SBOX_TEST_SUCCEEDED; | |
| 98 } | |
| 99 | |
| 100 default: // Do nothing. | |
| 101 break; | |
| 102 } | |
| 103 | |
| 104 return SBOX_TEST_SUCCEEDED; | |
| 105 } | |
| 106 | |
| 107 TEST(HandleCloserTest, CheckForMarkerFiles) { | |
| 108 TestRunner runner; | |
| 109 runner.SetTimeout(2000); | |
| 110 runner.SetTestState(EVERY_STATE); | |
| 111 sandbox::TargetPolicy* policy = runner.GetPolicy(); | |
| 112 | |
| 113 string16 command = string16(L"CheckForFileHandles Y"); | |
| 114 for (int i = 0; i < arraysize(kFileExtensions); ++i) { | |
| 115 string16 handle_name; | |
| 116 base::win::ScopedHandle marker(GetMarkerFile(kFileExtensions[i])); | |
| 117 CHECK(marker.IsValid()); | |
| 118 CHECK(sandbox::GetHandleName(marker, &handle_name)); | |
| 119 command += (L" "); | |
| 120 command += handle_name; | |
| 121 } | |
| 122 | |
| 123 EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(command.c_str())) << | |
| 124 "Failed: " << command; | |
| 125 } | |
| 126 | |
| 127 TEST(HandleCloserTest, CloseMarkerFiles) { | |
| 128 TestRunner runner; | |
| 129 runner.SetTimeout(2000); | |
| 130 runner.SetTestState(EVERY_STATE); | |
| 131 sandbox::TargetPolicy* policy = runner.GetPolicy(); | |
| 132 | |
| 133 string16 command = string16(L"CheckForFileHandles N"); | |
| 134 for (int i = 0; i < arraysize(kFileExtensions); ++i) { | |
| 135 string16 handle_name; | |
| 136 base::win::ScopedHandle marker(GetMarkerFile(kFileExtensions[i])); | |
| 137 CHECK(marker.IsValid()); | |
| 138 CHECK(sandbox::GetHandleName(marker, &handle_name)); | |
| 139 CHECK_EQ(policy->AddKernelObjectToClose(L"File", handle_name.c_str()), | |
| 140 SBOX_ALL_OK); | |
| 141 command += (L" "); | |
| 142 command += handle_name; | |
| 143 } | |
| 144 | |
| 145 EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(command.c_str())) << | |
| 146 "Failed: " << command; | |
| 147 } | |
| 148 | |
| 149 void WINAPI ThreadPoolTask(void* event, BOOLEAN timeout) { | |
| 150 static volatile LONG waiters_remaining = kWaitCount; | |
| 151 CHECK(!timeout); | |
| 152 CHECK(::CloseHandle(event)); | |
| 153 if (::InterlockedDecrement(&waiters_remaining) == 0) | |
| 154 CHECK(::SetEvent(finish_event)); | |
| 155 } | |
| 156 | |
| 157 // Run a thread pool inside a sandbox without a CSRSS connection. | |
| 158 SBOX_TESTS_COMMAND int RunThreadPool(int argc, wchar_t **argv) { | |
| 159 HANDLE wait_list[20]; | |
| 160 CHECK(finish_event = ::CreateEvent(NULL, TRUE, FALSE, NULL)); | |
| 161 | |
| 162 // Set up a bunch of waiters. | |
| 163 HANDLE pool = NULL; | |
| 164 for (int i = 0; i < kWaitCount; ++i) { | |
| 165 HANDLE event = ::CreateEvent(NULL, TRUE, FALSE, NULL); | |
| 166 CHECK(event); | |
| 167 CHECK(::RegisterWaitForSingleObject(&pool, event, ThreadPoolTask, event, | |
| 168 INFINITE, WT_EXECUTEONLYONCE)); | |
| 169 wait_list[i] = event; | |
| 170 } | |
| 171 | |
| 172 // Signal all the waiters. | |
| 173 for (int i = 0; i < kWaitCount; ++i) | |
| 174 CHECK(::SetEvent(wait_list[i])); | |
| 175 | |
| 176 CHECK_EQ(::WaitForSingleObject(finish_event, INFINITE), WAIT_OBJECT_0); | |
| 177 CHECK(::CloseHandle(finish_event)); | |
| 178 | |
| 179 return SBOX_TEST_SUCCEEDED; | |
| 180 } | |
| 181 | |
| 182 TEST(HandleCloserTest, RunThreadPool) { | |
| 183 TestRunner runner; | |
| 184 runner.SetTimeout(2000); | |
| 185 runner.SetTestState(AFTER_REVERT); | |
| 186 sandbox::TargetPolicy* policy = runner.GetPolicy(); | |
| 187 | |
| 188 // Sever the CSRSS connection by closing ALPC ports inside the sandbox. | |
| 189 CHECK_EQ(policy->AddKernelObjectToClose(L"ALPC Port", NULL), SBOX_ALL_OK); | |
| 190 | |
| 191 EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(L"RunThreadPool")); | |
| 192 } | |
| 193 | |
| 194 } // namespace sandbox | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10783004:
Move Windows Sandbox, trybots version (don't commit me!) (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src