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
14namespace {
15
16const 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.
19HANDLE 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, &timestamp, 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.
46HANDLE finish_event;
47const int kWaitCount = 20;
48
49}  // namespace
50
51namespace 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.
56SBOX_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
107TEST(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
127TEST(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
149void 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.
158SBOX_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
182TEST(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
195