ReactOS 0.4.16-dev-2491-g3dc6630
Functions
NtQueryInformationThread.c File Reference
#include "precomp.h"
#include <internal/ps_i.h>
Include dependency graph for NtQueryInformationThread.c:

Go to the source code of this file.

Functions

static void Test_ThreadBasicInformationClass (void)
 
static ULONG NTAPI DummyThread (_In_ PVOID Parameter)
 
static void Test_ThreadHideFromDebuggerClass (void)
 
static void Test_ThreadQueryAlignmentProbe (void)
 
 START_TEST (NtQueryInformationThread)
 

Function Documentation

◆ DummyThread()

static ULONG NTAPI DummyThread ( _In_ PVOID  Parameter)
static

Definition at line 106 of file NtQueryInformationThread.c.

108{
109 HANDLE hWaitEvent = (HANDLE)Parameter;
110 NTSTATUS Status;
111
112 /* Indefinitely wait for the kill signal */
113 Status = NtWaitForSingleObject(hWaitEvent, FALSE, NULL);
114 ASSERT(NT_SUCCESS(Status));
115
116 NtTerminateThread(NtCurrentThread(), Status);
117 return Status;
118}
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
Status
Status
Definition: gdiplustypes.h:25
ASSERT
#define ASSERT(a)
Definition: mode.c:44
NtTerminateThread
NTSTATUS NtTerminateThread(IN HANDLE ThreadHandle OPTIONAL, IN NTSTATUS ExitStatus)
Definition: kill.c:1279
NtWaitForSingleObject
NTSYSAPI NTSTATUS NTAPI NtWaitForSingleObject(IN HANDLE hObject, IN BOOLEAN bAlertable, IN PLARGE_INTEGER Timeout)
HANDLE
PVOID HANDLE
Definition: typedefs.h:73
NtCurrentThread
#define NtCurrentThread()
Definition: winternl.h:5368
Parameter
_Inout_opt_ PVOID Parameter
Definition: rtltypes.h:336

Referenced by Test_ThreadHideFromDebuggerClass().

◆ START_TEST()

START_TEST ( NtQueryInformationThread  )

Definition at line 298 of file NtQueryInformationThread.c.

299{
300 Test_ThreadBasicInformationClass();
301 Test_ThreadHideFromDebuggerClass();
302 Test_ThreadQueryAlignmentProbe();
303}
Test_ThreadHideFromDebuggerClass
static void Test_ThreadHideFromDebuggerClass(void)
Definition: NtQueryInformationThread.c:122
Test_ThreadBasicInformationClass
static void Test_ThreadBasicInformationClass(void)
Definition: NtQueryInformationThread.c:13
Test_ThreadQueryAlignmentProbe
static void Test_ThreadQueryAlignmentProbe(void)
Definition: NtQueryInformationThread.c:268

◆ Test_ThreadBasicInformationClass()

static void Test_ThreadBasicInformationClass ( void  )
static

Definition at line 13 of file NtQueryInformationThread.c.

