Home | History | Annotate | Download | only in src
      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 "sandbox/win/src/interceptors_64.h"
      6 
      7 #include "sandbox/win/src/interceptors.h"
      8 #include "sandbox/win/src/filesystem_interception.h"
      9 #include "sandbox/win/src/named_pipe_interception.h"
     10 #include "sandbox/win/src/policy_target.h"
     11 #include "sandbox/win/src/process_thread_interception.h"
     12 #include "sandbox/win/src/registry_interception.h"
     13 #include "sandbox/win/src/sandbox_nt_types.h"
     14 #include "sandbox/win/src/sandbox_types.h"
     15 #include "sandbox/win/src/sync_interception.h"
     16 #include "sandbox/win/src/target_interceptions.h"
     17 
     18 namespace sandbox {
     19 
     20 SANDBOX_INTERCEPT NtExports g_nt;
     21 SANDBOX_INTERCEPT OriginalFunctions g_originals;
     22 
     23 NTSTATUS WINAPI TargetNtMapViewOfSection64(
     24     HANDLE section, HANDLE process, PVOID *base, ULONG_PTR zero_bits,
     25     SIZE_T commit_size, PLARGE_INTEGER offset, PSIZE_T view_size,
     26     SECTION_INHERIT inherit, ULONG allocation_type, ULONG protect) {
     27   NtMapViewOfSectionFunction orig_fn = reinterpret_cast<
     28       NtMapViewOfSectionFunction>(g_originals[MAP_VIEW_OF_SECTION_ID]);
     29 
     30   return TargetNtMapViewOfSection(orig_fn, section, process, base, zero_bits,
     31                                   commit_size, offset, view_size, inherit,
     32                                   allocation_type, protect);
     33 }
     34 
     35 NTSTATUS WINAPI TargetNtUnmapViewOfSection64(HANDLE process, PVOID base) {
     36   NtUnmapViewOfSectionFunction orig_fn = reinterpret_cast<
     37       NtUnmapViewOfSectionFunction>(g_originals[UNMAP_VIEW_OF_SECTION_ID]);
     38   return TargetNtUnmapViewOfSection(orig_fn, process, base);
     39 }
     40 
     41 // -----------------------------------------------------------------------
     42 
     43 NTSTATUS WINAPI TargetNtSetInformationThread64(
     44     HANDLE thread, NT_THREAD_INFORMATION_CLASS thread_info_class,
     45     PVOID thread_information, ULONG thread_information_bytes) {
     46   NtSetInformationThreadFunction orig_fn = reinterpret_cast<
     47       NtSetInformationThreadFunction>(g_originals[SET_INFORMATION_THREAD_ID]);
     48   return TargetNtSetInformationThread(orig_fn, thread, thread_info_class,
     49                                       thread_information,
     50                                       thread_information_bytes);
     51 }
     52 
     53 NTSTATUS WINAPI TargetNtOpenThreadToken64(
     54     HANDLE thread, ACCESS_MASK desired_access, BOOLEAN open_as_self,
     55     PHANDLE token) {
     56   NtOpenThreadTokenFunction orig_fn = reinterpret_cast<
     57       NtOpenThreadTokenFunction>(g_originals[OPEN_THREAD_TOKEN_ID]);
     58   return TargetNtOpenThreadToken(orig_fn, thread, desired_access, open_as_self,
     59                                  token);
     60 }
     61 
     62 NTSTATUS WINAPI TargetNtOpenThreadTokenEx64(
     63     HANDLE thread, ACCESS_MASK desired_access, BOOLEAN open_as_self,
     64     ULONG handle_attributes, PHANDLE token) {
     65   NtOpenThreadTokenExFunction orig_fn = reinterpret_cast<
     66       NtOpenThreadTokenExFunction>(g_originals[OPEN_THREAD_TOKEN_EX_ID]);
     67   return TargetNtOpenThreadTokenEx(orig_fn, thread, desired_access,
     68                                    open_as_self, handle_attributes, token);
     69 }
     70 
     71 HANDLE WINAPI TargetCreateThread64(
     72     LPSECURITY_ATTRIBUTES thread_attributes, SIZE_T stack_size,
     73     LPTHREAD_START_ROUTINE start_address, PVOID parameter, DWORD creation_flags,
     74     LPDWORD thread_id) {
     75   CreateThreadFunction orig_fn = reinterpret_cast<
     76       CreateThreadFunction>(g_originals[CREATE_THREAD_ID]);
     77   return TargetCreateThread(orig_fn, thread_attributes, stack_size,
     78                             start_address, parameter, creation_flags,
     79                             thread_id);
     80 }
     81 
     82 LCID WINAPI TargetGetUserDefaultLCID64(void) {
     83   GetUserDefaultLCIDFunction orig_fn = reinterpret_cast<
     84       GetUserDefaultLCIDFunction>(g_originals[GET_USER_DEFAULT_LCID_ID]);
     85   return TargetGetUserDefaultLCID(orig_fn);
     86 }
     87 
     88 // -----------------------------------------------------------------------
     89 
     90 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtCreateFile64(
     91     PHANDLE file, ACCESS_MASK desired_access,
     92     POBJECT_ATTRIBUTES object_attributes, PIO_STATUS_BLOCK io_status,
     93     PLARGE_INTEGER allocation_size, ULONG file_attributes, ULONG sharing,
     94     ULONG disposition, ULONG options, PVOID ea_buffer, ULONG ea_length) {
     95   NtCreateFileFunction orig_fn = reinterpret_cast<
     96       NtCreateFileFunction>(g_originals[CREATE_FILE_ID]);
     97   return TargetNtCreateFile(orig_fn, file, desired_access, object_attributes,
     98                             io_status, allocation_size, file_attributes,
     99                             sharing, disposition, options, ea_buffer,
    100                             ea_length);
    101 }
    102 
    103 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenFile64(
    104     PHANDLE file, ACCESS_MASK desired_access,
    105     POBJECT_ATTRIBUTES object_attributes, PIO_STATUS_BLOCK io_status,
    106     ULONG sharing, ULONG options) {
    107   NtOpenFileFunction orig_fn = reinterpret_cast<
    108       NtOpenFileFunction>(g_originals[OPEN_FILE_ID]);
    109   return TargetNtOpenFile(orig_fn, file, desired_access, object_attributes,
    110                           io_status, sharing, options);
    111 }
    112 
    113 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtQueryAttributesFile64(
    114     POBJECT_ATTRIBUTES object_attributes,
    115     PFILE_BASIC_INFORMATION file_attributes) {
    116   NtQueryAttributesFileFunction orig_fn = reinterpret_cast<
    117       NtQueryAttributesFileFunction>(g_originals[QUERY_ATTRIB_FILE_ID]);
    118   return TargetNtQueryAttributesFile(orig_fn, object_attributes,
    119                                      file_attributes);
    120 }
    121 
    122 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtQueryFullAttributesFile64(
    123     POBJECT_ATTRIBUTES object_attributes,
    124     PFILE_NETWORK_OPEN_INFORMATION file_attributes) {
    125   NtQueryFullAttributesFileFunction orig_fn = reinterpret_cast<
    126       NtQueryFullAttributesFileFunction>(
    127           g_originals[QUERY_FULL_ATTRIB_FILE_ID]);
    128   return TargetNtQueryFullAttributesFile(orig_fn, object_attributes,
    129                                          file_attributes);
    130 }
    131 
    132 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtSetInformationFile64(
    133     HANDLE file, PIO_STATUS_BLOCK io_status, PVOID file_information,
    134     ULONG length, FILE_INFORMATION_CLASS file_information_class) {
    135   NtSetInformationFileFunction orig_fn = reinterpret_cast<
    136       NtSetInformationFileFunction>(g_originals[SET_INFO_FILE_ID]);
    137   return TargetNtSetInformationFile(orig_fn, file, io_status, file_information,
    138                                     length, file_information_class);
    139 }
    140 
    141 // -----------------------------------------------------------------------
    142 
    143 SANDBOX_INTERCEPT HANDLE WINAPI TargetCreateNamedPipeW64(
    144     LPCWSTR pipe_name, DWORD open_mode, DWORD pipe_mode, DWORD max_instance,
    145     DWORD out_buffer_size, DWORD in_buffer_size, DWORD default_timeout,
    146     LPSECURITY_ATTRIBUTES security_attributes) {
    147   CreateNamedPipeWFunction orig_fn = reinterpret_cast<
    148       CreateNamedPipeWFunction>(g_originals[CREATE_NAMED_PIPE_ID]);
    149   return TargetCreateNamedPipeW(orig_fn, pipe_name, open_mode, pipe_mode,
    150                                 max_instance, out_buffer_size, in_buffer_size,
    151                                 default_timeout, security_attributes);
    152 }
    153 
    154 // -----------------------------------------------------------------------
    155 
    156 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenThread64(
    157     PHANDLE thread, ACCESS_MASK desired_access,
    158     POBJECT_ATTRIBUTES object_attributes, PCLIENT_ID client_id) {
    159   NtOpenThreadFunction orig_fn = reinterpret_cast<
    160       NtOpenThreadFunction>(g_originals[OPEN_TREAD_ID]);
    161   return TargetNtOpenThread(orig_fn, thread, desired_access, object_attributes,
    162                             client_id);
    163 }
    164 
    165 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenProcess64(
    166     PHANDLE process, ACCESS_MASK desired_access,
    167     POBJECT_ATTRIBUTES object_attributes, PCLIENT_ID client_id) {
    168   NtOpenProcessFunction orig_fn = reinterpret_cast<
    169       NtOpenProcessFunction>(g_originals[OPEN_PROCESS_ID]);
    170   return TargetNtOpenProcess(orig_fn, process, desired_access,
    171                              object_attributes, client_id);
    172 }
    173 
    174 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenProcessToken64(
    175     HANDLE process, ACCESS_MASK desired_access, PHANDLE token) {
    176   NtOpenProcessTokenFunction orig_fn = reinterpret_cast<
    177       NtOpenProcessTokenFunction>(g_originals[OPEN_PROCESS_TOKEN_ID]);
    178   return TargetNtOpenProcessToken(orig_fn, process, desired_access, token);
    179 }
    180 
    181 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenProcessTokenEx64(
    182     HANDLE process, ACCESS_MASK desired_access, ULONG handle_attributes,
    183     PHANDLE token) {
    184   NtOpenProcessTokenExFunction orig_fn = reinterpret_cast<
    185       NtOpenProcessTokenExFunction>(g_originals[OPEN_PROCESS_TOKEN_EX_ID]);
    186   return TargetNtOpenProcessTokenEx(orig_fn, process, desired_access,
    187                                     handle_attributes, token);
    188 }
    189 
    190 SANDBOX_INTERCEPT BOOL WINAPI TargetCreateProcessW64(
    191     LPCWSTR application_name, LPWSTR command_line,
    192     LPSECURITY_ATTRIBUTES process_attributes,
    193     LPSECURITY_ATTRIBUTES thread_attributes, BOOL inherit_handles, DWORD flags,
    194     LPVOID environment, LPCWSTR current_directory, LPSTARTUPINFOW startup_info,
    195     LPPROCESS_INFORMATION process_information) {
    196   CreateProcessWFunction orig_fn = reinterpret_cast<
    197       CreateProcessWFunction>(g_originals[CREATE_PROCESSW_ID]);
    198   return TargetCreateProcessW(orig_fn, application_name, command_line,
    199                               process_attributes, thread_attributes,
    200                               inherit_handles, flags, environment,
    201                               current_directory, startup_info,
    202                               process_information);
    203 }
    204 
    205 SANDBOX_INTERCEPT BOOL WINAPI TargetCreateProcessA64(
    206     LPCSTR application_name, LPSTR command_line,
    207     LPSECURITY_ATTRIBUTES process_attributes,
    208     LPSECURITY_ATTRIBUTES thread_attributes, BOOL inherit_handles, DWORD flags,
    209     LPVOID environment, LPCSTR current_directory, LPSTARTUPINFOA startup_info,
    210     LPPROCESS_INFORMATION process_information) {
    211   CreateProcessAFunction orig_fn = reinterpret_cast<
    212       CreateProcessAFunction>(g_originals[CREATE_PROCESSA_ID]);
    213   return TargetCreateProcessA(orig_fn, application_name, command_line,
    214                               process_attributes, thread_attributes,
    215                               inherit_handles, flags, environment,
    216                               current_directory, startup_info,
    217                               process_information);
    218 }
    219 
    220 // -----------------------------------------------------------------------
    221 
    222 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtCreateKey64(
    223     PHANDLE key, ACCESS_MASK desired_access,
    224     POBJECT_ATTRIBUTES object_attributes, ULONG title_index,
    225     PUNICODE_STRING class_name, ULONG create_options, PULONG disposition) {
    226   NtCreateKeyFunction orig_fn = reinterpret_cast<
    227       NtCreateKeyFunction>(g_originals[CREATE_KEY_ID]);
    228   return TargetNtCreateKey(orig_fn, key, desired_access, object_attributes,
    229                            title_index, class_name, create_options,
    230                            disposition);
    231 }
    232 
    233 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenKey64(
    234     PHANDLE key, ACCESS_MASK desired_access,
    235     POBJECT_ATTRIBUTES object_attributes) {
    236   NtOpenKeyFunction orig_fn = reinterpret_cast<
    237       NtOpenKeyFunction>(g_originals[OPEN_KEY_ID]);
    238   return TargetNtOpenKey(orig_fn, key, desired_access, object_attributes);
    239 }
    240 
    241 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenKeyEx64(
    242     PHANDLE key, ACCESS_MASK desired_access,
    243     POBJECT_ATTRIBUTES object_attributes, ULONG open_options) {
    244   NtOpenKeyExFunction orig_fn = reinterpret_cast<
    245       NtOpenKeyExFunction>(g_originals[OPEN_KEY_EX_ID]);
    246   return TargetNtOpenKeyEx(orig_fn, key, desired_access, object_attributes,
    247                            open_options);
    248 }
    249 
    250 // -----------------------------------------------------------------------
    251 
    252 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtCreateEvent64(
    253     PHANDLE event_handle, ACCESS_MASK desired_access,
    254     POBJECT_ATTRIBUTES object_attributes, EVENT_TYPE event_type,
    255     BOOLEAN initial_state) {
    256   NtCreateEventFunction orig_fn = reinterpret_cast<
    257       NtCreateEventFunction>(g_originals[CREATE_EVENT_ID]);
    258   return TargetNtCreateEvent(orig_fn, event_handle, desired_access,
    259                              object_attributes, event_type, initial_state);
    260 }
    261 
    262 SANDBOX_INTERCEPT NTSTATUS WINAPI TargetNtOpenEvent64(
    263     PHANDLE event_handle, ACCESS_MASK desired_access,
    264     POBJECT_ATTRIBUTES object_attributes) {
    265   NtOpenEventFunction orig_fn = reinterpret_cast<
    266       NtOpenEventFunction>(g_originals[OPEN_EVENT_ID]);
    267   return TargetNtOpenEvent(orig_fn, event_handle, desired_access,
    268                            object_attributes);
    269 }
    270 
    271 }  // namespace sandbox
    272