ReactOS 0.4.15-dev-7711-g5627da4
NtQueryInformationToken.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS API tests
3 * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
4 * PURPOSE: Tests for the NtQueryInformationToken API
5 * COPYRIGHT: Copyright 2022 George Bișoc <george.bisoc@reactos.org>
6 */
7
8#include "precomp.h"
9
10static
13{
16
19 &Token);
20 if (!Success)
21 {
22 ok(FALSE, "OpenProcessToken() has failed to get the process' token (error code: %lu)!\n", GetLastError());
23 return NULL;
24 }
25
26 return Token;
27}
28
29static
30VOID
33{
35 PTOKEN_USER UserToken;
37 UNICODE_STRING SidString;
38
39 /*
40 * Query the exact buffer length to hold
41 * our stuff, STATUS_BUFFER_TOO_SMALL must
42 * be expected here.
43 */
46 NULL,
47 0,
50
51 /* Allocate the buffer based on the size we got */
52 UserToken = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
53 if (!UserToken)
54 {
55 ok(FALSE, "Failed to allocate from heap for token user (required buffer length %lu)!\n", BufferLength);
56 return;
57 }
58
59 /* Now do the actual query */
62 UserToken,
66
67 RtlConvertSidToUnicodeString(&SidString, UserToken->User.Sid, TRUE);
68 trace("=============== TokenUser ===============\n");
69 trace("The SID of current token user is: %s\n", wine_dbgstr_w(SidString.Buffer));
70 trace("=========================================\n\n");
71 RtlFreeUnicodeString(&SidString);
72
73 RtlFreeHeap(RtlGetProcessHeap(), 0, UserToken);
74}
75
76static
77VOID
80{
82 PTOKEN_GROUPS Groups;
84
85 /*
86 * Query the exact buffer length to hold
87 * our stuff, STATUS_BUFFER_TOO_SMALL must
88 * be expected here.
89 */
92 NULL,
93 0,
96
97 /* Allocate the buffer based on the size we got */
98 Groups = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
99 if (!Groups)
100 {
101 ok(FALSE, "Failed to allocate from heap for token groups (required buffer length %lu)!\n", BufferLength);
102 return;
103 }
104
105 /*
106 * Now do the actual query and validate the
107 * number of groups.
108 */
111 Groups,
113 &BufferLength);
115 ok(Groups->GroupCount == 10, "The number of groups must be 10 (current number %lu)!\n", Groups->GroupCount);
116
117 RtlFreeHeap(RtlGetProcessHeap(), 0, Groups);
118}
119
120static
121VOID
124{
128
129 /*
130 * Query the exact buffer length to hold
131 * our stuff, STATUS_BUFFER_TOO_SMALL must
132 * be expected here.
133 */
136 NULL,
137 0,
138 &BufferLength);
140
141 /* Allocate the buffer based on the size we got */
142 Privileges = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
143 if (!Privileges)
144 {
145 ok(FALSE, "Failed to allocate from heap for token privileges (required buffer length %lu)!\n", BufferLength);
146 return;
147 }
148
149 /*
150 * Now do the actual query and validate the
151 * number of privileges.
152 */
157 &BufferLength);
159 ok(Privileges->PrivilegeCount == 20, "The number of privileges must be 20 (current number %lu)!\n", Privileges->PrivilegeCount);
160
161 RtlFreeHeap(RtlGetProcessHeap(), 0, Privileges);
162}
163
164static
165VOID
168{
172 UNICODE_STRING SidString;
173
174 /*
175 * Query the exact buffer length to hold
176 * our stuff, STATUS_BUFFER_TOO_SMALL must
177 * be expected here.
178 */
181 NULL,
182 0,
183 &BufferLength);
185
186 /* Allocate the buffer based on the size we got */
187 Owner = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
188 if (!Owner)
189 {
190 ok(FALSE, "Failed to allocate from heap for token owner (required buffer length %lu)!\n", BufferLength);
191 return;
192 }
193
194 /*
195 * Now do the actual query and validate the
196 * token owner (must be the local admin).
197 */
200 Owner,
202 &BufferLength);
204
206 ok_wstr(SidString.Buffer, L"S-1-5-32-544");
207 RtlFreeUnicodeString(&SidString);
208
209 RtlFreeHeap(RtlGetProcessHeap(), 0, Owner);
210}
211
212static
213VOID
216{
220 UNICODE_STRING SidString;
221
222 /*
223 * Query the exact buffer length to hold
224 * our stuff, STATUS_BUFFER_TOO_SMALL must
225 * be expected here.
226 */
229 NULL,
230 0,
231 &BufferLength);
233
234 /* Allocate the buffer based on the size we got */
235 PrimaryGroup = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
236 if (!PrimaryGroup)
237 {
238 ok(FALSE, "Failed to allocate from heap for token primary group (required buffer length %lu)!\n", BufferLength);
239 return;
240 }
241
242 /* Now do the actual query */
247 &BufferLength);
249
250 RtlConvertSidToUnicodeString(&SidString, PrimaryGroup->PrimaryGroup, TRUE);
251 trace("=============== TokenPrimaryGroup ===============\n");
252 trace("The primary group SID of current token is: %s\n", wine_dbgstr_w(SidString.Buffer));
253 trace("=========================================\n\n");
254 RtlFreeUnicodeString(&SidString);
255
256 RtlFreeHeap(RtlGetProcessHeap(), 0, PrimaryGroup);
257}
258
259static
260VOID
263{
267
268 /*
269 * Query the exact buffer length to hold
270 * our stuff, STATUS_BUFFER_TOO_SMALL must
271 * be expected here.
272 */
275 NULL,
276 0,
277 &BufferLength);
279
280 /* Allocate the buffer based on the size we got */
281 Dacl = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
282 if (!Dacl)
283 {
284 ok(FALSE, "Failed to allocate from heap for token default DACL (required buffer length %lu)!\n", BufferLength);
285 return;
286 }
287
288 /*
289 * Now do the actual query and validate the
290 * ACL revision and number count of ACEs.
291 */
294 Dacl,
296 &BufferLength);
298 ok(Dacl->DefaultDacl->AclRevision == 2, "The ACL revision of token default DACL must be 2 (current revision %u)!\n", Dacl->DefaultDacl->AclRevision);
299 ok(Dacl->DefaultDacl->AceCount == 2, "The ACL's ACE count must be 2 (current ACE count %u)!\n", Dacl->DefaultDacl->AceCount);
300
301 RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl);
302}
303
304static
305VOID
308{
312 CHAR SourceName[8];
313
314 /*
315 * Query the exact buffer length to hold
316 * our stuff, STATUS_BUFFER_TOO_SMALL must
317 * be expected here.
318 */
321 NULL,
322 0,
323 &BufferLength);
325
326 /* Allocate the buffer based on the size we got */
327 Source = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
328 if (!Source)
329 {
330 ok(FALSE, "Failed to allocate from heap for token source (required buffer length %lu)!\n", BufferLength);
331 return;
332 }
333
334 /* Now do the actual query */
337 Source,
339 &BufferLength);
341
342 /*
343 * Subtract the source name from the queried buffer
344 * and compare it. The source name in question must be
345 * "User32" as the primary token of the current calling
346 * process is generated when the user has successfully
347 * logged in and he's into the desktop.
348 */
349 SourceName[0] = Source->SourceName[0];
350 SourceName[1] = Source->SourceName[1];
351 SourceName[2] = Source->SourceName[2];
352 SourceName[3] = Source->SourceName[3];
353 SourceName[4] = Source->SourceName[4];
354 SourceName[5] = Source->SourceName[5];
355 SourceName[6] = '\0';
356 ok_str(SourceName, "User32");
357
358 RtlFreeHeap(RtlGetProcessHeap(), 0, Source);
359}
360
361static
362VOID
365{
369
370 /*
371 * Query the token type. The token of the
372 * current calling process must be primary
373 * since we aren't impersonating the security
374 * context of a client.
375 */
377 TokenType,
378 &Type,
379 sizeof(TOKEN_TYPE),
380 &BufferLength);
382 ok(Type == TokenPrimary, "The current token is not primary!\n");
383}
384
385static
386VOID
389{
393 HANDLE DupToken;
395
396 /*
397 * Windows throws STATUS_INVALID_INFO_CLASS here
398 * because one cannot simply query the impersonation
399 * level of a primary token.
400 */
403 &Level,
405 &BufferLength);
407
408 /*
409 * Initialize the object attribute and duplicate
410 * the token into an actual impersonation one.
411 */
413 NULL,
414 0,
415 NULL,
416 NULL);
417
421 FALSE,
423 &DupToken);
424 if (!NT_SUCCESS(Status))
425 {
426 ok(FALSE, "Failed to duplicate token (Status code %lx)!\n", Status);
427 return;
428 }
429
430 /* Now do the actual query */
433 &Level,
435 &BufferLength);
437 ok(Level == SecurityAnonymous, "The current token impersonation level is not anonymous!\n");
438 NtClose(DupToken);
439}
440
441static
442VOID
445{
447 PTOKEN_STATISTICS Statistics;
449
450 /*
451 * Query the exact buffer length to hold
452 * our stuff, STATUS_BUFFER_TOO_SMALL must
453 * be expected here.
454 */
457 NULL,
458 0,
459 &BufferLength);
461
462 /* Allocate the buffer based on the size we got */
463 Statistics = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
464 if (!Statistics)
465 {
466 ok(FALSE, "Failed to allocate from heap for token statistics (required buffer length %lu)!\n", BufferLength);
467 return;
468 }
469
470 /* Do the actual query */
473 Statistics,
475 &BufferLength);
477
478 trace("=============== TokenStatistics ===============\n");
479 trace("Token ID: %lu %lu\n", Statistics->TokenId.LowPart, Statistics->TokenId.HighPart);
480 trace("Authentication ID: %lu %lu\n", Statistics->AuthenticationId.LowPart, Statistics->AuthenticationId.HighPart);
481 trace("Dynamic Charged: %lu\n", Statistics->DynamicCharged);
482 trace("Dynamic Available: %lu\n", Statistics->DynamicAvailable);
483 trace("Modified ID: %lu %lu\n", Statistics->ModifiedId.LowPart, Statistics->ModifiedId.HighPart);
484 trace("=========================================\n\n");
485
486 RtlFreeHeap(RtlGetProcessHeap(), 0, Statistics);
487}
488
489static
490VOID
493{
495 PTOKEN_GROUPS_AND_PRIVILEGES PrivsAndGroups;
496 TOKEN_GROUPS SidToRestrict;
497 HANDLE FilteredToken;
501
502 /*
503 * Create a World SID and filter the token
504 * by adding a restricted SID.
505 */
507 1,
509 0, 0, 0, 0, 0, 0, 0,
510 &WorldSid);
511 if (!NT_SUCCESS(Status))
512 {
513 ok(FALSE, "Failed to allocate World SID (Status code %lx)!\n", Status);
514 return;
515 }
516
517 SidToRestrict.GroupCount = 1;
518 SidToRestrict.Groups[0].Attributes = 0;
519 SidToRestrict.Groups[0].Sid = WorldSid;
520
522 0,
523 NULL,
524 NULL,
525 &SidToRestrict,
526 &FilteredToken);
527 if (!NT_SUCCESS(Status))
528 {
529 ok(FALSE, "Failed to filter the current token (Status code %lx)!\n", Status);
530 RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
531 return;
532 }
533
534 /*
535 * Query the exact buffer length to hold
536 * our stuff, STATUS_BUFFER_TOO_SMALL must
537 * be expected here.
538 */
539 Status = NtQueryInformationToken(FilteredToken,
541 NULL,
542 0,
543 &BufferLength);
545
546 /* Allocate the buffer based on the size we got */
547 PrivsAndGroups = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
548 if (!PrivsAndGroups)
549 {
550 ok(FALSE, "Failed to allocate from heap for token privileges and groups (required buffer length %lu)!\n", BufferLength);
551 RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
552 NtClose(FilteredToken);
553 return;
554 }
555
556 /* Do the actual query */
557 Status = NtQueryInformationToken(FilteredToken,
559 PrivsAndGroups,
561 &BufferLength);
563
564 trace("=============== TokenGroupsAndPrivileges ===============\n");
565 trace("SID count: %lu\n", PrivsAndGroups->SidCount);
566 trace("SID length: %lu\n", PrivsAndGroups->SidLength);
567 trace("Restricted SID count: %lu\n", PrivsAndGroups->RestrictedSidCount);
568 trace("Restricted SID length: %lu\n", PrivsAndGroups->RestrictedSidLength);
569 trace("Privilege count: %lu\n", PrivsAndGroups->PrivilegeCount);
570 trace("Privilege length: %lu\n", PrivsAndGroups->PrivilegeLength);
571 trace("Authentication ID: %lu %lu\n", PrivsAndGroups->AuthenticationId.LowPart, PrivsAndGroups->AuthenticationId.HighPart);
572 trace("=========================================\n\n");
573
574 RtlFreeHeap(RtlGetProcessHeap(), 0, PrivsAndGroups);
575 RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
576 NtClose(FilteredToken);
577}
578
579static
580VOID
583{
585 PTOKEN_GROUPS RestrictedGroups;
586 TOKEN_GROUPS SidToRestrict;
588 HANDLE FilteredToken;
591
592 /*
593 * Query the exact buffer length to hold
594 * our stuff, STATUS_BUFFER_TOO_SMALL must
595 * be expected here.
596 */
599 NULL,
600 0,
601 &BufferLength);
603
604 /* Allocate the buffer based on the size we got */
605 RestrictedGroups = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
606 if (!RestrictedGroups)
607 {
608 ok(FALSE, "Failed to allocate from heap for restricted SIDs (required buffer length %lu)!\n", BufferLength);
609 return;
610 }
611
612 /*
613 * Query the number of restricted SIDs. Originally the token
614 * doesn't have any restricted SIDs inserted.
615 */
618 RestrictedGroups,
620 &BufferLength);
622 ok(RestrictedGroups->GroupCount == 0, "There mustn't be any restricted SIDs before filtering (number of restricted SIDs %lu)!\n", RestrictedGroups->GroupCount);
623
624 RtlFreeHeap(RtlGetProcessHeap(), 0, RestrictedGroups);
625 RestrictedGroups = NULL;
626
628 1,
630 0, 0, 0, 0, 0, 0, 0,
631 &WorldSid);
632 if (!NT_SUCCESS(Status))
633 {
634 ok(FALSE, "Failed to allocate World SID (Status code %lx)!\n", Status);
635 return;
636 }
637
638 SidToRestrict.GroupCount = 1;
639 SidToRestrict.Groups[0].Attributes = 0;
640 SidToRestrict.Groups[0].Sid = WorldSid;
641
643 0,
644 NULL,
645 NULL,
646 &SidToRestrict,
647 &FilteredToken);
648 if (!NT_SUCCESS(Status))
649 {
650 ok(FALSE, "Failed to filter the current token (Status code %lx)!\n", Status);
651 RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
652 return;
653 }
654
655 Status = NtQueryInformationToken(FilteredToken,
657 NULL,
658 0,
659 &BufferLength);
661
662 RestrictedGroups = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength);
663 if (!RestrictedGroups)
664 {
665 ok(FALSE, "Failed to allocate from heap for restricted SIDs (required buffer length %lu)!\n", BufferLength);
666 RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
667 return;
668 }
669
670 /*
671 * Do a query again, this time we must have a
672 * restricted SID inserted into the token.
673 */
674 Status = NtQueryInformationToken(FilteredToken,
676 RestrictedGroups,
678 &BufferLength);
680 ok(RestrictedGroups->GroupCount == 1, "There must be only one restricted SID added in token (number of restricted SIDs %lu)!\n", RestrictedGroups->GroupCount);
681
682 RtlFreeHeap(RtlGetProcessHeap(), 0, RestrictedGroups);
683 RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid);
684 NtClose(FilteredToken);
685}
686
687static
688VOID
691{
695
696 /*
697 * Query the session ID. Generally the current
698 * process token is not under any terminal service
699 * so the ID must be 0.
700 */
703 &SessionId,
704 sizeof(ULONG),
705 &BufferLength);
707 ok(SessionId == 0, "The session ID of current token must be 0 (current session %lu)!\n", SessionId);
708}
709
710static
711VOID
714{
716 ULONG IsTokenInert;
718 HANDLE FilteredToken;
719
720 /*
721 * Query the sandbox inert token information,
722 * it must not be inert.
723 */
726 &IsTokenInert,
727 sizeof(ULONG),
728 &BufferLength);
730 ok(IsTokenInert == FALSE, "The token must not be a sandbox inert one!\n");
731
732 /*
733 * Try to turn the token into an inert
734 * one by filtering it.
735 */
738 NULL,
739 NULL,
740 NULL,
741 &FilteredToken);
742 if (!NT_SUCCESS(Status))
743 {
744 ok(FALSE, "Failed to filter the current token (Status code %lx)!\n", Status);
745 return;
746 }
747
748 /*
749 * Now do a query again, this time
750 * the token should be inert.
751 */
752 Status = NtQueryInformationToken(FilteredToken,
754 &IsTokenInert,
755 sizeof(ULONG),
756 &BufferLength);
758 ok(IsTokenInert == TRUE, "The token must be a sandbox inert one after filtering!\n");
759
760 NtClose(FilteredToken);
761}
762
763static
764VOID
767{
769 TOKEN_ORIGIN Origin;
771
772 /* Query the token origin */
775 &Origin,
776 sizeof(TOKEN_ORIGIN),
777 &BufferLength);
779 ok(Origin.OriginatingLogonSession.LowPart == 0x3e7, "The LowPart field of the originating logon session must be SYSTEM_LUID (current value %lu)!\n",
781 ok(Origin.OriginatingLogonSession.HighPart == 0x0, "The HighPart field of the logon session must be 0 (current value %lu)!\n",
783}
784
786{
789 PVOID Dummy;
790 ULONG DummyReturnLength;
791
792 /* ReturnLength is NULL */
794 TokenUser,
795 NULL,
796 0,
797 NULL);
799
800 /* We don't give any token here */
802 TokenUser,
803 &Dummy,
804 0,
805 &DummyReturnLength);
807
809
810 /* Class 0 is unused on Windows */
812 0,
813 &Dummy,
814 0,
815 &DummyReturnLength);
817
818 /* We give a bogus info class */
820 0xa0a,
821 &Dummy,
822 0,
823 &DummyReturnLength);
825
826 /* Now perform tests for each class */
842
843 NtClose(Token);
844}
static VOID QueryTokenImpersonationTests(_In_ HANDLE Token)
static VOID QueryTokenDefaultDaclTests(_In_ HANDLE Token)
static VOID QueryTokenSessionIdTests(_In_ HANDLE Token)
static VOID QueryTokenStatisticsTests(_In_ HANDLE Token)
static VOID QueryTokenOwnerTests(_In_ HANDLE Token)
static VOID QueryTokenOriginTests(_In_ HANDLE Token)
static VOID QueryTokenPrivilegesTests(_In_ HANDLE Token)
static VOID QueryTokenPrimaryGroupTests(_In_ HANDLE Token)
static VOID QueryTokenSourceTests(_In_ HANDLE Token)
static VOID QueryTokenTypeTests(_In_ HANDLE Token)
static VOID QueryTokenUserTests(_In_ HANDLE Token)
static VOID QueryTokenGroupsTests(_In_ HANDLE Token)
static VOID QueryTokenRestrictedSidsTest(_In_ HANDLE Token)
static HANDLE OpenCurrentToken(VOID)
static VOID QueryTokenIsSandboxInert(_In_ HANDLE Token)
static VOID QueryTokenPrivilegesAndGroupsTests(_In_ HANDLE Token)
Type
Definition: Type.h:7
WCHAR SourceName[256]
Definition: arping.c:28
TOKEN_TYPE
Definition: asmpp.cpp:29
#define ok_ntstatus(status, expected)
Definition: atltest.h:135
#define trace
Definition: atltest.h:70
#define ok_str(x, y)
Definition: atltest.h:127
#define ok(value,...)
Definition: atltest.h:57
#define ok_wstr(x, y)
Definition: atltest.h:130
#define START_TEST(x)
Definition: atltest.h:75
LONG NTSTATUS
Definition: precomp.h:26
PSID WorldSid
Definition: globals.c:15
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:294
#define GetCurrentProcess()
Definition: compat.h:759
ULONG SessionId
Definition: dllmain.c:28
static SID_IDENTIFIER_AUTHORITY WorldAuthority
Definition: security.c:14
@ Success
Definition: eventcreate.c:712
unsigned int BOOL
Definition: ntddk_ex.h:94
Status
Definition: gdiplustypes.h:25
#define wine_dbgstr_w
Definition: kernel32.h:34
enum _SECURITY_IMPERSONATION_LEVEL SECURITY_IMPERSONATION_LEVEL
@ SecurityAnonymous
Definition: lsa.idl:55
@ TokenImpersonation
Definition: imports.h:274
@ TokenPrimary
Definition: imports.h:273
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define _In_
Definition: ms_sal.h:308
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3169
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL Dacl
Definition: rtlfuncs.h:1593
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1597
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID _Inout_ PULONG _Out_writes_bytes_to_opt_ PrimaryGroupSize PSID PrimaryGroup
Definition: rtlfuncs.h:1599
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_ BOOLEAN _In_ TOKEN_TYPE TokenType
Definition: sefuncs.h:411
#define SANDBOX_INERT
Definition: setypes.h:115
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
NTSYSAPI NTSTATUS NTAPI RtlAllocateAndInitializeSid(IN PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, IN UCHAR SubAuthorityCount, IN ULONG SubAuthority0, IN ULONG SubAuthority1, IN ULONG SubAuthority2, IN ULONG SubAuthority3, IN ULONG SubAuthority4, IN ULONG SubAuthority5, IN ULONG SubAuthority6, IN ULONG SubAuthority7, OUT PSID *Sid)
Definition: sid.c:290
NTSYSAPI NTSTATUS NTAPI RtlConvertSidToUnicodeString(OUT PUNICODE_STRING DestinationString, IN PVOID Sid, IN BOOLEAN AllocateDestinationString)
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define L(x)
Definition: ntvdm.h:50
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
LONG HighPart
DWORD LowPart
SID_AND_ATTRIBUTES Groups[ANYSIZE_ARRAY]
Definition: setypes.h:1018
$ULONG GroupCount
Definition: setypes.h:1014
LUID OriginatingLogonSession
Definition: setypes.h:1107
LUID AuthenticationId
Definition: setypes.h:1087
$ULONG DynamicAvailable
Definition: setypes.h:1092
$ULONG DynamicCharged
Definition: setypes.h:1091
SID_AND_ATTRIBUTES User
Definition: setypes.h:1010
_Must_inspect_result_ __kernel_entry NTSTATUS NTAPI NtQueryInformationToken(_In_ HANDLE TokenHandle, _In_ TOKEN_INFORMATION_CLASS TokenInformationClass, _Out_writes_bytes_to_opt_(TokenInformationLength, *ReturnLength) PVOID TokenInformation, _In_ ULONG TokenInformationLength, _Out_ PULONG ReturnLength)
Queries a specific type of information in regard of an access token based upon the information class....
Definition: tokencls.c:473
NTSTATUS NTAPI NtFilterToken(_In_ HANDLE ExistingTokenHandle, _In_ ULONG Flags, _In_opt_ PTOKEN_GROUPS SidsToDisable, _In_opt_ PTOKEN_PRIVILEGES PrivilegesToDelete, _In_opt_ PTOKEN_GROUPS RestrictedSids, _Out_ PHANDLE NewTokenHandle)
Creates an access token in a restricted form from the original existing token, that is,...
Definition: tokenlif.c:2075
_Must_inspect_result_ __kernel_entry NTSTATUS NTAPI NtDuplicateToken(_In_ HANDLE ExistingTokenHandle, _In_ ACCESS_MASK DesiredAccess, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ BOOLEAN EffectiveOnly, _In_ TOKEN_TYPE TokenType, _Out_ PHANDLE NewTokenHandle)
Duplicates a token.
Definition: tokenlif.c:1869
uint32_t ULONG
Definition: typedefs.h:59
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:56
_In_ PSECURITY_SUBJECT_CONTEXT _In_ BOOLEAN _In_ ACCESS_MASK _In_ ACCESS_MASK _Outptr_opt_ PPRIVILEGE_SET * Privileges
Definition: sefuncs.h:17
#define TOKEN_QUERY_SOURCE
Definition: setypes.h:929
#define TOKEN_DUPLICATE
Definition: setypes.h:926
#define SECURITY_WORLD_SID_AUTHORITY
Definition: setypes.h:527
#define SECURITY_WORLD_RID
Definition: setypes.h:541
#define TOKEN_QUERY
Definition: setypes.h:928
@ TokenDefaultDacl
Definition: setypes.h:971
@ TokenGroupsAndPrivileges
Definition: setypes.h:978
@ TokenSource
Definition: setypes.h:972
@ TokenStatistics
Definition: setypes.h:975
@ TokenImpersonationLevel
Definition: setypes.h:974
@ TokenSandBoxInert
Definition: setypes.h:980
@ TokenRestrictedSids
Definition: setypes.h:976
@ TokenGroups
Definition: setypes.h:967
@ TokenPrivileges
Definition: setypes.h:968
@ TokenUser
Definition: setypes.h:966
@ TokenOrigin
Definition: setypes.h:982
@ TokenPrimaryGroup
Definition: setypes.h:970
@ TokenSessionId
Definition: setypes.h:977
@ TokenOwner
Definition: setypes.h:969
#define TOKEN_READ
Definition: setypes.h:951
char CHAR
Definition: xmlstorage.h:175