ReactOS  0.4.15-dev-4923-g379188a
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 
10 static
11 HANDLE
13 {
14  BOOL Success;
15  HANDLE Token;
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 
29 static
30 VOID
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  */
45  TokenUser,
46  NULL,
47  0,
48  &BufferLength);
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 */
61  TokenUser,
62  UserToken,
64  &BufferLength);
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 
76 static
77 VOID
80 {
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,
94  &BufferLength);
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  */
110  TokenGroups,
111  Groups,
112  BufferLength,
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 
120 static
121 VOID
123  _In_ HANDLE Token)
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  */
155  Privileges,
156  BufferLength,
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 
164 static
165 VOID
167  _In_ HANDLE Token)
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  */
180  TokenOwner,
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  */
199  TokenOwner,
200  Owner,
201  BufferLength,
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 
212 static
213 VOID
215  _In_ HANDLE Token)
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 */
245  PrimaryGroup,
246  BufferLength,
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 
259 static
260 VOID
262  _In_ HANDLE Token)
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,
295  BufferLength,
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 
304 static
305 VOID
307  _In_ HANDLE Token)
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  */
320  TokenSource,
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 */
336  TokenSource,
337  Source,
338  BufferLength,
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 
361 static
362 VOID
364  _In_ HANDLE Token)
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 
385 static
386 VOID
388  _In_ HANDLE Token)
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 
419  TOKEN_QUERY,
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 */
431  Status = NtQueryInformationToken(DupToken,
433  &Level,
435  &BufferLength);
437  ok(Level == SecurityAnonymous, "The current token impersonation level is not anonymous!\n");
438  NtClose(DupToken);
439 }
440 
441 static
442 VOID
444  _In_ HANDLE Token)
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,
474  BufferLength,
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 
489 static
490 VOID
492  _In_ HANDLE Token)
493 {
495  PTOKEN_GROUPS_AND_PRIVILEGES PrivsAndGroups;
496  TOKEN_GROUPS SidToRestrict;
497  HANDLE FilteredToken;
498  PSID WorldSid;
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,
560  BufferLength,
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 
579 static
580 VOID
582  _In_ HANDLE Token)
583 {
585  PTOKEN_GROUPS RestrictedGroups;
586  TOKEN_GROUPS SidToRestrict;
588  HANDLE FilteredToken;
589  PSID WorldSid;
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,
619  BufferLength,
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,
677  BufferLength,
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 
687 static
688 VOID
690  _In_ HANDLE Token)
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 
710 static
711 VOID
713  _In_ HANDLE Token)
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 
763 static
764 VOID
766  _In_ HANDLE Token)
767 {
769  TOKEN_ORIGIN Origin;
771 
772  /* Query the token origin */
774  TokenOrigin,
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 {
788  HANDLE Token;
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 }
LUID AuthenticationId
Definition: setypes.h:1083
static HANDLE OpenCurrentToken(VOID)
static VOID QueryTokenSourceTests(_In_ HANDLE Token)
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3767
#define ok_str(x, y)
Definition: atltest.h:127
GLint x0
Definition: linetemp.h:95
#define TRUE
Definition: types.h:120
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
static VOID QueryTokenImpersonationTests(_In_ HANDLE Token)
$ULONG DynamicCharged
Definition: setypes.h:1087
char CHAR
Definition: xmlstorage.h:175
ULONG SessionId
Definition: dllmain.c:28
LONG NTSTATUS
Definition: precomp.h:26
static SID_IDENTIFIER_AUTHORITY WorldAuthority
Definition: security.c:14
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
static VOID QueryTokenRestrictedSidsTest(_In_ HANDLE Token)
_IRQL_requires_same_ _In_ PLSA_STRING _In_ SECURITY_LOGON_TYPE _In_ ULONG _In_ ULONG _In_opt_ PTOKEN_GROUPS _In_ PTOKEN_SOURCE _Out_ PVOID _Out_ PULONG _Inout_ PLUID _Out_ PHANDLE Token
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:2071
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1040
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:55
static VOID QueryTokenPrivilegesAndGroupsTests(_In_ HANDLE Token)
TOpcodeData Groups[17][8]
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
START_TEST(NtQueryInformationToken)
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
static VOID QueryTokenTypeTests(_In_ HANDLE Token)
#define L(x)
Definition: ntvdm.h:50
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
enum _SECURITY_IMPERSONATION_LEVEL SECURITY_IMPERSONATION_LEVEL
#define _In_
Definition: ms_sal.h:308
static VOID QueryTokenGroupsTests(_In_ HANDLE Token)
LUID OriginatingLogonSession
Definition: setypes.h:1103
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
Status
Definition: gdiplustypes.h:24
_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:1585
_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
#define trace
Definition: atltest.h:70
#define TOKEN_QUERY
Definition: setypes.h:924
static VOID QueryTokenUserTests(_In_ HANDLE Token)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define SECURITY_WORLD_SID_AUTHORITY
Definition: setypes.h:527
DWORD LowPart
Type
Definition: Type.h:6
#define TOKEN_QUERY_SOURCE
Definition: setypes.h:925
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define SECURITY_WORLD_RID
Definition: setypes.h:541
_In_ PSECURITY_SUBJECT_CONTEXT _In_ BOOLEAN _In_ ACCESS_MASK _In_ ACCESS_MASK _Outptr_opt_ PPRIVILEGE_SET * Privileges
Definition: sefuncs.h:13
static VOID QueryTokenDefaultDaclTests(_In_ HANDLE Token)
NTSYSAPI NTSTATUS NTAPI RtlConvertSidToUnicodeString(OUT PUNICODE_STRING DestinationString, IN PVOID Sid, IN BOOLEAN AllocateDestinationString)
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3402
static VOID QueryTokenIsSandboxInert(_In_ HANDLE Token)
#define TOKEN_DUPLICATE
Definition: setypes.h:922
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL Dacl
Definition: rtlfuncs.h:1579
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:240
#define TOKEN_READ
Definition: setypes.h:947
LONG HighPart
static VOID QueryTokenSessionIdTests(_In_ HANDLE Token)
_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:1865
PSID WorldSid
Definition: globals.c:15
#define ok_wstr(x, y)
Definition: atltest.h:130
#define GetCurrentProcess()
Definition: compat.h:618
enum _TOKEN_TYPE TOKEN_TYPE
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define ok(value,...)
Definition: atltest.h:57
SID_AND_ATTRIBUTES Groups[ANYSIZE_ARRAY]
Definition: setypes.h:1014
_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:1583
#define NULL
Definition: types.h:112
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:296
WCHAR SourceName[256]
Definition: arping.c:28
$ULONG GroupCount
Definition: setypes.h:1010
#define ok_ntstatus(status, expected)
Definition: atltest.h:135
static VOID QueryTokenStatisticsTests(_In_ HANDLE Token)
static VOID QueryTokenOwnerTests(_In_ HANDLE Token)
unsigned int ULONG
Definition: retypes.h:1
SID_AND_ATTRIBUTES User
Definition: setypes.h:1006
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define SANDBOX_INERT
Definition: setypes.h:115
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
#define STATUS_SUCCESS
Definition: shellext.h:65
static VOID QueryTokenOriginTests(_In_ HANDLE Token)
$ULONG DynamicAvailable
Definition: setypes.h:1088
static VOID QueryTokenPrivilegesTests(_In_ HANDLE Token)
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_ BOOLEAN _In_ TOKEN_TYPE TokenType
Definition: sefuncs.h:401
static VOID QueryTokenPrimaryGroupTests(_In_ HANDLE Token)