14{
15 NTSTATUS Status;
16 PTHREAD_BASIC_INFORMATION ThreadInfoBasic;
17 ULONG ReturnedLength;
18
19 ThreadInfoBasic = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(THREAD_BASIC_INFORMATION));
20 if (!ThreadInfoBasic)
21 {
22 skip("Failed to allocate memory for THREAD_BASIC_INFORMATION!\n");
23 return;
24 }
25
26 /* Everything is NULL */
27 Status = NtQueryInformationThread(NULL,
28 ThreadBasicInformation,
29 NULL,
30 0,
31 NULL);
32 ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
33
34 /* Don't give a valid thread handle */
35 Status = NtQueryInformationThread(NULL,
36 ThreadBasicInformation,
37 ThreadInfoBasic,
38 sizeof(THREAD_BASIC_INFORMATION),
39 NULL);
40 ok_hex(Status, STATUS_INVALID_HANDLE);
41
42 /* The information length is incorrect */
43 Status = NtQueryInformationThread(GetCurrentThread(),
44 ThreadBasicInformation,
45 ThreadInfoBasic,
46 0,
47 NULL);
48 ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
49
50 /* Don't query anything from the function */
51 Status = NtQueryInformationThread(GetCurrentThread(),
52 ThreadBasicInformation,
53 NULL,
54 sizeof(THREAD_BASIC_INFORMATION),
55 NULL);
56 ok_hex(Status, STATUS_ACCESS_VIOLATION);
57
58 /* The buffer is misaligned and length information is wrong */
59 Status = NtQueryInformationThread(GetCurrentThread(),
60 ThreadBasicInformation,
61 (PVOID)1,
62 0,
63 NULL);
64 ok_hex(Status, STATUS_INFO_LENGTH_MISMATCH);
65
66 /* The buffer is misaligned */
67 Status = NtQueryInformationThread(GetCurrentThread(),
68 ThreadBasicInformation,
69 (PVOID)1,
70 sizeof(THREAD_BASIC_INFORMATION),
71 NULL);
72 ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
73
74 /* The buffer is misaligned, try with an alignment size of 2 */
75 Status = NtQueryInformationThread(GetCurrentThread(),
76 ThreadBasicInformation,
77 (PVOID)2,
78 sizeof(THREAD_BASIC_INFORMATION),
79 NULL);
80 ok_hex(Status, STATUS_DATATYPE_MISALIGNMENT);
81
82 /* Query the basic information we need from the thread */
83 Status = NtQueryInformationThread(GetCurrentThread(),
84 ThreadBasicInformation,
85 ThreadInfoBasic,
86 sizeof(THREAD_BASIC_INFORMATION),
87 &ReturnedLength);
88 ok_hex(Status, STATUS_SUCCESS);
89 ok(ReturnedLength != 0, "The size of the buffer pointed by ThreadInformation shouldn't be 0!\n");
90
91 /* Output the thread basic information details */
92 trace("ReturnedLength = %lu\n", ReturnedLength);
93 trace("ThreadInfoBasic->ExitStatus = 0x%08lx\n", ThreadInfoBasic->ExitStatus);
94 trace("ThreadInfoBasic->TebBaseAddress = %p\n", ThreadInfoBasic->TebBaseAddress);
95 trace("ThreadInfoBasic->ClientId.UniqueProcess = %p\n", ThreadInfoBasic->ClientId.UniqueProcess);
96 trace("ThreadInfoBasic->ClientId.UniqueThread = %p\n", ThreadInfoBasic->ClientId.UniqueThread);
97 trace("ThreadInfoBasic->AffinityMask = %lu\n", ThreadInfoBasic->AffinityMask);
98 trace("ThreadInfoBasic->Priority = %li\n", ThreadInfoBasic->Priority);
99 trace("ThreadInfoBasic->BasePriority = %li\n", ThreadInfoBasic->BasePriority);
100
101 HeapFree(GetProcessHeap(), 0, ThreadInfoBasic);
102}
ok_hex
#define ok_hex(expression, result)
Definition: atltest.h:94
trace
#define trace
Definition: atltest.h:70
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
ReturnedLength
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG _In_ ULONG _Out_ PULONG ReturnedLength
Definition: batclass.h:188
STATUS_INVALID_HANDLE
#define STATUS_INVALID_HANDLE
Definition: d3dkmdt.h:40
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
ThreadBasicInformation
@ ThreadBasicInformation
Definition: compat.h:935
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
HEAP_ZERO_MEMORY
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
NtQueryInformationThread
NTSTATUS NTAPI NtQueryInformationThread(_In_ HANDLE ThreadHandle, _In_ THREADINFOCLASS ThreadInformationClass, _Out_writes_bytes_to_opt_(ThreadInformationLength, *ReturnLength) PVOID ThreadInformation, _In_ ULONG ThreadInformationLength, _Out_opt_ PULONG ReturnLength)
Definition: query.c:2899
STATUS_DATATYPE_MISALIGNMENT
#define STATUS_DATATYPE_MISALIGNMENT
Definition: ntstatus.h:263
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_CLIENT_ID::UniqueThread
HANDLE UniqueThread
Definition: compat.h:826
_CLIENT_ID::UniqueProcess
HANDLE UniqueProcess
Definition: compat.h:825
_THREAD_BASIC_INFORMATION
Definition: compat.h:926
_THREAD_BASIC_INFORMATION::ClientId
CLIENT_ID ClientId
Definition: compat.h:929
_THREAD_BASIC_INFORMATION::Priority
KPRIORITY Priority
Definition: compat.h:931
_THREAD_BASIC_INFORMATION::BasePriority
KPRIORITY BasePriority
Definition: compat.h:932
_THREAD_BASIC_INFORMATION::ExitStatus
NTSTATUS ExitStatus
Definition: compat.h:927
_THREAD_BASIC_INFORMATION::TebBaseAddress
PVOID TebBaseAddress
Definition: compat.h:928
_THREAD_BASIC_INFORMATION::AffinityMask
KAFFINITY AffinityMask
Definition: compat.h:930
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_INFO_LENGTH_MISMATCH
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
GetCurrentThread
HANDLE WINAPI GetCurrentThread(void)
Definition: proc.c:1146

