VirtualBox

source: vbox/trunk/src/VBox/HostDrivers/Support/win/SUPDrv-win.cpp@ 57108

Last change on this file since 57108 was 57108, checked in by vboxsync, 10 years ago

supdrv: Added SUPKERNELFEATURES_SMAP to SUPR0GetKernelFeatures and document the API in the header.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 179.4 KB
Line 
1/* $Id: SUPDrv-win.cpp 57108 2015-07-28 11:49:23Z vboxsync $ */
2/** @file
3 * VBoxDrv - The VirtualBox Support Driver - Windows NT specifics.
4 */
5
6/*
7 * Copyright (C) 2006-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27/*******************************************************************************
28* Header Files *
29*******************************************************************************/
30#define IPRT_NT_MAP_TO_ZW
31#define LOG_GROUP LOG_GROUP_SUP_DRV
32#include "../SUPDrvInternal.h"
33#include <excpt.h>
34#include <ntimage.h>
35
36#include <iprt/assert.h>
37#include <iprt/avl.h>
38#include <iprt/ctype.h>
39#include <iprt/initterm.h>
40#include <iprt/mem.h>
41#include <iprt/process.h>
42#include <iprt/power.h>
43#include <iprt/rand.h>
44#include <iprt/semaphore.h>
45#include <iprt/spinlock.h>
46#include <iprt/string.h>
47#include <VBox/log.h>
48#include <VBox/err.h>
49
50#include <iprt/asm-amd64-x86.h>
51
52#ifdef VBOX_WITH_HARDENING
53# include "SUPHardenedVerify-win.h"
54#endif
55
56
57/*******************************************************************************
58* Defined Constants And Macros *
59*******************************************************************************/
60/** The support service name. */
61#define SERVICE_NAME "VBoxDrv"
62/** The Pool tag (VBox). */
63#define SUPDRV_NT_POOL_TAG 'xoBV'
64
65/** NT device name for user access. */
66#define DEVICE_NAME_NT_USR L"\\Device\\VBoxDrvU"
67#ifdef VBOX_WITH_HARDENING
68/** Macro for checking for deflecting calls to the stub device. */
69# define VBOXDRV_COMPLETE_IRP_AND_RETURN_IF_STUB_DEV(a_pDevObj, a_pIrp) \
70 do { if ((a_pDevObj) == g_pDevObjStub) \
71 return supdrvNtCompleteRequest(STATUS_ACCESS_DENIED, a_pIrp); \
72 } while (0)
73/** Macro for checking for deflecting calls to the stub and error info
74 * devices. */
75# define VBOXDRV_COMPLETE_IRP_AND_RETURN_IF_STUB_OR_ERROR_INFO_DEV(a_pDevObj, a_pIrp) \
76 do { if ((a_pDevObj) == g_pDevObjStub || (a_pDevObj) == g_pDevObjErrorInfo) \
77 return supdrvNtCompleteRequest(STATUS_ACCESS_DENIED, a_pIrp); \
78 } while (0)
79#else
80# define VBOXDRV_COMPLETE_IRP_AND_RETURN_IF_STUB_DEV(a_pDevObj, a_pIrp) do {} while (0)
81# define VBOXDRV_COMPLETE_IRP_AND_RETURN_IF_STUB_OR_ERROR_INFO_DEV(a_pDevObj, a_pIrp) do {} while (0)
82#endif
83
84/** Enables the fast I/O control code path. */
85#define VBOXDRV_WITH_FAST_IO
86
87
88/*******************************************************************************
89* Structures and Typedefs *
90*******************************************************************************/
91/**
92 * Device extension used by VBoxDrvU.
93 */
94typedef struct SUPDRVDEVEXTUSR
95{
96 /** Global cookie (same location as in SUPDRVDEVEXT, different value). */
97 uint32_t u32Cookie;
98 /** Pointer to the main driver extension. */
99 PSUPDRVDEVEXT pMainDrvExt;
100} SUPDRVDEVEXTUSR;
101AssertCompileMembersAtSameOffset(SUPDRVDEVEXT, u32Cookie, SUPDRVDEVEXTUSR, u32Cookie);
102/** Pointer to the VBoxDrvU device extension. */
103typedef SUPDRVDEVEXTUSR *PSUPDRVDEVEXTUSR;
104/** Value of SUPDRVDEVEXTUSR::u32Cookie. */
105#define SUPDRVDEVEXTUSR_COOKIE UINT32_C(0x12345678)
106
107/** Get the main device extension. */
108#define SUPDRVNT_GET_DEVEXT(pDevObj) \
109 ( pDevObj != g_pDevObjUsr \
110 ? (PSUPDRVDEVEXT)pDevObj->DeviceExtension \
111 : ((PSUPDRVDEVEXTUSR)pDevObj->DeviceExtension)->pMainDrvExt )
112
113#ifdef VBOX_WITH_HARDENING
114
115/**
116 * Device extension used by VBoxDrvStub.
117 */
118typedef struct SUPDRVDEVEXTSTUB
119{
120 /** Common header. */
121 SUPDRVDEVEXTUSR Common;
122} SUPDRVDEVEXTSTUB;
123/** Pointer to the VBoxDrvStub device extension. */
124typedef SUPDRVDEVEXTSTUB *PSUPDRVDEVEXTSTUB;
125/** Value of SUPDRVDEVEXTSTUB::Common.u32Cookie. */
126#define SUPDRVDEVEXTSTUB_COOKIE UINT32_C(0x90abcdef)
127
128
129/**
130 * Device extension used by VBoxDrvErrorInfo.
131 */
132typedef struct SUPDRVDEVEXTERRORINFO
133{
134 /** Common header. */
135 SUPDRVDEVEXTUSR Common;
136} SUPDRVDEVEXTERRORINFO;
137/** Pointer to the VBoxDrvErrorInfo device extension. */
138typedef SUPDRVDEVEXTERRORINFO *PSUPDRVDEVEXTERRORINFO;
139/** Value of SUPDRVDEVEXTERRORINFO::Common.u32Cookie. */
140#define SUPDRVDEVEXTERRORINFO_COOKIE UINT32_C(0xBadC0ca0)
141
142/**
143 * Error info for a failed VBoxDrv or VBoxDrvStub open attempt.
144 */
145typedef struct SUPDRVNTERRORINFO
146{
147 /** The list entry (in g_ErrorInfoHead). */
148 RTLISTNODE ListEntry;
149 /** The ID of the process this error info belongs to. */
150 HANDLE hProcessId;
151 /** The ID of the thread owning this info. */
152 HANDLE hThreadId;
153 /** Milliseconds createion timestamp (for cleaning up). */
154 uint64_t uCreatedMsTs;
155 /** Number of bytes of valid info. */
156 uint32_t cchErrorInfo;
157 /** The error info. */
158 char szErrorInfo[2048];
159} SUPDRVNTERRORINFO;
160/** Pointer to error info. */
161typedef SUPDRVNTERRORINFO *PSUPDRVNTERRORINFO;
162
163
164/**
165 * The kind of process we're protecting.
166 */
167typedef enum SUPDRVNTPROTECTKIND
168{
169 kSupDrvNtProtectKind_Invalid = 0,
170
171 /** Stub process protection while performing process verification.
172 * Next: StubSpawning (or free) */
173 kSupDrvNtProtectKind_StubUnverified,
174 /** Stub process protection before it creates the VM process.
175 * Next: StubParent, StubDead. */
176 kSupDrvNtProtectKind_StubSpawning,
177 /** Stub process protection while having a VM process as child.
178 * Next: StubDead */
179 kSupDrvNtProtectKind_StubParent,
180 /** Dead stub process. */
181 kSupDrvNtProtectKind_StubDead,
182
183 /** Potential VM process.
184 * Next: VmProcessConfirmed, VmProcessDead. */
185 kSupDrvNtProtectKind_VmProcessUnconfirmed,
186 /** Confirmed VM process.
187 * Next: VmProcessDead. */
188 kSupDrvNtProtectKind_VmProcessConfirmed,
189 /** Dead VM process. */
190 kSupDrvNtProtectKind_VmProcessDead,
191
192 /** End of valid protection kinds. */
193 kSupDrvNtProtectKind_End
194} SUPDRVNTPROTECTKIND;
195
196/**
197 * A NT process protection structure.
198 */
199typedef struct SUPDRVNTPROTECT
200{
201 /** The AVL node core structure. The process ID is the pid. */
202 AVLPVNODECORE AvlCore;
203 /** Magic value (SUPDRVNTPROTECT_MAGIC). */
204 uint32_t volatile u32Magic;
205 /** Reference counter. */
206 uint32_t volatile cRefs;
207 /** The kind of process we're protecting. */
208 SUPDRVNTPROTECTKIND volatile enmProcessKind;
209 /** 7,: Hack to allow the supid themes service duplicate handle privileges to
210 * our process. */
211 bool fThemesFirstProcessCreateHandle : 1;
212 /** Vista, 7 & 8: Hack to allow more rights to the handle returned by
213 * NtCreateUserProcess. Only applicable to VmProcessUnconfirmed. */
214 bool fFirstProcessCreateHandle : 1;
215 /** Vista, 7 & 8: Hack to allow more rights to the handle returned by
216 * NtCreateUserProcess. Only applicable to VmProcessUnconfirmed. */
217 bool fFirstThreadCreateHandle : 1;
218 /** 8.1: Hack to allow more rights to the handle returned by
219 * NtCreateUserProcess. Only applicable to VmProcessUnconfirmed. */
220 bool fCsrssFirstProcessCreateHandle : 1;
221 /** Vista, 7 & 8: Hack to allow more rights to the handle duplicated by CSRSS
222 * during process creation. Only applicable to VmProcessUnconfirmed. On
223 * 32-bit systems we allow two as ZoneAlarm's system call hooks has been
224 * observed to do some seemingly unnecessary duplication work. */
225 int32_t volatile cCsrssFirstProcessDuplicateHandle;
226
227 /** The parent PID for VM processes, otherwise NULL. */
228 HANDLE hParentPid;
229 /** The TID of the thread opening VBoxDrv or VBoxDrvStub, NULL if not opened. */
230 HANDLE hOpenTid;
231 /** The PID of the CSRSS process associated with this process. */
232 HANDLE hCsrssPid;
233 /** Pointer to the CSRSS process structure (referenced). */
234 PEPROCESS pCsrssProcess;
235 /** State dependent data. */
236 union
237 {
238 /** A stub process in the StubParent state will keep a reference to a child
239 * while it's in the VmProcessUnconfirmed state so that it can be cleaned up
240 * correctly if things doesn't work out. */
241 struct SUPDRVNTPROTECT *pChild;
242 /** A process in the VmProcessUnconfirmed state will keep a weak
243 * reference to the parent's protection structure so it can clean up the pChild
244 * reference the parent has to it. */
245 struct SUPDRVNTPROTECT *pParent;
246 } u;
247} SUPDRVNTPROTECT;
248/** Pointer to a NT process protection record. */
249typedef SUPDRVNTPROTECT *PSUPDRVNTPROTECT;
250/** The SUPDRVNTPROTECT::u32Magic value (Robert A. Heinlein). */
251# define SUPDRVNTPROTECT_MAGIC UINT32_C(0x19070707)
252/** The SUPDRVNTPROTECT::u32Magic value of a dead structure. */
253# define SUPDRVNTPROTECT_MAGIC_DEAD UINT32_C(0x19880508)
254
255/** Pointer to ObGetObjectType. */
256typedef POBJECT_TYPE (NTAPI *PFNOBGETOBJECTTYPE)(PVOID);
257/** Pointer to ObRegisterCallbacks. */
258typedef NTSTATUS (NTAPI *PFNOBREGISTERCALLBACKS)(POB_CALLBACK_REGISTRATION, PVOID *);
259/** Pointer to ObUnregisterCallbacks. */
260typedef VOID (NTAPI *PFNOBUNREGISTERCALLBACKS)(PVOID);
261/** Pointer to PsSetCreateProcessNotifyRoutineEx. */
262typedef NTSTATUS (NTAPI *PFNPSSETCREATEPROCESSNOTIFYROUTINEEX)(PCREATE_PROCESS_NOTIFY_ROUTINE_EX, BOOLEAN);
263/** Pointer to PsReferenceProcessFilePointer. */
264typedef NTSTATUS (NTAPI *PFNPSREFERENCEPROCESSFILEPOINTER)(PEPROCESS, PFILE_OBJECT *);
265/** Pointer to PsIsProtectedProcessLight. */
266typedef BOOLEAN (NTAPI *PFNPSISPROTECTEDPROCESSLIGHT)(PEPROCESS);
267/** Pointer to ZwAlpcCreatePort. */
268typedef NTSTATUS (NTAPI *PFNZWALPCCREATEPORT)(PHANDLE, POBJECT_ATTRIBUTES, struct _ALPC_PORT_ATTRIBUTES *);
269
270#endif /* VBOX_WITH_HARDENINIG */
271
272
273/*******************************************************************************
274* Internal Functions *
275*******************************************************************************/
276static void _stdcall VBoxDrvNtUnload(PDRIVER_OBJECT pDrvObj);
277static NTSTATUS _stdcall VBoxDrvNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);
278static NTSTATUS _stdcall VBoxDrvNtCleanup(PDEVICE_OBJECT pDevObj, PIRP pIrp);
279static NTSTATUS _stdcall VBoxDrvNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);
280#ifdef VBOXDRV_WITH_FAST_IO
281static BOOLEAN _stdcall VBoxDrvNtFastIoDeviceControl(PFILE_OBJECT pFileObj, BOOLEAN fWait, PVOID pvInput, ULONG cbInput,
282 PVOID pvOutput, ULONG cbOutput, ULONG uCmd,
283 PIO_STATUS_BLOCK pIoStatus, PDEVICE_OBJECT pDevObj);
284#endif
285static NTSTATUS _stdcall VBoxDrvNtDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
286static int VBoxDrvNtDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack);
287static NTSTATUS _stdcall VBoxDrvNtInternalDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp);
288static VOID _stdcall VBoxPowerDispatchCallback(PVOID pCallbackContext, PVOID pArgument1, PVOID pArgument2);
289static NTSTATUS _stdcall VBoxDrvNtRead(PDEVICE_OBJECT pDevObj, PIRP pIrp);
290static NTSTATUS _stdcall VBoxDrvNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp);
291static NTSTATUS VBoxDrvNtErr2NtStatus(int rc);
292#ifdef VBOX_WITH_HARDENING
293static NTSTATUS supdrvNtProtectInit(void);
294static void supdrvNtProtectTerm(void);
295static int supdrvNtProtectCreate(PSUPDRVNTPROTECT *ppNtProtect, HANDLE hPid,
296 SUPDRVNTPROTECTKIND enmProcessKind, bool fLink);
297static void supdrvNtProtectRelease(PSUPDRVNTPROTECT pNtProtect);
298static PSUPDRVNTPROTECT supdrvNtProtectLookup(HANDLE hPid);
299static int supdrvNtProtectFindAssociatedCsrss(PSUPDRVNTPROTECT pNtProtect);
300static int supdrvNtProtectVerifyProcess(PSUPDRVNTPROTECT pNtProtect);
301
302static bool supdrvNtIsDebuggerAttached(void);
303static void supdrvNtErrorInfoCleanupProcess(HANDLE hProcessId);
304
305#endif
306
307
308/*******************************************************************************
309* Exported Functions *
310*******************************************************************************/
311RT_C_DECLS_BEGIN
312ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath);
313RT_C_DECLS_END
314
315
316/*******************************************************************************
317* Global Variables *
318*******************************************************************************/
319/** Pointer to the system device instance. */
320static PDEVICE_OBJECT g_pDevObjSys = NULL;
321/** Pointer to the user device instance. */
322static PDEVICE_OBJECT g_pDevObjUsr = NULL;
323#ifdef VBOXDRV_WITH_FAST_IO
324/** Fast I/O dispatch table. */
325static FAST_IO_DISPATCH const g_VBoxDrvFastIoDispatch =
326{
327 /* .SizeOfFastIoDispatch = */ sizeof(g_VBoxDrvFastIoDispatch),
328 /* .FastIoCheckIfPossible = */ NULL,
329 /* .FastIoRead = */ NULL,
330 /* .FastIoWrite = */ NULL,
331 /* .FastIoQueryBasicInfo = */ NULL,
332 /* .FastIoQueryStandardInfo = */ NULL,
333 /* .FastIoLock = */ NULL,
334 /* .FastIoUnlockSingle = */ NULL,
335 /* .FastIoUnlockAll = */ NULL,
336 /* .FastIoUnlockAllByKey = */ NULL,
337 /* .FastIoDeviceControl = */ VBoxDrvNtFastIoDeviceControl,
338 /* .AcquireFileForNtCreateSection = */ NULL,
339 /* .ReleaseFileForNtCreateSection = */ NULL,
340 /* .FastIoDetachDevice = */ NULL,
341 /* .FastIoQueryNetworkOpenInfo = */ NULL,
342 /* .AcquireForModWrite = */ NULL,
343 /* .MdlRead = */ NULL,
344 /* .MdlReadComplete = */ NULL,
345 /* .PrepareMdlWrite = */ NULL,
346 /* .MdlWriteComplete = */ NULL,
347 /* .FastIoReadCompressed = */ NULL,
348 /* .FastIoWriteCompressed = */ NULL,
349 /* .MdlReadCompleteCompressed = */ NULL,
350 /* .MdlWriteCompleteCompressed = */ NULL,
351 /* .FastIoQueryOpen = */ NULL,
352 /* .ReleaseForModWrite = */ NULL,
353 /* .AcquireForCcFlush = */ NULL,
354 /* .ReleaseForCcFlush = */ NULL,
355};
356#endif /* VBOXDRV_WITH_FAST_IO */
357
358#ifdef VBOX_WITH_HARDENING
359/** Pointer to the stub device instance. */
360static PDEVICE_OBJECT g_pDevObjStub = NULL;
361/** Spinlock protecting g_NtProtectTree as well as the releasing of protection
362 * structures. */
363static RTSPINLOCK g_hNtProtectLock = NIL_RTSPINLOCK;
364/** AVL tree of SUPDRVNTPROTECT structures. */
365static AVLPVTREE g_NtProtectTree = NULL;
366/** Cookie returned by ObRegisterCallbacks for the callbacks. */
367static PVOID g_pvObCallbacksCookie = NULL;
368/** Combined windows NT version number. See SUP_MAKE_NT_VER_COMBINED. */
369uint32_t g_uNtVerCombined = 0;
370/** Pointer to ObGetObjectType if available.. */
371static PFNOBGETOBJECTTYPE g_pfnObGetObjectType = NULL;
372/** Pointer to ObRegisterCallbacks if available.. */
373static PFNOBREGISTERCALLBACKS g_pfnObRegisterCallbacks = NULL;
374/** Pointer to ObUnregisterCallbacks if available.. */
375static PFNOBUNREGISTERCALLBACKS g_pfnObUnRegisterCallbacks = NULL;
376/** Pointer to PsSetCreateProcessNotifyRoutineEx if available.. */
377static PFNPSSETCREATEPROCESSNOTIFYROUTINEEX g_pfnPsSetCreateProcessNotifyRoutineEx = NULL;
378/** Pointer to PsReferenceProcessFilePointer if available. */
379static PFNPSREFERENCEPROCESSFILEPOINTER g_pfnPsReferenceProcessFilePointer = NULL;
380/** Pointer to PsIsProtectedProcessLight. */
381static PFNPSISPROTECTEDPROCESSLIGHT g_pfnPsIsProtectedProcessLight = NULL;
382/** Pointer to ZwAlpcCreatePort. */
383static PFNZWALPCCREATEPORT g_pfnZwAlpcCreatePort = NULL;
384
385# ifdef RT_ARCH_AMD64
386extern "C" {
387/** Pointer to KiServiceLinkage (used to fake missing ZwQueryVirtualMemory on
388 * XP64 / W2K3-64). */
389PFNRT g_pfnKiServiceLinkage = NULL;
390/** Pointer to KiServiceInternal (used to fake missing ZwQueryVirtualMemory on
391 * XP64 / W2K3-64) */
392PFNRT g_pfnKiServiceInternal = NULL;
393}
394# endif
395/** The primary ALPC port object type. (LpcPortObjectType at init time.) */
396static POBJECT_TYPE g_pAlpcPortObjectType1 = NULL;
397/** The secondary ALPC port object type. (Sampled at runtime.) */
398static POBJECT_TYPE volatile g_pAlpcPortObjectType2 = NULL;
399
400/** Pointer to the error information device instance. */
401static PDEVICE_OBJECT g_pDevObjErrorInfo = NULL;
402/** Fast mutex semaphore protecting the error info list. */
403static RTSEMMUTEX g_hErrorInfoLock = NIL_RTSEMMUTEX;
404/** Head of the error info (SUPDRVNTERRORINFO). */
405static RTLISTANCHOR g_ErrorInfoHead;
406
407#endif
408
409
410/**
411 * Takes care of creating the devices and their symbolic links.
412 *
413 * @returns NT status code.
414 * @param pDrvObj Pointer to driver object.
415 */
416static NTSTATUS vboxdrvNtCreateDevices(PDRIVER_OBJECT pDrvObj)
417{
418 /*
419 * System device.
420 */
421 UNICODE_STRING DevName;
422 RtlInitUnicodeString(&DevName, SUPDRV_NT_DEVICE_NAME_SYS);
423 NTSTATUS rcNt = IoCreateDevice(pDrvObj, sizeof(SUPDRVDEVEXT), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &g_pDevObjSys);
424 if (NT_SUCCESS(rcNt))
425 {
426 /*
427 * User device.
428 */
429 RtlInitUnicodeString(&DevName, SUPDRV_NT_DEVICE_NAME_USR);
430 rcNt = IoCreateDevice(pDrvObj, sizeof(SUPDRVDEVEXTUSR), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &g_pDevObjUsr);
431 if (NT_SUCCESS(rcNt))
432 {
433 PSUPDRVDEVEXTUSR pDevExtUsr = (PSUPDRVDEVEXTUSR)g_pDevObjUsr->DeviceExtension;
434 pDevExtUsr->pMainDrvExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension;
435 pDevExtUsr->u32Cookie = SUPDRVDEVEXTUSR_COOKIE;
436
437#ifdef VBOX_WITH_HARDENING
438 /*
439 * Hardened stub device.
440 */
441 RtlInitUnicodeString(&DevName, SUPDRV_NT_DEVICE_NAME_STUB);
442 rcNt = IoCreateDevice(pDrvObj, sizeof(SUPDRVDEVEXTSTUB), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &g_pDevObjStub);
443 if (NT_SUCCESS(rcNt))
444 {
445 if (NT_SUCCESS(rcNt))
446 {
447 PSUPDRVDEVEXTSTUB pDevExtStub = (PSUPDRVDEVEXTSTUB)g_pDevObjStub->DeviceExtension;
448 pDevExtStub->Common.pMainDrvExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension;
449 pDevExtStub->Common.u32Cookie = SUPDRVDEVEXTSTUB_COOKIE;
450
451 /*
452 * Hardened error information device.
453 */
454 RtlInitUnicodeString(&DevName, SUPDRV_NT_DEVICE_NAME_ERROR_INFO);
455 rcNt = IoCreateDevice(pDrvObj, sizeof(SUPDRVDEVEXTERRORINFO), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE,
456 &g_pDevObjErrorInfo);
457 if (NT_SUCCESS(rcNt))
458 {
459 g_pDevObjErrorInfo->Flags |= DO_BUFFERED_IO;
460
461 if (NT_SUCCESS(rcNt))
462 {
463 PSUPDRVDEVEXTERRORINFO pDevExtStub = (PSUPDRVDEVEXTERRORINFO)g_pDevObjStub->DeviceExtension;
464 pDevExtStub->Common.pMainDrvExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension;
465 pDevExtStub->Common.u32Cookie = SUPDRVDEVEXTERRORINFO_COOKIE;
466
467#endif
468 /* Done. */
469 return rcNt;
470#ifdef VBOX_WITH_HARDENING
471 }
472
473 /* Bail out. */
474 IoDeleteDevice(g_pDevObjErrorInfo);
475 g_pDevObjErrorInfo = NULL;
476 }
477 }
478
479 /* Bail out. */
480 IoDeleteDevice(g_pDevObjStub);
481 g_pDevObjUsr = NULL;
482 }
483#endif
484 IoDeleteDevice(g_pDevObjUsr);
485 g_pDevObjUsr = NULL;
486 }
487 IoDeleteDevice(g_pDevObjSys);
488 g_pDevObjSys = NULL;
489 }
490 return rcNt;
491}
492
493/**
494 * Destroys the devices and links created by vboxdrvNtCreateDevices.
495 */
496static void vboxdrvNtDestroyDevices(void)
497{
498 if (g_pDevObjUsr)
499 {
500 PSUPDRVDEVEXTUSR pDevExtUsr = (PSUPDRVDEVEXTUSR)g_pDevObjUsr->DeviceExtension;
501 pDevExtUsr->pMainDrvExt = NULL;
502 }
503#ifdef VBOX_WITH_HARDENING
504 if (g_pDevObjStub)
505 {
506 PSUPDRVDEVEXTSTUB pDevExtStub = (PSUPDRVDEVEXTSTUB)g_pDevObjStub->DeviceExtension;
507 pDevExtStub->Common.pMainDrvExt = NULL;
508 }
509 if (g_pDevObjErrorInfo)
510 {
511 PSUPDRVDEVEXTERRORINFO pDevExtErrorInfo = (PSUPDRVDEVEXTERRORINFO)g_pDevObjStub->DeviceExtension;
512 pDevExtErrorInfo->Common.pMainDrvExt = NULL;
513 }
514#endif
515
516#ifdef VBOX_WITH_HARDENING
517 IoDeleteDevice(g_pDevObjErrorInfo);
518 g_pDevObjErrorInfo = NULL;
519 IoDeleteDevice(g_pDevObjStub);
520 g_pDevObjStub = NULL;
521#endif
522 IoDeleteDevice(g_pDevObjUsr);
523 g_pDevObjUsr = NULL;
524 IoDeleteDevice(g_pDevObjSys);
525 g_pDevObjSys = NULL;
526}
527
528
529/**
530 * Driver entry point.
531 *
532 * @returns appropriate status code.
533 * @param pDrvObj Pointer to driver object.
534 * @param pRegPath Registry base path.
535 */
536ULONG _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath)
537{
538 /*
539 * Sanity checks.
540 */
541#ifdef VBOXDRV_WITH_FAST_IO
542 if (g_VBoxDrvFastIoDispatch.FastIoDeviceControl != VBoxDrvNtFastIoDeviceControl)
543 {
544 DbgPrint("VBoxDrv: FastIoDeviceControl=%p instead of %p\n",
545 g_VBoxDrvFastIoDispatch.FastIoDeviceControl, VBoxDrvNtFastIoDeviceControl);
546 return STATUS_INTERNAL_ERROR;
547 }
548#endif
549
550 /*
551 * Initialize the runtime (IPRT).
552 */
553 NTSTATUS rcNt;
554 int vrc = RTR0Init(0);
555 if (RT_SUCCESS(vrc))
556 {
557 Log(("VBoxDrv::DriverEntry\n"));
558
559#ifdef VBOX_WITH_HARDENING
560 /*
561 * Initialize process protection.
562 */
563 rcNt = supdrvNtProtectInit();
564 if (NT_SUCCESS(rcNt))
565#endif
566 {
567 /*
568 * Create device.
569 * (That means creating a device object and a symbolic link so the DOS
570 * subsystems (OS/2, win32, ++) can access the device.)
571 */
572 rcNt = vboxdrvNtCreateDevices(pDrvObj);
573 if (NT_SUCCESS(rcNt))
574 {
575 /*
576 * Initialize the device extension.
577 */
578 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension;
579 memset(pDevExt, 0, sizeof(*pDevExt));
580
581 vrc = supdrvInitDevExt(pDevExt, sizeof(SUPDRVSESSION));
582 if (!vrc)
583 {
584 /*
585 * Setup the driver entry points in pDrvObj.
586 */
587 pDrvObj->DriverUnload = VBoxDrvNtUnload;
588 pDrvObj->MajorFunction[IRP_MJ_CREATE] = VBoxDrvNtCreate;
589 pDrvObj->MajorFunction[IRP_MJ_CLEANUP] = VBoxDrvNtCleanup;
590 pDrvObj->MajorFunction[IRP_MJ_CLOSE] = VBoxDrvNtClose;
591 pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VBoxDrvNtDeviceControl;
592 pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxDrvNtInternalDeviceControl;
593 pDrvObj->MajorFunction[IRP_MJ_READ] = VBoxDrvNtRead;
594 pDrvObj->MajorFunction[IRP_MJ_WRITE] = VBoxDrvNtNotSupportedStub;
595
596#ifdef VBOXDRV_WITH_FAST_IO
597 /* Fast I/O to speed up guest execution roundtrips. */
598 pDrvObj->FastIoDispatch = (PFAST_IO_DISPATCH)&g_VBoxDrvFastIoDispatch;
599#endif
600
601 /*
602 * Register ourselves for power state changes. We don't
603 * currently care if this fails.
604 */
605 UNICODE_STRING CallbackName;
606 RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState");
607
608 OBJECT_ATTRIBUTES Attr;
609 InitializeObjectAttributes(&Attr, &CallbackName, OBJ_CASE_INSENSITIVE, NULL, NULL);
610
611 rcNt = ExCreateCallback(&pDevExt->pObjPowerCallback, &Attr, TRUE, TRUE);
612 if (rcNt == STATUS_SUCCESS)
613 pDevExt->hPowerCallback = ExRegisterCallback(pDevExt->pObjPowerCallback,
614 VBoxPowerDispatchCallback,
615 g_pDevObjSys);
616
617 /*
618 * Done! Returning success!
619 */
620 Log(("VBoxDrv::DriverEntry returning STATUS_SUCCESS\n"));
621 return STATUS_SUCCESS;
622 }
623
624 Log(("supdrvInitDevExit failed with vrc=%d!\n", vrc));
625 rcNt = VBoxDrvNtErr2NtStatus(vrc);
626
627 vboxdrvNtDestroyDevices();
628 }
629#ifdef VBOX_WITH_HARDENING
630 supdrvNtProtectTerm();
631#endif
632 }
633 RTTermRunCallbacks(RTTERMREASON_UNLOAD, 0);
634 RTR0Term();
635 }
636 else
637 {
638 Log(("RTR0Init failed with vrc=%d!\n", vrc));
639 rcNt = VBoxDrvNtErr2NtStatus(vrc);
640 }
641 if (NT_SUCCESS(rcNt))
642 rcNt = STATUS_INVALID_PARAMETER;
643 return rcNt;
644}
645
646
647/**
648 * Unload the driver.
649 *
650 * @param pDrvObj Driver object.
651 */
652void _stdcall VBoxDrvNtUnload(PDRIVER_OBJECT pDrvObj)
653{
654 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension;
655
656 Log(("VBoxDrvNtUnload at irql %d\n", KeGetCurrentIrql()));
657
658 /* Clean up the power callback registration. */
659 if (pDevExt->hPowerCallback)
660 ExUnregisterCallback(pDevExt->hPowerCallback);
661 if (pDevExt->pObjPowerCallback)
662 ObDereferenceObject(pDevExt->pObjPowerCallback);
663
664 /*
665 * We ASSUME that it's not possible to unload a driver with open handles.
666 */
667 supdrvDeleteDevExt(pDevExt);
668#ifdef VBOX_WITH_HARDENING
669 supdrvNtProtectTerm();
670#endif
671 RTTermRunCallbacks(RTTERMREASON_UNLOAD, 0);
672 RTR0Term();
673 vboxdrvNtDestroyDevices();
674
675 NOREF(pDrvObj);
676}
677
678
679/**
680 * For simplifying request completion into a simple return statement, extended
681 * version.
682 *
683 * @returns rcNt
684 * @param rcNt The status code.
685 * @param uInfo Extra info value.
686 * @param pIrp The IRP.
687 */
688DECLINLINE(NTSTATUS) supdrvNtCompleteRequestEx(NTSTATUS rcNt, ULONG_PTR uInfo, PIRP pIrp)
689{
690 pIrp->IoStatus.Status = rcNt;
691 pIrp->IoStatus.Information = uInfo;
692 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
693 return rcNt;
694}
695
696
697/**
698 * For simplifying request completion into a simple return statement.
699 *
700 * @returns rcNt
701 * @param rcNt The status code.
702 * @param pIrp The IRP.
703 */
704DECLINLINE(NTSTATUS) supdrvNtCompleteRequest(NTSTATUS rcNt, PIRP pIrp)
705{
706 return supdrvNtCompleteRequestEx(rcNt, 0 /*uInfo*/, pIrp);
707}
708
709
710/**
711 * Create (i.e. Open) file entry point.
712 *
713 * @param pDevObj Device object.
714 * @param pIrp Request packet.
715 */
716NTSTATUS _stdcall VBoxDrvNtCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp)
717{
718 Log(("VBoxDrvNtCreate: RequestorMode=%d\n", pIrp->RequestorMode));
719 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
720 PFILE_OBJECT pFileObj = pStack->FileObject;
721 PSUPDRVDEVEXT pDevExt = SUPDRVNT_GET_DEVEXT(pDevObj);
722
723 /*
724 * We are not remotely similar to a directory...
725 * (But this is possible.)
726 */
727 if (pStack->Parameters.Create.Options & FILE_DIRECTORY_FILE)
728 return supdrvNtCompleteRequest(STATUS_NOT_A_DIRECTORY, pIrp);
729
730 /*
731 * Don't create a session for kernel clients, they'll close the handle
732 * immediately and work with the file object via
733 * VBoxDrvNtInternalDeviceControl. The first request will be one to
734 * create a session.
735 */
736 NTSTATUS rcNt;
737 if (pIrp->RequestorMode == KernelMode)
738 {
739 if (pDevObj == g_pDevObjSys)
740 return supdrvNtCompleteRequestEx(STATUS_SUCCESS, FILE_OPENED, pIrp);
741
742 rcNt = STATUS_ACCESS_DENIED;
743 }
744#ifdef VBOX_WITH_HARDENING
745 /*
746 * Anyone can open the error device.
747 */
748 else if (pDevObj == g_pDevObjErrorInfo)
749 {
750 pFileObj->FsContext = NULL;
751 return supdrvNtCompleteRequestEx(STATUS_SUCCESS, FILE_OPENED, pIrp);
752 }
753#endif
754 else
755 {
756#if defined(VBOX_WITH_HARDENING) && !defined(VBOX_WITHOUT_DEBUGGER_CHECKS)
757 /*
758 * Make sure no debuggers are attached to non-user processes.
759 */
760 if ( pDevObj != g_pDevObjUsr
761 && supdrvNtIsDebuggerAttached())
762 {
763 LogRel(("vboxdrv: Process %p is being debugged, access to vboxdrv / vboxdrvu declined.\n",
764 PsGetProcessId(PsGetCurrentProcess())));
765 rcNt = STATUS_TRUST_FAILURE;
766 }
767 else
768#endif
769 {
770 int rc = VINF_SUCCESS;
771
772#ifdef VBOX_WITH_HARDENING
773 /*
774 * Access to the stub device is only granted to processes which
775 * passes verification.
776 *
777 * Note! The stub device has no need for a SUPDRVSESSION structure,
778 * so the it uses the SUPDRVNTPROTECT directly instead.
779 */
780 if (pDevObj == g_pDevObjStub)
781 {
782 PSUPDRVNTPROTECT pNtProtect = NULL;
783 rc = supdrvNtProtectCreate(&pNtProtect, PsGetProcessId(PsGetCurrentProcess()),
784 kSupDrvNtProtectKind_StubUnverified, true /*fLink*/);
785 if (RT_SUCCESS(rc))
786 {
787 rc = supdrvNtProtectFindAssociatedCsrss(pNtProtect);
788 if (RT_SUCCESS(rc))
789 rc = supdrvNtProtectVerifyProcess(pNtProtect);
790 if (RT_SUCCESS(rc))
791 {
792 pFileObj->FsContext = pNtProtect; /* Keeps reference. */
793 return supdrvNtCompleteRequestEx(STATUS_SUCCESS, FILE_OPENED, pIrp);
794 }
795
796 supdrvNtProtectRelease(pNtProtect);
797 }
798 LogRel(("vboxdrv: Declined %p access to VBoxDrvStub: rc=%d\n", PsGetProcessId(PsGetCurrentProcess()), rc));
799 }
800 /*
801 * Unrestricted access is only granted to a process in the
802 * VmProcessUnconfirmed state that checks out correctly and is
803 * allowed to transition to VmProcessConfirmed. Again, only one
804 * session per process.
805 */
806 else if (pDevObj != g_pDevObjUsr)
807 {
808 PSUPDRVNTPROTECT pNtProtect = supdrvNtProtectLookup(PsGetProcessId(PsGetCurrentProcess()));
809 if (pNtProtect)
810 {
811 if (pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed)
812 {
813 rc = supdrvNtProtectVerifyProcess(pNtProtect);
814 if (RT_SUCCESS(rc))
815 {
816 /* Create a session. */
817 PSUPDRVSESSION pSession;
818 rc = supdrvCreateSession(pDevExt, true /*fUser*/, pDevObj == g_pDevObjSys /*fUnrestricted*/,
819 &pSession);
820 if (RT_SUCCESS(rc))
821 {
822 rc = supdrvSessionHashTabInsert(pDevExt, pSession, (PSUPDRVSESSION *)&pFileObj->FsContext, NULL);
823 supdrvSessionRelease(pSession);
824 if (RT_SUCCESS(rc))
825 {
826 pSession->pNtProtect = pNtProtect; /* Keeps reference. */
827 return supdrvNtCompleteRequestEx(STATUS_SUCCESS, FILE_OPENED, pIrp);
828 }
829 }
830
831 /* No second attempt. */
832 RTSpinlockAcquire(g_hNtProtectLock);
833 if (pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessConfirmed)
834 pNtProtect->enmProcessKind = kSupDrvNtProtectKind_VmProcessDead;
835 RTSpinlockRelease(g_hNtProtectLock);
836
837 LogRel(("vboxdrv: supdrvCreateSession failed for process %p: rc=%d.\n",
838 PsGetProcessId(PsGetCurrentProcess()), rc));
839 }
840 else
841 LogRel(("vboxdrv: Process %p failed process verification: rc=%d.\n",
842 PsGetProcessId(PsGetCurrentProcess()), rc));
843 }
844 else
845 {
846 LogRel(("vboxdrv: %p is not a budding VM process (enmProcessKind=%d).\n",
847 PsGetProcessId(PsGetCurrentProcess()), pNtProtect->enmProcessKind));
848 rc = VERR_ACCESS_DENIED;
849 }
850 supdrvNtProtectRelease(pNtProtect);
851 }
852 else
853 {
854 LogRel(("vboxdrv: %p is not a budding VM process.\n", PsGetProcessId(PsGetCurrentProcess())));
855 rc = VERR_ACCESS_DENIED;
856 }
857 }
858 /*
859 * Call common code to create an unprivileged session.
860 */
861 else
862 {
863 PSUPDRVSESSION pSession;
864 rc = supdrvCreateSession(pDevExt, true /*fUser*/, false /*fUnrestricted*/, &pSession);
865 if (RT_SUCCESS(rc))
866 {
867 rc = supdrvSessionHashTabInsert(pDevExt, pSession, (PSUPDRVSESSION *)&pFileObj->FsContext, NULL);
868 supdrvSessionRelease(pSession);
869 if (RT_SUCCESS(rc))
870 {
871 pFileObj->FsContext = pSession; /* Keeps reference. No race. */
872 pSession->pNtProtect = NULL;
873 return supdrvNtCompleteRequestEx(STATUS_SUCCESS, FILE_OPENED, pIrp);
874 }
875 }
876 }
877
878#else /* !VBOX_WITH_HARDENING */
879 /*
880 * Call common code to create a session.
881 */
882 pFileObj->FsContext = NULL;
883 PSUPDRVSESSION pSession;
884 rc = supdrvCreateSession(pDevExt, true /*fUser*/, pDevObj == g_pDevObjSys /*fUnrestricted*/, &pSession);
885 if (RT_SUCCESS(rc))
886 {
887 rc = supdrvSessionHashTabInsert(pDevExt, pSession, (PSUPDRVSESSION *)&pFileObj->FsContext, NULL);
888 supdrvSessionRelease(pSession);
889 if (RT_SUCCESS(rc))
890 return supdrvNtCompleteRequestEx(STATUS_SUCCESS, FILE_OPENED, pIrp);
891
892 }
893#endif /* !VBOX_WITH_HARDENING */
894
895 /* bail out */
896 rcNt = VBoxDrvNtErr2NtStatus(rc);
897 }
898 }
899
900 Assert(!NT_SUCCESS(rcNt));
901 pFileObj->FsContext = NULL;
902 return supdrvNtCompleteRequest(rcNt, pIrp); /* Note. the IoStatus is completely ignored on error. */
903}
904
905
906/**
907 * Clean up file handle entry point.
908 *
909 * @param pDevObj Device object.
910 * @param pIrp Request packet.
911 */
912NTSTATUS _stdcall VBoxDrvNtCleanup(PDEVICE_OBJECT pDevObj, PIRP pIrp)
913{
914 PSUPDRVDEVEXT pDevExt = SUPDRVNT_GET_DEVEXT(pDevObj);
915 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
916 PFILE_OBJECT pFileObj = pStack->FileObject;
917
918#ifdef VBOX_WITH_HARDENING
919 if (pDevObj == g_pDevObjStub)
920 {
921 PSUPDRVNTPROTECT pNtProtect = (PSUPDRVNTPROTECT)pFileObj->FsContext;
922 Log(("VBoxDrvNtCleanup: pDevExt=%p pFileObj=%p pNtProtect=%p\n", pDevExt, pFileObj, pNtProtect));
923 if (pNtProtect)
924 {
925 supdrvNtProtectRelease(pNtProtect);
926 pFileObj->FsContext = NULL;
927 }
928 }
929 else if (pDevObj == g_pDevObjErrorInfo)
930 supdrvNtErrorInfoCleanupProcess(PsGetCurrentProcessId());
931 else
932#endif
933 {
934 PSUPDRVSESSION pSession = supdrvSessionHashTabLookup(pDevExt, RTProcSelf(), RTR0ProcHandleSelf(),
935 (PSUPDRVSESSION *)&pFileObj->FsContext);
936 Log(("VBoxDrvNtCleanup: pDevExt=%p pFileObj=%p pSession=%p\n", pDevExt, pFileObj, pSession));
937 if (pSession)
938 {
939 supdrvSessionHashTabRemove(pDevExt, pSession, NULL);
940 supdrvSessionRelease(pSession); /* Drops the reference from supdrvSessionHashTabLookup. */
941 }
942 }
943
944 return supdrvNtCompleteRequest(STATUS_SUCCESS, pIrp);
945}
946
947
948/**
949 * Close file entry point.
950 *
951 * @param pDevObj Device object.
952 * @param pIrp Request packet.
953 */
954NTSTATUS _stdcall VBoxDrvNtClose(PDEVICE_OBJECT pDevObj, PIRP pIrp)
955{
956 PSUPDRVDEVEXT pDevExt = SUPDRVNT_GET_DEVEXT(pDevObj);
957 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
958 PFILE_OBJECT pFileObj = pStack->FileObject;
959
960#ifdef VBOX_WITH_HARDENING
961 if (pDevObj == g_pDevObjStub)
962 {
963 PSUPDRVNTPROTECT pNtProtect = (PSUPDRVNTPROTECT)pFileObj->FsContext;
964 Log(("VBoxDrvNtClose: pDevExt=%p pFileObj=%p pNtProtect=%p\n", pDevExt, pFileObj, pNtProtect));
965 if (pNtProtect)
966 {
967 supdrvNtProtectRelease(pNtProtect);
968 pFileObj->FsContext = NULL;
969 }
970 }
971 else if (pDevObj == g_pDevObjErrorInfo)
972 supdrvNtErrorInfoCleanupProcess(PsGetCurrentProcessId());
973 else
974#endif
975 {
976 PSUPDRVSESSION pSession = supdrvSessionHashTabLookup(pDevExt, RTProcSelf(), RTR0ProcHandleSelf(),
977 (PSUPDRVSESSION *)&pFileObj->FsContext);
978 Log(("VBoxDrvNtCleanup: pDevExt=%p pFileObj=%p pSession=%p\n", pDevExt, pFileObj, pSession));
979 if (pSession)
980 {
981 supdrvSessionHashTabRemove(pDevExt, pSession, NULL);
982 supdrvSessionRelease(pSession); /* Drops the reference from supdrvSessionHashTabLookup. */
983 }
984 }
985
986 return supdrvNtCompleteRequest(STATUS_SUCCESS, pIrp);
987}
988
989
990#ifdef VBOXDRV_WITH_FAST_IO
991/**
992 * Fast I/O device control callback.
993 *
994 * This performs no buffering, neither on the way in or out.
995 *
996 * @returns TRUE if handled, FALSE if the normal I/O control routine should be
997 * called.
998 * @param pFileObj The file object.
999 * @param fWait Whether it's a blocking call
1000 * @param pvInput The input buffer as specified by the user.
1001 * @param cbInput The size of the input buffer.
1002 * @param pvOutput The output buffer as specfied by the user.
1003 * @param cbOutput The size of the output buffer.
1004 * @param uFunction The function.
1005 * @param pIoStatus Where to return the status of the operation.
1006 * @param pDevObj The device object..
1007 */
1008static BOOLEAN _stdcall VBoxDrvNtFastIoDeviceControl(PFILE_OBJECT pFileObj, BOOLEAN fWait, PVOID pvInput, ULONG cbInput,
1009 PVOID pvOutput, ULONG cbOutput, ULONG uCmd,
1010 PIO_STATUS_BLOCK pIoStatus, PDEVICE_OBJECT pDevObj)
1011{
1012 /*
1013 * Only the normal devices, not the stub or error info ones.
1014 */
1015 if (pDevObj != g_pDevObjSys && pDevObj != g_pDevObjUsr)
1016 {
1017 pIoStatus->Status = STATUS_NOT_SUPPORTED;
1018 pIoStatus->Information = 0;
1019 return TRUE;
1020 }
1021
1022 /*
1023 * Check the input a little bit and get a the session references.
1024 */
1025 PSUPDRVDEVEXT pDevExt = SUPDRVNT_GET_DEVEXT(pDevObj);
1026 PSUPDRVSESSION pSession = supdrvSessionHashTabLookup(pDevExt, RTProcSelf(), RTR0ProcHandleSelf(),
1027 (PSUPDRVSESSION *)&pFileObj->FsContext);
1028 if (!pSession)
1029 {
1030 pIoStatus->Status = STATUS_TRUST_FAILURE;
1031 pIoStatus->Information = 0;
1032 return TRUE;
1033 }
1034
1035 if (pSession->fUnrestricted)
1036 {
1037#if defined(VBOX_WITH_HARDENING) && !defined(VBOX_WITHOUT_DEBUGGER_CHECKS)
1038 if (supdrvNtIsDebuggerAttached())
1039 {
1040 pIoStatus->Status = STATUS_TRUST_FAILURE;
1041 pIoStatus->Information = 0;
1042 supdrvSessionRelease(pSession);
1043 return TRUE;
1044 }
1045#endif
1046
1047 /*
1048 * Deal with the 2-3 high-speed IOCtl that takes their arguments from
1049 * the session and iCmd, and does not return anything.
1050 */
1051 if ( uCmd == SUP_IOCTL_FAST_DO_RAW_RUN
1052 || uCmd == SUP_IOCTL_FAST_DO_HM_RUN
1053 || uCmd == SUP_IOCTL_FAST_DO_NOP)
1054 {
1055 int rc = supdrvIOCtlFast(uCmd, (unsigned)(uintptr_t)pvOutput/* VMCPU id */, pDevExt, pSession);
1056 pIoStatus->Status = RT_SUCCESS(rc) ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER;
1057 pIoStatus->Information = 0; /* Could be used to pass rc if we liked. */
1058 supdrvSessionRelease(pSession);
1059 return TRUE;
1060 }
1061 }
1062
1063 /*
1064 * The normal path.
1065 */
1066 NTSTATUS rcNt;
1067 unsigned cbOut = 0;
1068 int rc = 0;
1069 Log2(("VBoxDrvNtFastIoDeviceControl(%p): ioctl=%#x pvIn=%p cbIn=%#x pvOut=%p cbOut=%#x pSession=%p\n",
1070 pDevExt, uCmd, pvInput, cbInput, pvOutput, cbOutput, pSession));
1071
1072# ifdef RT_ARCH_AMD64
1073 /* Don't allow 32-bit processes to do any I/O controls. */
1074 if (!IoIs32bitProcess(NULL))
1075# endif
1076 {
1077 /*
1078 * In this fast I/O device control path we have to do our own buffering.
1079 */
1080 /* Verify that the I/O control function matches our pattern. */
1081 if ((uCmd & 0x3) == METHOD_BUFFERED)
1082 {
1083 /* Get the header so we can validate it a little bit against the
1084 parameters before allocating any memory kernel for the reqest. */
1085 SUPREQHDR Hdr;
1086 if (cbInput >= sizeof(Hdr) && cbOutput >= sizeof(Hdr))
1087 {
1088 __try
1089 {
1090 RtlCopyMemory(&Hdr, pvInput, sizeof(Hdr));
1091 rcNt = STATUS_SUCCESS;
1092 }
1093 __except(EXCEPTION_EXECUTE_HANDLER)
1094 {
1095 rcNt = GetExceptionCode();
1096 }
1097 }
1098 else
1099 rcNt = STATUS_INVALID_PARAMETER;
1100 if (NT_SUCCESS(rcNt))
1101 {
1102 /* Verify that the sizes in the request header are correct. */
1103 ULONG cbBuf = RT_MAX(cbInput, cbOutput);
1104 if ( cbInput == Hdr.cbIn
1105 && cbOutput == Hdr.cbOut
1106 && cbBuf < _1M*16)
1107 {
1108 /* Allocate a buffer and copy all the input into it. */
1109 PSUPREQHDR pHdr = (PSUPREQHDR)ExAllocatePoolWithTag(NonPagedPool, cbBuf, 'VBox');
1110 if (pHdr)
1111 {
1112 __try
1113 {
1114 RtlCopyMemory(pHdr, pvInput, cbInput);
1115 if (cbInput < cbBuf)
1116 RtlZeroMemory((uint8_t *)pHdr + cbInput, cbBuf - cbInput);
1117 if (!memcmp(pHdr, &Hdr, sizeof(Hdr)))
1118 rcNt = STATUS_SUCCESS;
1119 else
1120 rcNt = STATUS_INVALID_PARAMETER;
1121 }
1122 __except(EXCEPTION_EXECUTE_HANDLER)
1123 {
1124 rcNt = GetExceptionCode();
1125 }
1126 if (NT_SUCCESS(rcNt))
1127 {
1128 /*
1129 * Now call the common code to do the real work.
1130 */
1131 rc = supdrvIOCtl(uCmd, pDevExt, pSession, pHdr, cbBuf);
1132 if (RT_SUCCESS(rc))
1133 {
1134 /*
1135 * Copy back the result.
1136 */
1137 cbOut = pHdr->cbOut;
1138 if (cbOut > cbOutput)
1139 {
1140 cbOut = cbOutput;
1141 OSDBGPRINT(("VBoxDrvNtFastIoDeviceControl: too much output! %#x > %#x; uCmd=%#x!\n",
1142 pHdr->cbOut, cbOut, uCmd));
1143 }
1144 if (cbOut)
1145 {
1146 __try
1147 {
1148 RtlCopyMemory(pvOutput, pHdr, cbOut);
1149 rcNt = STATUS_SUCCESS;
1150 }
1151 __except(EXCEPTION_EXECUTE_HANDLER)
1152 {
1153 rcNt = GetExceptionCode();
1154 }
1155 }
1156 else
1157 rcNt = STATUS_SUCCESS;
1158 }
1159 else if (rc == VERR_INVALID_PARAMETER)
1160 rcNt = STATUS_INVALID_PARAMETER;
1161 else
1162 rcNt = STATUS_NOT_SUPPORTED;
1163 Log2(("VBoxDrvNtFastIoDeviceControl: returns %#x cbOut=%d rc=%#x\n", rcNt, cbOut, rc));
1164 }
1165 else
1166 Log(("VBoxDrvNtFastIoDeviceControl: Error reading %u bytes of user memory at %p (uCmd=%#x)\n",
1167 cbInput, pvInput, uCmd));
1168 ExFreePoolWithTag(pHdr, 'VBox');
1169 }
1170 else
1171 rcNt = STATUS_NO_MEMORY;
1172 }
1173 else
1174 {
1175 Log(("VBoxDrvNtFastIoDeviceControl: Mismatching sizes (%#x) - Hdr=%#lx/%#lx Irp=%#lx/%#lx!\n",
1176 uCmd, Hdr.cbIn, Hdr.cbOut, cbInput, cbOutput));
1177 rcNt = STATUS_INVALID_PARAMETER;
1178 }
1179 }
1180 }
1181 else
1182 {
1183 Log(("VBoxDrvNtFastIoDeviceControl: not buffered request (%#x) - not supported\n", uCmd));
1184 rcNt = STATUS_NOT_SUPPORTED;
1185 }
1186 }
1187# ifdef RT_ARCH_AMD64
1188 else
1189 {
1190 Log(("VBoxDrvNtFastIoDeviceControl: WOW64 req - not supported\n"));
1191 rcNt = STATUS_NOT_SUPPORTED;
1192 }
1193# endif
1194
1195 /* complete the request. */
1196 pIoStatus->Status = rcNt;
1197 pIoStatus->Information = cbOut;
1198 supdrvSessionRelease(pSession);
1199 return TRUE; /* handled. */
1200}
1201#endif /* VBOXDRV_WITH_FAST_IO */
1202
1203
1204/**
1205 * Device I/O Control entry point.
1206 *
1207 * @param pDevObj Device object.
1208 * @param pIrp Request packet.
1209 */
1210NTSTATUS _stdcall VBoxDrvNtDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
1211{
1212 VBOXDRV_COMPLETE_IRP_AND_RETURN_IF_STUB_OR_ERROR_INFO_DEV(pDevObj, pIrp);
1213
1214 PSUPDRVDEVEXT pDevExt = SUPDRVNT_GET_DEVEXT(pDevObj);
1215 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
1216 PSUPDRVSESSION pSession = supdrvSessionHashTabLookup(pDevExt, RTProcSelf(), RTR0ProcHandleSelf(),
1217 (PSUPDRVSESSION *)&pStack->FileObject->FsContext);
1218
1219 if (!RT_VALID_PTR(pSession))
1220 return supdrvNtCompleteRequest(STATUS_TRUST_FAILURE, pIrp);
1221
1222 /*
1223 * Deal with the 2-3 high-speed IOCtl that takes their arguments from
1224 * the session and iCmd, and does not return anything.
1225 */
1226 if (pSession->fUnrestricted)
1227 {
1228#if defined(VBOX_WITH_HARDENING) && !defined(VBOX_WITHOUT_DEBUGGER_CHECKS)
1229 if (supdrvNtIsDebuggerAttached())
1230 {
1231 supdrvSessionRelease(pSession);
1232 return supdrvNtCompleteRequest(STATUS_TRUST_FAILURE, pIrp);
1233 }
1234#endif
1235
1236 ULONG ulCmd = pStack->Parameters.DeviceIoControl.IoControlCode;
1237 if ( ulCmd == SUP_IOCTL_FAST_DO_RAW_RUN
1238 || ulCmd == SUP_IOCTL_FAST_DO_HM_RUN
1239 || ulCmd == SUP_IOCTL_FAST_DO_NOP)
1240 {
1241 int rc = supdrvIOCtlFast(ulCmd, (unsigned)(uintptr_t)pIrp->UserBuffer /* VMCPU id */, pDevExt, pSession);
1242
1243 /* Complete the I/O request. */
1244 supdrvSessionRelease(pSession);
1245 return supdrvNtCompleteRequest(RT_SUCCESS(rc) ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER, pIrp);
1246 }
1247 }
1248
1249 return VBoxDrvNtDeviceControlSlow(pDevExt, pSession, pIrp, pStack);
1250}
1251
1252
1253/**
1254 * Worker for VBoxDrvNtDeviceControl that takes the slow IOCtl functions.
1255 *
1256 * @returns NT status code.
1257 *
1258 * @param pDevObj Device object.
1259 * @param pSession The session.
1260 * @param pIrp Request packet.
1261 * @param pStack The stack location containing the DeviceControl parameters.
1262 */
1263static int VBoxDrvNtDeviceControlSlow(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PIRP pIrp, PIO_STACK_LOCATION pStack)
1264{
1265 NTSTATUS rcNt;
1266 unsigned cbOut = 0;
1267 int rc = 0;
1268 Log2(("VBoxDrvNtDeviceControlSlow(%p,%p): ioctl=%#x pBuf=%p cbIn=%#x cbOut=%#x pSession=%p\n",
1269 pDevExt, pIrp, pStack->Parameters.DeviceIoControl.IoControlCode,
1270 pIrp->AssociatedIrp.SystemBuffer, pStack->Parameters.DeviceIoControl.InputBufferLength,
1271 pStack->Parameters.DeviceIoControl.OutputBufferLength, pSession));
1272
1273#ifdef RT_ARCH_AMD64
1274 /* Don't allow 32-bit processes to do any I/O controls. */
1275 if (!IoIs32bitProcess(pIrp))
1276#endif
1277 {
1278 /* Verify that it's a buffered CTL. */
1279 if ((pStack->Parameters.DeviceIoControl.IoControlCode & 0x3) == METHOD_BUFFERED)
1280 {
1281 /* Verify that the sizes in the request header are correct. */
1282 PSUPREQHDR pHdr = (PSUPREQHDR)pIrp->AssociatedIrp.SystemBuffer;
1283 if ( pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr)
1284 && pStack->Parameters.DeviceIoControl.InputBufferLength == pHdr->cbIn
1285 && pStack->Parameters.DeviceIoControl.OutputBufferLength == pHdr->cbOut)
1286 {
1287 /* Zero extra output bytes to make sure we don't leak anything. */
1288 if (pHdr->cbIn < pHdr->cbOut)
1289 RtlZeroMemory((uint8_t *)pHdr + pHdr->cbIn, pHdr->cbOut - pHdr->cbIn);
1290
1291 /*
1292 * Do the job.
1293 */
1294 rc = supdrvIOCtl(pStack->Parameters.DeviceIoControl.IoControlCode, pDevExt, pSession, pHdr,
1295 RT_MAX(pHdr->cbIn, pHdr->cbOut));
1296 if (!rc)
1297 {
1298 rcNt = STATUS_SUCCESS;
1299 cbOut = pHdr->cbOut;
1300 if (cbOut > pStack->Parameters.DeviceIoControl.OutputBufferLength)
1301 {
1302 cbOut = pStack->Parameters.DeviceIoControl.OutputBufferLength;
1303 OSDBGPRINT(("VBoxDrvLinuxIOCtl: too much output! %#x > %#x; uCmd=%#x!\n",
1304 pHdr->cbOut, cbOut, pStack->Parameters.DeviceIoControl.IoControlCode));
1305 }
1306 }
1307 else
1308 rcNt = STATUS_INVALID_PARAMETER;
1309 Log2(("VBoxDrvNtDeviceControlSlow: returns %#x cbOut=%d rc=%#x\n", rcNt, cbOut, rc));
1310 }
1311 else
1312 {
1313 Log(("VBoxDrvNtDeviceControlSlow: Mismatching sizes (%#x) - Hdr=%#lx/%#lx Irp=%#lx/%#lx!\n",
1314 pStack->Parameters.DeviceIoControl.IoControlCode,
1315 pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cbIn : 0,
1316 pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cbOut : 0,
1317 pStack->Parameters.DeviceIoControl.InputBufferLength,
1318 pStack->Parameters.DeviceIoControl.OutputBufferLength));
1319 rcNt = STATUS_INVALID_PARAMETER;
1320 }
1321 }
1322 else
1323 {
1324 Log(("VBoxDrvNtDeviceControlSlow: not buffered request (%#x) - not supported\n",
1325 pStack->Parameters.DeviceIoControl.IoControlCode));
1326 rcNt = STATUS_NOT_SUPPORTED;
1327 }
1328 }
1329#ifdef RT_ARCH_AMD64
1330 else
1331 {
1332 Log(("VBoxDrvNtDeviceControlSlow: WOW64 req - not supported\n"));
1333 rcNt = STATUS_NOT_SUPPORTED;
1334 }
1335#endif
1336
1337 /* complete the request. */
1338 pIrp->IoStatus.Status = rcNt;
1339 pIrp->IoStatus.Information = cbOut;
1340 supdrvSessionRelease(pSession);
1341 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
1342 return rcNt;
1343}
1344
1345
1346/**
1347 * Internal Device I/O Control entry point, used for IDC.
1348 *
1349 * @param pDevObj Device object.
1350 * @param pIrp Request packet.
1351 */
1352NTSTATUS _stdcall VBoxDrvNtInternalDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp)
1353{
1354 VBOXDRV_COMPLETE_IRP_AND_RETURN_IF_STUB_OR_ERROR_INFO_DEV(pDevObj, pIrp);
1355
1356 PSUPDRVDEVEXT pDevExt = SUPDRVNT_GET_DEVEXT(pDevObj);
1357 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
1358 PFILE_OBJECT pFileObj = pStack ? pStack->FileObject : NULL;
1359 PSUPDRVSESSION pSession = pFileObj ? (PSUPDRVSESSION)pFileObj->FsContext : NULL;
1360 NTSTATUS rcNt;
1361 unsigned cbOut = 0;
1362 int rc = 0;
1363 Log2(("VBoxDrvNtInternalDeviceControl(%p,%p): ioctl=%#x pBuf=%p cbIn=%#x cbOut=%#x pSession=%p\n",
1364 pDevExt, pIrp, pStack->Parameters.DeviceIoControl.IoControlCode,
1365 pIrp->AssociatedIrp.SystemBuffer, pStack->Parameters.DeviceIoControl.InputBufferLength,
1366 pStack->Parameters.DeviceIoControl.OutputBufferLength, pSession));
1367
1368 /* Verify that it's a buffered CTL. */
1369 if ((pStack->Parameters.DeviceIoControl.IoControlCode & 0x3) == METHOD_BUFFERED)
1370 {
1371 /* Verify the pDevExt in the session. */
1372 if ( pStack->Parameters.DeviceIoControl.IoControlCode != SUPDRV_IDC_REQ_CONNECT
1373 ? VALID_PTR(pSession) && pSession->pDevExt == pDevExt
1374 : !pSession
1375 )
1376 {
1377 /* Verify that the size in the request header is correct. */
1378 PSUPDRVIDCREQHDR pHdr = (PSUPDRVIDCREQHDR)pIrp->AssociatedIrp.SystemBuffer;
1379 if ( pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr)
1380 && pStack->Parameters.DeviceIoControl.InputBufferLength == pHdr->cb
1381 && pStack->Parameters.DeviceIoControl.OutputBufferLength == pHdr->cb)
1382 {
1383 /*
1384 * Call the generic code.
1385 *
1386 * Note! Connect and disconnect requires some extra attention
1387 * in order to get the session handling right.
1388 */
1389 if (pStack->Parameters.DeviceIoControl.IoControlCode == SUPDRV_IDC_REQ_DISCONNECT)
1390 pFileObj->FsContext = NULL;
1391
1392 rc = supdrvIDC(pStack->Parameters.DeviceIoControl.IoControlCode, pDevExt, pSession, pHdr);
1393 if (!rc)
1394 {
1395 if (pStack->Parameters.DeviceIoControl.IoControlCode == SUPDRV_IDC_REQ_CONNECT)
1396 pFileObj->FsContext = ((PSUPDRVIDCREQCONNECT)pHdr)->u.Out.pSession;
1397
1398 rcNt = STATUS_SUCCESS;
1399 cbOut = pHdr->cb;
1400 }
1401 else
1402 {
1403 rcNt = STATUS_INVALID_PARAMETER;
1404 if (pStack->Parameters.DeviceIoControl.IoControlCode == SUPDRV_IDC_REQ_DISCONNECT)
1405 pFileObj->FsContext = pSession;
1406 }
1407 Log2(("VBoxDrvNtInternalDeviceControl: returns %#x/rc=%#x\n", rcNt, rc));
1408 }
1409 else
1410 {
1411 Log(("VBoxDrvNtInternalDeviceControl: Mismatching sizes (%#x) - Hdr=%#lx Irp=%#lx/%#lx!\n",
1412 pStack->Parameters.DeviceIoControl.IoControlCode,
1413 pStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(*pHdr) ? pHdr->cb : 0,
1414 pStack->Parameters.DeviceIoControl.InputBufferLength,
1415 pStack->Parameters.DeviceIoControl.OutputBufferLength));
1416 rcNt = STATUS_INVALID_PARAMETER;
1417 }
1418 }
1419 else
1420 rcNt = STATUS_NOT_SUPPORTED;
1421 }
1422 else
1423 {
1424 Log(("VBoxDrvNtInternalDeviceControl: not buffered request (%#x) - not supported\n",
1425 pStack->Parameters.DeviceIoControl.IoControlCode));
1426 rcNt = STATUS_NOT_SUPPORTED;
1427 }
1428
1429 /* complete the request. */
1430 pIrp->IoStatus.Status = rcNt;
1431 pIrp->IoStatus.Information = cbOut;
1432 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
1433 return rcNt;
1434}
1435
1436
1437/**
1438 * Implementation of the read major function for VBoxDrvErrorInfo.
1439 *
1440 * This is a stub function for the other devices.
1441 *
1442 * @returns NT status code.
1443 * @param pDevObj The device object.
1444 * @param pIrp The I/O request packet.
1445 */
1446NTSTATUS _stdcall VBoxDrvNtRead(PDEVICE_OBJECT pDevObj, PIRP pIrp)
1447{
1448 Log(("VBoxDrvNtRead\n"));
1449
1450 NTSTATUS rcNt;
1451 pIrp->IoStatus.Information = 0;
1452
1453#ifdef VBOX_WITH_HARDENING
1454 /*
1455 * VBoxDrvErrorInfo?
1456 */
1457 if (pDevObj == g_pDevObjErrorInfo)
1458 {
1459 PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
1460 if ( pStack
1461 && (pIrp->Flags & IRP_BUFFERED_IO))
1462 {
1463 /*
1464 * Look up the process error information.
1465 */
1466 HANDLE hCurThreadId = PsGetCurrentThreadId();
1467 HANDLE hCurProcessId = PsGetCurrentProcessId();
1468 int rc = RTSemMutexRequestNoResume(g_hErrorInfoLock, RT_INDEFINITE_WAIT);
1469 if (RT_SUCCESS(rc))
1470 {
1471 PSUPDRVNTERRORINFO pCur;
1472 RTListForEach(&g_ErrorInfoHead, pCur, SUPDRVNTERRORINFO, ListEntry)
1473 {
1474 if ( pCur->hProcessId == hCurProcessId
1475 && pCur->hThreadId == hCurThreadId)
1476 break;
1477 }
1478
1479 /*
1480 * Did we find error info and is the caller requesting data within it?
1481 * If so, cehck the destination buffer and copy the data into it.
1482 */
1483 if ( pCur
1484 && pStack->Parameters.Read.ByteOffset.QuadPart < pCur->cchErrorInfo
1485 && pStack->Parameters.Read.ByteOffset.QuadPart >= 0)
1486 {
1487 PVOID pvDstBuf = pIrp->AssociatedIrp.SystemBuffer;
1488 if (pvDstBuf)
1489 {
1490 uint32_t offRead = (uint32_t)pStack->Parameters.Read.ByteOffset.QuadPart;
1491 uint32_t cbToRead = pCur->cchErrorInfo - (uint32_t)offRead;
1492 if (cbToRead > pStack->Parameters.Read.Length)
1493 {
1494 cbToRead = pStack->Parameters.Read.Length;
1495 RT_BZERO((uint8_t *)pvDstBuf + cbToRead, pStack->Parameters.Read.Length - cbToRead);
1496 }
1497 memcpy(pvDstBuf, &pCur->szErrorInfo[offRead], cbToRead);
1498 pIrp->IoStatus.Information = cbToRead;
1499
1500 rcNt = STATUS_SUCCESS;
1501 }
1502 else
1503 rcNt = STATUS_INVALID_ADDRESS;
1504 }
1505 /*
1506 * End of file. Free the info.
1507 */
1508 else if (pCur)
1509 {
1510 RTListNodeRemove(&pCur->ListEntry);
1511 RTMemFree(pCur);
1512 rcNt = STATUS_END_OF_FILE;
1513 }
1514 /*
1515 * We found no error info. Return EOF.
1516 */
1517 else
1518 rcNt = STATUS_END_OF_FILE;
1519
1520 RTSemMutexRelease(g_hErrorInfoLock);
1521 }
1522 else
1523 rcNt = STATUS_UNSUCCESSFUL;
1524 }
1525 else
1526 rcNt = STATUS_INVALID_PARAMETER;
1527 }
1528 else
1529#endif /* VBOX_WITH_HARDENING */
1530 {
1531 /*
1532 * Stub.
1533 */
1534 rcNt = STATUS_NOT_SUPPORTED;
1535 }
1536
1537 /*
1538 * Complete the request.
1539 */
1540 pIrp->IoStatus.Status = rcNt;
1541 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
1542 return rcNt;
1543}
1544
1545
1546/**
1547 * Stub function for functions we don't implemented.
1548 *
1549 * @returns STATUS_NOT_SUPPORTED
1550 * @param pDevObj Device object.
1551 * @param pIrp IRP.
1552 */
1553NTSTATUS _stdcall VBoxDrvNtNotSupportedStub(PDEVICE_OBJECT pDevObj, PIRP pIrp)
1554{
1555 Log(("VBoxDrvNtNotSupportedStub\n"));
1556 NOREF(pDevObj);
1557
1558 pIrp->IoStatus.Information = 0;
1559 pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
1560 IoCompleteRequest(pIrp, IO_NO_INCREMENT);
1561
1562 return STATUS_NOT_SUPPORTED;
1563}
1564
1565
1566/**
1567 * ExRegisterCallback handler for power events
1568 *
1569 * @param pCallbackContext User supplied parameter (pDevObj)
1570 * @param pArgument1 First argument
1571 * @param pArgument2 Second argument
1572 */
1573VOID _stdcall VBoxPowerDispatchCallback(PVOID pCallbackContext, PVOID pArgument1, PVOID pArgument2)
1574{
1575 PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)pCallbackContext;
1576
1577 Log(("VBoxPowerDispatchCallback: %x %x\n", pArgument1, pArgument2));
1578
1579 /* Power change imminent? */
1580 if ((unsigned)pArgument1 == PO_CB_SYSTEM_STATE_LOCK)
1581 {
1582 if ((unsigned)pArgument2 == 0)
1583 Log(("VBoxPowerDispatchCallback: about to go into suspend mode!\n"));
1584 else
1585 Log(("VBoxPowerDispatchCallback: resumed!\n"));
1586
1587 /* Inform any clients that have registered themselves with IPRT. */
1588 RTPowerSignalEvent(((unsigned)pArgument2 == 0) ? RTPOWEREVENT_SUSPEND : RTPOWEREVENT_RESUME);
1589 }
1590}
1591
1592
1593/**
1594 * Called to clean up the session structure before it's freed.
1595 *
1596 * @param pDevExt The device globals.
1597 * @param pSession The session that's being cleaned up.
1598 */
1599void VBOXCALL supdrvOSCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
1600{
1601#ifdef VBOX_WITH_HARDENING
1602 if (pSession->pNtProtect)
1603 {
1604 supdrvNtProtectRelease(pSession->pNtProtect);
1605 pSession->pNtProtect = NULL;
1606 }
1607#endif
1608}
1609
1610
1611void VBOXCALL supdrvOSSessionHashTabInserted(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
1612{
1613 NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
1614}
1615
1616
1617void VBOXCALL supdrvOSSessionHashTabRemoved(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, void *pvUser)
1618{
1619 NOREF(pDevExt); NOREF(pSession); NOREF(pvUser);
1620}
1621
1622
1623/**
1624 * Initializes any OS specific object creator fields.
1625 */
1626void VBOXCALL supdrvOSObjInitCreator(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession)
1627{
1628 NOREF(pObj);
1629 NOREF(pSession);
1630}
1631
1632
1633/**
1634 * Checks if the session can access the object.
1635 *
1636 * @returns true if a decision has been made.
1637 * @returns false if the default access policy should be applied.
1638 *
1639 * @param pObj The object in question.
1640 * @param pSession The session wanting to access the object.
1641 * @param pszObjName The object name, can be NULL.
1642 * @param prc Where to store the result when returning true.
1643 */
1644bool VBOXCALL supdrvOSObjCanAccess(PSUPDRVOBJ pObj, PSUPDRVSESSION pSession, const char *pszObjName, int *prc)
1645{
1646 NOREF(pObj);
1647 NOREF(pSession);
1648 NOREF(pszObjName);
1649 NOREF(prc);
1650 return false;
1651}
1652
1653
1654/**
1655 * Force async tsc mode (stub).
1656 */
1657bool VBOXCALL supdrvOSGetForcedAsyncTscMode(PSUPDRVDEVEXT pDevExt)
1658{
1659 return false;
1660}
1661
1662
1663/**
1664 * Whether the host takes CPUs offline during a suspend/resume operation.
1665 */
1666bool VBOXCALL supdrvOSAreCpusOfflinedOnSuspend(void)
1667{
1668 return false;
1669}
1670
1671
1672/**
1673 * Whether the hardware TSC has been synchronized by the OS.
1674 */
1675bool VBOXCALL supdrvOSAreTscDeltasInSync(void)
1676{
1677 /* If IPRT didn't find KeIpiGenericCall we pretend windows(, the firmware,
1678 or whoever) always configures TSCs perfectly. */
1679 return !RTMpOnPairIsConcurrentExecSupported();
1680}
1681
1682
1683#define MY_SystemLoadGdiDriverInSystemSpaceInformation 54
1684#define MY_SystemUnloadGdiDriverInformation 27
1685
1686typedef struct MYSYSTEMGDIDRIVERINFO
1687{
1688 UNICODE_STRING Name; /**< In: image file name. */
1689 PVOID ImageAddress; /**< Out: the load address. */
1690 PVOID SectionPointer; /**< Out: section object. */
1691 PVOID EntryPointer; /**< Out: entry point address. */
1692 PVOID ExportSectionPointer; /**< Out: export directory/section. */
1693 ULONG ImageLength; /**< Out: SizeOfImage. */
1694} MYSYSTEMGDIDRIVERINFO;
1695
1696extern "C" __declspec(dllimport) NTSTATUS NTAPI ZwSetSystemInformation(ULONG, PVOID, ULONG);
1697
1698int VBOXCALL supdrvOSLdrOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const char *pszFilename)
1699{
1700 pImage->pvNtSectionObj = NULL;
1701 pImage->hMemLock = NIL_RTR0MEMOBJ;
1702
1703#ifdef VBOX_WITHOUT_NATIVE_R0_LOADER
1704# ifndef RT_ARCH_X86
1705# error "VBOX_WITHOUT_NATIVE_R0_LOADER is only safe on x86."
1706# endif
1707 NOREF(pDevExt); NOREF(pszFilename); NOREF(pImage);
1708 return VERR_NOT_SUPPORTED;
1709
1710#else
1711 /*
1712 * Convert the filename from DOS UTF-8 to NT UTF-16.
1713 */
1714 size_t cwcFilename;
1715 int rc = RTStrCalcUtf16LenEx(pszFilename, RTSTR_MAX, &cwcFilename);
1716 if (RT_FAILURE(rc))
1717 return rc;
1718
1719 PRTUTF16 pwcsFilename = (PRTUTF16)RTMemTmpAlloc((4 + cwcFilename + 1) * sizeof(RTUTF16));
1720 if (!pwcsFilename)
1721 return VERR_NO_TMP_MEMORY;
1722
1723 pwcsFilename[0] = '\\';
1724 pwcsFilename[1] = '?';
1725 pwcsFilename[2] = '?';
1726 pwcsFilename[3] = '\\';
1727 PRTUTF16 pwcsTmp = &pwcsFilename[4];
1728 rc = RTStrToUtf16Ex(pszFilename, RTSTR_MAX, &pwcsTmp, cwcFilename + 1, NULL);
1729 if (RT_SUCCESS(rc))
1730 {
1731 /*
1732 * Try load it.
1733 */
1734 MYSYSTEMGDIDRIVERINFO Info;
1735 RtlInitUnicodeString(&Info.Name, pwcsFilename);
1736 Info.ImageAddress = NULL;
1737 Info.SectionPointer = NULL;
1738 Info.EntryPointer = NULL;
1739 Info.ExportSectionPointer = NULL;
1740 Info.ImageLength = 0;
1741
1742 NTSTATUS rcNt = ZwSetSystemInformation(MY_SystemLoadGdiDriverInSystemSpaceInformation, &Info, sizeof(Info));
1743 if (NT_SUCCESS(rcNt))
1744 {
1745 pImage->pvImage = Info.ImageAddress;
1746 pImage->pvNtSectionObj = Info.SectionPointer;
1747 Log(("ImageAddress=%p SectionPointer=%p ImageLength=%#x cbImageBits=%#x rcNt=%#x '%ls'\n",
1748 Info.ImageAddress, Info.SectionPointer, Info.ImageLength, pImage->cbImageBits, rcNt, Info.Name.Buffer));
1749# ifdef DEBUG_bird
1750 SUPR0Printf("ImageAddress=%p SectionPointer=%p ImageLength=%#x cbImageBits=%#x rcNt=%#x '%ws'\n",
1751 Info.ImageAddress, Info.SectionPointer, Info.ImageLength, pImage->cbImageBits, rcNt, Info.Name.Buffer);
1752# endif
1753 if (pImage->cbImageBits == Info.ImageLength)
1754 {
1755 /*
1756 * Lock down the entire image, just to be on the safe side.
1757 */
1758 rc = RTR0MemObjLockKernel(&pImage->hMemLock, pImage->pvImage, pImage->cbImageBits, RTMEM_PROT_READ);
1759 if (RT_FAILURE(rc))
1760 {
1761 pImage->hMemLock = NIL_RTR0MEMOBJ;
1762 supdrvOSLdrUnload(pDevExt, pImage);
1763 }
1764 }
1765 else
1766 {
1767 supdrvOSLdrUnload(pDevExt, pImage);
1768 rc = VERR_LDR_MISMATCH_NATIVE;
1769 }
1770 }
1771 else
1772 {
1773 Log(("rcNt=%#x '%ls'\n", rcNt, pwcsFilename));
1774 SUPR0Printf("VBoxDrv: rcNt=%x '%ws'\n", rcNt, pwcsFilename);
1775 switch (rcNt)
1776 {
1777 case /* 0xc0000003 */ STATUS_INVALID_INFO_CLASS:
1778# ifdef RT_ARCH_AMD64
1779 /* Unwind will crash and BSOD, so no fallback here! */
1780 rc = VERR_NOT_IMPLEMENTED;
1781# else
1782 /*
1783 * Use the old way of loading the modules.
1784 *
1785 * Note! We do *NOT* try class 26 because it will probably
1786 * not work correctly on terminal servers and such.
1787 */
1788 rc = VERR_NOT_SUPPORTED;
1789# endif
1790 break;
1791 case /* 0xc0000034 */ STATUS_OBJECT_NAME_NOT_FOUND:
1792 rc = VERR_MODULE_NOT_FOUND;
1793 break;
1794 case /* 0xC0000263 */ STATUS_DRIVER_ENTRYPOINT_NOT_FOUND:
1795 rc = VERR_LDR_IMPORTED_SYMBOL_NOT_FOUND;
1796 break;
1797 case /* 0xC0000428 */ STATUS_INVALID_IMAGE_HASH:
1798 rc = VERR_LDR_IMAGE_HASH;
1799 break;
1800 case /* 0xC000010E */ STATUS_IMAGE_ALREADY_LOADED:
1801 Log(("WARNING: see @bugref{4853} for cause of this failure on Windows 7 x64\n"));
1802 rc = VERR_ALREADY_LOADED;
1803 break;
1804 default:
1805 rc = VERR_LDR_GENERAL_FAILURE;
1806 break;
1807 }
1808
1809 pImage->pvNtSectionObj = NULL;
1810 }
1811 }
1812
1813 RTMemTmpFree(pwcsFilename);
1814 NOREF(pDevExt);
1815 return rc;
1816#endif
1817}
1818
1819
1820void VBOXCALL supdrvOSLdrNotifyOpened(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1821{
1822 NOREF(pDevExt); NOREF(pImage);
1823}
1824
1825
1826int VBOXCALL supdrvOSLdrValidatePointer(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, void *pv, const uint8_t *pbImageBits)
1827{
1828 NOREF(pDevExt); NOREF(pImage); NOREF(pv); NOREF(pbImageBits);
1829 return VINF_SUCCESS;
1830}
1831
1832
1833/**
1834 * memcmp + log.
1835 *
1836 * @returns Same as memcmp.
1837 * @param pImage The image.
1838 * @param pbImageBits The image bits ring-3 uploads.
1839 * @param uRva The RVA to start comparing at.
1840 * @param cb The number of bytes to compare.
1841 */
1842static int supdrvNtCompare(PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, uint32_t uRva, uint32_t cb)
1843{
1844 int iDiff = memcmp((uint8_t const *)pImage->pvImage + uRva, pbImageBits + uRva, cb);
1845 if (iDiff)
1846 {
1847 uint32_t cbLeft = cb;
1848 const uint8_t *pbNativeBits = (const uint8_t *)pImage->pvImage;
1849 for (size_t off = uRva; cbLeft > 0; off++, cbLeft--)
1850 if (pbNativeBits[off] != pbImageBits[off])
1851 {
1852 char szBytes[128];
1853 RTStrPrintf(szBytes, sizeof(szBytes), "native: %.*Rhxs our: %.*Rhxs",
1854 RT_MIN(12, cbLeft), &pbNativeBits[off],
1855 RT_MIN(12, cbLeft), &pbImageBits[off]);
1856 SUPR0Printf("VBoxDrv: Mismatch at %#x of %s: %s\n", off, pImage->szName, szBytes);
1857 break;
1858 }
1859 }
1860 return iDiff;
1861}
1862
1863int VBOXCALL supdrvOSLdrLoad(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage, const uint8_t *pbImageBits, PSUPLDRLOAD pReq)
1864{
1865 NOREF(pDevExt); NOREF(pReq);
1866 if (pImage->pvNtSectionObj)
1867 {
1868 /*
1869 * Usually, the entire image matches exactly.
1870 */
1871 if (!memcmp(pImage->pvImage, pbImageBits, pImage->cbImageBits))
1872 return VINF_SUCCESS;
1873
1874 /*
1875 * However, on Windows Server 2003 (sp2 x86) both import thunk tables
1876 * are fixed up and we typically get a mismatch in the INIT section.
1877 *
1878 * So, lets see if everything matches when excluding the
1879 * OriginalFirstThunk tables. To make life simpler, set the max number
1880 * of imports to 16 and just record and sort the locations that needs
1881 * to be excluded from the comparison.
1882 */
1883 IMAGE_NT_HEADERS const *pNtHdrs;
1884 pNtHdrs = (IMAGE_NT_HEADERS const *)(pbImageBits
1885 + ( *(uint16_t *)pbImageBits == IMAGE_DOS_SIGNATURE
1886 ? ((IMAGE_DOS_HEADER const *)pbImageBits)->e_lfanew
1887 : 0));
1888 if ( pNtHdrs->Signature == IMAGE_NT_SIGNATURE
1889 && pNtHdrs->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR_MAGIC
1890 && pNtHdrs->OptionalHeader.NumberOfRvaAndSizes > IMAGE_DIRECTORY_ENTRY_IMPORT
1891 && pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size >= sizeof(IMAGE_IMPORT_DESCRIPTOR)
1892 && pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress > sizeof(IMAGE_NT_HEADERS)
1893 && pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress < pImage->cbImageBits
1894 )
1895 {
1896 struct MyRegion
1897 {
1898 uint32_t uRva;
1899 uint32_t cb;
1900 } aExcludeRgns[16];
1901 unsigned cExcludeRgns = 0;
1902 uint32_t cImpsLeft = pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size
1903 / sizeof(IMAGE_IMPORT_DESCRIPTOR);
1904 IMAGE_IMPORT_DESCRIPTOR const *pImp;
1905 pImp = (IMAGE_IMPORT_DESCRIPTOR const *)(pbImageBits
1906 + pNtHdrs->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
1907 while ( cImpsLeft-- > 0
1908 && cExcludeRgns < RT_ELEMENTS(aExcludeRgns))
1909 {
1910 uint32_t uRvaThunk = pImp->OriginalFirstThunk;
1911 if ( uRvaThunk > sizeof(IMAGE_NT_HEADERS)
1912 && uRvaThunk <= pImage->cbImageBits - sizeof(IMAGE_THUNK_DATA)
1913 && uRvaThunk != pImp->FirstThunk)
1914 {
1915 /* Find the size of the thunk table. */
1916 IMAGE_THUNK_DATA const *paThunk = (IMAGE_THUNK_DATA const *)(pbImageBits + uRvaThunk);
1917 uint32_t cMaxThunks = (pImage->cbImageBits - uRvaThunk) / sizeof(IMAGE_THUNK_DATA);
1918 uint32_t cThunks = 0;
1919 while (cThunks < cMaxThunks && paThunk[cThunks].u1.Function != 0)
1920 cThunks++;
1921
1922 /* Ordered table insert. */
1923 unsigned i = 0;
1924 for (; i < cExcludeRgns; i++)
1925 if (uRvaThunk < aExcludeRgns[i].uRva)
1926 break;
1927 if (i != cExcludeRgns)
1928 memmove(&aExcludeRgns[i + 1], &aExcludeRgns[i], (cExcludeRgns - i) * sizeof(aExcludeRgns[0]));
1929 aExcludeRgns[i].uRva = uRvaThunk;
1930 aExcludeRgns[i].cb = cThunks * sizeof(IMAGE_THUNK_DATA);
1931 cExcludeRgns++;
1932 }
1933
1934 /* advance */
1935 pImp++;
1936 }
1937
1938 /*
1939 * Ok, do the comparison.
1940 */
1941 int iDiff = 0;
1942 uint32_t uRvaNext = 0;
1943 for (unsigned i = 0; !iDiff && i < cExcludeRgns; i++)
1944 {
1945 if (uRvaNext < aExcludeRgns[i].uRva)
1946 iDiff = supdrvNtCompare(pImage, pbImageBits, uRvaNext, aExcludeRgns[i].uRva - uRvaNext);
1947 uRvaNext = aExcludeRgns[i].uRva + aExcludeRgns[i].cb;
1948 }
1949 if (!iDiff && uRvaNext < pImage->cbImageBits)
1950 iDiff = supdrvNtCompare(pImage, pbImageBits, uRvaNext, pImage->cbImageBits - uRvaNext);
1951 if (!iDiff)
1952 return VINF_SUCCESS;
1953 }
1954 else
1955 supdrvNtCompare(pImage, pbImageBits, 0, pImage->cbImageBits);
1956 return VERR_LDR_MISMATCH_NATIVE;
1957 }
1958 return VERR_INTERNAL_ERROR_4;
1959}
1960
1961
1962void VBOXCALL supdrvOSLdrUnload(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
1963{
1964 if (pImage->pvNtSectionObj)
1965 {
1966 if (pImage->hMemLock != NIL_RTR0MEMOBJ)
1967 {
1968 RTR0MemObjFree(pImage->hMemLock, false /*fFreeMappings*/);
1969 pImage->hMemLock = NIL_RTR0MEMOBJ;
1970 }
1971
1972 NTSTATUS rcNt = ZwSetSystemInformation(MY_SystemUnloadGdiDriverInformation,
1973 &pImage->pvNtSectionObj, sizeof(pImage->pvNtSectionObj));
1974 if (rcNt != STATUS_SUCCESS)
1975 SUPR0Printf("VBoxDrv: failed to unload '%s', rcNt=%#x\n", pImage->szName, rcNt);
1976 pImage->pvNtSectionObj = NULL;
1977 }
1978 NOREF(pDevExt);
1979}
1980
1981
1982#ifdef SUPDRV_WITH_MSR_PROBER
1983
1984#if 1
1985/** @todo make this selectable. */
1986# define AMD_MSR_PASSCODE 0x9c5a203a
1987#else
1988# define ASMRdMsrEx(a, b, c) ASMRdMsr(a)
1989# define ASMWrMsrEx(a, b, c) ASMWrMsr(a,c)
1990#endif
1991
1992
1993/**
1994 * Argument package used by supdrvOSMsrProberRead and supdrvOSMsrProberWrite.
1995 */
1996typedef struct SUPDRVNTMSPROBERARGS
1997{
1998 uint32_t uMsr;
1999 uint64_t uValue;
2000 bool fGp;
2001} SUPDRVNTMSPROBERARGS;
2002
2003/** @callback_method_impl{FNRTMPWORKER, Worker for supdrvOSMsrProberRead.} */
2004static DECLCALLBACK(void) supdrvNtMsProberReadOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
2005{
2006 /*
2007 * rdmsr and wrmsr faults can be caught even with interrupts disabled.
2008 * (At least on 32-bit XP.)
2009 */
2010 SUPDRVNTMSPROBERARGS *pArgs = (SUPDRVNTMSPROBERARGS *)pvUser1; NOREF(idCpu); NOREF(pvUser2);
2011 RTCCUINTREG fOldFlags = ASMIntDisableFlags();
2012 __try
2013 {
2014 pArgs->uValue = ASMRdMsrEx(pArgs->uMsr, AMD_MSR_PASSCODE);
2015 pArgs->fGp = false;
2016 }
2017 __except(EXCEPTION_EXECUTE_HANDLER)
2018 {
2019 pArgs->fGp = true;
2020 pArgs->uValue = 0;
2021 }
2022 ASMSetFlags(fOldFlags);
2023}
2024
2025
2026int VBOXCALL supdrvOSMsrProberRead(uint32_t uMsr, RTCPUID idCpu, uint64_t *puValue)
2027{
2028 SUPDRVNTMSPROBERARGS Args;
2029 Args.uMsr = uMsr;
2030 Args.uValue = 0;
2031 Args.fGp = true;
2032
2033 if (idCpu == NIL_RTCPUID)
2034 supdrvNtMsProberReadOnCpu(idCpu, &Args, NULL);
2035 else
2036 {
2037 int rc = RTMpOnSpecific(idCpu, supdrvNtMsProberReadOnCpu, &Args, NULL);
2038 if (RT_FAILURE(rc))
2039 return rc;
2040 }
2041
2042 if (Args.fGp)
2043 return VERR_ACCESS_DENIED;
2044 *puValue = Args.uValue;
2045 return VINF_SUCCESS;
2046}
2047
2048
2049/** @callback_method_impl{FNRTMPWORKER, Worker for supdrvOSMsrProberWrite.} */
2050static DECLCALLBACK(void) supdrvNtMsProberWriteOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
2051{
2052 /*
2053 * rdmsr and wrmsr faults can be caught even with interrupts disabled.
2054 * (At least on 32-bit XP.)
2055 */
2056 SUPDRVNTMSPROBERARGS *pArgs = (SUPDRVNTMSPROBERARGS *)pvUser1; NOREF(idCpu); NOREF(pvUser2);
2057 RTCCUINTREG fOldFlags = ASMIntDisableFlags();
2058 __try
2059 {
2060 ASMWrMsrEx(pArgs->uMsr, AMD_MSR_PASSCODE, pArgs->uValue);
2061 pArgs->fGp = false;
2062 }
2063 __except(EXCEPTION_EXECUTE_HANDLER)
2064 {
2065 pArgs->fGp = true;
2066 }
2067 ASMSetFlags(fOldFlags);
2068}
2069
2070int VBOXCALL supdrvOSMsrProberWrite(uint32_t uMsr, RTCPUID idCpu, uint64_t uValue)
2071{
2072 SUPDRVNTMSPROBERARGS Args;
2073 Args.uMsr = uMsr;
2074 Args.uValue = uValue;
2075 Args.fGp = true;
2076
2077 if (idCpu == NIL_RTCPUID)
2078 supdrvNtMsProberReadOnCpu(idCpu, &Args, NULL);
2079 else
2080 {
2081 int rc = RTMpOnSpecific(idCpu, supdrvNtMsProberReadOnCpu, &Args, NULL);
2082 if (RT_FAILURE(rc))
2083 return rc;
2084 }
2085
2086 if (Args.fGp)
2087 return VERR_ACCESS_DENIED;
2088 return VINF_SUCCESS;
2089}
2090
2091/** @callback_method_impl{FNRTMPWORKER, Worker for supdrvOSMsrProberModify.} */
2092static DECLCALLBACK(void) supdrvNtMsProberModifyOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
2093{
2094 PSUPMSRPROBER pReq = (PSUPMSRPROBER)pvUser1;
2095 register uint32_t uMsr = pReq->u.In.uMsr;
2096 bool const fFaster = pReq->u.In.enmOp == SUPMSRPROBEROP_MODIFY_FASTER;
2097 uint64_t uBefore = 0;
2098 uint64_t uWritten = 0;
2099 uint64_t uAfter = 0;
2100 bool fBeforeGp = true;
2101 bool fModifyGp = true;
2102 bool fAfterGp = true;
2103 bool fRestoreGp = true;
2104 RTCCUINTREG fOldFlags;
2105
2106 /*
2107 * Do the job.
2108 */
2109 fOldFlags = ASMIntDisableFlags();
2110 ASMCompilerBarrier(); /* paranoia */
2111 if (!fFaster)
2112 ASMWriteBackAndInvalidateCaches();
2113
2114 __try
2115 {
2116 uBefore = ASMRdMsrEx(uMsr, AMD_MSR_PASSCODE);
2117 fBeforeGp = false;
2118 }
2119 __except(EXCEPTION_EXECUTE_HANDLER)
2120 {
2121 fBeforeGp = true;
2122 }
2123 if (!fBeforeGp)
2124 {
2125 register uint64_t uRestore = uBefore;
2126
2127 /* Modify. */
2128 uWritten = uRestore;
2129 uWritten &= pReq->u.In.uArgs.Modify.fAndMask;
2130 uWritten |= pReq->u.In.uArgs.Modify.fOrMask;
2131 __try
2132 {
2133 ASMWrMsrEx(uMsr, AMD_MSR_PASSCODE, uWritten);
2134 fModifyGp = false;
2135 }
2136 __except(EXCEPTION_EXECUTE_HANDLER)
2137 {
2138 fModifyGp = true;
2139 }
2140
2141 /* Read modified value. */
2142 __try
2143 {
2144 uAfter = ASMRdMsrEx(uMsr, AMD_MSR_PASSCODE);
2145 fAfterGp = false;
2146 }
2147 __except(EXCEPTION_EXECUTE_HANDLER)
2148 {
2149 fAfterGp = true;
2150 }
2151
2152 /* Restore original value. */
2153 __try
2154 {
2155 ASMWrMsrEx(uMsr, AMD_MSR_PASSCODE, uRestore);
2156 fRestoreGp = false;
2157 }
2158 __except(EXCEPTION_EXECUTE_HANDLER)
2159 {
2160 fRestoreGp = true;
2161 }
2162
2163 /* Invalid everything we can. */
2164 if (!fFaster)
2165 {
2166 ASMWriteBackAndInvalidateCaches();
2167 ASMReloadCR3();
2168 ASMNopPause();
2169 }
2170 }
2171
2172 ASMCompilerBarrier(); /* paranoia */
2173 ASMSetFlags(fOldFlags);
2174
2175 /*
2176 * Write out the results.
2177 */
2178 pReq->u.Out.uResults.Modify.uBefore = uBefore;
2179 pReq->u.Out.uResults.Modify.uWritten = uWritten;
2180 pReq->u.Out.uResults.Modify.uAfter = uAfter;
2181 pReq->u.Out.uResults.Modify.fBeforeGp = fBeforeGp;
2182 pReq->u.Out.uResults.Modify.fModifyGp = fModifyGp;
2183 pReq->u.Out.uResults.Modify.fAfterGp = fAfterGp;
2184 pReq->u.Out.uResults.Modify.fRestoreGp = fRestoreGp;
2185 RT_ZERO(pReq->u.Out.uResults.Modify.afReserved);
2186}
2187
2188
2189int VBOXCALL supdrvOSMsrProberModify(RTCPUID idCpu, PSUPMSRPROBER pReq)
2190{
2191 if (idCpu == NIL_RTCPUID)
2192 {
2193 supdrvNtMsProberModifyOnCpu(idCpu, pReq, NULL);
2194 return VINF_SUCCESS;
2195 }
2196 return RTMpOnSpecific(idCpu, supdrvNtMsProberModifyOnCpu, pReq, NULL);
2197}
2198
2199#endif /* SUPDRV_WITH_MSR_PROBER */
2200
2201
2202/**
2203 * Converts an IPRT error code to an nt status code.
2204 *
2205 * @returns corresponding nt status code.
2206 * @param rc IPRT error status code.
2207 */
2208static NTSTATUS VBoxDrvNtErr2NtStatus(int rc)
2209{
2210 switch (rc)
2211 {
2212 case VINF_SUCCESS: return STATUS_SUCCESS;
2213 case VERR_GENERAL_FAILURE: return STATUS_NOT_SUPPORTED;
2214 case VERR_INVALID_PARAMETER: return STATUS_INVALID_PARAMETER;
2215 case VERR_INVALID_MAGIC: return STATUS_UNKNOWN_REVISION;
2216 case VERR_INVALID_HANDLE: return STATUS_INVALID_HANDLE;
2217 case VERR_INVALID_POINTER: return STATUS_INVALID_ADDRESS;
2218 case VERR_LOCK_FAILED: return STATUS_NOT_LOCKED;
2219 case VERR_ALREADY_LOADED: return STATUS_IMAGE_ALREADY_LOADED;
2220 case VERR_PERMISSION_DENIED: return STATUS_ACCESS_DENIED;
2221 case VERR_VERSION_MISMATCH: return STATUS_REVISION_MISMATCH;
2222 }
2223
2224 if (rc < 0)
2225 {
2226 if (((uint32_t)rc & UINT32_C(0xffff0000)) == UINT32_C(0xffff0000))
2227 return (NTSTATUS)( ((uint32_t)rc & UINT32_C(0xffff)) | SUP_NT_STATUS_BASE );
2228 }
2229 return STATUS_UNSUCCESSFUL;
2230}
2231
2232
2233#if 0 /* See alternative in SUPDrvA-win.asm */
2234/**
2235 * Alternative version of SUPR0Printf for Windows.
2236 *
2237 * @returns 0.
2238 * @param pszFormat The format string.
2239 */
2240SUPR0DECL(int) SUPR0Printf(const char *pszFormat, ...)
2241{
2242 va_list va;
2243 char szMsg[512];
2244
2245 va_start(va, pszFormat);
2246 size_t cch = RTStrPrintfV(szMsg, sizeof(szMsg) - 1, pszFormat, va);
2247 szMsg[sizeof(szMsg) - 1] = '\0';
2248 va_end(va);
2249
2250 RTLogWriteDebugger(szMsg, cch);
2251 return 0;
2252}
2253#endif
2254
2255
2256SUPR0DECL(uint32_t) SUPR0GetKernelFeatures(void)
2257{
2258 return 0;
2259}
2260
2261
2262#ifdef VBOX_WITH_HARDENING
2263
2264/** @name Identifying Special Processes: CSRSS.EXE
2265 * @{ */
2266
2267
2268/**
2269 * Checks if the process is a system32 process by the given name.
2270 *
2271 * @returns true / false.
2272 * @param pProcess The process to check.
2273 * @param pszName The lower case process name (no path!).
2274 */
2275static bool supdrvNtProtectIsSystem32ProcessMatch(PEPROCESS pProcess, const char *pszName)
2276{
2277 Assert(strlen(pszName) < 16); /* see buffer below */
2278
2279 /*
2280 * This test works on XP+.
2281 */
2282 const char *pszImageFile = (const char *)PsGetProcessImageFileName(pProcess);
2283 if (!pszImageFile)
2284 return false;
2285
2286 if (RTStrICmp(pszImageFile, pszName) != 0)
2287 return false;
2288
2289 /*
2290 * This test requires a Vista+ API.
2291 */
2292 if (g_pfnPsReferenceProcessFilePointer)
2293 {
2294 PFILE_OBJECT pFile = NULL;
2295 NTSTATUS rcNt = g_pfnPsReferenceProcessFilePointer(pProcess, &pFile);
2296 if (!NT_SUCCESS(rcNt))
2297 return false;
2298
2299 union
2300 {
2301 OBJECT_NAME_INFORMATION Info;
2302 uint8_t abBuffer[sizeof(g_System32NtPath) + 16 * sizeof(WCHAR)];
2303 } Buf;
2304 ULONG cbIgn;
2305 rcNt = ObQueryNameString(pFile, &Buf.Info, sizeof(Buf) - sizeof(WCHAR), &cbIgn);
2306 ObDereferenceObject(pFile);
2307 if (!NT_SUCCESS(rcNt))
2308 return false;
2309
2310 /* Terminate the name. */
2311 PRTUTF16 pwszName = Buf.Info.Name.Buffer;
2312 pwszName[Buf.Info.Name.Length / sizeof(RTUTF16)] = '\0';
2313
2314 /* Match the name against the system32 directory path. */
2315 uint32_t cbSystem32 = g_System32NtPath.UniStr.Length;
2316 if (Buf.Info.Name.Length < cbSystem32)
2317 return false;
2318 if (memcmp(pwszName, g_System32NtPath.UniStr.Buffer, cbSystem32))
2319 return false;
2320 pwszName += cbSystem32 / sizeof(RTUTF16);
2321 if (*pwszName++ != '\\')
2322 return false;
2323
2324 /* Compare the name. */
2325 const char *pszRight = pszName;
2326 for (;;)
2327 {
2328 WCHAR wchLeft = *pwszName++;
2329 char chRight = *pszRight++;
2330 Assert(chRight == RT_C_TO_LOWER(chRight));
2331
2332 if ( wchLeft != chRight
2333 && RT_C_TO_LOWER(wchLeft) != chRight)
2334 return false;
2335 if (!chRight)
2336 break;
2337 }
2338 }
2339
2340 return true;
2341}
2342
2343
2344/**
2345 * Checks if the current process is likely to be CSRSS.
2346 *
2347 * @returns true/false.
2348 * @param pProcess The process.
2349 */
2350static bool supdrvNtProtectIsCsrssByProcess(PEPROCESS pProcess)
2351{
2352 /*
2353 * On Windows 8.1 CSRSS.EXE is a protected process.
2354 */
2355 if (g_pfnPsIsProtectedProcessLight)
2356 {
2357 if (!g_pfnPsIsProtectedProcessLight(pProcess))
2358 return false;
2359 }
2360
2361 /*
2362 * The name tests.
2363 */
2364 if (!supdrvNtProtectIsSystem32ProcessMatch(pProcess, "csrss.exe"))
2365 return false;
2366
2367 /** @todo Could extend the CSRSS.EXE check with that the TokenUser of the
2368 * current process must be "NT AUTHORITY\SYSTEM" (S-1-5-18). */
2369
2370 return true;
2371}
2372
2373
2374/**
2375 * Helper for supdrvNtProtectGetAlpcPortObjectType that tries out a name.
2376 *
2377 * @returns true if done, false if not.
2378 * @param pwszPortNm The port path.
2379 * @param ppObjType The object type return variable, updated when
2380 * returning true.
2381 */
2382static bool supdrvNtProtectGetAlpcPortObjectType2(PCRTUTF16 pwszPortNm, POBJECT_TYPE *ppObjType)
2383{
2384 bool fDone = false;
2385
2386 UNICODE_STRING UniStrPortNm;
2387 UniStrPortNm.Buffer = (WCHAR *)pwszPortNm;
2388 UniStrPortNm.Length = (USHORT)(RTUtf16Len(pwszPortNm) * sizeof(WCHAR));
2389 UniStrPortNm.MaximumLength = UniStrPortNm.Length + sizeof(WCHAR);
2390
2391 OBJECT_ATTRIBUTES ObjAttr;
2392 InitializeObjectAttributes(&ObjAttr, &UniStrPortNm, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL);
2393
2394 HANDLE hPort;
2395 NTSTATUS rcNt = g_pfnZwAlpcCreatePort(&hPort, &ObjAttr, NULL /*pPortAttribs*/);
2396 if (NT_SUCCESS(rcNt))
2397 {
2398 PVOID pvObject;
2399 rcNt = ObReferenceObjectByHandle(hPort, 0 /*DesiredAccess*/, NULL /*pObjectType*/,
2400 KernelMode, &pvObject, NULL /*pHandleInfo*/);
2401 if (NT_SUCCESS(rcNt))
2402 {
2403 POBJECT_TYPE pObjType = g_pfnObGetObjectType(pvObject);
2404 if (pObjType)
2405 {
2406 SUPR0Printf("vboxdrv: ALPC Port Object Type %p (vs %p)\n", pObjType, *ppObjType);
2407 *ppObjType = pObjType;
2408 fDone = true;
2409 }
2410 ObDereferenceObject(pvObject);
2411 }
2412 NtClose(hPort);
2413 }
2414 return fDone;
2415}
2416
2417
2418/**
2419 * Attempts to retrieve the ALPC Port object type.
2420 *
2421 * We've had at least three reports that using LpcPortObjectType when trying to
2422 * get at the ApiPort object results in STATUS_OBJECT_TYPE_MISMATCH errors.
2423 * It's not known who has modified LpcPortObjectType or AlpcPortObjectType (not
2424 * exported) so that it differs from the actual ApiPort type, or maybe this
2425 * unknown entity is intercepting our attempt to reference the port and
2426 * tries to mislead us. The paranoid explanataion is of course that some evil
2427 * root kit like software is messing with the OS, however, it's possible that
2428 * this is valid kernel behavior that 99.8% of our users and 100% of the
2429 * developers are not triggering for some reason.
2430 *
2431 * The code here creates an ALPC port object and gets it's type. It will cache
2432 * the result in g_pAlpcPortObjectType2 on success.
2433 *
2434 * @returns Object type.
2435 * @param uSessionId The session id.
2436 * @param pszSessionId The session id formatted as a string.
2437 */
2438static POBJECT_TYPE supdrvNtProtectGetAlpcPortObjectType(uint32_t uSessionId, const char *pszSessionId)
2439{
2440 POBJECT_TYPE pObjType = *LpcPortObjectType;
2441
2442 if ( g_pfnZwAlpcCreatePort
2443 && g_pfnObGetObjectType)
2444 {
2445 int rc;
2446 ssize_t cchTmp; NOREF(cchTmp);
2447 char szTmp[16];
2448 RTUTF16 wszPortNm[128];
2449 size_t offRand;
2450
2451 /*
2452 * First attempt is in the session directory.
2453 */
2454 rc = RTUtf16CopyAscii(wszPortNm, RT_ELEMENTS(wszPortNm), "\\Sessions\\");
2455 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), pszSessionId);
2456 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), "\\VBoxDrv-");
2457 cchTmp = RTStrFormatU32(szTmp, sizeof(szTmp), (uint32_t)(uintptr_t)PsGetProcessId(PsGetCurrentProcess()), 16, 0, 0, 0);
2458 Assert(cchTmp > 0);
2459 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), szTmp);
2460 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), "-");
2461 offRand = RTUtf16Len(wszPortNm);
2462 cchTmp = RTStrFormatU32(szTmp, sizeof(szTmp), RTRandU32(), 16, 0, 0, 0);
2463 Assert(cchTmp > 0);
2464 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), szTmp);
2465 AssertRCSuccess(rc);
2466
2467 bool fDone = supdrvNtProtectGetAlpcPortObjectType2(wszPortNm, &pObjType);
2468 if (!fDone)
2469 {
2470 wszPortNm[offRand] = '\0';
2471 cchTmp = RTStrFormatU32(szTmp, sizeof(szTmp), RTRandU32(), 16, 0, 0, 0); Assert(cchTmp > 0);
2472 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), szTmp);
2473 AssertRCSuccess(rc);
2474
2475 fDone = supdrvNtProtectGetAlpcPortObjectType2(wszPortNm, &pObjType);
2476 }
2477 if (!fDone)
2478 {
2479 /*
2480 * Try base names.
2481 */
2482 if (uSessionId == 0)
2483 rc = RTUtf16CopyAscii(wszPortNm, RT_ELEMENTS(wszPortNm), "\\BaseNamedObjects\\VBoxDrv-");
2484 else
2485 {
2486 rc = RTUtf16CopyAscii(wszPortNm, RT_ELEMENTS(wszPortNm), "\\Sessions\\");
2487 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), pszSessionId);
2488 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), "\\BaseNamedObjects\\VBoxDrv-");
2489 }
2490 cchTmp = RTStrFormatU32(szTmp, sizeof(szTmp), (uint32_t)(uintptr_t)PsGetProcessId(PsGetCurrentProcess()), 16, 0, 0, 0);
2491 Assert(cchTmp > 0);
2492 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), szTmp);
2493 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), "-");
2494 offRand = RTUtf16Len(wszPortNm);
2495 cchTmp = RTStrFormatU32(szTmp, sizeof(szTmp), RTRandU32(), 16, 0, 0, 0);
2496 Assert(cchTmp > 0);
2497 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), szTmp);
2498 AssertRCSuccess(rc);
2499
2500 bool fDone = supdrvNtProtectGetAlpcPortObjectType2(wszPortNm, &pObjType);
2501 if (!fDone)
2502 {
2503 wszPortNm[offRand] = '\0';
2504 cchTmp = RTStrFormatU32(szTmp, sizeof(szTmp), RTRandU32(), 16, 0, 0, 0);
2505 Assert(cchTmp > 0);
2506 rc |= RTUtf16CatAscii(wszPortNm, RT_ELEMENTS(wszPortNm), szTmp);
2507 AssertRCSuccess(rc);
2508
2509 fDone = supdrvNtProtectGetAlpcPortObjectType2(wszPortNm, &pObjType);
2510 }
2511 }
2512
2513 /* Cache the result in g_pAlpcPortObjectType2. */
2514 if ( g_pAlpcPortObjectType2 == NULL
2515 && pObjType != g_pAlpcPortObjectType1
2516 && fDone)
2517 g_pAlpcPortObjectType2 = pObjType;
2518
2519 }
2520
2521 return pObjType;
2522}
2523
2524
2525/**
2526 * Called in the context of VBoxDrvNtCreate to determin the CSRSS for the
2527 * current process.
2528 *
2529 * The Client/Server Runtime Subsystem (CSRSS) process needs to be allowed some
2530 * additional access right so we need to make 101% sure we correctly identify
2531 * the CSRSS process a process is associated with.
2532 *
2533 * @returns IPRT status code.
2534 * @param pNtProtect The NT protected process structure. The
2535 * hCsrssPid member will be updated on success.
2536 */
2537static int supdrvNtProtectFindAssociatedCsrss(PSUPDRVNTPROTECT pNtProtect)
2538{
2539 Assert(pNtProtect->AvlCore.Key == PsGetCurrentProcessId());
2540 Assert(pNtProtect->pCsrssProcess == NULL);
2541 Assert(pNtProtect->hCsrssPid == NULL);
2542
2543 /*
2544 * We'll try use the ApiPort LPC object for the session we're in to track
2545 * down the CSRSS process. So, we start by constructing a path to it.
2546 */
2547 int rc;
2548 uint32_t uSessionId = PsGetProcessSessionId(PsGetCurrentProcess());
2549 char szSessionId[16];
2550 WCHAR wszApiPort[48];
2551 if (uSessionId == 0)
2552 {
2553 szSessionId[0] = '0';
2554 szSessionId[1] = '\0';
2555 rc = RTUtf16CopyAscii(wszApiPort, RT_ELEMENTS(wszApiPort), "\\Windows\\ApiPort");
2556 }
2557 else
2558 {
2559 ssize_t cchTmp = RTStrFormatU32(szSessionId, sizeof(szSessionId), uSessionId, 10, 0, 0, 0);
2560 AssertReturn(cchTmp > 0, (int)cchTmp);
2561 rc = RTUtf16CopyAscii(wszApiPort, RT_ELEMENTS(wszApiPort), "\\Sessions\\");
2562 if (RT_SUCCESS(rc))
2563 rc = RTUtf16CatAscii(wszApiPort, RT_ELEMENTS(wszApiPort), szSessionId);
2564 if (RT_SUCCESS(rc))
2565 rc = RTUtf16CatAscii(wszApiPort, RT_ELEMENTS(wszApiPort), "\\Windows\\ApiPort");
2566 }
2567 AssertRCReturn(rc, rc);
2568
2569 UNICODE_STRING ApiPortStr;
2570 ApiPortStr.Buffer = wszApiPort;
2571 ApiPortStr.Length = (USHORT)(RTUtf16Len(wszApiPort) * sizeof(RTUTF16));
2572 ApiPortStr.MaximumLength = ApiPortStr.Length + sizeof(RTUTF16);
2573
2574 /*
2575 * The object cannot be opened, but we can reference it by name.
2576 */
2577 void *pvApiPortObj = NULL;
2578 NTSTATUS rcNt = ObReferenceObjectByName(&ApiPortStr,
2579 0,
2580 NULL /*pAccessState*/,
2581 STANDARD_RIGHTS_READ,
2582 g_pAlpcPortObjectType1,
2583 KernelMode,
2584 NULL /*pvParseContext*/,
2585 &pvApiPortObj);
2586 if ( rcNt == STATUS_OBJECT_TYPE_MISMATCH
2587 && g_pAlpcPortObjectType2 != NULL)
2588 rcNt = ObReferenceObjectByName(&ApiPortStr,
2589 0,
2590 NULL /*pAccessState*/,
2591 STANDARD_RIGHTS_READ,
2592 g_pAlpcPortObjectType2,
2593 KernelMode,
2594 NULL /*pvParseContext*/,
2595 &pvApiPortObj);
2596 if ( rcNt == STATUS_OBJECT_TYPE_MISMATCH
2597 && g_pfnObGetObjectType
2598 && g_pfnZwAlpcCreatePort)
2599 rcNt = ObReferenceObjectByName(&ApiPortStr,
2600 0,
2601 NULL /*pAccessState*/,
2602 STANDARD_RIGHTS_READ,
2603 supdrvNtProtectGetAlpcPortObjectType(uSessionId, szSessionId),
2604 KernelMode,
2605 NULL /*pvParseContext*/,
2606 &pvApiPortObj);
2607 if (!NT_SUCCESS(rcNt))
2608 {
2609 SUPR0Printf("vboxdrv: Error opening '%ls': %#x\n", wszApiPort, rcNt);
2610 return rcNt == STATUS_OBJECT_TYPE_MISMATCH ? VERR_SUPDRV_APIPORT_OPEN_ERROR_TYPE : VERR_SUPDRV_APIPORT_OPEN_ERROR;
2611 }
2612
2613 /*
2614 * Query the processes in the system so we can locate CSRSS.EXE candidates.
2615 * Note! Attempts at using SystemSessionProcessInformation failed with
2616 * STATUS_ACCESS_VIOLATION.
2617 * Note! The 32 bytes on the size of to counteract the allocation header
2618 * that rtR0MemAllocEx slaps on everything.
2619 */
2620 ULONG cbNeeded = _64K - 32;
2621 uint32_t cbBuf;
2622 uint8_t *pbBuf = NULL;
2623 do
2624 {
2625 cbBuf = RT_ALIGN(cbNeeded + _4K, _64K) - 32;
2626 pbBuf = (uint8_t *)RTMemAlloc(cbBuf);
2627 if (!pbBuf)
2628 break;
2629
2630 cbNeeded = 0;
2631#if 0 /* doesn't work. */
2632 SYSTEM_SESSION_PROCESS_INFORMATION Req;
2633 Req.SessionId = uSessionId;
2634 Req.BufferLength = cbBuf;
2635 Req.Buffer = pbBuf;
2636 rcNt = NtQuerySystemInformation(SystemSessionProcessInformation, &Req, sizeof(Req), &cbNeeded);
2637#else
2638 rcNt = NtQuerySystemInformation(SystemProcessInformation, pbBuf, cbBuf, &cbNeeded);
2639#endif
2640 if (NT_SUCCESS(rcNt))
2641 break;
2642
2643 RTMemFree(pbBuf);
2644 pbBuf = NULL;
2645 } while ( rcNt == STATUS_INFO_LENGTH_MISMATCH
2646 && cbNeeded > cbBuf
2647 && cbNeeded < 32U*_1M);
2648
2649 if ( pbBuf
2650 && NT_SUCCESS(rcNt)
2651 && cbNeeded >= sizeof(SYSTEM_PROCESS_INFORMATION))
2652 {
2653 /*
2654 * Walk the returned data and look for the process associated with the
2655 * ApiPort object. The ApiPort object keeps the EPROCESS address of
2656 * the owner process (i.e. CSRSS) relatively early in the structure. On
2657 * 64-bit windows 8.1 it's at offset 0x18. So, obtain the EPROCESS
2658 * pointer to likely CSRSS processes and check for a match in the first
2659 * 0x40 bytes of the ApiPort object.
2660 */
2661 rc = VERR_SUPDRV_CSRSS_NOT_FOUND;
2662 for (uint32_t offBuf = 0; offBuf <= cbNeeded - sizeof(SYSTEM_PROCESS_INFORMATION);)
2663 {
2664 PRTNT_SYSTEM_PROCESS_INFORMATION pProcInfo = (PRTNT_SYSTEM_PROCESS_INFORMATION)&pbBuf[offBuf];
2665 if ( pProcInfo->ProcessName.Length == 9 * sizeof(WCHAR)
2666 && pProcInfo->NumberOfThreads > 2 /* Very low guess. */
2667 && pProcInfo->HandleCount > 32 /* Very low guess, I hope. */
2668 && (uintptr_t)pProcInfo->ProcessName.Buffer - (uintptr_t)pbBuf < cbNeeded
2669 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[0]) == 'c'
2670 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[1]) == 's'
2671 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[2]) == 'r'
2672 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[3]) == 's'
2673 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[4]) == 's'
2674 && pProcInfo->ProcessName.Buffer[5] == '.'
2675 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[6]) == 'e'
2676 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[7]) == 'x'
2677 && RT_C_TO_LOWER(pProcInfo->ProcessName.Buffer[8]) == 'e' )
2678 {
2679
2680 /* Get the process structure and perform some more thorough
2681 process checks. */
2682 PEPROCESS pProcess;
2683 rcNt = PsLookupProcessByProcessId(pProcInfo->UniqueProcessId, &pProcess);
2684 if (NT_SUCCESS(rcNt))
2685 {
2686 if (supdrvNtProtectIsCsrssByProcess(pProcess))
2687 {
2688 if (PsGetProcessSessionId(pProcess) == uSessionId)
2689 {
2690 /* Final test, check the ApiPort.
2691 Note! The old LPC (pre Vista) objects has the PID
2692 much earlier in the structure. Might be
2693 worth looking for it instead. */
2694 bool fThatsIt = false;
2695 __try
2696 {
2697 PEPROCESS *ppPortProc = (PEPROCESS *)pvApiPortObj;
2698 uint32_t cTests = g_uNtVerCombined >= SUP_NT_VER_VISTA ? 16 : 38; /* ALPC since Vista. */
2699 do
2700 {
2701 fThatsIt = *ppPortProc == pProcess;
2702 ppPortProc++;
2703 } while (!fThatsIt && --cTests > 0);
2704 }
2705 __except(EXCEPTION_EXECUTE_HANDLER)
2706 {
2707 fThatsIt = false;
2708 }
2709 if (fThatsIt)
2710 {
2711 /* Ok, we found it! Keep the process structure
2712 reference as well as the PID so we can
2713 safely identify it later on. */
2714 pNtProtect->hCsrssPid = pProcInfo->UniqueProcessId;
2715 pNtProtect->pCsrssProcess = pProcess;
2716 rc = VINF_SUCCESS;
2717 break;
2718 }
2719 }
2720 }
2721
2722 ObDereferenceObject(pProcess);
2723 }
2724 }
2725
2726 /* Advance. */
2727 if (!pProcInfo->NextEntryOffset)
2728 break;
2729 offBuf += pProcInfo->NextEntryOffset;
2730 }
2731 }
2732 else
2733 rc = VERR_SUPDRV_SESSION_PROCESS_ENUM_ERROR;
2734 RTMemFree(pbBuf);
2735 ObDereferenceObject(pvApiPortObj);
2736 return rc;
2737}
2738
2739
2740/**
2741 * Checks that the given process is the CSRSS process associated with protected
2742 * process.
2743 *
2744 * @returns true / false.
2745 * @param pNtProtect The NT protection structure.
2746 * @param pCsrss The process structure of the alleged CSRSS.EXE
2747 * process.
2748 */
2749static bool supdrvNtProtectIsAssociatedCsrss(PSUPDRVNTPROTECT pNtProtect, PEPROCESS pCsrss)
2750{
2751 if (pNtProtect->pCsrssProcess == pCsrss)
2752 {
2753 if (pNtProtect->hCsrssPid == PsGetProcessId(pCsrss))
2754 {
2755 return true;
2756 }
2757 }
2758 return false;
2759}
2760
2761
2762/**
2763 * Checks if the given process is the stupid themes service.
2764 *
2765 * The caller does some screening of access masks and what not. We do the rest.
2766 *
2767 * @returns true / false.
2768 * @param pNtProtect The NT protection structure.
2769 * @param pAnnoyingProcess The process structure of an process that might
2770 * happen to be the annoying themes process.
2771 */
2772static bool supdrvNtProtectIsFrigginThemesService(PSUPDRVNTPROTECT pNtProtect, PEPROCESS pAnnoyingProcess)
2773{
2774 /*
2775 * Check the process name.
2776 */
2777 if (!supdrvNtProtectIsSystem32ProcessMatch(pAnnoyingProcess, "svchost.exe"))
2778 return false;
2779
2780 /** @todo Come up with more checks. */
2781
2782 return true;
2783}
2784
2785
2786#ifdef VBOX_WITHOUT_DEBUGGER_CHECKS
2787/**
2788 * Checks if the given process is one of the whitelisted debuggers.
2789 *
2790 * @returns true / false.
2791 * @param pProcess The process to check.
2792 */
2793static bool supdrvNtProtectIsWhitelistedDebugger(PEPROCESS pProcess)
2794{
2795 const char *pszImageFile = (const char *)PsGetProcessImageFileName(pProcess);
2796 if (!pszImageFile)
2797 return false;
2798
2799 if (pszImageFile[0] == 'w' || pszImageFile[0] == 'W')
2800 {
2801 if (RTStrICmp(pszImageFile, "windbg.exe") == 0)
2802 return true;
2803 if (RTStrICmp(pszImageFile, "werfault.exe") == 0)
2804 return true;
2805 if (RTStrICmp(pszImageFile, "werfaultsecure.exe") == 0)
2806 return true;
2807 }
2808 else if (pszImageFile[0] == 'd' || pszImageFile[0] == 'D')
2809 {
2810 if (RTStrICmp(pszImageFile, "drwtsn32.exe") == 0)
2811 return true;
2812 if (RTStrICmp(pszImageFile, "dwwin.exe") == 0)
2813 return true;
2814 }
2815
2816 return false;
2817}
2818#endif /* VBOX_WITHOUT_DEBUGGER_CHECKS */
2819
2820
2821/** @} */
2822
2823
2824/** @name Process Creation Callbacks.
2825 * @{ */
2826
2827
2828/**
2829 * Cleans up VBoxDrv or VBoxDrvStub error info not collected by the dead process.
2830 *
2831 * @param hProcessId The ID of the dead process.
2832 */
2833static void supdrvNtErrorInfoCleanupProcess(HANDLE hProcessId)
2834{
2835 int rc = RTSemMutexRequestNoResume(g_hErrorInfoLock, RT_INDEFINITE_WAIT);
2836 if (RT_SUCCESS(rc))
2837 {
2838 PSUPDRVNTERRORINFO pCur, pNext;
2839 RTListForEachSafe(&g_ErrorInfoHead, pCur, pNext, SUPDRVNTERRORINFO, ListEntry)
2840 {
2841 if (pCur->hProcessId == hProcessId)
2842 {
2843 RTListNodeRemove(&pCur->ListEntry);
2844 RTMemFree(pCur);
2845 }
2846 }
2847 RTSemMutexRelease(g_hErrorInfoLock);
2848 }
2849}
2850
2851
2852/**
2853 * Common worker used by the process creation hooks as well as the process
2854 * handle creation hooks to check if a VM process is being created.
2855 *
2856 * @returns true if likely to be a VM process, false if not.
2857 * @param pNtStub The NT protection structure for the possible
2858 * stub process.
2859 * @param hParentPid The parent pid.
2860 * @param hChildPid The child pid.
2861 */
2862static bool supdrvNtProtectIsSpawningStubProcess(PSUPDRVNTPROTECT pNtStub, HANDLE hParentPid, HANDLE hChildPid)
2863{
2864 bool fRc = false;
2865 if (pNtStub->AvlCore.Key == hParentPid) /* paranoia */
2866 {
2867 if (pNtStub->enmProcessKind == kSupDrvNtProtectKind_StubSpawning)
2868 {
2869 /* Compare short names. */
2870 PEPROCESS pStubProcess;
2871 NTSTATUS rcNt = PsLookupProcessByProcessId(hParentPid, &pStubProcess);
2872 if (NT_SUCCESS(rcNt))
2873 {
2874 PEPROCESS pChildProcess;
2875 rcNt = PsLookupProcessByProcessId(hChildPid, &pChildProcess);
2876 if (NT_SUCCESS(rcNt))
2877 {
2878 const char *pszStub = (const char *)PsGetProcessImageFileName(pStubProcess);
2879 const char *pszChild = (const char *)PsGetProcessImageFileName(pChildProcess);
2880 fRc = pszStub != NULL
2881 && pszChild != NULL
2882 && strcmp(pszStub, pszChild) == 0;
2883
2884 /** @todo check that the full image names matches. */
2885
2886 ObDereferenceObject(pChildProcess);
2887 }
2888 ObDereferenceObject(pStubProcess);
2889 }
2890 }
2891 }
2892 return fRc;
2893}
2894
2895
2896/**
2897 * Common code used by the notifies to protect a child process.
2898 *
2899 * @returns VBox status code.
2900 * @param pNtStub The NT protect structure for the parent.
2901 * @param hChildPid The child pid.
2902 */
2903static int supdrvNtProtectProtectNewStubChild(PSUPDRVNTPROTECT pNtParent, HANDLE hChildPid)
2904{
2905 /*
2906 * Create a child protection struction.
2907 */
2908 PSUPDRVNTPROTECT pNtChild;
2909 int rc = supdrvNtProtectCreate(&pNtChild, hChildPid, kSupDrvNtProtectKind_VmProcessUnconfirmed, false /*fLink*/);
2910 if (RT_SUCCESS(rc))
2911 {
2912 pNtChild->fFirstProcessCreateHandle = true;
2913 pNtChild->fFirstThreadCreateHandle = true;
2914 pNtChild->fCsrssFirstProcessCreateHandle = true;
2915 pNtChild->cCsrssFirstProcessDuplicateHandle = ARCH_BITS == 32 ? 2 : 1;
2916 pNtChild->fThemesFirstProcessCreateHandle = true;
2917 pNtChild->hParentPid = pNtParent->AvlCore.Key;
2918 pNtChild->hCsrssPid = pNtParent->hCsrssPid;
2919 pNtChild->pCsrssProcess = pNtParent->pCsrssProcess;
2920 if (pNtChild->pCsrssProcess)
2921 ObReferenceObject(pNtChild->pCsrssProcess);
2922
2923 /*
2924 * Take the spinlock, recheck parent conditions and link things.
2925 */
2926 RTSpinlockAcquire(g_hNtProtectLock);
2927 if (pNtParent->enmProcessKind == kSupDrvNtProtectKind_StubSpawning)
2928 {
2929 bool fSuccess = RTAvlPVInsert(&g_NtProtectTree, &pNtChild->AvlCore);
2930 if (fSuccess)
2931 {
2932 pNtParent->u.pChild = pNtChild; /* Parent keeps the initial reference. */
2933 pNtParent->enmProcessKind = kSupDrvNtProtectKind_StubParent;
2934 pNtChild->u.pParent = pNtParent;
2935
2936 RTSpinlockRelease(g_hNtProtectLock);
2937 return VINF_SUCCESS;
2938 }
2939
2940 rc = VERR_INTERNAL_ERROR_2;
2941 }
2942 else
2943 rc = VERR_WRONG_ORDER;
2944 pNtChild->enmProcessKind = kSupDrvNtProtectKind_VmProcessDead;
2945 RTSpinlockRelease(g_hNtProtectLock);
2946
2947 supdrvNtProtectRelease(pNtChild);
2948 }
2949 return rc;
2950}
2951
2952
2953/**
2954 * Common process termination code.
2955 *
2956 * Transitions protected process to the dead states, protecting against handle
2957 * PID reuse (esp. with unconfirmed VM processes) and handle cleanup issues.
2958 *
2959 * @param hDeadPid The PID of the dead process.
2960 */
2961static void supdrvNtProtectUnprotectDeadProcess(HANDLE hDeadPid)
2962{
2963 PSUPDRVNTPROTECT pNtProtect = supdrvNtProtectLookup(hDeadPid);
2964 if (pNtProtect)
2965 {
2966 PSUPDRVNTPROTECT pNtChild = NULL;
2967
2968 RTSpinlockAcquire(g_hNtProtectLock);
2969
2970 /*
2971 * If this is an unconfirmed VM process, we must release the reference
2972 * the parent structure holds.
2973 */
2974 if (pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed)
2975 {
2976 PSUPDRVNTPROTECT pNtParent = pNtProtect->u.pParent;
2977 AssertRelease(pNtParent); AssertRelease(pNtParent->u.pChild == pNtProtect);
2978 pNtParent->u.pChild = NULL;
2979 pNtProtect->u.pParent = NULL;
2980 pNtChild = pNtProtect;
2981 }
2982 /*
2983 * If this is a stub exitting before the VM process gets confirmed,
2984 * release the protection of the potential VM process as this is not
2985 * the prescribed behavior.
2986 */
2987 else if ( pNtProtect->enmProcessKind == kSupDrvNtProtectKind_StubParent
2988 && pNtProtect->u.pChild)
2989 {
2990 pNtChild = pNtProtect->u.pChild;
2991 pNtProtect->u.pChild = NULL;
2992 pNtChild->u.pParent = NULL;
2993 pNtChild->enmProcessKind = kSupDrvNtProtectKind_VmProcessDead;
2994 }
2995
2996 /*
2997 * Transition it to the dead state to prevent it from opening the
2998 * support driver again or be posthumously abused as a vm process parent.
2999 */
3000 if ( pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed
3001 || pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessConfirmed)
3002 pNtProtect->enmProcessKind = kSupDrvNtProtectKind_VmProcessDead;
3003 else if ( pNtProtect->enmProcessKind == kSupDrvNtProtectKind_StubParent
3004 || pNtProtect->enmProcessKind == kSupDrvNtProtectKind_StubSpawning
3005 || pNtProtect->enmProcessKind == kSupDrvNtProtectKind_StubUnverified)
3006 pNtProtect->enmProcessKind = kSupDrvNtProtectKind_StubDead;
3007
3008 RTSpinlockRelease(g_hNtProtectLock);
3009
3010 supdrvNtProtectRelease(pNtProtect);
3011 supdrvNtProtectRelease(pNtChild);
3012
3013 /*
3014 * Do session cleanups.
3015 */
3016 AssertReturnVoid((HANDLE)(uintptr_t)RTProcSelf() == hDeadPid);
3017 if (g_pDevObjSys)
3018 {
3019 PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)g_pDevObjSys->DeviceExtension;
3020 PSUPDRVSESSION pSession = supdrvSessionHashTabLookup(pDevExt, (RTPROCESS)(uintptr_t)hDeadPid,
3021 RTR0ProcHandleSelf(), NULL);
3022 if (pSession)
3023 {
3024 supdrvSessionHashTabRemove(pDevExt, pSession, NULL);
3025 supdrvSessionRelease(pSession); /* Drops the reference from supdrvSessionHashTabLookup. */
3026 }
3027 }
3028 }
3029}
3030
3031
3032/**
3033 * Common worker for the process creation callback that verifies a new child
3034 * being created by the handle creation callback code.
3035 *
3036 * @param pNtStub The parent.
3037 * @param pNtVm The child.
3038 * @param fCallerChecks The result of any additional tests the caller made.
3039 * This is in order to avoid duplicating the failure
3040 * path code.
3041 */
3042static void supdrvNtProtectVerifyNewChildProtection(PSUPDRVNTPROTECT pNtStub, PSUPDRVNTPROTECT pNtVm, bool fCallerChecks)
3043{
3044 if ( fCallerChecks
3045 && pNtStub->enmProcessKind == kSupDrvNtProtectKind_StubParent
3046 && pNtVm->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed
3047 && pNtVm->u.pParent == pNtStub
3048 && pNtStub->u.pChild == pNtVm)
3049 {
3050 /* Fine, reset the CSRSS hack (fixes ViRobot APT Shield 2.0 issue). */
3051 pNtVm->fFirstProcessCreateHandle = true;
3052 return;
3053 }
3054
3055 LogRel(("vboxdrv: Misdetected vm stub; hParentPid=%p hChildPid=%p\n", pNtStub->AvlCore.Key, pNtVm->AvlCore.Key));
3056 if (pNtStub->enmProcessKind != kSupDrvNtProtectKind_VmProcessConfirmed)
3057 supdrvNtProtectUnprotectDeadProcess(pNtVm->AvlCore.Key);
3058}
3059
3060
3061/**
3062 * Old style callback (since forever).
3063 *
3064 * @param hParentPid The parent PID.
3065 * @param hNewPid The PID of the new child.
3066 * @param fCreated TRUE if it's a creation notification,
3067 * FALSE if termination.
3068 * @remarks ASSUMES this arrives before the handle creation callback.
3069 */
3070static VOID __stdcall
3071supdrvNtProtectCallback_ProcessCreateNotify(HANDLE hParentPid, HANDLE hNewPid, BOOLEAN fCreated)
3072{
3073 /*
3074 * Is it a new process that needs protection?
3075 */
3076 if (fCreated)
3077 {
3078 PSUPDRVNTPROTECT pNtStub = supdrvNtProtectLookup(hParentPid);
3079 if (pNtStub)
3080 {
3081 PSUPDRVNTPROTECT pNtVm = supdrvNtProtectLookup(hNewPid);
3082 if (!pNtVm)
3083 {
3084 if (supdrvNtProtectIsSpawningStubProcess(pNtStub, hParentPid, hNewPid))
3085 supdrvNtProtectProtectNewStubChild(pNtStub, hNewPid);
3086 }
3087 else
3088 {
3089 supdrvNtProtectVerifyNewChildProtection(pNtStub, pNtVm, true);
3090 supdrvNtProtectRelease(pNtVm);
3091 }
3092 supdrvNtProtectRelease(pNtStub);
3093 }
3094 }
3095 /*
3096 * Process termination, do clean ups.
3097 */
3098 else
3099 {
3100 supdrvNtProtectUnprotectDeadProcess(hNewPid);
3101 supdrvNtErrorInfoCleanupProcess(hNewPid);
3102 }
3103}
3104
3105
3106/**
3107 * New style callback (Vista SP1+ / w2k8).
3108 *
3109 * @param pNewProcess The new process.
3110 * @param hNewPid The PID of the new process.
3111 * @param pInfo Process creation details. NULL if process
3112 * termination notification.
3113 * @remarks ASSUMES this arrives before the handle creation callback.
3114 */
3115static VOID __stdcall
3116supdrvNtProtectCallback_ProcessCreateNotifyEx(PEPROCESS pNewProcess, HANDLE hNewPid, PPS_CREATE_NOTIFY_INFO pInfo)
3117{
3118 /*
3119 * Is it a new process that needs protection?
3120 */
3121 if (pInfo)
3122 {
3123 PSUPDRVNTPROTECT pNtStub = supdrvNtProtectLookup(pInfo->CreatingThreadId.UniqueProcess);
3124
3125 Log(("vboxdrv/NewProcessEx: ctx=%04zx/%p pid=%04zx ppid=%04zx ctor=%04zx/%04zx rcNt=%#x %.*ls\n",
3126 PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3127 hNewPid, pInfo->ParentProcessId,
3128 pInfo->CreatingThreadId.UniqueProcess, pInfo->CreatingThreadId.UniqueThread, pInfo->CreationStatus,
3129 pInfo->FileOpenNameAvailable && pInfo->ImageFileName ? (size_t)pInfo->ImageFileName->Length / 2 : 0,
3130 pInfo->FileOpenNameAvailable && pInfo->ImageFileName ? pInfo->ImageFileName->Buffer : NULL));
3131
3132 if (pNtStub)
3133 {
3134 PSUPDRVNTPROTECT pNtVm = supdrvNtProtectLookup(hNewPid);
3135 if (!pNtVm)
3136 {
3137 /* Parent must be creator. */
3138 if (pInfo->CreatingThreadId.UniqueProcess == pInfo->ParentProcessId)
3139 {
3140 if (supdrvNtProtectIsSpawningStubProcess(pNtStub, pInfo->ParentProcessId, hNewPid))
3141 supdrvNtProtectProtectNewStubChild(pNtStub, hNewPid);
3142 }
3143 }
3144 else
3145 {
3146 /* Parent must be creator (as above). */
3147 supdrvNtProtectVerifyNewChildProtection(pNtStub, pNtVm,
3148 pInfo->CreatingThreadId.UniqueProcess == pInfo->ParentProcessId);
3149 supdrvNtProtectRelease(pNtVm);
3150 }
3151 supdrvNtProtectRelease(pNtStub);
3152 }
3153 }
3154 /*
3155 * Process termination, do clean ups.
3156 */
3157 else
3158 {
3159 supdrvNtProtectUnprotectDeadProcess(hNewPid);
3160 supdrvNtErrorInfoCleanupProcess(hNewPid);
3161 }
3162}
3163
3164/** @} */
3165
3166
3167/** @name Process Handle Callbacks.
3168 * @{ */
3169
3170/** Process rights that we allow for handles to stub and VM processes. */
3171# define SUPDRV_NT_ALLOW_PROCESS_RIGHTS \
3172 ( PROCESS_TERMINATE \
3173 | PROCESS_VM_READ \
3174 | PROCESS_QUERY_INFORMATION \
3175 | PROCESS_QUERY_LIMITED_INFORMATION \
3176 | PROCESS_SUSPEND_RESUME \
3177 | DELETE \
3178 | READ_CONTROL \
3179 | SYNCHRONIZE)
3180
3181/** Evil process rights. */
3182# define SUPDRV_NT_EVIL_PROCESS_RIGHTS \
3183 ( PROCESS_CREATE_THREAD \
3184 | PROCESS_SET_SESSIONID /*?*/ \
3185 | PROCESS_VM_OPERATION \
3186 | PROCESS_VM_WRITE \
3187 | PROCESS_DUP_HANDLE \
3188 | PROCESS_CREATE_PROCESS /*?*/ \
3189 | PROCESS_SET_QUOTA /*?*/ \
3190 | PROCESS_SET_INFORMATION \
3191 | PROCESS_SET_LIMITED_INFORMATION /*?*/ \
3192 | 0)
3193AssertCompile((SUPDRV_NT_ALLOW_PROCESS_RIGHTS & SUPDRV_NT_EVIL_PROCESS_RIGHTS) == 0);
3194
3195
3196static OB_PREOP_CALLBACK_STATUS __stdcall
3197supdrvNtProtectCallback_ProcessHandlePre(PVOID pvUser, POB_PRE_OPERATION_INFORMATION pOpInfo)
3198{
3199 Assert(pvUser == NULL);
3200 Assert(pOpInfo->Operation == OB_OPERATION_HANDLE_CREATE || pOpInfo->Operation == OB_OPERATION_HANDLE_DUPLICATE);
3201 Assert(pOpInfo->ObjectType == *PsProcessType);
3202
3203 /*
3204 * Protected? Kludge required for NtOpenProcess calls comming in before
3205 * the create process hook triggers on Windows 8.1 (possibly others too).
3206 */
3207 HANDLE hObjPid = PsGetProcessId((PEPROCESS)pOpInfo->Object);
3208 PSUPDRVNTPROTECT pNtProtect = supdrvNtProtectLookup(hObjPid);
3209 if (!pNtProtect)
3210 {
3211 HANDLE hParentPid = PsGetProcessInheritedFromUniqueProcessId((PEPROCESS)pOpInfo->Object);
3212 PSUPDRVNTPROTECT pNtStub = supdrvNtProtectLookup(hParentPid);
3213 if (pNtStub)
3214 {
3215 if (supdrvNtProtectIsSpawningStubProcess(pNtStub, hParentPid, hObjPid))
3216 {
3217 supdrvNtProtectProtectNewStubChild(pNtStub, hObjPid);
3218 pNtProtect = supdrvNtProtectLookup(hObjPid);
3219 }
3220 supdrvNtProtectRelease(pNtStub);
3221 }
3222 }
3223 pOpInfo->CallContext = pNtProtect; /* Just for reference. */
3224 if (pNtProtect)
3225 {
3226 /*
3227 * Ok, it's a protected process. Strip rights as required or possible.
3228 */
3229 static ACCESS_MASK const s_fCsrssStupidDesires = 0x1fffff;
3230 ACCESS_MASK fAllowedRights = SUPDRV_NT_ALLOW_PROCESS_RIGHTS;
3231
3232 if (pOpInfo->Operation == OB_OPERATION_HANDLE_CREATE)
3233 {
3234 /* Don't restrict the process accessing itself. */
3235 if ((PEPROCESS)pOpInfo->Object == PsGetCurrentProcess())
3236 {
3237 pOpInfo->CallContext = NULL; /* don't assert */
3238 pNtProtect->fFirstProcessCreateHandle = false;
3239
3240 Log(("vboxdrv/ProcessHandlePre: %sctx=%04zx/%p wants %#x to %p in pid=%04zx [%d] %s\n",
3241 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3242 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess,
3243 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind,
3244 PsGetProcessImageFileName(PsGetCurrentProcess()) ));
3245 }
3246#ifdef VBOX_WITHOUT_DEBUGGER_CHECKS
3247 /* Allow debuggers full access. */
3248 else if (supdrvNtProtectIsWhitelistedDebugger(PsGetCurrentProcess()))
3249 {
3250 pOpInfo->CallContext = NULL; /* don't assert */
3251 pNtProtect->fFirstProcessCreateHandle = false;
3252
3253 Log(("vboxdrv/ProcessHandlePre: %sctx=%04zx/%p wants %#x to %p in pid=%04zx [%d] %s [debugger]\n",
3254 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3255 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess,
3256 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind,
3257 PsGetProcessImageFileName(PsGetCurrentProcess()) ));
3258 }
3259#endif
3260 else
3261 {
3262 /* Special case 1 on Vista, 7 & 8:
3263 The CreateProcess code passes the handle over to CSRSS.EXE
3264 and the code inBaseSrvCreateProcess will duplicate the
3265 handle with 0x1fffff as access mask. NtDuplicateObject will
3266 fail this call before it ever gets down here.
3267
3268 Special case 2 on 8.1:
3269 The CreateProcess code requires additional rights for
3270 something, we'll drop these in the stub code. */
3271 if ( pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed
3272 && pNtProtect->fFirstProcessCreateHandle
3273 && pOpInfo->KernelHandle == 0
3274 && pNtProtect->hParentPid == PsGetProcessId(PsGetCurrentProcess())
3275 && ExGetPreviousMode() != KernelMode)
3276 {
3277 if ( !pOpInfo->KernelHandle
3278 && pOpInfo->Parameters->CreateHandleInformation.DesiredAccess == s_fCsrssStupidDesires)
3279 {
3280 if (g_uNtVerCombined < SUP_MAKE_NT_VER_SIMPLE(6, 3))
3281 fAllowedRights |= s_fCsrssStupidDesires;
3282 else
3283 fAllowedRights = fAllowedRights
3284 | PROCESS_VM_OPERATION
3285 | PROCESS_VM_WRITE
3286 | PROCESS_SET_INFORMATION
3287 | PROCESS_SET_LIMITED_INFORMATION
3288 | 0;
3289 pOpInfo->CallContext = NULL; /* don't assert this. */
3290 }
3291 pNtProtect->fFirstProcessCreateHandle = false;
3292 }
3293
3294 /* Special case 3 on 8.1:
3295 The interaction between the CreateProcess code and CSRSS.EXE
3296 has changed to the better with Windows 8.1. CSRSS.EXE no
3297 longer duplicates the process (thread too) handle, but opens
3298 it, thus allowing us to do our job. */
3299 if ( g_uNtVerCombined >= SUP_MAKE_NT_VER_SIMPLE(6, 3)
3300 && pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed
3301 && pNtProtect->fCsrssFirstProcessCreateHandle
3302 && pOpInfo->KernelHandle == 0
3303 && ExGetPreviousMode() == UserMode
3304 && supdrvNtProtectIsAssociatedCsrss(pNtProtect, PsGetCurrentProcess()) )
3305 {
3306 pNtProtect->fCsrssFirstProcessCreateHandle = false;
3307 if (pOpInfo->Parameters->CreateHandleInformation.DesiredAccess == s_fCsrssStupidDesires)
3308 {
3309 /* Not needed: PROCESS_CREATE_THREAD, PROCESS_SET_SESSIONID,
3310 PROCESS_CREATE_PROCESS */
3311 fAllowedRights = fAllowedRights
3312 | PROCESS_VM_OPERATION
3313 | PROCESS_VM_WRITE
3314 | PROCESS_DUP_HANDLE /* Needed for CreateProcess/VBoxTestOGL. */
3315 | 0;
3316 pOpInfo->CallContext = NULL; /* don't assert this. */
3317 }
3318 }
3319
3320 /* Special case 4, Windows 7, Vista, possibly 8, but not 8.1:
3321 The Themes service requires PROCESS_DUP_HANDLE access to our
3322 process or we won't get any menus and dialogs will be half
3323 unreadable. This is _very_ unfortunate and more work will
3324 go into making this more secure. */
3325 if ( g_uNtVerCombined >= SUP_MAKE_NT_VER_SIMPLE(6, 0)
3326 && g_uNtVerCombined < SUP_MAKE_NT_VER_SIMPLE(6, 2)
3327 && pOpInfo->Parameters->CreateHandleInformation.DesiredAccess == 0x1478 /* 6.1.7600.16385 (win7_rtm.090713-1255) */
3328 && pNtProtect->fThemesFirstProcessCreateHandle
3329 && pOpInfo->KernelHandle == 0
3330 && ExGetPreviousMode() == UserMode
3331 && supdrvNtProtectIsFrigginThemesService(pNtProtect, PsGetCurrentProcess()) )
3332 {
3333 pNtProtect->fThemesFirstProcessCreateHandle = true; /* Only once! */
3334 fAllowedRights |= PROCESS_DUP_HANDLE;
3335 pOpInfo->CallContext = NULL; /* don't assert this. */
3336 }
3337
3338 Log(("vboxdrv/ProcessHandlePre: %sctx=%04zx/%p wants %#x to %p/pid=%04zx [%d], allow %#x => %#x; %s [prev=%#x]\n",
3339 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3340 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess,
3341 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind, fAllowedRights,
3342 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess & fAllowedRights,
3343 PsGetProcessImageFileName(PsGetCurrentProcess()), ExGetPreviousMode() ));
3344
3345 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess &= fAllowedRights;
3346 }
3347 }
3348 else
3349 {
3350 /* Don't restrict the process accessing itself. */
3351 if ( (PEPROCESS)pOpInfo->Object == PsGetCurrentProcess()
3352 && pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess == pOpInfo->Object)
3353 {
3354 Log(("vboxdrv/ProcessHandlePre: ctx=%04zx/%p[%p] dup from %04zx/%p with %#x to %p in pid=%04zx [%d] %s\n",
3355 PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3356 pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess,
3357 PsGetProcessId((PEPROCESS)pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess),
3358 pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess,
3359 pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess,
3360 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind,
3361 PsGetProcessImageFileName(PsGetCurrentProcess()) ));
3362
3363 pOpInfo->CallContext = NULL; /* don't assert */
3364 }
3365 else
3366 {
3367 /* Special case 5 on Vista, 7 & 8:
3368 This is the CSRSS.EXE end of special case #1. */
3369 if ( g_uNtVerCombined < SUP_MAKE_NT_VER_SIMPLE(6, 3)
3370 && pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed
3371 && pNtProtect->cCsrssFirstProcessDuplicateHandle > 0
3372 && pOpInfo->KernelHandle == 0
3373 && pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess == s_fCsrssStupidDesires
3374 && pNtProtect->hParentPid
3375 == PsGetProcessId((PEPROCESS)pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess)
3376 && pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess == PsGetCurrentProcess()
3377 && ExGetPreviousMode() == UserMode
3378 && supdrvNtProtectIsAssociatedCsrss(pNtProtect, PsGetCurrentProcess()))
3379 {
3380 if (ASMAtomicDecS32(&pNtProtect->cCsrssFirstProcessDuplicateHandle) >= 0)
3381 {
3382 /* Not needed: PROCESS_CREATE_THREAD, PROCESS_SET_SESSIONID,
3383 PROCESS_CREATE_PROCESS, PROCESS_DUP_HANDLE */
3384 fAllowedRights = fAllowedRights
3385 | PROCESS_VM_OPERATION
3386 | PROCESS_VM_WRITE
3387 | PROCESS_DUP_HANDLE /* Needed for launching VBoxTestOGL. */
3388 | 0;
3389 pOpInfo->CallContext = NULL; /* don't assert this. */
3390 }
3391 }
3392
3393 Log(("vboxdrv/ProcessHandlePre: %sctx=%04zx/%p[%p] dup from %04zx/%p with %#x to %p in pid=%04zx [%d] %s\n",
3394 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3395 pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess,
3396 PsGetProcessId((PEPROCESS)pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess),
3397 pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess,
3398 pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess,
3399 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind,
3400 PsGetProcessImageFileName(PsGetCurrentProcess()) ));
3401
3402 pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess &= fAllowedRights;
3403 }
3404 }
3405 supdrvNtProtectRelease(pNtProtect);
3406 }
3407
3408 return OB_PREOP_SUCCESS;
3409}
3410
3411
3412static VOID __stdcall
3413supdrvNtProtectCallback_ProcessHandlePost(PVOID pvUser, POB_POST_OPERATION_INFORMATION pOpInfo)
3414{
3415 Assert(pvUser == NULL);
3416 Assert(pOpInfo->Operation == OB_OPERATION_HANDLE_CREATE || pOpInfo->Operation == OB_OPERATION_HANDLE_DUPLICATE);
3417 Assert(pOpInfo->ObjectType == *PsProcessType);
3418
3419 if ( pOpInfo->CallContext
3420 && NT_SUCCESS(pOpInfo->ReturnStatus))
3421 {
3422 ACCESS_MASK const fGrantedAccess = pOpInfo->Operation == OB_OPERATION_HANDLE_CREATE
3423 ? pOpInfo->Parameters->CreateHandleInformation.GrantedAccess
3424 : pOpInfo->Parameters->DuplicateHandleInformation.GrantedAccess;
3425 AssertReleaseMsg( !(fGrantedAccess & ~( SUPDRV_NT_ALLOW_PROCESS_RIGHTS
3426 | WRITE_OWNER | WRITE_DAC /* these two might be forced upon us */
3427 | PROCESS_UNKNOWN_4000 /* Seen set on win 8.1 */
3428 /*| PROCESS_UNKNOWN_8000 */ ) )
3429 || pOpInfo->KernelHandle,
3430 ("GrantedAccess=%#x - we allow %#x - we did not allow %#x\n",
3431 fGrantedAccess, SUPDRV_NT_ALLOW_PROCESS_RIGHTS, fGrantedAccess & ~SUPDRV_NT_ALLOW_PROCESS_RIGHTS));
3432 }
3433}
3434
3435# undef SUPDRV_NT_ALLOW_PROCESS_RIGHTS
3436
3437/** @} */
3438
3439
3440/** @name Thread Handle Callbacks
3441 * @{ */
3442
3443/* From ntifs.h */
3444extern "C" NTKERNELAPI PEPROCESS __stdcall IoThreadToProcess(PETHREAD);
3445
3446/** Thread rights that we allow for handles to stub and VM processes. */
3447# define SUPDRV_NT_ALLOWED_THREAD_RIGHTS \
3448 ( THREAD_TERMINATE \
3449 | THREAD_GET_CONTEXT \
3450 | THREAD_QUERY_INFORMATION \
3451 | THREAD_QUERY_LIMITED_INFORMATION \
3452 | DELETE \
3453 | READ_CONTROL \
3454 | SYNCHRONIZE)
3455/** @todo consider THREAD_SET_LIMITED_INFORMATION & THREAD_RESUME */
3456
3457/** Evil thread rights.
3458 * @remarks THREAD_RESUME is not included as it seems to be forced upon us by
3459 * Windows 8.1, at least for some processes. We dont' actively
3460 * allow it though, just tollerate it when forced to. */
3461# define SUPDRV_NT_EVIL_THREAD_RIGHTS \
3462 ( THREAD_SUSPEND_RESUME \
3463 | THREAD_SET_CONTEXT \
3464 | THREAD_SET_INFORMATION \
3465 | THREAD_SET_LIMITED_INFORMATION /*?*/ \
3466 | THREAD_SET_THREAD_TOKEN /*?*/ \
3467 | THREAD_IMPERSONATE /*?*/ \
3468 | THREAD_DIRECT_IMPERSONATION /*?*/ \
3469 /*| THREAD_RESUME - see remarks. */ \
3470 | 0)
3471AssertCompile((SUPDRV_NT_EVIL_THREAD_RIGHTS & SUPDRV_NT_ALLOWED_THREAD_RIGHTS) == 0);
3472
3473
3474static OB_PREOP_CALLBACK_STATUS __stdcall
3475supdrvNtProtectCallback_ThreadHandlePre(PVOID pvUser, POB_PRE_OPERATION_INFORMATION pOpInfo)
3476{
3477 Assert(pvUser == NULL);
3478 Assert(pOpInfo->Operation == OB_OPERATION_HANDLE_CREATE || pOpInfo->Operation == OB_OPERATION_HANDLE_DUPLICATE);
3479 Assert(pOpInfo->ObjectType == *PsThreadType);
3480
3481 PEPROCESS pProcess = IoThreadToProcess((PETHREAD)pOpInfo->Object);
3482 PSUPDRVNTPROTECT pNtProtect = supdrvNtProtectLookup(PsGetProcessId(pProcess));
3483 pOpInfo->CallContext = pNtProtect; /* Just for reference. */
3484 if (pNtProtect)
3485 {
3486 static ACCESS_MASK const s_fCsrssStupidDesires = 0x1fffff;
3487 ACCESS_MASK fAllowedRights = SUPDRV_NT_ALLOWED_THREAD_RIGHTS;
3488
3489 if (pOpInfo->Operation == OB_OPERATION_HANDLE_CREATE)
3490 {
3491 /* Don't restrict the process accessing its own threads. */
3492 if (pProcess == PsGetCurrentProcess())
3493 {
3494 Log(("vboxdrv/ThreadHandlePre: %sctx=%04zx/%p wants %#x to %p in pid=%04zx [%d] self\n",
3495 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3496 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess,
3497 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind));
3498 pOpInfo->CallContext = NULL; /* don't assert */
3499 pNtProtect->fFirstThreadCreateHandle = false;
3500 }
3501#ifdef VBOX_WITHOUT_DEBUGGER_CHECKS
3502 /* Allow debuggers full access. */
3503 else if (supdrvNtProtectIsWhitelistedDebugger(PsGetCurrentProcess()))
3504 {
3505 Log(("vboxdrv/ThreadHandlePre: %sctx=%04zx/%p wants %#x to %p in pid=%04zx [%d] %s [debugger]\n",
3506 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3507 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess,
3508 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind,
3509 PsGetProcessImageFileName(PsGetCurrentProcess()) ));
3510 pOpInfo->CallContext = NULL; /* don't assert */
3511 }
3512#endif
3513 else
3514 {
3515 /* Special case 1 on Vista, 7, 8:
3516 The CreateProcess code passes the handle over to CSRSS.EXE
3517 and the code inBaseSrvCreateProcess will duplicate the
3518 handle with 0x1fffff as access mask. NtDuplicateObject will
3519 fail this call before it ever gets down here. */
3520 if ( g_uNtVerCombined < SUP_MAKE_NT_VER_SIMPLE(6, 3)
3521 && pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed
3522 && pNtProtect->fFirstThreadCreateHandle
3523 && pOpInfo->KernelHandle == 0
3524 && ExGetPreviousMode() == UserMode
3525 && pNtProtect->hParentPid == PsGetProcessId(PsGetCurrentProcess()) )
3526 {
3527 if ( !pOpInfo->KernelHandle
3528 && pOpInfo->Parameters->CreateHandleInformation.DesiredAccess == s_fCsrssStupidDesires)
3529 {
3530 fAllowedRights |= s_fCsrssStupidDesires;
3531 pOpInfo->CallContext = NULL; /* don't assert this. */
3532 }
3533 pNtProtect->fFirstThreadCreateHandle = false;
3534 }
3535
3536 /* Special case 2 on 8.1, possibly also Vista, 7, 8:
3537 When creating a process like VBoxTestOGL from the VM process,
3538 CSRSS.EXE will try talk to the calling thread and, it
3539 appears, impersonate it. We unfortunately need to allow
3540 this or there will be no 3D support. Typical DbgPrint:
3541 "SXS: BasepCreateActCtx() Calling csrss server failed. Status = 0xc00000a5" */
3542 SUPDRVNTPROTECTKIND enmProcessKind;
3543 if ( g_uNtVerCombined >= SUP_MAKE_NT_VER_COMBINED(6, 0, 0, 0, 0)
3544 && ( (enmProcessKind = pNtProtect->enmProcessKind) == kSupDrvNtProtectKind_VmProcessConfirmed
3545 || enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed)
3546 && pOpInfo->KernelHandle == 0
3547 && ExGetPreviousMode() == UserMode
3548 && supdrvNtProtectIsAssociatedCsrss(pNtProtect, PsGetCurrentProcess()) )
3549 {
3550 fAllowedRights |= THREAD_IMPERSONATE;
3551 fAllowedRights |= THREAD_DIRECT_IMPERSONATION;
3552 //fAllowedRights |= THREAD_SET_LIMITED_INFORMATION; - try without this one
3553 pOpInfo->CallContext = NULL; /* don't assert this. */
3554 }
3555
3556 Log(("vboxdrv/ThreadHandlePre: %sctx=%04zx/%p wants %#x to %p in pid=%04zx [%d], allow %#x => %#x; %s [prev=%#x]\n",
3557 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3558 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess,
3559 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind, fAllowedRights,
3560 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess & fAllowedRights,
3561 PsGetProcessImageFileName(PsGetCurrentProcess()), ExGetPreviousMode()));
3562
3563 pOpInfo->Parameters->CreateHandleInformation.DesiredAccess &= fAllowedRights;
3564 }
3565 }
3566 else
3567 {
3568 /* Don't restrict the process accessing its own threads. */
3569 if ( pProcess == PsGetCurrentProcess()
3570 && (PEPROCESS)pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess == pProcess)
3571 {
3572 Log(("vboxdrv/ThreadHandlePre: %sctx=%04zx/%p[%p] dup from %04zx/%p with %#x to %p in pid=%04zx [%d] self\n",
3573 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3574 pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess,
3575 PsGetProcessId((PEPROCESS)pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess),
3576 pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess,
3577 pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess,
3578 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind,
3579 PsGetProcessImageFileName(PsGetCurrentProcess()) ));
3580 pOpInfo->CallContext = NULL; /* don't assert */
3581 }
3582 else
3583 {
3584 /* Special case 3 on Vista, 7, 8:
3585 This is the follow up to special case 1. */
3586 SUPDRVNTPROTECTKIND enmProcessKind;
3587 if ( g_uNtVerCombined >= SUP_MAKE_NT_VER_COMBINED(6, 0, 0, 0, 0)
3588 && ( (enmProcessKind = pNtProtect->enmProcessKind) == kSupDrvNtProtectKind_VmProcessConfirmed
3589 || enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed)
3590 && pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess == PsGetCurrentProcess()
3591 && pOpInfo->KernelHandle == 0
3592 && ExGetPreviousMode() == UserMode
3593 && supdrvNtProtectIsAssociatedCsrss(pNtProtect, PsGetCurrentProcess()) )
3594 {
3595 fAllowedRights |= THREAD_IMPERSONATE;
3596 fAllowedRights |= THREAD_DIRECT_IMPERSONATION;
3597 //fAllowedRights |= THREAD_SET_LIMITED_INFORMATION; - try without this one
3598 pOpInfo->CallContext = NULL; /* don't assert this. */
3599 }
3600
3601 Log(("vboxdrv/ThreadHandlePre: %sctx=%04zx/%p[%p] dup from %04zx/%p with %#x to %p in pid=%04zx [%d], allow %#x => %#x; %s\n",
3602 pOpInfo->KernelHandle ? "k" : "", PsGetProcessId(PsGetCurrentProcess()), PsGetCurrentProcess(),
3603 pOpInfo->Parameters->DuplicateHandleInformation.TargetProcess,
3604 PsGetProcessId((PEPROCESS)pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess),
3605 pOpInfo->Parameters->DuplicateHandleInformation.SourceProcess,
3606 pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess,
3607 pOpInfo->Object, pNtProtect->AvlCore.Key, pNtProtect->enmProcessKind, fAllowedRights,
3608 pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess & fAllowedRights,
3609 PsGetProcessImageFileName(PsGetCurrentProcess()) ));
3610
3611 pOpInfo->Parameters->DuplicateHandleInformation.DesiredAccess &= fAllowedRights;
3612 }
3613 }
3614
3615 supdrvNtProtectRelease(pNtProtect);
3616 }
3617
3618 return OB_PREOP_SUCCESS;
3619}
3620
3621
3622static VOID __stdcall
3623supdrvNtProtectCallback_ThreadHandlePost(PVOID pvUser, POB_POST_OPERATION_INFORMATION pOpInfo)
3624{
3625 Assert(pvUser == NULL);
3626 Assert(pOpInfo->Operation == OB_OPERATION_HANDLE_CREATE || pOpInfo->Operation == OB_OPERATION_HANDLE_DUPLICATE);
3627 Assert(pOpInfo->ObjectType == *PsThreadType);
3628
3629 if ( pOpInfo->CallContext
3630 && NT_SUCCESS(pOpInfo->ReturnStatus))
3631 {
3632 ACCESS_MASK const fGrantedAccess = pOpInfo->Parameters->CreateHandleInformation.GrantedAccess;
3633 AssertReleaseMsg( !(fGrantedAccess & ~( SUPDRV_NT_ALLOWED_THREAD_RIGHTS
3634 | WRITE_OWNER | WRITE_DAC /* these two might be forced upon us */
3635 | THREAD_RESUME /* This seems to be force upon us too with 8.1. */
3636 ) )
3637 || pOpInfo->KernelHandle,
3638 ("GrantedAccess=%#x - we allow %#x - we did not allow %#x\n",
3639 fGrantedAccess, SUPDRV_NT_ALLOWED_THREAD_RIGHTS, fGrantedAccess & ~SUPDRV_NT_ALLOWED_THREAD_RIGHTS));
3640 }
3641}
3642
3643# undef SUPDRV_NT_ALLOWED_THREAD_RIGHTS
3644
3645/** @} */
3646
3647
3648/**
3649 * Creates a new process protection structure.
3650 *
3651 * @returns VBox status code.
3652 * @param ppNtProtect Where to return the pointer to the structure
3653 * on success.
3654 * @param hPid The process ID of the process to protect.
3655 * @param enmProcessKind The kind of process we're protecting.
3656 * @param fLink Whether to link the structure into the tree.
3657 */
3658static int supdrvNtProtectCreate(PSUPDRVNTPROTECT *ppNtProtect, HANDLE hPid, SUPDRVNTPROTECTKIND enmProcessKind, bool fLink)
3659{
3660 AssertReturn(g_hNtProtectLock != NIL_RTSPINLOCK, VERR_WRONG_ORDER);
3661
3662 PSUPDRVNTPROTECT pNtProtect = (PSUPDRVNTPROTECT)RTMemAllocZ(sizeof(*pNtProtect));
3663 if (!pNtProtect)
3664 return VERR_NO_MEMORY;
3665
3666 pNtProtect->AvlCore.Key = hPid;
3667 pNtProtect->u32Magic = SUPDRVNTPROTECT_MAGIC;
3668 pNtProtect->cRefs = 1;
3669 pNtProtect->enmProcessKind = enmProcessKind;
3670 pNtProtect->hParentPid = NULL;
3671 pNtProtect->hOpenTid = NULL;
3672 pNtProtect->hCsrssPid = NULL;
3673 pNtProtect->pCsrssProcess = NULL;
3674
3675 if (fLink)
3676 {
3677 RTSpinlockAcquire(g_hNtProtectLock);
3678 bool fSuccess = RTAvlPVInsert(&g_NtProtectTree, &pNtProtect->AvlCore);
3679 RTSpinlockRelease(g_hNtProtectLock);
3680
3681 if (!fSuccess)
3682 {
3683 /* Duplicate entry, fail. */
3684 pNtProtect->u32Magic = SUPDRVNTPROTECT_MAGIC_DEAD;
3685 LogRel(("supdrvNtProtectCreate: Duplicate (%#x).\n", pNtProtect->AvlCore.Key));
3686 RTMemFree(pNtProtect);
3687 return VERR_DUPLICATE;
3688 }
3689 }
3690
3691 *ppNtProtect = pNtProtect;
3692 return VINF_SUCCESS;
3693}
3694
3695
3696/**
3697 * Releases a reference to a NT protection structure.
3698 *
3699 * @param pNtProtect The NT protection structure.
3700 */
3701static void supdrvNtProtectRelease(PSUPDRVNTPROTECT pNtProtect)
3702{
3703 if (!pNtProtect)
3704 return;
3705 AssertReturnVoid(pNtProtect->u32Magic == SUPDRVNTPROTECT_MAGIC);
3706
3707 RTSpinlockAcquire(g_hNtProtectLock);
3708 uint32_t cRefs = ASMAtomicDecU32(&pNtProtect->cRefs);
3709 if (cRefs != 0)
3710 RTSpinlockRelease(g_hNtProtectLock);
3711 else
3712 {
3713 /*
3714 * That was the last reference. Remove it from the tree, invalidate it
3715 * and free the resources associated with it. Also, release any
3716 * child/parent references related to this protection structure.
3717 */
3718 ASMAtomicWriteU32(&pNtProtect->u32Magic, SUPDRVNTPROTECT_MAGIC_DEAD);
3719 PSUPDRVNTPROTECT pRemoved = (PSUPDRVNTPROTECT)RTAvlPVRemove(&g_NtProtectTree, pNtProtect->AvlCore.Key);
3720
3721 PSUPDRVNTPROTECT pRemovedChild = NULL;
3722 PSUPDRVNTPROTECT pChild = NULL;
3723 if (pNtProtect->enmProcessKind == kSupDrvNtProtectKind_StubParent)
3724 {
3725 pChild = pNtProtect->u.pChild;
3726 if (pChild)
3727 {
3728 pNtProtect->u.pChild = NULL;
3729 pChild->u.pParent = NULL;
3730 pChild->enmProcessKind = kSupDrvNtProtectKind_VmProcessDead;
3731 uint32_t cChildRefs = ASMAtomicDecU32(&pChild->cRefs);
3732 if (!cChildRefs)
3733 pRemovedChild = (PSUPDRVNTPROTECT)RTAvlPVRemove(&g_NtProtectTree, pChild->AvlCore.Key);
3734 else
3735 pChild = NULL;
3736 }
3737 }
3738 else
3739 AssertRelease(pNtProtect->enmProcessKind != kSupDrvNtProtectKind_VmProcessUnconfirmed);
3740
3741 RTSpinlockRelease(g_hNtProtectLock);
3742 Assert(pRemoved == pNtProtect);
3743 Assert(pRemovedChild == pChild);
3744
3745 if (pNtProtect->pCsrssProcess)
3746 {
3747 ObDereferenceObject(pNtProtect->pCsrssProcess);
3748 pNtProtect->pCsrssProcess = NULL;
3749 }
3750
3751 RTMemFree(pNtProtect);
3752 if (pChild)
3753 RTMemFree(pChild);
3754 }
3755}
3756
3757
3758/**
3759 * Looks up a PID in the NT protect tree.
3760 *
3761 * @returns Pointer to a NT protection structure (with a referenced) on success,
3762 * NULL if not found.
3763 * @param hPid The process ID.
3764 */
3765static PSUPDRVNTPROTECT supdrvNtProtectLookup(HANDLE hPid)
3766{
3767 RTSpinlockAcquire(g_hNtProtectLock);
3768 PSUPDRVNTPROTECT pFound = (PSUPDRVNTPROTECT)RTAvlPVGet(&g_NtProtectTree, hPid);
3769 if (pFound)
3770 ASMAtomicIncU32(&pFound->cRefs);
3771 RTSpinlockRelease(g_hNtProtectLock);
3772 return pFound;
3773}
3774
3775
3776/**
3777 * Validates a few facts about the stub process when the VM process opens
3778 * vboxdrv.
3779 *
3780 * This makes sure the stub process is still around and that it has neither
3781 * debugger nor extra threads in it.
3782 *
3783 * @returns VBox status code.
3784 * @param pNtProtect The unconfirmed VM process currently trying to
3785 * open vboxdrv.
3786 * @param pErrInfo Additional error information.
3787 */
3788static int supdrvNtProtectVerifyStubForVmProcess(PSUPDRVNTPROTECT pNtProtect, PRTERRINFO pErrInfo)
3789{
3790 /*
3791 * Grab a reference to the parent stub process.
3792 */
3793 SUPDRVNTPROTECTKIND enmStub = kSupDrvNtProtectKind_Invalid;
3794 PSUPDRVNTPROTECT pNtStub = NULL;
3795 RTSpinlockAcquire(g_hNtProtectLock);
3796 if (pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed)
3797 {
3798 pNtStub = pNtProtect->u.pParent; /* weak reference. */
3799 if (pNtStub)
3800 {
3801 enmStub = pNtStub->enmProcessKind;
3802 if (enmStub == kSupDrvNtProtectKind_StubParent)
3803 {
3804 uint32_t cRefs = ASMAtomicIncU32(&pNtStub->cRefs);
3805 Assert(cRefs > 0 && cRefs < 1024);
3806 }
3807 else
3808 pNtStub = NULL;
3809 }
3810 }
3811 RTSpinlockRelease(g_hNtProtectLock);
3812
3813 /*
3814 * We require the stub process to be present.
3815 */
3816 if (!pNtStub)
3817 return RTErrInfoSetF(pErrInfo, VERR_SUP_VP_STUB_NOT_FOUND, "Missing stub process (enmStub=%d).", enmStub);
3818
3819 /*
3820 * Open the parent process and thread so we can check for debuggers and unwanted threads.
3821 */
3822 int rc;
3823 PEPROCESS pStubProcess;
3824 NTSTATUS rcNt = PsLookupProcessByProcessId(pNtStub->AvlCore.Key, &pStubProcess);
3825 if (NT_SUCCESS(rcNt))
3826 {
3827 HANDLE hStubProcess;
3828 rcNt = ObOpenObjectByPointer(pStubProcess, OBJ_KERNEL_HANDLE, NULL /*PassedAccessState*/,
3829 0 /*DesiredAccess*/, *PsProcessType, KernelMode, &hStubProcess);
3830 if (NT_SUCCESS(rcNt))
3831 {
3832 PETHREAD pStubThread;
3833 rcNt = PsLookupThreadByThreadId(pNtStub->hOpenTid, &pStubThread);
3834 if (NT_SUCCESS(rcNt))
3835 {
3836 HANDLE hStubThread;
3837 rcNt = ObOpenObjectByPointer(pStubThread, OBJ_KERNEL_HANDLE, NULL /*PassedAccessState*/,
3838 0 /*DesiredAccess*/, *PsThreadType, KernelMode, &hStubThread);
3839 if (NT_SUCCESS(rcNt))
3840 {
3841 /*
3842 * Do some simple sanity checking.
3843 */
3844 rc = supHardNtVpDebugger(hStubProcess, pErrInfo);
3845 if (RT_SUCCESS(rc))
3846 rc = supHardNtVpThread(hStubProcess, hStubThread, pErrInfo);
3847
3848 /* Clean up. */
3849 rcNt = NtClose(hStubThread); AssertMsg(NT_SUCCESS(rcNt), ("%#x\n", rcNt));
3850 }
3851 else
3852 rc = RTErrInfoSetF(pErrInfo, VERR_SUP_VP_STUB_THREAD_OPEN_ERROR,
3853 "Error opening stub thread %p (tid %p, pid %p): %#x",
3854 pStubThread, pNtStub->hOpenTid, pNtStub->AvlCore.Key, rcNt);
3855 }
3856 else
3857 rc = RTErrInfoSetF(pErrInfo, VERR_SUP_VP_STUB_THREAD_NOT_FOUND,
3858 "Failed to locate thread %p in %p: %#x", pNtStub->hOpenTid, pNtStub->AvlCore.Key, rcNt);
3859 rcNt = NtClose(hStubProcess); AssertMsg(NT_SUCCESS(rcNt), ("%#x\n", rcNt));
3860 }
3861 else
3862 rc = RTErrInfoSetF(pErrInfo, VERR_SUP_VP_STUB_OPEN_ERROR,
3863 "Error opening stub process %p (pid %p): %#x", pStubProcess, pNtStub->AvlCore.Key, rcNt);
3864 ObDereferenceObject(pStubProcess);
3865 }
3866 else
3867 rc = RTErrInfoSetF(pErrInfo, VERR_SUP_VP_STUB_NOT_FOUND,
3868 "Failed to locate stub process %p: %#x", pNtStub->AvlCore.Key, rcNt);
3869
3870 supdrvNtProtectRelease(pNtStub);
3871 return rc;
3872}
3873
3874
3875/**
3876 * Worker for supdrvNtProtectVerifyProcess that verifies the handles to a VM
3877 * process and its thread.
3878 *
3879 * @returns VBox status code.
3880 * @param pNtProtect The NT protect structure for getting information
3881 * about special processes.
3882 * @param pErrInfo Where to return additional error details.
3883 */
3884static int supdrvNtProtectRestrictHandlesToProcessAndThread(PSUPDRVNTPROTECT pNtProtect, PRTERRINFO pErrInfo)
3885{
3886 /*
3887 * What to protect.
3888 */
3889 PEPROCESS pProtectedProcess = PsGetCurrentProcess();
3890 HANDLE hProtectedPid = PsGetProcessId(pProtectedProcess);
3891 PETHREAD pProtectedThread = PsGetCurrentThread();
3892 AssertReturn(pNtProtect->AvlCore.Key == hProtectedPid, VERR_INTERNAL_ERROR_5);
3893
3894 /*
3895 * Take a snapshot of all the handles in the system.
3896 * Note! The 32 bytes on the size of to counteract the allocation header
3897 * that rtR0MemAllocEx slaps on everything.
3898 */
3899 uint32_t cbBuf = _256K - 32;
3900 uint8_t *pbBuf = (uint8_t *)RTMemAlloc(cbBuf);
3901 ULONG cbNeeded = cbBuf;
3902 NTSTATUS rcNt = NtQuerySystemInformation(SystemExtendedHandleInformation, pbBuf, cbBuf, &cbNeeded);
3903 if (!NT_SUCCESS(rcNt))
3904 {
3905 while ( rcNt == STATUS_INFO_LENGTH_MISMATCH
3906 && cbNeeded > cbBuf
3907 && cbBuf <= 32U*_1M)
3908 {
3909 cbBuf = RT_ALIGN_32(cbNeeded + _4K, _64K) - 32;
3910 RTMemFree(pbBuf);
3911 pbBuf = (uint8_t *)RTMemAlloc(cbBuf);
3912 if (!pbBuf)
3913 return RTErrInfoSetF(pErrInfo, VERR_NO_MEMORY, "Error allocating %zu bytes for querying handles.", cbBuf);
3914 rcNt = NtQuerySystemInformation(SystemExtendedHandleInformation, pbBuf, cbBuf, &cbNeeded);
3915 }
3916 if (!NT_SUCCESS(rcNt))
3917 {
3918 RTMemFree(pbBuf);
3919 return RTErrInfoSetF(pErrInfo, RTErrConvertFromNtStatus(rcNt),
3920 "NtQuerySystemInformation/SystemExtendedHandleInformation failed: %#x\n", rcNt);
3921 }
3922 }
3923
3924 /*
3925 * Walk the information and look for handles to the two objects we're protecting.
3926 */
3927 int rc = VINF_SUCCESS;
3928# ifdef VBOX_WITHOUT_DEBUGGER_CHECKS
3929 HANDLE idLastDebugger = (HANDLE)~(uintptr_t)0;
3930# endif
3931
3932 uint32_t cCsrssProcessHandles = 0;
3933 uint32_t cSystemProcessHandles = 0;
3934 uint32_t cEvilProcessHandles = 0;
3935 uint32_t cBenignProcessHandles = 0;
3936
3937 uint32_t cCsrssThreadHandles = 0;
3938 uint32_t cEvilThreadHandles = 0;
3939 uint32_t cBenignThreadHandles = 0;
3940
3941 SYSTEM_HANDLE_INFORMATION_EX const *pInfo = (SYSTEM_HANDLE_INFORMATION_EX const *)pbBuf;
3942 ULONG_PTR i = pInfo->NumberOfHandles;
3943 AssertRelease(RT_OFFSETOF(SYSTEM_HANDLE_INFORMATION_EX, Handles[i]) == cbNeeded);
3944 while (i-- > 0)
3945 {
3946 const char *pszType;
3947 SYSTEM_HANDLE_ENTRY_INFO_EX const *pHandleInfo = &pInfo->Handles[i];
3948 if (pHandleInfo->Object == pProtectedProcess)
3949 {
3950 /* Handles within the protected process are fine. */
3951 if ( !(pHandleInfo->GrantedAccess & SUPDRV_NT_EVIL_PROCESS_RIGHTS)
3952 || pHandleInfo->UniqueProcessId == hProtectedPid)
3953 {
3954 cBenignProcessHandles++;
3955 continue;
3956 }
3957
3958 /* CSRSS is allowed to have one evil process handle.
3959 See the special cases in the hook code. */
3960 if ( cCsrssProcessHandles < 1
3961 && pHandleInfo->UniqueProcessId == pNtProtect->hCsrssPid)
3962 {
3963 cCsrssProcessHandles++;
3964 continue;
3965 }
3966
3967 /* The system process is allowed having two open process handle in
3968 Windows 8.1 and later, and one in earlier. This is probably a
3969 little overly paranoid as I think we can safely trust the
3970 system process... */
3971 if ( cSystemProcessHandles < (g_uNtVerCombined >= SUP_MAKE_NT_VER_SIMPLE(6, 3) ? 2 : 1)
3972 && pHandleInfo->UniqueProcessId == PsGetProcessId(PsInitialSystemProcess))
3973 {
3974 cSystemProcessHandles++;
3975 continue;
3976 }
3977
3978 cEvilProcessHandles++;
3979 pszType = "process";
3980 }
3981 else if (pHandleInfo->Object == pProtectedThread)
3982 {
3983 /* Handles within the protected process is fine. */
3984 if ( !(pHandleInfo->GrantedAccess & SUPDRV_NT_EVIL_THREAD_RIGHTS)
3985 || pHandleInfo->UniqueProcessId == hProtectedPid)
3986 {
3987 cBenignThreadHandles++;
3988 continue;
3989 }
3990
3991 /* CSRSS is allowed to have one evil handle to the primary thread
3992 for LPC purposes. See the hook for special case. */
3993 if ( cCsrssThreadHandles < 1
3994 && pHandleInfo->UniqueProcessId == pNtProtect->hCsrssPid)
3995 {
3996 cCsrssThreadHandles++;
3997 continue;
3998 }
3999
4000 cEvilThreadHandles++;
4001 pszType = "thread";
4002 }
4003 else
4004 continue;
4005
4006# ifdef VBOX_WITHOUT_DEBUGGER_CHECKS
4007 /* Ignore whitelisted debuggers. */
4008 if (pHandleInfo->UniqueProcessId == idLastDebugger)
4009 continue;
4010 PEPROCESS pDbgProc;
4011 NTSTATUS rcNt = PsLookupProcessByProcessId(pHandleInfo->UniqueProcessId, &pDbgProc);
4012 if (NT_SUCCESS(rcNt))
4013 {
4014 bool fIsDebugger = supdrvNtProtectIsWhitelistedDebugger(pDbgProc);
4015 ObDereferenceObject(pDbgProc);
4016 if (fIsDebugger)
4017 {
4018 idLastDebugger = pHandleInfo->UniqueProcessId;
4019 continue;
4020 }
4021 }
4022# endif
4023
4024 /* Found evil handle. Currently ignoring on pre-Vista. */
4025# ifndef VBOX_WITH_VISTA_NO_SP
4026 if ( g_uNtVerCombined >= SUP_NT_VER_VISTA
4027# else
4028 if ( g_uNtVerCombined >= SUP_MAKE_NT_VER_COMBINED(6, 0, 6001, 0, 0)
4029# endif
4030 || g_pfnObRegisterCallbacks)
4031 {
4032 LogRel(("vboxdrv: Found evil handle to budding VM process: pid=%p h=%p acc=%#x attr=%#x type=%s\n",
4033 pHandleInfo->UniqueProcessId, pHandleInfo->HandleValue,
4034 pHandleInfo->GrantedAccess, pHandleInfo->HandleAttributes, pszType));
4035 rc = RTErrInfoAddF(pErrInfo, VERR_SUPDRV_HARDENING_EVIL_HANDLE,
4036 *pErrInfo->pszMsg
4037 ? "\nFound evil handle to budding VM process: pid=%p h=%p acc=%#x attr=%#x type=%s"
4038 : "Found evil handle to budding VM process: pid=%p h=%p acc=%#x attr=%#x type=%s",
4039 pHandleInfo->UniqueProcessId, pHandleInfo->HandleValue,
4040 pHandleInfo->GrantedAccess, pHandleInfo->HandleAttributes, pszType);
4041
4042 /* Try add the process name. */
4043 PEPROCESS pOffendingProcess;
4044 rcNt = PsLookupProcessByProcessId(pHandleInfo->UniqueProcessId, &pOffendingProcess);
4045 if (NT_SUCCESS(rcNt))
4046 {
4047 const char *pszName = (const char *)PsGetProcessImageFileName(pOffendingProcess);
4048 if (pszName && *pszName)
4049 rc = RTErrInfoAddF(pErrInfo, rc, " [%s]", pszName);
4050
4051 ObDereferenceObject(pOffendingProcess);
4052 }
4053 }
4054 }
4055
4056 RTMemFree(pbBuf);
4057 return rc;
4058}
4059
4060
4061/**
4062 * Checks if the current process checks out as a VM process stub.
4063 *
4064 * @returns VBox status code.
4065 * @param pNtProtect The NT protect structure. This is upgraded to a
4066 * final protection kind (state) on success.
4067 */
4068static int supdrvNtProtectVerifyProcess(PSUPDRVNTPROTECT pNtProtect)
4069{
4070 AssertReturn(PsGetProcessId(PsGetCurrentProcess()) == pNtProtect->AvlCore.Key, VERR_INTERNAL_ERROR_3);
4071
4072 /*
4073 * Do the verification. The handle restriction checks are only preformed
4074 * on VM processes.
4075 */
4076 int rc = VINF_SUCCESS;
4077 PSUPDRVNTERRORINFO pErrorInfo = (PSUPDRVNTERRORINFO)RTMemAllocZ(sizeof(*pErrorInfo));
4078 if (RT_SUCCESS(rc))
4079 {
4080 pErrorInfo->hProcessId = PsGetCurrentProcessId();
4081 pErrorInfo->hThreadId = PsGetCurrentThreadId();
4082 RTERRINFO ErrInfo;
4083 RTErrInfoInit(&ErrInfo, pErrorInfo->szErrorInfo, sizeof(pErrorInfo->szErrorInfo));
4084
4085 if (pNtProtect->enmProcessKind >= kSupDrvNtProtectKind_VmProcessUnconfirmed)
4086 rc = supdrvNtProtectRestrictHandlesToProcessAndThread(pNtProtect, &ErrInfo);
4087 if (RT_SUCCESS(rc))
4088 {
4089 rc = supHardenedWinVerifyProcess(NtCurrentProcess(), NtCurrentThread(), SUPHARDNTVPKIND_VERIFY_ONLY, 0 /*fFlags*/,
4090 NULL /*pcFixes*/, &ErrInfo);
4091 if (RT_SUCCESS(rc) && pNtProtect->enmProcessKind >= kSupDrvNtProtectKind_VmProcessUnconfirmed)
4092 rc = supdrvNtProtectVerifyStubForVmProcess(pNtProtect, &ErrInfo);
4093 }
4094 }
4095 else
4096 rc = VERR_NO_MEMORY;
4097
4098 /*
4099 * Upgrade and return.
4100 */
4101 HANDLE hOpenTid = PsGetCurrentThreadId();
4102 RTSpinlockAcquire(g_hNtProtectLock);
4103
4104 /* Stub process verficiation is pretty much straight forward. */
4105 if (pNtProtect->enmProcessKind == kSupDrvNtProtectKind_StubUnverified)
4106 {
4107 pNtProtect->enmProcessKind = RT_SUCCESS(rc) ? kSupDrvNtProtectKind_StubSpawning : kSupDrvNtProtectKind_StubDead;
4108 pNtProtect->hOpenTid = hOpenTid;
4109 }
4110 /* The VM process verification is a little bit more complicated
4111 because we need to drop the parent process reference as well. */
4112 else if (pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessUnconfirmed)
4113 {
4114 AssertRelease(pNtProtect->cRefs >= 2); /* Parent + Caller */
4115 PSUPDRVNTPROTECT pParent = pNtProtect->u.pParent;
4116 AssertRelease(pParent);
4117 AssertRelease(pParent->u.pParent == pNtProtect);
4118 AssertRelease(pParent->enmProcessKind == kSupDrvNtProtectKind_StubParent);
4119 pParent->u.pParent = NULL;
4120
4121 pNtProtect->u.pParent = NULL;
4122 ASMAtomicDecU32(&pNtProtect->cRefs);
4123
4124 if (RT_SUCCESS(rc))
4125 {
4126 pNtProtect->enmProcessKind = kSupDrvNtProtectKind_VmProcessConfirmed;
4127 pNtProtect->hOpenTid = hOpenTid;
4128 }
4129 else
4130 pNtProtect->enmProcessKind = kSupDrvNtProtectKind_VmProcessDead;
4131 }
4132
4133 /* Since the stub and VM processes are only supposed to have one thread,
4134 we're not supposed to be subject to any races from within the processes.
4135
4136 There is a race between VM process verification and the stub process
4137 exiting, though. We require the stub process to be alive until the new
4138 VM process has made it thru the validation. So, when the stub
4139 terminates the notification handler will change the state of both stub
4140 and VM process to dead.
4141
4142 Also, I'm not entirely certain where the process
4143 termination notification is triggered from, so that can theorically
4144 create a race in both cases. */
4145 else
4146 {
4147 AssertReleaseMsg( pNtProtect->enmProcessKind == kSupDrvNtProtectKind_StubDead
4148 || pNtProtect->enmProcessKind == kSupDrvNtProtectKind_VmProcessDead,
4149 ("enmProcessKind=%d rc=%Rrc\n", pNtProtect->enmProcessKind, rc));
4150 if (RT_SUCCESS(rc))
4151 rc = VERR_INVALID_STATE; /* There should be no races here. */
4152 }
4153
4154 RTSpinlockRelease(g_hNtProtectLock);
4155
4156 /*
4157 * Free error info on success, keep it on failure.
4158 */
4159 if (RT_SUCCESS(rc))
4160 RTMemFree(pErrorInfo);
4161 else if (pErrorInfo)
4162 {
4163 pErrorInfo->cchErrorInfo = (uint32_t)strlen(pErrorInfo->szErrorInfo);
4164 if (!pErrorInfo->cchErrorInfo)
4165 pErrorInfo->cchErrorInfo = (uint32_t)RTStrPrintf(pErrorInfo->szErrorInfo, sizeof(pErrorInfo->szErrorInfo),
4166 "supdrvNtProtectVerifyProcess: rc=%d", rc);
4167 if (RT_FAILURE(rc))
4168 RTLogWriteDebugger(pErrorInfo->szErrorInfo, pErrorInfo->cchErrorInfo);
4169
4170 int rc2 = RTSemMutexRequest(g_hErrorInfoLock, RT_INDEFINITE_WAIT);
4171 if (RT_SUCCESS(rc2))
4172 {
4173 pErrorInfo->uCreatedMsTs = RTTimeMilliTS();
4174
4175 /* Free old entries. */
4176 PSUPDRVNTERRORINFO pCur;
4177 while ( (pCur = RTListGetFirst(&g_ErrorInfoHead, SUPDRVNTERRORINFO, ListEntry)) != NULL
4178 && (int64_t)(pErrorInfo->uCreatedMsTs - pCur->uCreatedMsTs) > 60000 /*60sec*/)
4179 {
4180 RTListNodeRemove(&pCur->ListEntry);
4181 RTMemFree(pCur);
4182 }
4183
4184 /* Insert our new entry. */
4185 RTListAppend(&g_ErrorInfoHead, &pErrorInfo->ListEntry);
4186
4187 RTSemMutexRelease(g_hErrorInfoLock);
4188 }
4189 else
4190 RTMemFree(pErrorInfo);
4191 }
4192
4193 return rc;
4194}
4195
4196
4197# ifndef VBOX_WITHOUT_DEBUGGER_CHECKS
4198
4199/**
4200 * Checks if the current process is being debugged.
4201 * @return @c true if debugged, @c false if not.
4202 */
4203static bool supdrvNtIsDebuggerAttached(void)
4204{
4205 return PsIsProcessBeingDebugged(PsGetCurrentProcess()) != FALSE;
4206}
4207
4208# endif /* !VBOX_WITHOUT_DEBUGGER_CHECKS */
4209
4210
4211/**
4212 * Terminates the hardening bits.
4213 */
4214static void supdrvNtProtectTerm(void)
4215{
4216 /*
4217 * Stop intercepting process and thread handle creation calls.
4218 */
4219 if (g_pvObCallbacksCookie)
4220 {
4221 g_pfnObUnRegisterCallbacks(g_pvObCallbacksCookie);
4222 g_pvObCallbacksCookie = NULL;
4223 }
4224
4225 /*
4226 * Stop intercepting process creation and termination notifications.
4227 */
4228 NTSTATUS rcNt;
4229 if (g_pfnPsSetCreateProcessNotifyRoutineEx)
4230 rcNt = g_pfnPsSetCreateProcessNotifyRoutineEx(supdrvNtProtectCallback_ProcessCreateNotifyEx, TRUE /*fRemove*/);
4231 else
4232 rcNt = PsSetCreateProcessNotifyRoutine(supdrvNtProtectCallback_ProcessCreateNotify, TRUE /*fRemove*/);
4233 AssertMsg(NT_SUCCESS(rcNt), ("rcNt=%#x\n", rcNt));
4234
4235 Assert(g_NtProtectTree == NULL);
4236
4237 /*
4238 * Clean up globals.
4239 */
4240 RTSpinlockDestroy(g_hNtProtectLock);
4241 g_NtProtectTree = NIL_RTSPINLOCK;
4242
4243 RTSemMutexDestroy(g_hErrorInfoLock);
4244 g_hErrorInfoLock = NIL_RTSEMMUTEX;
4245
4246 PSUPDRVNTERRORINFO pCur;
4247 while ((pCur = RTListGetFirst(&g_ErrorInfoHead, SUPDRVNTERRORINFO, ListEntry)) != NULL)
4248 {
4249 RTListNodeRemove(&pCur->ListEntry);
4250 RTMemFree(pCur);
4251 }
4252
4253 supHardenedWinTermImageVerifier();
4254}
4255
4256# ifdef RT_ARCH_X86
4257DECLASM(void) supdrvNtQueryVirtualMemory_0xAF(void);
4258DECLASM(void) supdrvNtQueryVirtualMemory_0xB0(void);
4259DECLASM(void) supdrvNtQueryVirtualMemory_0xB1(void);
4260DECLASM(void) supdrvNtQueryVirtualMemory_0xB2(void);
4261DECLASM(void) supdrvNtQueryVirtualMemory_0xB3(void);
4262DECLASM(void) supdrvNtQueryVirtualMemory_0xB4(void);
4263DECLASM(void) supdrvNtQueryVirtualMemory_0xB5(void);
4264DECLASM(void) supdrvNtQueryVirtualMemory_0xB6(void);
4265DECLASM(void) supdrvNtQueryVirtualMemory_0xB7(void);
4266DECLASM(void) supdrvNtQueryVirtualMemory_0xB8(void);
4267DECLASM(void) supdrvNtQueryVirtualMemory_0xB9(void);
4268DECLASM(void) supdrvNtQueryVirtualMemory_0xBA(void);
4269DECLASM(void) supdrvNtQueryVirtualMemory_0xBB(void);
4270DECLASM(void) supdrvNtQueryVirtualMemory_0xBC(void);
4271DECLASM(void) supdrvNtQueryVirtualMemory_0xBD(void);
4272DECLASM(void) supdrvNtQueryVirtualMemory_0xBE(void);
4273# elif defined(RT_ARCH_AMD64)
4274DECLASM(void) supdrvNtQueryVirtualMemory_0x1F(void);
4275DECLASM(void) supdrvNtQueryVirtualMemory_0x20(void);
4276DECLASM(void) supdrvNtQueryVirtualMemory_0x21(void);
4277DECLASM(void) supdrvNtQueryVirtualMemory_0x22(void);
4278DECLASM(void) supdrvNtQueryVirtualMemory_0x23(void);
4279extern "C" NTSYSAPI NTSTATUS NTAPI ZwRequestWaitReplyPort(HANDLE, PVOID, PVOID);
4280# endif
4281
4282/**
4283 * Initalizes the hardening bits.
4284 *
4285 * @returns NT status code.
4286 */
4287static NTSTATUS supdrvNtProtectInit(void)
4288{
4289 /*
4290 * Initialize the globals.
4291 */
4292
4293 /* The NT version. */
4294 ULONG uMajor, uMinor, uBuild;
4295 PsGetVersion(&uMajor, &uMinor, &uBuild, NULL);
4296 g_uNtVerCombined = SUP_MAKE_NT_VER_COMBINED(uMajor, uMinor, uBuild, 0, 0);
4297
4298 /* Resolve methods we want but isn't available everywhere. */
4299 UNICODE_STRING RoutineName;
4300
4301 RtlInitUnicodeString(&RoutineName, L"ObGetObjectType");
4302 g_pfnObGetObjectType = (PFNOBGETOBJECTTYPE)MmGetSystemRoutineAddress(&RoutineName);
4303
4304 RtlInitUnicodeString(&RoutineName, L"ObRegisterCallbacks");
4305 g_pfnObRegisterCallbacks = (PFNOBREGISTERCALLBACKS)MmGetSystemRoutineAddress(&RoutineName);
4306
4307 RtlInitUnicodeString(&RoutineName, L"ObUnRegisterCallbacks");
4308 g_pfnObUnRegisterCallbacks = (PFNOBUNREGISTERCALLBACKS)MmGetSystemRoutineAddress(&RoutineName);
4309
4310 RtlInitUnicodeString(&RoutineName, L"PsSetCreateProcessNotifyRoutineEx");
4311 g_pfnPsSetCreateProcessNotifyRoutineEx = (PFNPSSETCREATEPROCESSNOTIFYROUTINEEX)MmGetSystemRoutineAddress(&RoutineName);
4312
4313 RtlInitUnicodeString(&RoutineName, L"PsReferenceProcessFilePointer");
4314 g_pfnPsReferenceProcessFilePointer = (PFNPSREFERENCEPROCESSFILEPOINTER)MmGetSystemRoutineAddress(&RoutineName);
4315
4316 RtlInitUnicodeString(&RoutineName, L"PsIsProtectedProcessLight");
4317 g_pfnPsIsProtectedProcessLight = (PFNPSISPROTECTEDPROCESSLIGHT)MmGetSystemRoutineAddress(&RoutineName);
4318
4319 RtlInitUnicodeString(&RoutineName, L"ZwAlpcCreatePort");
4320 g_pfnZwAlpcCreatePort = (PFNZWALPCCREATEPORT)MmGetSystemRoutineAddress(&RoutineName);
4321
4322 RtlInitUnicodeString(&RoutineName, L"ZwQueryVirtualMemory"); /* Yes, using Zw version here. */
4323 g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)MmGetSystemRoutineAddress(&RoutineName);
4324 if (!g_pfnNtQueryVirtualMemory && g_uNtVerCombined < SUP_NT_VER_VISTA)
4325 {
4326 /* XP & W2K3 doesn't have this function exported, so we've cooked up a
4327 few alternative in the assembly helper file that uses the code in
4328 ZwReadFile with a different eax value. We figure the syscall number
4329 by inspecting ZwQueryVolumeInformationFile as it's the next number. */
4330# ifdef RT_ARCH_X86
4331 uint8_t const *pbCode = (uint8_t const *)(uintptr_t)ZwQueryVolumeInformationFile;
4332 if (*pbCode == 0xb8) /* mov eax, dword */
4333 switch (*(uint32_t const *)&pbCode[1])
4334 {
4335 case 0xb0: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xAF; break; /* just in case */
4336 case 0xb1: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB0; break; /* just in case */
4337 case 0xb2: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB1; break; /* just in case */
4338 case 0xb3: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB2; break; /* XP SP3 */
4339 case 0xb4: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB2; break; /* just in case */
4340 case 0xb5: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB3; break; /* just in case */
4341 case 0xb6: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB4; break; /* just in case */
4342 case 0xb7: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB5; break; /* just in case */
4343 case 0xb8: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB6; break; /* just in case */
4344 case 0xb9: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB7; break; /* just in case */
4345 case 0xba: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xB8; break; /* just in case */
4346 case 0xbb: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xBA; break; /* W2K3 R2 SP2 */
4347 case 0xbc: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xBB; break; /* just in case */
4348 case 0xbd: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xBC; break; /* just in case */
4349 case 0xbe: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xBD; break; /* just in case */
4350 case 0xbf: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0xBE; break; /* just in case */
4351 }
4352# elif defined(RT_ARCH_AMD64)
4353 uint8_t const *pbCode = (uint8_t const *)(uintptr_t)ZwRequestWaitReplyPort;
4354 if ( pbCode[ 0] == 0x48 /* mov rax, rsp */
4355 && pbCode[ 1] == 0x8b
4356 && pbCode[ 2] == 0xc4
4357 && pbCode[ 3] == 0xfa /* cli */
4358 && pbCode[ 4] == 0x48 /* sub rsp, 10h */
4359 && pbCode[ 5] == 0x83
4360 && pbCode[ 6] == 0xec
4361 && pbCode[ 7] == 0x10
4362 && pbCode[ 8] == 0x50 /* push rax */
4363 && pbCode[ 9] == 0x9c /* pushfq */
4364 && pbCode[10] == 0x6a /* push 10 */
4365 && pbCode[11] == 0x10
4366 && pbCode[12] == 0x48 /* lea rax, [nt!KiServiceLinkage] */
4367 && pbCode[13] == 0x8d
4368 && pbCode[14] == 0x05
4369 && pbCode[19] == 0x50 /* push rax */
4370 && pbCode[20] == 0xb8 /* mov eax,1fh <- the syscall no. */
4371 /*&& pbCode[21] == 0x1f*/
4372 && pbCode[22] == 0x00
4373 && pbCode[23] == 0x00
4374 && pbCode[24] == 0x00
4375 && pbCode[25] == 0xe9 /* jmp KiServiceInternal */
4376 )
4377 {
4378 uint8_t const *pbKiServiceInternal = &pbCode[30] + *(int32_t const *)&pbCode[26];
4379 uint8_t const *pbKiServiceLinkage = &pbCode[19] + *(int32_t const *)&pbCode[15];
4380 if (*pbKiServiceLinkage == 0xc3)
4381 {
4382 g_pfnKiServiceInternal = (PFNRT)pbKiServiceInternal;
4383 g_pfnKiServiceLinkage = (PFNRT)pbKiServiceLinkage;
4384 switch (pbCode[21])
4385 {
4386 case 0x1e: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0x1F; break;
4387 case 0x1f: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0x20; break;
4388 case 0x20: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0x21; break;
4389 case 0x21: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0x22; break;
4390 case 0x22: g_pfnNtQueryVirtualMemory = (PFNNTQUERYVIRTUALMEMORY)supdrvNtQueryVirtualMemory_0x23; break;
4391 }
4392 }
4393 }
4394# endif
4395 }
4396 if (!g_pfnNtQueryVirtualMemory)
4397 {
4398 LogRel(("vboxdrv: Cannot locate ZwQueryVirtualMemory in ntoskrnl, nor were we able to cook up a replacement.\n"));
4399 return STATUS_PROCEDURE_NOT_FOUND;
4400 }
4401
4402# ifdef VBOX_STRICT
4403 if ( g_uNtVerCombined >= SUP_NT_VER_W70
4404 && ( g_pfnObGetObjectType == NULL
4405 || g_pfnZwAlpcCreatePort == NULL) )
4406 {
4407 LogRel(("vboxdrv: g_pfnObGetObjectType=%p g_pfnZwAlpcCreatePort=%p.\n", g_pfnObGetObjectType, g_pfnZwAlpcCreatePort));
4408 return STATUS_PROCEDURE_NOT_FOUND;
4409 }
4410# endif
4411
4412 /* LPC object type. */
4413 g_pAlpcPortObjectType1 = *LpcPortObjectType;
4414
4415 /* The spinlock protecting our structures. */
4416 int rc = RTSpinlockCreate(&g_hNtProtectLock, RTSPINLOCK_FLAGS_INTERRUPT_UNSAFE, "NtProtectLock");
4417 if (RT_FAILURE(rc))
4418 return VBoxDrvNtErr2NtStatus(rc);
4419 g_NtProtectTree = NULL;
4420
4421 NTSTATUS rcNt;
4422
4423 /* The mutex protecting the error information. */
4424 RTListInit(&g_ErrorInfoHead);
4425 rc = RTSemMutexCreate(&g_hErrorInfoLock);
4426 if (RT_SUCCESS(rc))
4427 {
4428 /* Image stuff + certificates. */
4429 rc = supHardenedWinInitImageVerifier(NULL);
4430 if (RT_SUCCESS(rc))
4431 {
4432 /*
4433 * Intercept process creation and termination.
4434 */
4435 if (g_pfnPsSetCreateProcessNotifyRoutineEx)
4436 rcNt = g_pfnPsSetCreateProcessNotifyRoutineEx(supdrvNtProtectCallback_ProcessCreateNotifyEx, FALSE /*fRemove*/);
4437 else
4438 rcNt = PsSetCreateProcessNotifyRoutine(supdrvNtProtectCallback_ProcessCreateNotify, FALSE /*fRemove*/);
4439 if (NT_SUCCESS(rcNt))
4440 {
4441 /*
4442 * Intercept process and thread handle creation calls.
4443 * The preferred method is only available on Vista SP1+.
4444 */
4445 if (g_pfnObRegisterCallbacks && g_pfnObUnRegisterCallbacks)
4446 {
4447 static OB_OPERATION_REGISTRATION s_aObOperations[] =
4448 {
4449 {
4450 PsProcessType,
4451 OB_OPERATION_HANDLE_CREATE | OB_OPERATION_HANDLE_DUPLICATE,
4452 supdrvNtProtectCallback_ProcessHandlePre,
4453 supdrvNtProtectCallback_ProcessHandlePost,
4454 },
4455 {
4456 PsThreadType,
4457 OB_OPERATION_HANDLE_CREATE | OB_OPERATION_HANDLE_DUPLICATE,
4458 supdrvNtProtectCallback_ThreadHandlePre,
4459 supdrvNtProtectCallback_ThreadHandlePost,
4460 },
4461 };
4462 static OB_CALLBACK_REGISTRATION s_ObCallbackReg =
4463 {
4464 /* .Version = */ OB_FLT_REGISTRATION_VERSION,
4465 /* .OperationRegistrationCount = */ RT_ELEMENTS(s_aObOperations),
4466 /* .Altitude.Length = */ 0,
4467 /* .Altitude.MaximumLength = */ 0,
4468 /* .Altitude.Buffer = */ NULL,
4469 /* .RegistrationContext = */ NULL,
4470 /* .OperationRegistration = */ &s_aObOperations[0]
4471 };
4472 static WCHAR const *s_apwszAltitudes[] = /** @todo get a valid number */
4473 {
4474 L"48596.98940", L"46935.19485", L"49739.39704", L"40334.74976",
4475 L"66667.98940", L"69888.19485", L"69889.39704", L"60364.74976",
4476 L"85780.98940", L"88978.19485", L"89939.39704", L"80320.74976",
4477 L"329879.98940", L"326787.19485", L"328915.39704", L"320314.74976",
4478 };
4479
4480 rcNt = STATUS_FLT_INSTANCE_ALTITUDE_COLLISION;
4481 for (uint32_t i = 0; i < RT_ELEMENTS(s_apwszAltitudes) && rcNt == STATUS_FLT_INSTANCE_ALTITUDE_COLLISION; i++)
4482 {
4483 s_ObCallbackReg.Altitude.Buffer = (WCHAR *)s_apwszAltitudes[i];
4484 s_ObCallbackReg.Altitude.Length = (uint16_t)RTUtf16Len(s_apwszAltitudes[i]) * sizeof(WCHAR);
4485 s_ObCallbackReg.Altitude.MaximumLength = s_ObCallbackReg.Altitude.Length + sizeof(WCHAR);
4486
4487 rcNt = g_pfnObRegisterCallbacks(&s_ObCallbackReg, &g_pvObCallbacksCookie);
4488 if (NT_SUCCESS(rcNt))
4489 {
4490 /*
4491 * Happy ending.
4492 */
4493 return STATUS_SUCCESS;
4494 }
4495 }
4496 LogRel(("vboxdrv: ObRegisterCallbacks failed with rcNt=%#x\n", rcNt));
4497 g_pvObCallbacksCookie = NULL;
4498 }
4499 else
4500 {
4501 /*
4502 * For the time being, we do not implement extra process
4503 * protection on pre-Vista-SP1 systems as they are lacking
4504 * necessary KPIs. XP is end of life, we do not wish to
4505 * spend more time on it, so we don't put up a fuss there.
4506 * Vista users without SP1 can install SP1 (or later), darn it,
4507 * so refuse to load.
4508 */
4509 /** @todo Hack up an XP solution - will require hooking kernel APIs or doing bad
4510 * stuff to a couple of object types. */
4511# ifndef VBOX_WITH_VISTA_NO_SP
4512 if (g_uNtVerCombined >= SUP_NT_VER_VISTA)
4513# else
4514 if (g_uNtVerCombined >= SUP_MAKE_NT_VER_COMBINED(6, 0, 6001, 0, 0))
4515# endif
4516 {
4517 DbgPrint("vboxdrv: ObRegisterCallbacks was not found. Please make sure you got the latest updates and service packs installed\n");
4518 rcNt = STATUS_SXS_VERSION_CONFLICT;
4519 }
4520 else
4521 {
4522 Log(("vboxdrv: ObRegisterCallbacks was not found; ignored pre-Vista\n"));
4523 return rcNt = STATUS_SUCCESS;
4524 }
4525 g_pvObCallbacksCookie = NULL;
4526 }
4527
4528 /*
4529 * Drop process create/term notifications.
4530 */
4531 if (g_pfnPsSetCreateProcessNotifyRoutineEx)
4532 g_pfnPsSetCreateProcessNotifyRoutineEx(supdrvNtProtectCallback_ProcessCreateNotifyEx, TRUE /*fRemove*/);
4533 else
4534 PsSetCreateProcessNotifyRoutine(supdrvNtProtectCallback_ProcessCreateNotify, TRUE /*fRemove*/);
4535 }
4536 else
4537 LogRel(("vboxdrv: PsSetCreateProcessNotifyRoutine%s failed with rcNt=%#x\n",
4538 g_pfnPsSetCreateProcessNotifyRoutineEx ? "Ex" : "", rcNt));
4539 supHardenedWinTermImageVerifier();
4540 }
4541 else
4542 rcNt = VBoxDrvNtErr2NtStatus(rc);
4543
4544 RTSemMutexDestroy(g_hErrorInfoLock);
4545 g_hErrorInfoLock = NIL_RTSEMMUTEX;
4546 }
4547 else
4548 rcNt = VBoxDrvNtErr2NtStatus(rc);
4549
4550 RTSpinlockDestroy(g_hNtProtectLock);
4551 g_NtProtectTree = NIL_RTSPINLOCK;
4552 return rcNt;
4553}
4554
4555#endif /* VBOX_WITH_HARDENING */
4556
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette