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 "sandbox/win/tests/common/controller.h" 6 7 #include <string> 8 9 #include "base/process/process.h" 10 #include "base/strings/sys_string_conversions.h" 11 #include "base/win/windows_version.h" 12 #include "sandbox/win/src/sandbox_factory.h" 13 14 namespace { 15 16 static const int kDefaultTimeout = 60000; 17 18 // Constructs a full path to a file inside the system32 folder. 19 std::wstring MakePathToSys32(const wchar_t* name, bool is_obj_man_path) { 20 wchar_t windows_path[MAX_PATH] = {0}; 21 if (0 == ::GetSystemWindowsDirectoryW(windows_path, MAX_PATH)) 22 return std::wstring(); 23 24 std::wstring full_path(windows_path); 25 if (full_path.empty()) 26 return full_path; 27 28 if (is_obj_man_path) 29 full_path.insert(0, L"\\??\\"); 30 31 full_path += L"\\system32\\"; 32 full_path += name; 33 return full_path; 34 } 35 36 // Constructs a full path to a file inside the syswow64 folder. 37 std::wstring MakePathToSysWow64(const wchar_t* name, bool is_obj_man_path) { 38 wchar_t windows_path[MAX_PATH] = {0}; 39 if (0 == ::GetSystemWindowsDirectoryW(windows_path, MAX_PATH)) 40 return std::wstring(); 41 42 std::wstring full_path(windows_path); 43 if (full_path.empty()) 44 return full_path; 45 46 if (is_obj_man_path) 47 full_path.insert(0, L"\\??\\"); 48 49 full_path += L"\\SysWOW64\\"; 50 full_path += name; 51 return full_path; 52 } 53 54 bool IsProcessRunning(HANDLE process) { 55 DWORD exit_code = 0; 56 if (::GetExitCodeProcess(process, &exit_code)) 57 return exit_code == STILL_ACTIVE; 58 return false; 59 } 60 61 } // namespace 62 63 namespace sandbox { 64 65 std::wstring MakePathToSys(const wchar_t* name, bool is_obj_man_path) { 66 return (base::win::OSInfo::GetInstance()->wow64_status() == 67 base::win::OSInfo::WOW64_ENABLED) ? 68 MakePathToSysWow64(name, is_obj_man_path) : 69 MakePathToSys32(name, is_obj_man_path); 70 } 71 72 BrokerServices* GetBroker() { 73 static BrokerServices* broker = SandboxFactory::GetBrokerServices(); 74 static bool is_initialized = false; 75 76 if (!broker) { 77 return NULL; 78 } 79 80 if (!is_initialized) { 81 if (SBOX_ALL_OK != broker->Init()) 82 return NULL; 83 84 is_initialized = true; 85 } 86 87 return broker; 88 } 89 90 TestRunner::TestRunner(JobLevel job_level, TokenLevel startup_token, 91 TokenLevel main_token) 92 : is_init_(false), is_async_(false), no_sandbox_(false), 93 target_process_id_(0) { 94 Init(job_level, startup_token, main_token); 95 } 96 97 TestRunner::TestRunner() 98 : is_init_(false), is_async_(false), no_sandbox_(false), 99 target_process_id_(0) { 100 Init(JOB_LOCKDOWN, USER_RESTRICTED_SAME_ACCESS, USER_LOCKDOWN); 101 } 102 103 void TestRunner::Init(JobLevel job_level, TokenLevel startup_token, 104 TokenLevel main_token) { 105 broker_ = NULL; 106 policy_ = NULL; 107 timeout_ = kDefaultTimeout; 108 state_ = AFTER_REVERT; 109 is_async_= false; 110 kill_on_destruction_ = true; 111 target_process_id_ = 0; 112 113 broker_ = GetBroker(); 114 if (!broker_) 115 return; 116 117 policy_ = broker_->CreatePolicy(); 118 if (!policy_) 119 return; 120 121 policy_->SetJobLevel(job_level, 0); 122 policy_->SetTokenLevel(startup_token, main_token); 123 124 is_init_ = true; 125 } 126 127 TargetPolicy* TestRunner::GetPolicy() { 128 return policy_; 129 } 130 131 TestRunner::~TestRunner() { 132 if (target_process_ && kill_on_destruction_) 133 ::TerminateProcess(target_process_, 0); 134 135 if (policy_) 136 policy_->Release(); 137 } 138 139 bool TestRunner::AddRule(TargetPolicy::SubSystem subsystem, 140 TargetPolicy::Semantics semantics, 141 const wchar_t* pattern) { 142 if (!is_init_) 143 return false; 144 145 return (SBOX_ALL_OK == policy_->AddRule(subsystem, semantics, pattern)); 146 } 147 148 bool TestRunner::AddRuleSys32(TargetPolicy::Semantics semantics, 149 const wchar_t* pattern) { 150 if (!is_init_) 151 return false; 152 153 std::wstring win32_path = MakePathToSys32(pattern, false); 154 if (win32_path.empty()) 155 return false; 156 157 if (!AddRule(TargetPolicy::SUBSYS_FILES, semantics, win32_path.c_str())) 158 return false; 159 160 if (base::win::OSInfo::GetInstance()->wow64_status() != 161 base::win::OSInfo::WOW64_ENABLED) 162 return true; 163 164 win32_path = MakePathToSysWow64(pattern, false); 165 if (win32_path.empty()) 166 return false; 167 168 return AddRule(TargetPolicy::SUBSYS_FILES, semantics, win32_path.c_str()); 169 } 170 171 bool TestRunner::AddFsRule(TargetPolicy::Semantics semantics, 172 const wchar_t* pattern) { 173 if (!is_init_) 174 return false; 175 176 return AddRule(TargetPolicy::SUBSYS_FILES, semantics, pattern); 177 } 178 179 int TestRunner::RunTest(const wchar_t* command) { 180 if (MAX_STATE > 10) 181 return SBOX_TEST_INVALID_PARAMETER; 182 183 wchar_t state_number[2]; 184 state_number[0] = L'0' + state_; 185 state_number[1] = L'\0'; 186 std::wstring full_command(state_number); 187 full_command += L" "; 188 full_command += command; 189 190 return InternalRunTest(full_command.c_str()); 191 } 192 193 int TestRunner::InternalRunTest(const wchar_t* command) { 194 if (!is_init_) 195 return SBOX_TEST_FAILED_TO_RUN_TEST; 196 197 // For simplicity TestRunner supports only one process per instance. 198 if (target_process_) { 199 if (IsProcessRunning(target_process_)) 200 return SBOX_TEST_FAILED_TO_RUN_TEST; 201 target_process_.Close(); 202 target_process_id_ = 0; 203 } 204 205 // Get the path to the sandboxed process. 206 wchar_t prog_name[MAX_PATH]; 207 GetModuleFileNameW(NULL, prog_name, MAX_PATH); 208 209 // Launch the sandboxed process. 210 ResultCode result = SBOX_ALL_OK; 211 PROCESS_INFORMATION target = {0}; 212 213 std::wstring arguments(L"\""); 214 arguments += prog_name; 215 arguments += L"\" -child"; 216 arguments += no_sandbox_ ? L"-no-sandbox " : L" "; 217 arguments += command; 218 219 if (no_sandbox_) { 220 STARTUPINFO startup_info = {sizeof(STARTUPINFO)}; 221 if (!::CreateProcessW(prog_name, &arguments[0], NULL, NULL, FALSE, 0, 222 NULL, NULL, &startup_info, &target)) { 223 return SBOX_ERROR_GENERIC; 224 } 225 broker_->AddTargetPeer(target.hProcess); 226 } else { 227 result = broker_->SpawnTarget(prog_name, arguments.c_str(), policy_, 228 &target); 229 } 230 231 if (SBOX_ALL_OK != result) 232 return SBOX_TEST_FAILED_TO_RUN_TEST; 233 234 ::ResumeThread(target.hThread); 235 236 // For an asynchronous run we don't bother waiting. 237 if (is_async_) { 238 target_process_.Set(target.hProcess); 239 target_process_id_ = target.dwProcessId; 240 ::CloseHandle(target.hThread); 241 return SBOX_TEST_SUCCEEDED; 242 } 243 244 if (::IsDebuggerPresent()) { 245 // Don't kill the target process on a time-out while we are debugging. 246 timeout_ = INFINITE; 247 } 248 249 if (WAIT_TIMEOUT == ::WaitForSingleObject(target.hProcess, timeout_)) { 250 ::TerminateProcess(target.hProcess, SBOX_TEST_TIMED_OUT); 251 ::CloseHandle(target.hProcess); 252 ::CloseHandle(target.hThread); 253 return SBOX_TEST_TIMED_OUT; 254 } 255 256 DWORD exit_code = SBOX_TEST_LAST_RESULT; 257 if (!::GetExitCodeProcess(target.hProcess, &exit_code)) { 258 ::CloseHandle(target.hProcess); 259 ::CloseHandle(target.hThread); 260 return SBOX_TEST_FAILED_TO_RUN_TEST; 261 } 262 263 ::CloseHandle(target.hProcess); 264 ::CloseHandle(target.hThread); 265 266 return exit_code; 267 } 268 269 void TestRunner::SetTimeout(DWORD timeout_ms) { 270 timeout_ = timeout_ms; 271 } 272 273 void TestRunner::SetTestState(SboxTestsState desired_state) { 274 state_ = desired_state; 275 } 276 277 // This is the main procedure for the target (child) application. We'll find out 278 // the target test and call it. 279 // We expect the arguments to be: 280 // argv[1] = "-child" 281 // argv[2] = SboxTestsState when to run the command 282 // argv[3] = command to run 283 // argv[4...] = command arguments. 284 int DispatchCall(int argc, wchar_t **argv) { 285 if (argc < 4) 286 return SBOX_TEST_INVALID_PARAMETER; 287 288 // We hard code two tests to avoid dispatch failures. 289 if (0 == _wcsicmp(argv[3], L"wait")) { 290 Sleep(INFINITE); 291 return SBOX_TEST_TIMED_OUT; 292 } 293 294 if (0 == _wcsicmp(argv[3], L"ping")) 295 return SBOX_TEST_PING_OK; 296 297 SboxTestsState state = static_cast<SboxTestsState>(_wtoi(argv[2])); 298 if ((state <= MIN_STATE) || (state >= MAX_STATE)) 299 return SBOX_TEST_INVALID_PARAMETER; 300 301 HMODULE module; 302 if (!GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | 303 GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, 304 reinterpret_cast<wchar_t*>(&DispatchCall), &module)) 305 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; 306 307 std::string command_name = base::SysWideToMultiByte(argv[3], CP_UTF8); 308 CommandFunction command = reinterpret_cast<CommandFunction>( 309 ::GetProcAddress(module, command_name.c_str())); 310 if (!command) 311 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; 312 313 if (BEFORE_INIT == state) 314 return command(argc - 4, argv + 4); 315 else if (EVERY_STATE == state) 316 command(argc - 4, argv + 4); 317 318 TargetServices* target = SandboxFactory::GetTargetServices(); 319 if (target) { 320 if (SBOX_ALL_OK != target->Init()) 321 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; 322 323 if (BEFORE_REVERT == state) 324 return command(argc - 4, argv + 4); 325 else if (EVERY_STATE == state) 326 command(argc - 4, argv + 4); 327 328 target->LowerToken(); 329 } else if (0 != _wcsicmp(argv[1], L"-child-no-sandbox")) { 330 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; 331 } 332 333 return command(argc - 4, argv + 4); 334 } 335 336 } // namespace sandbox 337