Referenced by START_TEST().

◆ Test_ThreadHideFromDebuggerClass()

static void Test_ThreadHideFromDebuggerClass ( void  )
static

Definition at line 122 of file NtQueryInformationThread.c.

123{
124 NTSTATUS Status;
125 HANDLE hWaitEvent = NULL, hThread = NULL;
126 BOOLEAN IsThreadHidden;
127 ULONG UlongData;
128 BOOL IsWow64 = FALSE;
129
130 if (GetNTVersion() < _WIN32_WINNT_VISTA)
131 {
132 skip("Skipping test as NtQueryInformationThread(ThreadHideFromDebugger) isn't supported prior to Vista\n");
133 return;
134 }
135 IsWow64Process(GetCurrentProcess(), &IsWow64);
136
137 Status = NtCreateEvent(&hWaitEvent,
138 EVENT_ALL_ACCESS,
139 NULL,
140 NotificationEvent,
141 FALSE);
142 ok_ntstatus(Status, STATUS_SUCCESS);
143 ok(hWaitEvent != NULL, "Expected not NULL, got NULL\n");
144 if (!NT_SUCCESS(Status))
145 {
146 skip("Could not create the stop event! (Status 0x%08lx)\n", Status);
147 goto Quit;
148 }
149
150 /* Create the dummy thread and wait for it to start up */
151 Status = RtlCreateUserThread(NtCurrentProcess(),
152 NULL,
153 FALSE,
154 0,
155 0,
156 0,
157 DummyThread,
158 (PVOID)hWaitEvent,
159 &hThread,
160 NULL);
161 ok_ntstatus(Status, STATUS_SUCCESS);
162 ok(hThread != NULL, "Expected not NULL, got NULL\n");
163 if (!NT_SUCCESS(Status))
164 {
165 skip("Failed to create the dummy thread (Status 0x%08lx)\n", Status);
166 goto Quit;
167 }
168
169
170 /* Verify that the thread is debuggable by default */
171 IsThreadHidden = 0xCC;
172 Status = NtQueryInformationThread(hThread,
173 ThreadHideFromDebugger,
174 &IsThreadHidden,
175 sizeof(IsThreadHidden),
176 NULL);
177 ok_ntstatus(Status, STATUS_SUCCESS);
178 ok_bool_false(IsThreadHidden, "IsThreadHidden is");
179
180 /* Make the thread hidden from the debugger -- The wrong way (1) */
181 IsThreadHidden = TRUE;
182 Status = NtSetInformationThread(hThread,
183 ThreadHideFromDebugger,
184 &IsThreadHidden,
185 sizeof(IsThreadHidden));
186 if (IsWow64)
187 ok_ntstatus(Status, STATUS_DATATYPE_MISALIGNMENT);
188 else
189 ok_ntstatus(Status, STATUS_INFO_LENGTH_MISMATCH);
190
191 /* The thread is still debuggable */
192 IsThreadHidden = 0xCC;
193 Status = NtQueryInformationThread(hThread,
194 ThreadHideFromDebugger,
195 &IsThreadHidden,
196 sizeof(IsThreadHidden),
197 NULL);
198 ok_ntstatus(Status, STATUS_SUCCESS);
199 ok_bool_false(IsThreadHidden, "IsThreadHidden is");
200
201 /* Make the thread hidden from the debugger -- The wrong way (2) */
202 UlongData = TRUE;
203 Status = NtSetInformationThread(hThread,
204 ThreadHideFromDebugger,
205 &UlongData,
206 sizeof(UlongData));
207 ok_ntstatus(Status, STATUS_INFO_LENGTH_MISMATCH);
208
209 /* The thread is still debuggable */
210 IsThreadHidden = 0xCC;
211 Status = NtQueryInformationThread(hThread,
212 ThreadHideFromDebugger,
213 &IsThreadHidden,
214 sizeof(IsThreadHidden),
215 NULL);
216 ok_ntstatus(Status, STATUS_SUCCESS);
217 ok_bool_false(IsThreadHidden, "IsThreadHidden is");
218
219 /* Make the thread hidden from the debugger -- The wrong way (3) */
220 UlongData = TRUE;
221 Status = NtSetInformationThread(hThread,
222 ThreadHideFromDebugger,
223 &UlongData,
224 sizeof(BOOLEAN));
225 ok_ntstatus(Status, STATUS_INFO_LENGTH_MISMATCH);
226
227 /* The thread is still debuggable */
228 IsThreadHidden = 0xCC;
229 Status = NtQueryInformationThread(hThread,
230 ThreadHideFromDebugger,
231 &IsThreadHidden,
232 sizeof(IsThreadHidden),
233 NULL);
234 ok_ntstatus(Status, STATUS_SUCCESS);
235 ok_bool_false(IsThreadHidden, "IsThreadHidden is");
236
237 /* Make the thread hidden from the debugger -- This way works! */
238 Status = NtSetInformationThread(hThread,
239 ThreadHideFromDebugger,
240 NULL, 0);
241 ok_ntstatus(Status, STATUS_SUCCESS);
242
243 /* Verify that the thread is now hidden from the debugger */
244 IsThreadHidden = 0xCC;
245 Status = NtQueryInformationThread(hThread,
246 ThreadHideFromDebugger,
247 &IsThreadHidden,
248 sizeof(IsThreadHidden),
249 NULL);
250 ok_ntstatus(Status, STATUS_SUCCESS);
251 ok_bool_true(IsThreadHidden, "IsThreadHidden is");
252
253
254 /* Send the kill signal and wait for the thread to terminate */
255 NtSetEvent(hWaitEvent, NULL);
256 NtWaitForSingleObject(hThread, FALSE, NULL);
257 /* Close the thread */
258 NtTerminateThread(hThread, STATUS_SUCCESS);
259 NtClose(hThread);
260Quit:
261 /* Close the event */
262 if (hWaitEvent)
263 NtClose(hWaitEvent);
264}
DummyThread
static ULONG NTAPI DummyThread(_In_ PVOID Parameter)
Definition: NtQueryInformationThread.c:106
IsWow64
#define IsWow64()
Definition: NtReadFile.c:37
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17
ok_bool_false
#define ok_bool_false(value, desc)
Definition: apitest.h:136
ok_bool_true
#define ok_bool_true(value, desc)
Definition: apitest.h:135
ok_ntstatus
#define ok_ntstatus(status, expected)
Definition: atltest.h:135
TRUE
#define TRUE
Definition: types.h:120
ThreadHideFromDebugger
@ ThreadHideFromDebugger
Definition: compat.h:952
GetCurrentProcess
#define GetCurrentProcess()
Definition: compat.h:759
IsWow64Process
#define IsWow64Process
Definition: compat.h:760
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
EVENT_ALL_ACCESS
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
RtlCreateUserThread
NTSYSAPI NTSTATUS NTAPI RtlCreateUserThread(_In_ PVOID ThreadContext, _Out_ HANDLE *OutThreadHandle, _Reserved_ PVOID Reserved1, _Reserved_ PVOID Reserved2, _Reserved_ PVOID Reserved3, _Reserved_ PVOID Reserved4, _Reserved_ PVOID Reserved5, _Reserved_ PVOID Reserved6, _Reserved_ PVOID Reserved7, _Reserved_ PVOID Reserved8)
hThread
HANDLE hThread
Definition: wizard.c:28
NtCurrentProcess
#define NtCurrentProcess()
Definition: nt_native.h:1660
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NotificationEvent
@ NotificationEvent
Definition: ntdef.template.h:365
NtSetEvent
NTSTATUS NTAPI NtSetEvent(IN HANDLE EventHandle, OUT PLONG PreviousState OPTIONAL)
Definition: event.c:463
NtCreateEvent
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:96
NtSetInformationThread
NTSTATUS NTAPI NtSetInformationThread(_In_ HANDLE ThreadHandle, _In_ THREADINFOCLASS ThreadInformationClass, _In_reads_bytes_(ThreadInformationLength) PVOID ThreadInformation, _In_ ULONG ThreadInformationLength)
Definition: query.c:2269
_WIN32_WINNT_VISTA
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25

