| OLD | NEW |
|---|
| (Empty) |
| 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 <windows.h> | |
| 6 #include <string> | |
| 7 | |
| 8 #include "sandbox/tests/validation_tests/commands.h" | |
| 9 | |
| 10 #include "sandbox/tests/common/controller.h" | |
| 11 | |
| 12 namespace { | |
| 13 | |
| 14 // Returns the HKEY corresponding to name. If there is no HKEY corresponding | |
| 15 // to the name it returns NULL. | |
| 16 HKEY GetHKEYFromString(const std::wstring &name) { | |
| 17 if (L"HKLM" == name) | |
| 18 return HKEY_LOCAL_MACHINE; | |
| 19 else if (L"HKCR" == name) | |
| 20 return HKEY_CLASSES_ROOT; | |
| 21 else if (L"HKCC" == name) | |
| 22 return HKEY_CURRENT_CONFIG; | |
| 23 else if (L"HKCU" == name) | |
| 24 return HKEY_CURRENT_USER; | |
| 25 else if (L"HKU" == name) | |
| 26 return HKEY_USERS; | |
| 27 | |
| 28 return NULL; | |
| 29 } | |
| 30 | |
| 31 // Modifies string to remove the leading and trailing quotes. | |
| 32 void trim_quote(std::wstring* string) { | |
| 33 std::wstring::size_type pos1 = string->find_first_not_of(L'"'); | |
| 34 std::wstring::size_type pos2 = string->find_last_not_of(L'"'); | |
| 35 | |
| 36 if (std::wstring::npos == pos1 || std::wstring::npos == pos2) | |
| 37 (*string) = L""; | |
| 38 else | |
| 39 (*string) = string->substr(pos1, pos2 + 1); | |
| 40 } | |
| 41 | |
| 42 int TestOpenFile(std::wstring path, bool for_write) { | |
| 43 wchar_t path_expanded[MAX_PATH + 1] = {0}; | |
| 44 DWORD size = ::ExpandEnvironmentStrings(path.c_str(), path_expanded, | |
| 45 MAX_PATH); | |
| 46 if (!size) | |
| 47 return sandbox::SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 48 | |
| 49 HANDLE file; | |
| 50 file = ::CreateFile(path_expanded, | |
| 51 for_write ? GENERIC_READ | GENERIC_WRITE : GENERIC_READ, | |
| 52 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, | |
| 53 NULL, // No security attributes. | |
| 54 OPEN_EXISTING, | |
| 55 FILE_FLAG_BACKUP_SEMANTICS, | |
| 56 NULL); // No template. | |
| 57 | |
| 58 if (INVALID_HANDLE_VALUE != file) { | |
| 59 ::CloseHandle(file); | |
| 60 return sandbox::SBOX_TEST_SUCCEEDED; | |
| 61 } else { | |
| 62 if (ERROR_ACCESS_DENIED == ::GetLastError()) { | |
| 63 return sandbox::SBOX_TEST_DENIED; | |
| 64 } else { | |
| 65 return sandbox::SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 66 } | |
| 67 } | |
| 68 } | |
| 69 | |
| 70 } // namespace | |
| 71 | |
| 72 namespace sandbox { | |
| 73 | |
| 74 SBOX_TESTS_COMMAND int ValidWindow(int argc, wchar_t **argv) { | |
| 75 if (1 != argc) | |
| 76 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 77 | |
| 78 HWND window = reinterpret_cast<HWND>(static_cast<ULONG_PTR>(_wtoi(argv[0]))); | |
| 79 | |
| 80 return TestValidWindow(window); | |
| 81 } | |
| 82 | |
| 83 int TestValidWindow(HWND window) { | |
| 84 if (::IsWindow(window)) | |
| 85 return SBOX_TEST_SUCCEEDED; | |
| 86 | |
| 87 return SBOX_TEST_DENIED; | |
| 88 } | |
| 89 | |
| 90 SBOX_TESTS_COMMAND int OpenProcessCmd(int argc, wchar_t **argv) { | |
| 91 if (2 != argc) | |
| 92 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 93 | |
| 94 DWORD process_id = _wtol(argv[0]); | |
| 95 DWORD access_mask = _wtol(argv[1]); | |
| 96 return TestOpenProcess(process_id, access_mask); | |
| 97 } | |
| 98 | |
| 99 int TestOpenProcess(DWORD process_id, DWORD access_mask) { | |
| 100 HANDLE process = ::OpenProcess(access_mask, | |
| 101 FALSE, // Do not inherit handle. | |
| 102 process_id); | |
| 103 if (NULL == process) { | |
| 104 if (ERROR_ACCESS_DENIED == ::GetLastError()) { | |
| 105 return SBOX_TEST_DENIED; | |
| 106 } else { | |
| 107 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 108 } | |
| 109 } else { | |
| 110 ::CloseHandle(process); | |
| 111 return SBOX_TEST_SUCCEEDED; | |
| 112 } | |
| 113 } | |
| 114 | |
| 115 SBOX_TESTS_COMMAND int OpenThreadCmd(int argc, wchar_t **argv) { | |
| 116 if (1 != argc) | |
| 117 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 118 | |
| 119 DWORD thread_id = _wtoi(argv[0]); | |
| 120 return TestOpenThread(thread_id); | |
| 121 } | |
| 122 | |
| 123 int TestOpenThread(DWORD thread_id) { | |
| 124 | |
| 125 HANDLE thread = ::OpenThread(THREAD_QUERY_INFORMATION, | |
| 126 FALSE, // Do not inherit handles. | |
| 127 thread_id); | |
| 128 | |
| 129 if (NULL == thread) { | |
| 130 if (ERROR_ACCESS_DENIED == ::GetLastError()) { | |
| 131 return SBOX_TEST_DENIED; | |
| 132 } else { | |
| 133 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 134 } | |
| 135 } else { | |
| 136 ::CloseHandle(thread); | |
| 137 return SBOX_TEST_SUCCEEDED; | |
| 138 } | |
| 139 } | |
| 140 | |
| 141 SBOX_TESTS_COMMAND int OpenFile(int argc, wchar_t **argv) { | |
| 142 if (1 != argc) | |
| 143 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 144 | |
| 145 std::wstring path = argv[0]; | |
| 146 trim_quote(&path); | |
| 147 | |
| 148 return TestOpenReadFile(path); | |
| 149 } | |
| 150 | |
| 151 int TestOpenReadFile(const std::wstring& path) { | |
| 152 return TestOpenFile(path, false); | |
| 153 } | |
| 154 | |
| 155 int TestOpenWriteFile(int argc, wchar_t **argv) { | |
| 156 if (1 != argc) | |
| 157 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 158 | |
| 159 std::wstring path = argv[0]; | |
| 160 trim_quote(&path); | |
| 161 | |
| 162 return TestOpenWriteFile(path); | |
| 163 } | |
| 164 | |
| 165 int TestOpenWriteFile(const std::wstring& path) { | |
| 166 return TestOpenFile(path, true); | |
| 167 } | |
| 168 | |
| 169 SBOX_TESTS_COMMAND int OpenKey(int argc, wchar_t **argv) { | |
| 170 if (0 == argc || argc > 2) | |
| 171 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 172 | |
| 173 // Get the hive. | |
| 174 HKEY base_key = GetHKEYFromString(argv[0]); | |
| 175 | |
| 176 // Get the subkey. | |
| 177 std::wstring subkey; | |
| 178 if (2 == argc) { | |
| 179 subkey = argv[1]; | |
| 180 trim_quote(&subkey); | |
| 181 } | |
| 182 | |
| 183 return TestOpenKey(base_key, subkey); | |
| 184 } | |
| 185 | |
| 186 int TestOpenKey(HKEY base_key, std::wstring subkey) { | |
| 187 HKEY key; | |
| 188 LONG err_code = ::RegOpenKeyEx(base_key, | |
| 189 subkey.c_str(), | |
| 190 0, // Reserved, must be 0. | |
| 191 MAXIMUM_ALLOWED, | |
| 192 &key); | |
| 193 if (ERROR_SUCCESS == err_code) { | |
| 194 ::RegCloseKey(key); | |
| 195 return SBOX_TEST_SUCCEEDED; | |
| 196 } else if (ERROR_INVALID_HANDLE == err_code || | |
| 197 ERROR_ACCESS_DENIED == err_code) { | |
| 198 return SBOX_TEST_DENIED; | |
| 199 } else { | |
| 200 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 201 } | |
| 202 } | |
| 203 | |
| 204 // Returns true if the current's thread desktop is the interactive desktop. | |
| 205 // In Vista there is a more direct test but for XP and w2k we need to check | |
| 206 // the object name. | |
| 207 bool IsInteractiveDesktop(bool* is_interactive) { | |
| 208 HDESK current_desk = ::GetThreadDesktop(::GetCurrentThreadId()); | |
| 209 if (NULL == current_desk) { | |
| 210 return false; | |
| 211 } | |
| 212 wchar_t current_desk_name[256] = {0}; | |
| 213 if (!::GetUserObjectInformationW(current_desk, UOI_NAME, current_desk_name, | |
| 214 sizeof(current_desk_name), NULL)) { | |
| 215 return false; | |
| 216 } | |
| 217 *is_interactive = (0 == _wcsicmp(L"default", current_desk_name)); | |
| 218 return true; | |
| 219 } | |
| 220 | |
| 221 SBOX_TESTS_COMMAND int OpenInteractiveDesktop(int, wchar_t **) { | |
| 222 return TestOpenInputDesktop(); | |
| 223 } | |
| 224 | |
| 225 int TestOpenInputDesktop() { | |
| 226 bool is_interactive = false; | |
| 227 if (IsInteractiveDesktop(&is_interactive) && is_interactive) { | |
| 228 return SBOX_TEST_SUCCEEDED; | |
| 229 } | |
| 230 HDESK desk = ::OpenInputDesktop(0, FALSE, DESKTOP_CREATEWINDOW); | |
| 231 if (desk) { | |
| 232 ::CloseDesktop(desk); | |
| 233 return SBOX_TEST_SUCCEEDED; | |
| 234 } | |
| 235 return SBOX_TEST_DENIED; | |
| 236 } | |
| 237 | |
| 238 SBOX_TESTS_COMMAND int SwitchToSboxDesktop(int, wchar_t **) { | |
| 239 return TestSwitchDesktop(); | |
| 240 } | |
| 241 | |
| 242 int TestSwitchDesktop() { | |
| 243 HDESK sbox_desk = ::GetThreadDesktop(::GetCurrentThreadId()); | |
| 244 if (NULL == sbox_desk) { | |
| 245 return SBOX_TEST_FAILED; | |
| 246 } | |
| 247 if (::SwitchDesktop(sbox_desk)) { | |
| 248 return SBOX_TEST_SUCCEEDED; | |
| 249 } | |
| 250 return SBOX_TEST_DENIED; | |
| 251 } | |
| 252 | |
| 253 SBOX_TESTS_COMMAND int SleepCmd(int argc, wchar_t **argv) { | |
| 254 if (1 != argc) | |
| 255 return SBOX_TEST_FAILED_TO_EXECUTE_COMMAND; | |
| 256 | |
| 257 ::Sleep(_wtoi(argv[0])); | |
| 258 return SBOX_TEST_SUCCEEDED; | |
| 259 } | |
| 260 | |
| 261 | |
| 262 } // namespace sandbox | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10689170:
Move the Windows sandbox to sandbox/win (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src