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/strings/stringprintf.h"
6 #include "base/win/scoped_handle.h"
7 #include "sandbox/win/src/handle_closer_agent.h"
8 #include "sandbox/win/src/sandbox.h"
9 #include "sandbox/win/src/sandbox_factory.h"
10 #include "sandbox/win/src/target_services.h"
11 #include "sandbox/win/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.
GetMarkerFile(const wchar_t * extension)19 HANDLE GetMarkerFile(const wchar_t *extension) {
20 wchar_t path_buffer[MAX_PATH + 1];
21 CHECK(::GetTempPath(MAX_PATH, path_buffer));
22 base::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.Get(), ×tamp, NULL, NULL));
33 marker_path += base::StringPrintf(L"%08x%08x%08x",
34 ::GetFileSize(module.Get(), 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.
CheckForFileHandles(int argc,wchar_t ** argv)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 = 4; // Handles are always a multiple of 4.
77 HANDLE handle = NULL;
78 int invalid_count = 0;
79 base::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
TEST(HandleCloserTest,CheckForMarkerFiles)107 TEST(HandleCloserTest, CheckForMarkerFiles) {
108 TestRunner runner;
109 runner.SetTimeout(2000);
110 runner.SetTestState(EVERY_STATE);
111 sandbox::TargetPolicy* policy = runner.GetPolicy();
112
113 base::string16 command = base::string16(L"CheckForFileHandles Y");
114 for (int i = 0; i < arraysize(kFileExtensions); ++i) {
115 base::string16 handle_name;
116 base::win::ScopedHandle marker(GetMarkerFile(kFileExtensions[i]));
117 CHECK(marker.IsValid());
118 CHECK(sandbox::GetHandleName(marker.Get(), &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
TEST(HandleCloserTest,CloseMarkerFiles)127 TEST(HandleCloserTest, CloseMarkerFiles) {
128 TestRunner runner;
129 runner.SetTimeout(2000);
130 runner.SetTestState(EVERY_STATE);
131 sandbox::TargetPolicy* policy = runner.GetPolicy();
132
133 base::string16 command = base::string16(L"CheckForFileHandles N");
134 for (int i = 0; i < arraysize(kFileExtensions); ++i) {
135 base::string16 handle_name;
136 base::win::ScopedHandle marker(GetMarkerFile(kFileExtensions[i]));
137 CHECK(marker.IsValid());
138 CHECK(sandbox::GetHandleName(marker.Get(), &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
ThreadPoolTask(void * event,BOOLEAN timeout)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.
RunThreadPool(int argc,wchar_t ** argv)158 SBOX_TESTS_COMMAND int RunThreadPool(int argc, wchar_t **argv) {
159 HANDLE wait_list[20];
160 finish_event = ::CreateEvent(NULL, TRUE, FALSE, NULL);
161 CHECK(finish_event);
162
163 // Set up a bunch of waiters.
164 HANDLE pool = NULL;
165 for (int i = 0; i < kWaitCount; ++i) {
166 HANDLE event = ::CreateEvent(NULL, TRUE, FALSE, NULL);
167 CHECK(event);
168 CHECK(::RegisterWaitForSingleObject(&pool, event, ThreadPoolTask, event,
169 INFINITE, WT_EXECUTEONLYONCE));
170 wait_list[i] = event;
171 }
172
173 // Signal all the waiters.
174 for (int i = 0; i < kWaitCount; ++i)
175 CHECK(::SetEvent(wait_list[i]));
176
177 CHECK_EQ(::WaitForSingleObject(finish_event, INFINITE), WAIT_OBJECT_0);
178 CHECK(::CloseHandle(finish_event));
179
180 return SBOX_TEST_SUCCEEDED;
181 }
182
TEST(HandleCloserTest,RunThreadPool)183 TEST(HandleCloserTest, RunThreadPool) {
184 TestRunner runner;
185 runner.SetTimeout(2000);
186 runner.SetTestState(AFTER_REVERT);
187 sandbox::TargetPolicy* policy = runner.GetPolicy();
188
189 // Sever the CSRSS connection by closing ALPC ports inside the sandbox.
190 CHECK_EQ(policy->AddKernelObjectToClose(L"ALPC Port", NULL), SBOX_ALL_OK);
191
192 EXPECT_EQ(SBOX_TEST_SUCCEEDED, runner.RunTest(L"RunThreadPool"));
193 }
194
195 } // namespace sandbox
196