Referenced by START_TEST().

◆ Test_ThreadQueryAlignmentProbe()

static void Test_ThreadQueryAlignmentProbe ( void  )
static

Definition at line 268 of file NtQueryInformationThread.c.

269{
270 ULONG InfoClass;
271
272 /* Iterate over the process info classes and begin the tests */
273 for (InfoClass = 0; InfoClass < _countof(PsThreadInfoClass); InfoClass++)
274 {
275 /* The buffer is misaligned */
276 QuerySetThreadValidator(QUERY,
277 InfoClass,
278 (PVOID)(ULONG_PTR)1,
279 PsThreadInfoClass[InfoClass].RequiredSizeQUERY,
280 STATUS_DATATYPE_MISALIGNMENT);
281
282 /* We query an invalid buffer address */
283 QuerySetThreadValidator(QUERY,
284 InfoClass,
285 (PVOID)(ULONG_PTR)PsThreadInfoClass[InfoClass].AlignmentQUERY,
286 PsThreadInfoClass[InfoClass].RequiredSizeQUERY,
287 STATUS_ACCESS_VIOLATION);
288
289 /* The information length is wrong */
290 QuerySetThreadValidator(QUERY,
291 InfoClass,
292 (PVOID)(ULONG_PTR)PsThreadInfoClass[InfoClass].AlignmentQUERY,
293 PsThreadInfoClass[InfoClass].RequiredSizeQUERY - 1,
294 STATUS_INFO_LENGTH_MISMATCH);
295 }
296}
QUERY
@ QUERY
Definition: precomp.h:18
QuerySetThreadValidator
VOID QuerySetThreadValidator(_In_ ALIGNMENT_PROBE_MODE ValidationMode, _In_ ULONG InfoClassIndex, _In_ PVOID InfoPointer, _In_ ULONG InfoLength, _In_ NTSTATUS ExpectedStatus)
Definition: probelib.c:259
PsThreadInfoClass
static const INFORMATION_CLASS_INFO PsThreadInfoClass[]
Definition: ps_i.h:362
_countof
#define _countof(array)
Definition: sndvol32.h:70
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65

Referenced by START_TEST().