1 /* $Id: token.c,v 1.36 2004/07/06 22:07:26 gvg Exp $
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * PURPOSE: Security manager
6 * FILE: kernel/se/token.c
7 * PROGRAMER: David Welch <welch@cwcom.net>
9 * 26/07/98: Added stubs for security functions
12 /* INCLUDES *****************************************************************/
15 #define NTOS_MODE_KERNEL
17 #include <internal/ob.h>
18 #include <internal/ps.h>
19 #include <internal/se.h>
20 #include <internal/safe.h>
23 #include <internal/debug.h>
25 /* GLOBALS *******************************************************************/
27 POBJECT_TYPE SepTokenObjectType
= NULL
;
29 static GENERIC_MAPPING SepTokenMapping
= {TOKEN_READ
,
34 #define SYSTEM_LUID 0x3E7;
36 /* FUNCTIONS *****************************************************************/
38 VOID
SepFreeProxyData(PVOID ProxyData
)
43 NTSTATUS
SepCopyProxyData(PVOID
* Dest
, PVOID Src
)
46 return(STATUS_NOT_IMPLEMENTED
);
49 NTSTATUS
SeExchangePrimaryToken(PEPROCESS Process
,
50 PACCESS_TOKEN NewToken
,
51 PACCESS_TOKEN
* OldTokenP
)
53 PACCESS_TOKEN OldToken
;
55 if (NewToken
->TokenType
!= TokenPrimary
)
57 return(STATUS_UNSUCCESSFUL
);
59 if (NewToken
->TokenInUse
!= 0)
61 return(STATUS_UNSUCCESSFUL
);
63 OldToken
= Process
->Token
;
64 Process
->Token
= NewToken
;
65 NewToken
->TokenInUse
= 1;
66 ObReferenceObjectByPointer(NewToken
,
70 OldToken
->TokenInUse
= 0;
71 *OldTokenP
= OldToken
;
72 return(STATUS_SUCCESS
);
76 RtlLengthSidAndAttributes(ULONG Count
,
77 PSID_AND_ATTRIBUTES Src
)
82 uLength
= Count
* sizeof(SID_AND_ATTRIBUTES
);
83 for (i
= 0; i
< Count
; i
++)
84 uLength
+= RtlLengthSid(Src
[i
].Sid
);
91 SepFindPrimaryGroupAndDefaultOwner(PACCESS_TOKEN Token
,
97 Token
->PrimaryGroup
= 0;
101 Token
->DefaultOwnerIndex
= Token
->UserAndGroupCount
;
104 /* Validate and set the primary group and user pointers */
105 for (i
= 0; i
< Token
->UserAndGroupCount
; i
++)
108 RtlEqualSid(Token
->UserAndGroups
[i
].Sid
, DefaultOwner
))
110 Token
->DefaultOwnerIndex
= i
;
113 if (RtlEqualSid(Token
->UserAndGroups
[i
].Sid
, PrimaryGroup
))
115 Token
->PrimaryGroup
= Token
->UserAndGroups
[i
].Sid
;
119 if (Token
->DefaultOwnerIndex
== Token
->UserAndGroupCount
)
121 return(STATUS_INVALID_OWNER
);
124 if (Token
->PrimaryGroup
== 0)
126 return(STATUS_INVALID_PRIMARY_GROUP
);
129 return(STATUS_SUCCESS
);
134 SepDuplicateToken(PACCESS_TOKEN Token
,
135 POBJECT_ATTRIBUTES ObjectAttributes
,
136 TOKEN_TYPE TokenType
,
137 SECURITY_IMPERSONATION_LEVEL Level
,
138 SECURITY_IMPERSONATION_LEVEL ExistingLevel
,
139 KPROCESSOR_MODE PreviousMode
,
140 PACCESS_TOKEN
* NewAccessToken
)
148 PACCESS_TOKEN AccessToken
;
150 Status
= ObCreateObject(PreviousMode
,
155 sizeof(ACCESS_TOKEN
),
158 (PVOID
*)&AccessToken
);
159 if (!NT_SUCCESS(Status
))
161 DPRINT1("ObCreateObject() failed (Status %lx)\n");
165 Status
= ZwAllocateLocallyUniqueId(&AccessToken
->TokenId
);
166 if (!NT_SUCCESS(Status
))
168 ObDereferenceObject(AccessToken
);
172 Status
= ZwAllocateLocallyUniqueId(&AccessToken
->ModifiedId
);
173 if (!NT_SUCCESS(Status
))
175 ObDereferenceObject(AccessToken
);
179 AccessToken
->TokenInUse
= 0;
180 AccessToken
->TokenType
= TokenType
;
181 AccessToken
->ImpersonationLevel
= Level
;
182 AccessToken
->AuthenticationId
.LowPart
= SYSTEM_LUID
;
183 AccessToken
->AuthenticationId
.HighPart
= 0;
185 AccessToken
->TokenSource
.SourceIdentifier
.LowPart
= Token
->TokenSource
.SourceIdentifier
.LowPart
;
186 AccessToken
->TokenSource
.SourceIdentifier
.HighPart
= Token
->TokenSource
.SourceIdentifier
.HighPart
;
187 memcpy(AccessToken
->TokenSource
.SourceName
,
188 Token
->TokenSource
.SourceName
,
189 sizeof(Token
->TokenSource
.SourceName
));
190 AccessToken
->ExpirationTime
.QuadPart
= Token
->ExpirationTime
.QuadPart
;
191 AccessToken
->UserAndGroupCount
= Token
->UserAndGroupCount
;
192 AccessToken
->DefaultOwnerIndex
= Token
->DefaultOwnerIndex
;
194 uLength
= sizeof(SID_AND_ATTRIBUTES
) * AccessToken
->UserAndGroupCount
;
195 for (i
= 0; i
< Token
->UserAndGroupCount
; i
++)
196 uLength
+= RtlLengthSid(Token
->UserAndGroups
[i
].Sid
);
198 AccessToken
->UserAndGroups
=
199 (PSID_AND_ATTRIBUTES
)ExAllocatePoolWithTag(NonPagedPool
,
201 TAG('T', 'O', 'K', 'u'));
203 EndMem
= &AccessToken
->UserAndGroups
[AccessToken
->UserAndGroupCount
];
205 Status
= RtlCopySidAndAttributesArray(AccessToken
->UserAndGroupCount
,
206 Token
->UserAndGroups
,
208 AccessToken
->UserAndGroups
,
212 if (NT_SUCCESS(Status
))
214 Status
= SepFindPrimaryGroupAndDefaultOwner(
220 if (NT_SUCCESS(Status
))
222 AccessToken
->PrivilegeCount
= Token
->PrivilegeCount
;
224 uLength
= AccessToken
->PrivilegeCount
* sizeof(LUID_AND_ATTRIBUTES
);
225 AccessToken
->Privileges
=
226 (PLUID_AND_ATTRIBUTES
)ExAllocatePoolWithTag(NonPagedPool
,
228 TAG('T', 'O', 'K', 'p'));
230 for (i
= 0; i
< AccessToken
->PrivilegeCount
; i
++)
232 RtlCopyLuid(&AccessToken
->Privileges
[i
].Luid
,
233 &Token
->Privileges
[i
].Luid
);
234 AccessToken
->Privileges
[i
].Attributes
=
235 Token
->Privileges
[i
].Attributes
;
238 if ( Token
->DefaultDacl
)
240 AccessToken
->DefaultDacl
=
241 (PACL
) ExAllocatePoolWithTag(NonPagedPool
,
242 Token
->DefaultDacl
->AclSize
,
243 TAG('T', 'O', 'K', 'd'));
244 memcpy(AccessToken
->DefaultDacl
,
246 Token
->DefaultDacl
->AclSize
);
250 AccessToken
->DefaultDacl
= 0;
254 if ( NT_SUCCESS(Status
) )
256 *NewAccessToken
= AccessToken
;
257 return(STATUS_SUCCESS
);
260 ObDereferenceObject(AccessToken
);
266 SepInitializeNewProcess(struct _EPROCESS
* NewProcess
,
267 struct _EPROCESS
* ParentProcess
)
270 PACCESS_TOKEN pNewToken
;
271 PACCESS_TOKEN pParentToken
;
273 OBJECT_ATTRIBUTES ObjectAttributes
;
275 pParentToken
= (PACCESS_TOKEN
) ParentProcess
->Token
;
277 InitializeObjectAttributes(&ObjectAttributes
,
283 Status
= SepDuplicateToken(pParentToken
,
286 pParentToken
->ImpersonationLevel
,
287 pParentToken
->ImpersonationLevel
,
290 if ( ! NT_SUCCESS(Status
) )
293 NewProcess
->Token
= pNewToken
;
294 return(STATUS_SUCCESS
);
298 NTSTATUS
SeCopyClientToken(PACCESS_TOKEN Token
,
299 SECURITY_IMPERSONATION_LEVEL Level
,
300 KPROCESSOR_MODE PreviousMode
,
301 PACCESS_TOKEN
* NewToken
)
304 OBJECT_ATTRIBUTES ObjectAttributes
;
306 InitializeObjectAttributes(&ObjectAttributes
,
311 Status
= SepDuplicateToken(Token
,
314 SecurityIdentification
,
326 SeCreateClientSecurity(IN
struct _ETHREAD
*Thread
,
327 IN PSECURITY_QUALITY_OF_SERVICE Qos
,
328 IN BOOLEAN RemoteClient
,
329 OUT PSECURITY_CLIENT_CONTEXT ClientContext
)
331 TOKEN_TYPE TokenType
;
333 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
;
336 PACCESS_TOKEN NewToken
;
338 Token
= PsReferenceEffectiveToken(Thread
,
341 &ImpersonationLevel
);
344 ClientContext
->DirectAccessEffectiveOnly
= Qos
->EffectiveOnly
;
348 if (Qos
->ImpersonationLevel
> ImpersonationLevel
)
352 ObDereferenceObject(Token
);
354 return(STATUS_UNSUCCESSFUL
);
356 if (ImpersonationLevel
== 0 ||
357 ImpersonationLevel
== 1 ||
358 (RemoteClient
!= FALSE
&& ImpersonationLevel
!= 3))
362 ObDereferenceObject(Token
);
364 return(STATUS_UNSUCCESSFUL
);
367 Qos
->EffectiveOnly
!= 0)
369 ClientContext
->DirectAccessEffectiveOnly
= TRUE
;
373 ClientContext
->DirectAccessEffectiveOnly
= FALSE
;
377 if (Qos
->ContextTrackingMode
== 0)
379 ClientContext
->DirectlyAccessClientToken
= FALSE
;
380 g
= SeCopyClientToken(Token
, ImpersonationLevel
, 0, &NewToken
);
383 // ObDeleteCapturedInsertInfo(NewToken);
385 if (TokenType
== TokenPrimary
|| Token
!= NULL
)
387 ObDereferenceObject(Token
);
396 ClientContext
->DirectlyAccessClientToken
= TRUE
;
397 if (RemoteClient
!= FALSE
)
399 // SeGetTokenControlInformation(Token, &ClientContext->Unknown11);
403 ClientContext
->SecurityQos
.Length
= sizeof(SECURITY_QUALITY_OF_SERVICE
);
404 ClientContext
->SecurityQos
.ImpersonationLevel
= Qos
->ImpersonationLevel
;
405 ClientContext
->SecurityQos
.ContextTrackingMode
= Qos
->ContextTrackingMode
;
406 ClientContext
->SecurityQos
.EffectiveOnly
= Qos
->EffectiveOnly
;
407 ClientContext
->ServerIsRemote
= RemoteClient
;
408 ClientContext
->Token
= NewToken
;
410 return(STATUS_SUCCESS
);
418 SeImpersonateClient(IN PSECURITY_CLIENT_CONTEXT ClientContext
,
419 IN PETHREAD ServerThread OPTIONAL
)
423 if (ClientContext
->DirectlyAccessClientToken
== FALSE
)
425 b
= ClientContext
->SecurityQos
.EffectiveOnly
;
429 b
= ClientContext
->DirectAccessEffectiveOnly
;
431 if (ServerThread
== NULL
)
433 ServerThread
= PsGetCurrentThread();
435 PsImpersonateClient(ServerThread
,
436 ClientContext
->Token
,
439 ClientContext
->SecurityQos
.ImpersonationLevel
);
444 SepDeleteToken(PVOID ObjectBody
)
446 PACCESS_TOKEN AccessToken
= (PACCESS_TOKEN
)ObjectBody
;
448 if (AccessToken
->UserAndGroups
)
449 ExFreePool(AccessToken
->UserAndGroups
);
451 if (AccessToken
->Privileges
)
452 ExFreePool(AccessToken
->Privileges
);
454 if (AccessToken
->DefaultDacl
)
455 ExFreePool(AccessToken
->DefaultDacl
);
460 SepInitializeTokenImplementation(VOID
)
462 SepTokenObjectType
= ExAllocatePool(NonPagedPool
, sizeof(OBJECT_TYPE
));
464 SepTokenObjectType
->Tag
= TAG('T', 'O', 'K', 'T');
465 SepTokenObjectType
->MaxObjects
= ULONG_MAX
;
466 SepTokenObjectType
->MaxHandles
= ULONG_MAX
;
467 SepTokenObjectType
->TotalObjects
= 0;
468 SepTokenObjectType
->TotalHandles
= 0;
469 SepTokenObjectType
->PagedPoolCharge
= 0;
470 SepTokenObjectType
->NonpagedPoolCharge
= sizeof(ACCESS_TOKEN
);
471 SepTokenObjectType
->Mapping
= &SepTokenMapping
;
472 SepTokenObjectType
->Dump
= NULL
;
473 SepTokenObjectType
->Open
= NULL
;
474 SepTokenObjectType
->Close
= NULL
;
475 SepTokenObjectType
->Delete
= SepDeleteToken
;
476 SepTokenObjectType
->Parse
= NULL
;
477 SepTokenObjectType
->Security
= NULL
;
478 SepTokenObjectType
->QueryName
= NULL
;
479 SepTokenObjectType
->OkayToClose
= NULL
;
480 SepTokenObjectType
->Create
= NULL
;
481 SepTokenObjectType
->DuplicationNotify
= NULL
;
483 RtlCreateUnicodeString(&SepTokenObjectType
->TypeName
,
485 ObpCreateTypeObject (SepTokenObjectType
);
493 NtQueryInformationToken(IN HANDLE TokenHandle
,
494 IN TOKEN_INFORMATION_CLASS TokenInformationClass
,
495 OUT PVOID TokenInformation
,
496 IN ULONG TokenInformationLength
,
497 OUT PULONG ReturnLength
)
504 PTOKEN_GROUPS PtrTokenGroups
;
505 PTOKEN_DEFAULT_DACL PtrDefaultDacl
;
506 PTOKEN_STATISTICS PtrTokenStatistics
;
508 Status
= ObReferenceObjectByHandle(TokenHandle
,
509 (TokenInformationClass
== TokenSource
) ? TOKEN_QUERY_SOURCE
: TOKEN_QUERY
,
514 if (!NT_SUCCESS(Status
))
519 switch (TokenInformationClass
)
522 DPRINT("NtQueryInformationToken(TokenUser)\n");
523 Length
= RtlLengthSidAndAttributes(1, Token
->UserAndGroups
);
524 if (TokenInformationLength
< Length
)
526 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
527 if (NT_SUCCESS(Status
))
528 Status
= STATUS_BUFFER_TOO_SMALL
;
532 Status
= RtlCopySidAndAttributesArray(1,
533 Token
->UserAndGroups
,
534 TokenInformationLength
,
536 (char*)TokenInformation
+ 8,
539 if (NT_SUCCESS(Status
))
541 Length
= TokenInformationLength
- Length
;
542 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
548 DPRINT("NtQueryInformationToken(TokenGroups)\n");
549 Length
= RtlLengthSidAndAttributes(Token
->UserAndGroupCount
- 1, &Token
->UserAndGroups
[1]) + sizeof(ULONG
);
550 if (TokenInformationLength
< Length
)
552 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
553 if (NT_SUCCESS(Status
))
554 Status
= STATUS_BUFFER_TOO_SMALL
;
558 EndMem
= (char*)TokenInformation
+ Token
->UserAndGroupCount
* sizeof(SID_AND_ATTRIBUTES
);
559 PtrTokenGroups
= (PTOKEN_GROUPS
)TokenInformation
;
560 PtrTokenGroups
->GroupCount
= Token
->UserAndGroupCount
- 1;
561 Status
= RtlCopySidAndAttributesArray(Token
->UserAndGroupCount
- 1,
562 &Token
->UserAndGroups
[1],
563 TokenInformationLength
,
564 PtrTokenGroups
->Groups
,
568 if (NT_SUCCESS(Status
))
570 Length
= TokenInformationLength
- Length
;
571 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
576 case TokenPrivileges
:
577 DPRINT("NtQueryInformationToken(TokenPrivileges)\n");
578 Length
= sizeof(ULONG
) + Token
->PrivilegeCount
* sizeof(LUID_AND_ATTRIBUTES
);
579 if (TokenInformationLength
< Length
)
581 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
582 if (NT_SUCCESS(Status
))
583 Status
= STATUS_BUFFER_TOO_SMALL
;
588 TOKEN_PRIVILEGES
* pPriv
= (TOKEN_PRIVILEGES
*)TokenInformation
;
590 pPriv
->PrivilegeCount
= Token
->PrivilegeCount
;
591 for (i
= 0; i
< Token
->PrivilegeCount
; i
++)
593 RtlCopyLuid(&pPriv
->Privileges
[i
].Luid
, &Token
->Privileges
[i
].Luid
);
594 pPriv
->Privileges
[i
].Attributes
= Token
->Privileges
[i
].Attributes
;
596 Status
= STATUS_SUCCESS
;
601 DPRINT("NtQueryInformationToken(TokenOwner)\n");
602 Length
= RtlLengthSid(Token
->UserAndGroups
[Token
->DefaultOwnerIndex
].Sid
) + sizeof(TOKEN_OWNER
);
603 if (TokenInformationLength
< Length
)
605 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
606 if (NT_SUCCESS(Status
))
607 Status
= STATUS_BUFFER_TOO_SMALL
;
611 ((PTOKEN_OWNER
)TokenInformation
)->Owner
=
612 (PSID
)(((PTOKEN_OWNER
)TokenInformation
) + 1);
613 RtlCopySid(TokenInformationLength
- sizeof(TOKEN_OWNER
),
614 ((PTOKEN_OWNER
)TokenInformation
)->Owner
,
615 Token
->UserAndGroups
[Token
->DefaultOwnerIndex
].Sid
);
616 Status
= STATUS_SUCCESS
;
620 case TokenPrimaryGroup
:
621 DPRINT("NtQueryInformationToken(TokenPrimaryGroup),"
622 "Token->PrimaryGroup = 0x%08x\n", Token
->PrimaryGroup
);
623 Length
= RtlLengthSid(Token
->PrimaryGroup
) + sizeof(TOKEN_PRIMARY_GROUP
);
624 if (TokenInformationLength
< Length
)
626 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
627 if (NT_SUCCESS(Status
))
628 Status
= STATUS_BUFFER_TOO_SMALL
;
632 ((PTOKEN_PRIMARY_GROUP
)TokenInformation
)->PrimaryGroup
=
633 (PSID
)(((PTOKEN_PRIMARY_GROUP
)TokenInformation
) + 1);
634 RtlCopySid(TokenInformationLength
- sizeof(TOKEN_PRIMARY_GROUP
),
635 ((PTOKEN_PRIMARY_GROUP
)TokenInformation
)->PrimaryGroup
,
636 Token
->PrimaryGroup
);
637 Status
= STATUS_SUCCESS
;
641 case TokenDefaultDacl
:
642 DPRINT("NtQueryInformationToken(TokenDefaultDacl)\n");
643 PtrDefaultDacl
= (PTOKEN_DEFAULT_DACL
) TokenInformation
;
644 Length
= (Token
->DefaultDacl
? Token
->DefaultDacl
->AclSize
: 0) + sizeof(TOKEN_DEFAULT_DACL
);
645 if (TokenInformationLength
< Length
)
647 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
648 if (NT_SUCCESS(Status
))
649 Status
= STATUS_BUFFER_TOO_SMALL
;
651 else if (!Token
->DefaultDacl
)
653 PtrDefaultDacl
->DefaultDacl
= 0;
654 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
658 PtrDefaultDacl
->DefaultDacl
= (PACL
) (PtrDefaultDacl
+ 1);
659 memmove(PtrDefaultDacl
->DefaultDacl
,
661 Token
->DefaultDacl
->AclSize
);
662 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
667 DPRINT("NtQueryInformationToken(TokenSource)\n");
668 if (TokenInformationLength
< sizeof(TOKEN_SOURCE
))
670 Length
= sizeof(TOKEN_SOURCE
);
671 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
672 if (NT_SUCCESS(Status
))
673 Status
= STATUS_BUFFER_TOO_SMALL
;
677 Status
= MmCopyToCaller(TokenInformation
, &Token
->TokenSource
, sizeof(TOKEN_SOURCE
));
682 DPRINT("NtQueryInformationToken(TokenType)\n");
683 if (TokenInformationLength
< sizeof(TOKEN_TYPE
))
685 Length
= sizeof(TOKEN_TYPE
);
686 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
687 if (NT_SUCCESS(Status
))
688 Status
= STATUS_BUFFER_TOO_SMALL
;
692 Status
= MmCopyToCaller(TokenInformation
, &Token
->TokenType
, sizeof(TOKEN_TYPE
));
696 case TokenImpersonationLevel
:
697 DPRINT("NtQueryInformationToken(TokenImpersonationLevel)\n");
698 if (TokenInformationLength
< sizeof(SECURITY_IMPERSONATION_LEVEL
))
700 Length
= sizeof(SECURITY_IMPERSONATION_LEVEL
);
701 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
702 if (NT_SUCCESS(Status
))
703 Status
= STATUS_BUFFER_TOO_SMALL
;
707 Status
= MmCopyToCaller(TokenInformation
, &Token
->ImpersonationLevel
, sizeof(SECURITY_IMPERSONATION_LEVEL
));
711 case TokenStatistics
:
712 DPRINT("NtQueryInformationToken(TokenStatistics)\n");
713 if (TokenInformationLength
< sizeof(TOKEN_STATISTICS
))
715 Length
= sizeof(TOKEN_STATISTICS
);
716 Status
= MmCopyToCaller(ReturnLength
, &Length
, sizeof(ULONG
));
717 if (NT_SUCCESS(Status
))
718 Status
= STATUS_BUFFER_TOO_SMALL
;
722 PtrTokenStatistics
= (PTOKEN_STATISTICS
)TokenInformation
;
723 PtrTokenStatistics
->TokenId
= Token
->TokenId
;
724 PtrTokenStatistics
->AuthenticationId
= Token
->AuthenticationId
;
725 PtrTokenStatistics
->ExpirationTime
= Token
->ExpirationTime
;
726 PtrTokenStatistics
->TokenType
= Token
->TokenType
;
727 PtrTokenStatistics
->ImpersonationLevel
= Token
->ImpersonationLevel
;
728 PtrTokenStatistics
->DynamicCharged
= Token
->DynamicCharged
;
729 PtrTokenStatistics
->DynamicAvailable
= Token
->DynamicAvailable
;
730 PtrTokenStatistics
->GroupCount
= Token
->UserAndGroupCount
- 1;
731 PtrTokenStatistics
->PrivilegeCount
= Token
->PrivilegeCount
;
732 PtrTokenStatistics
->ModifiedId
= Token
->ModifiedId
;
734 Status
= STATUS_SUCCESS
;
739 ObDereferenceObject(Token
);
745 * NtSetTokenInformation: Partly implemented.
747 * TokenOrigin, TokenDefaultDacl, TokenSessionId
751 NtSetInformationToken(IN HANDLE TokenHandle
,
752 IN TOKEN_INFORMATION_CLASS TokenInformationClass
,
753 OUT PVOID TokenInformation
,
754 IN ULONG TokenInformationLength
)
758 TOKEN_OWNER TokenOwnerSet
= { 0 };
759 TOKEN_PRIMARY_GROUP TokenPrimaryGroupSet
= { 0 };
760 DWORD NeededAccess
= 0;
762 switch (TokenInformationClass
)
765 case TokenPrimaryGroup
:
766 NeededAccess
= TOKEN_ADJUST_DEFAULT
;
770 return STATUS_NOT_IMPLEMENTED
;
773 Status
= ObReferenceObjectByHandle(TokenHandle
,
779 if (!NT_SUCCESS(Status
))
784 switch (TokenInformationClass
)
787 MmCopyFromCaller( &TokenOwnerSet
, TokenInformation
,
788 min(sizeof(TokenOwnerSet
),TokenInformationLength
) );
789 RtlCopySid(TokenInformationLength
- sizeof(TOKEN_OWNER
),
790 Token
->UserAndGroups
[Token
->DefaultOwnerIndex
].Sid
,
791 TokenOwnerSet
.Owner
);
792 Status
= STATUS_SUCCESS
;
793 DPRINT("NtSetInformationToken(TokenOwner)\n");
796 case TokenPrimaryGroup
:
797 MmCopyFromCaller( &TokenPrimaryGroupSet
, TokenInformation
,
798 min(sizeof(TokenPrimaryGroupSet
),
799 TokenInformationLength
) );
800 RtlCopySid(TokenInformationLength
- sizeof(TOKEN_PRIMARY_GROUP
),
802 TokenPrimaryGroupSet
.PrimaryGroup
);
803 Status
= STATUS_SUCCESS
;
804 DPRINT("NtSetInformationToken(TokenPrimaryGroup),"
805 "Token->PrimaryGroup = 0x%08x\n", Token
->PrimaryGroup
);
809 Status
= STATUS_NOT_IMPLEMENTED
;
813 ObDereferenceObject(Token
);
823 NtDuplicateToken(IN HANDLE ExistingTokenHandle
,
824 IN ACCESS_MASK DesiredAccess
,
825 IN POBJECT_ATTRIBUTES ObjectAttributes
,
826 IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
,
827 IN TOKEN_TYPE TokenType
,
828 OUT PHANDLE NewTokenHandle
)
831 PACCESS_TOKEN NewToken
;
833 ULONG ExistingImpersonationLevel
;
835 Status
= ObReferenceObjectByHandle(ExistingTokenHandle
,
841 if (!NT_SUCCESS(Status
))
843 DPRINT1 ("Failed to reference token (Status %lx)\n", Status
);
847 ExistingImpersonationLevel
= Token
->ImpersonationLevel
;
848 Status
= SepDuplicateToken(Token
,
852 ExistingImpersonationLevel
,
855 if (!NT_SUCCESS(Status
))
857 DPRINT1 ("Failed to duplicate token (Status %lx)\n", Status
);
861 return STATUS_SUCCESS
;
864 VOID
SepAdjustGroups(PACCESS_TOKEN Token
,
866 BOOLEAN ResetToDefault
,
867 PSID_AND_ATTRIBUTES Groups
,
869 KPROCESSOR_MODE PreviousMode
,
880 NtAdjustGroupsToken(IN HANDLE TokenHandle
,
881 IN BOOLEAN ResetToDefault
,
882 IN PTOKEN_GROUPS NewState
,
883 IN ULONG BufferLength
,
884 OUT PTOKEN_GROUPS PreviousState OPTIONAL
,
885 OUT PULONG ReturnLength
)
894 Status
= ObReferenceObjectByHandle(TokenHandle
,
902 SepAdjustGroups(Token
,
914 return(STATUS_NOT_IMPLEMENTED
);
921 SepAdjustPrivileges(PACCESS_TOKEN Token
,
923 KPROCESSOR_MODE PreviousMode
,
924 ULONG PrivilegeCount
,
925 PLUID_AND_ATTRIBUTES Privileges
,
926 PTOKEN_PRIVILEGES
* PreviousState
,
935 if (Token
->PrivilegeCount
> 0)
937 for (i
= 0; i
< Token
->PrivilegeCount
; i
++)
939 if (PreviousMode
!= KernelMode
)
941 if (Token
->Privileges
[i
]->Attributes
& SE_PRIVILEGE_ENABLED
== 0)
945 if (PreviousState
!= NULL
)
947 memcpy(&PreviousState
[i
],
948 &Token
->Privileges
[i
],
949 sizeof(LUID_AND_ATTRIBUTES
));
951 Token
->Privileges
[i
].Attributes
&= (~SE_PRIVILEGE_ENABLED
);
958 if (PreviousMode
!= KernelMode
)
960 Token
->TokenFlags
= Token
->TokenFlags
& (~1);
964 if (PrivilegeCount
<= ?)
977 NtAdjustPrivilegesToken (IN HANDLE TokenHandle
,
978 IN BOOLEAN DisableAllPrivileges
,
979 IN PTOKEN_PRIVILEGES NewState
,
980 IN ULONG BufferLength
,
981 OUT PTOKEN_PRIVILEGES PreviousState OPTIONAL
,
982 OUT PULONG ReturnLength OPTIONAL
)
984 // PLUID_AND_ATTRIBUTES Privileges;
985 KPROCESSOR_MODE PreviousMode
;
986 // ULONG PrivilegeCount;
1000 DPRINT ("NtAdjustPrivilegesToken() called\n");
1002 // PrivilegeCount = NewState->PrivilegeCount;
1003 PreviousMode
= KeGetPreviousMode ();
1004 // SeCaptureLuidAndAttributesArray(NewState->Privileges,
1014 Status
= ObReferenceObjectByHandle (TokenHandle
,
1015 TOKEN_ADJUST_PRIVILEGES
| TOKEN_QUERY
,
1020 if (!NT_SUCCESS(Status
))
1022 DPRINT1 ("Failed to reference token (Status %lx)\n", Status
);
1023 // SeReleaseLuidAndAttributesArray(Privileges,
1031 SepAdjustPrivileges(Token
,
1043 if (DisableAllPrivileges
== TRUE
)
1045 for (i
= 0; i
< Token
->PrivilegeCount
; i
++)
1047 if (Token
->Privileges
[i
].Attributes
!= 0)
1049 DPRINT ("Attributes differ\n");
1051 /* Save current privilege */
1052 if (PreviousState
!= NULL
&& k
< PreviousState
->PrivilegeCount
)
1054 PreviousState
->Privileges
[k
].Luid
= Token
->Privileges
[i
].Luid
;
1055 PreviousState
->Privileges
[k
].Attributes
= Token
->Privileges
[i
].Attributes
;
1059 /* Update current privlege */
1060 Token
->Privileges
[i
].Attributes
&= ~SE_PRIVILEGE_ENABLED
;
1063 Status
= STATUS_SUCCESS
;
1068 for (i
= 0; i
< Token
->PrivilegeCount
; i
++)
1070 for (j
= 0; j
< NewState
->PrivilegeCount
; j
++)
1072 if (Token
->Privileges
[i
].Luid
.LowPart
== NewState
->Privileges
[j
].Luid
.LowPart
&&
1073 Token
->Privileges
[i
].Luid
.HighPart
== NewState
->Privileges
[j
].Luid
.HighPart
)
1075 DPRINT ("Found privilege\n");
1077 if ((Token
->Privileges
[i
].Attributes
& SE_PRIVILEGE_ENABLED
) !=
1078 (NewState
->Privileges
[j
].Attributes
& SE_PRIVILEGE_ENABLED
))
1080 DPRINT ("Attributes differ\n");
1081 DPRINT ("Current attributes %lx desired attributes %lx\n",
1082 Token
->Privileges
[i
].Attributes
,
1083 NewState
->Privileges
[j
].Attributes
);
1085 /* Save current privilege */
1086 if (PreviousState
!= NULL
&& k
< PreviousState
->PrivilegeCount
)
1088 PreviousState
->Privileges
[k
].Luid
= Token
->Privileges
[i
].Luid
;
1089 PreviousState
->Privileges
[k
].Attributes
= Token
->Privileges
[i
].Attributes
;
1093 /* Update current privlege */
1094 Token
->Privileges
[i
].Attributes
&= ~SE_PRIVILEGE_ENABLED
;
1095 Token
->Privileges
[i
].Attributes
|=
1096 (NewState
->Privileges
[j
].Attributes
& SE_PRIVILEGE_ENABLED
);
1097 DPRINT ("New attributes %lx\n",
1098 Token
->Privileges
[i
].Attributes
);
1104 Status
= Count
< NewState
->PrivilegeCount
? STATUS_NOT_ALL_ASSIGNED
: STATUS_SUCCESS
;
1107 if (ReturnLength
!= NULL
)
1109 *ReturnLength
= sizeof(TOKEN_PRIVILEGES
) +
1110 (sizeof(LUID_AND_ATTRIBUTES
) * (k
- 1));
1113 ObDereferenceObject (Token
);
1115 // SeReleaseLuidAndAttributesArray(Privileges,
1119 DPRINT ("NtAdjustPrivilegesToken() done\n");
1126 SepCreateSystemProcessToken(struct _EPROCESS
* Process
)
1132 ULONG uLocalSystemLength
= RtlLengthSid(SeLocalSystemSid
);
1133 ULONG uWorldLength
= RtlLengthSid(SeWorldSid
);
1134 ULONG uAuthUserLength
= RtlLengthSid(SeAuthenticatedUserSid
);
1135 ULONG uAdminsLength
= RtlLengthSid(SeAliasAdminsSid
);
1137 PACCESS_TOKEN AccessToken
;
1142 * Initialize the token
1144 Status
= ObCreateObject(KernelMode
,
1149 sizeof(ACCESS_TOKEN
),
1152 (PVOID
*)&AccessToken
);
1153 if (!NT_SUCCESS(Status
))
1158 Status
= NtAllocateLocallyUniqueId(&AccessToken
->TokenId
);
1159 if (!NT_SUCCESS(Status
))
1161 ObDereferenceObject(AccessToken
);
1165 Status
= NtAllocateLocallyUniqueId(&AccessToken
->ModifiedId
);
1166 if (!NT_SUCCESS(Status
))
1168 ObDereferenceObject(AccessToken
);
1172 AccessToken
->AuthenticationId
.LowPart
= SYSTEM_LUID
;
1173 AccessToken
->AuthenticationId
.HighPart
= 0;
1175 AccessToken
->TokenType
= TokenPrimary
;
1176 AccessToken
->ImpersonationLevel
= SecurityDelegation
;
1177 AccessToken
->TokenSource
.SourceIdentifier
.LowPart
= 0;
1178 AccessToken
->TokenSource
.SourceIdentifier
.HighPart
= 0;
1179 memcpy(AccessToken
->TokenSource
.SourceName
, "SeMgr\0\0\0", 8);
1180 AccessToken
->ExpirationTime
.QuadPart
= -1;
1181 AccessToken
->UserAndGroupCount
= 4;
1183 uSize
= sizeof(SID_AND_ATTRIBUTES
) * AccessToken
->UserAndGroupCount
;
1184 uSize
+= uLocalSystemLength
;
1185 uSize
+= uWorldLength
;
1186 uSize
+= uAuthUserLength
;
1187 uSize
+= uAdminsLength
;
1189 AccessToken
->UserAndGroups
=
1190 (PSID_AND_ATTRIBUTES
)ExAllocatePoolWithTag(NonPagedPool
,
1192 TAG('T', 'O', 'K', 'u'));
1193 SidArea
= &AccessToken
->UserAndGroups
[AccessToken
->UserAndGroupCount
];
1196 AccessToken
->UserAndGroups
[i
].Sid
= (PSID
) SidArea
;
1197 AccessToken
->UserAndGroups
[i
++].Attributes
= 0;
1198 RtlCopySid(uLocalSystemLength
, SidArea
, SeLocalSystemSid
);
1199 SidArea
= (char*)SidArea
+ uLocalSystemLength
;
1201 AccessToken
->DefaultOwnerIndex
= i
;
1202 AccessToken
->UserAndGroups
[i
].Sid
= (PSID
) SidArea
;
1203 AccessToken
->PrimaryGroup
= (PSID
) SidArea
;
1204 AccessToken
->UserAndGroups
[i
++].Attributes
= SE_GROUP_ENABLED
|SE_GROUP_ENABLED_BY_DEFAULT
;
1205 Status
= RtlCopySid(uAdminsLength
, SidArea
, SeAliasAdminsSid
);
1206 SidArea
= (char*)SidArea
+ uAdminsLength
;
1208 AccessToken
->UserAndGroups
[i
].Sid
= (PSID
) SidArea
;
1209 AccessToken
->UserAndGroups
[i
++].Attributes
= SE_GROUP_ENABLED
|SE_GROUP_ENABLED_BY_DEFAULT
|SE_GROUP_MANDATORY
;
1210 RtlCopySid(uWorldLength
, SidArea
, SeWorldSid
);
1211 SidArea
= (char*)SidArea
+ uWorldLength
;
1213 AccessToken
->UserAndGroups
[i
].Sid
= (PSID
) SidArea
;
1214 AccessToken
->UserAndGroups
[i
++].Attributes
= SE_GROUP_ENABLED
|SE_GROUP_ENABLED_BY_DEFAULT
|SE_GROUP_MANDATORY
;
1215 RtlCopySid(uAuthUserLength
, SidArea
, SeAuthenticatedUserSid
);
1216 SidArea
= (char*)SidArea
+ uAuthUserLength
;
1218 AccessToken
->PrivilegeCount
= 20;
1220 uSize
= AccessToken
->PrivilegeCount
* sizeof(LUID_AND_ATTRIBUTES
);
1221 AccessToken
->Privileges
=
1222 (PLUID_AND_ATTRIBUTES
)ExAllocatePoolWithTag(NonPagedPool
,
1224 TAG('T', 'O', 'K', 'p'));
1227 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1228 AccessToken
->Privileges
[i
++].Luid
= SeTcbPrivilege
;
1230 AccessToken
->Privileges
[i
].Attributes
= 0;
1231 AccessToken
->Privileges
[i
++].Luid
= SeCreateTokenPrivilege
;
1233 AccessToken
->Privileges
[i
].Attributes
= 0;
1234 AccessToken
->Privileges
[i
++].Luid
= SeTakeOwnershipPrivilege
;
1236 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1237 AccessToken
->Privileges
[i
++].Luid
= SeCreatePagefilePrivilege
;
1239 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1240 AccessToken
->Privileges
[i
++].Luid
= SeLockMemoryPrivilege
;
1242 AccessToken
->Privileges
[i
].Attributes
= 0;
1243 AccessToken
->Privileges
[i
++].Luid
= SeAssignPrimaryTokenPrivilege
;
1245 AccessToken
->Privileges
[i
].Attributes
= 0;
1246 AccessToken
->Privileges
[i
++].Luid
= SeIncreaseQuotaPrivilege
;
1248 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1249 AccessToken
->Privileges
[i
++].Luid
= SeIncreaseBasePriorityPrivilege
;
1251 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1252 AccessToken
->Privileges
[i
++].Luid
= SeCreatePermanentPrivilege
;
1254 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1255 AccessToken
->Privileges
[i
++].Luid
= SeDebugPrivilege
;
1257 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1258 AccessToken
->Privileges
[i
++].Luid
= SeAuditPrivilege
;
1260 AccessToken
->Privileges
[i
].Attributes
= 0;
1261 AccessToken
->Privileges
[i
++].Luid
= SeSecurityPrivilege
;
1263 AccessToken
->Privileges
[i
].Attributes
= 0;
1264 AccessToken
->Privileges
[i
++].Luid
= SeSystemEnvironmentPrivilege
;
1266 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1267 AccessToken
->Privileges
[i
++].Luid
= SeChangeNotifyPrivilege
;
1269 AccessToken
->Privileges
[i
].Attributes
= 0;
1270 AccessToken
->Privileges
[i
++].Luid
= SeBackupPrivilege
;
1272 AccessToken
->Privileges
[i
].Attributes
= 0;
1273 AccessToken
->Privileges
[i
++].Luid
= SeRestorePrivilege
;
1275 AccessToken
->Privileges
[i
].Attributes
= 0;
1276 AccessToken
->Privileges
[i
++].Luid
= SeShutdownPrivilege
;
1278 AccessToken
->Privileges
[i
].Attributes
= 0;
1279 AccessToken
->Privileges
[i
++].Luid
= SeLoadDriverPrivilege
;
1281 AccessToken
->Privileges
[i
].Attributes
= SE_PRIVILEGE_ENABLED_BY_DEFAULT
|SE_PRIVILEGE_ENABLED
;
1282 AccessToken
->Privileges
[i
++].Luid
= SeProfileSingleProcessPrivilege
;
1284 AccessToken
->Privileges
[i
].Attributes
= 0;
1285 AccessToken
->Privileges
[i
++].Luid
= SeSystemtimePrivilege
;
1287 AccessToken
->Privileges
[i
].Attributes
= 0;
1288 AccessToken
->Privileges
[i
++].Luid
= SeUndockPrivilege
;
1290 AccessToken
->Privileges
[i
].Attributes
= 0;
1291 AccessToken
->Privileges
[i
++].Luid
= SeManageVolumePrivilege
;
1296 uSize
= sizeof(ACL
);
1297 uSize
+= sizeof(ACE
) + uLocalSystemLength
;
1298 uSize
+= sizeof(ACE
) + uAdminsLength
;
1299 uSize
= (uSize
& (~3)) + 8;
1300 AccessToken
->DefaultDacl
=
1301 (PACL
) ExAllocatePoolWithTag(NonPagedPool
,
1303 TAG('T', 'O', 'K', 'd'));
1304 Status
= RtlCreateAcl(AccessToken
->DefaultDacl
, uSize
, ACL_REVISION
);
1305 if ( NT_SUCCESS(Status
) )
1307 Status
= RtlAddAccessAllowedAce(AccessToken
->DefaultDacl
, ACL_REVISION
, GENERIC_ALL
, SeLocalSystemSid
);
1310 if ( NT_SUCCESS(Status
) )
1312 Status
= RtlAddAccessAllowedAce(AccessToken
->DefaultDacl
, ACL_REVISION
, GENERIC_READ
|GENERIC_EXECUTE
|READ_CONTROL
, SeAliasAdminsSid
);
1315 if ( ! NT_SUCCESS(Status
) )
1317 ObDereferenceObject(AccessToken
);
1321 Process
->Token
= AccessToken
;
1322 return(STATUS_SUCCESS
);
1327 NtCreateToken(OUT PHANDLE UnsafeTokenHandle
,
1328 IN ACCESS_MASK DesiredAccess
,
1329 IN POBJECT_ATTRIBUTES UnsafeObjectAttributes
,
1330 IN TOKEN_TYPE TokenType
,
1331 IN PLUID AuthenticationId
,
1332 IN PLARGE_INTEGER ExpirationTime
,
1333 IN PTOKEN_USER TokenUser
,
1334 IN PTOKEN_GROUPS TokenGroups
,
1335 IN PTOKEN_PRIVILEGES TokenPrivileges
,
1336 IN PTOKEN_OWNER TokenOwner
,
1337 IN PTOKEN_PRIMARY_GROUP TokenPrimaryGroup
,
1338 IN PTOKEN_DEFAULT_DACL TokenDefaultDacl
,
1339 IN PTOKEN_SOURCE TokenSource
)
1342 PACCESS_TOKEN AccessToken
;
1344 OBJECT_ATTRIBUTES SafeObjectAttributes
;
1345 POBJECT_ATTRIBUTES ObjectAttributes
;
1352 Status
= MmCopyFromCaller(&SafeObjectAttributes
,
1353 UnsafeObjectAttributes
,
1354 sizeof(OBJECT_ATTRIBUTES
));
1355 if (!NT_SUCCESS(Status
))
1358 ObjectAttributes
= &SafeObjectAttributes
;
1360 Status
= ZwAllocateLocallyUniqueId(&TokenId
);
1361 if (!NT_SUCCESS(Status
))
1364 Status
= ZwAllocateLocallyUniqueId(&ModifiedId
);
1365 if (!NT_SUCCESS(Status
))
1368 Status
= ObCreateObject(ExGetPreviousMode(),
1371 ExGetPreviousMode(),
1373 sizeof(ACCESS_TOKEN
),
1376 (PVOID
*)&AccessToken
);
1377 if (!NT_SUCCESS(Status
))
1379 DPRINT1("ObCreateObject() failed (Status %lx)\n");
1383 Status
= ObInsertObject ((PVOID
)AccessToken
,
1389 if (!NT_SUCCESS(Status
))
1391 DPRINT1("ObInsertObject() failed (Status %lx)\n");
1392 ObDereferenceObject (AccessToken
);
1396 RtlCopyLuid(&AccessToken
->TokenSource
.SourceIdentifier
,
1397 &TokenSource
->SourceIdentifier
);
1398 memcpy(AccessToken
->TokenSource
.SourceName
,
1399 TokenSource
->SourceName
,
1400 sizeof(TokenSource
->SourceName
));
1402 RtlCopyLuid(&AccessToken
->TokenId
, &TokenId
);
1403 RtlCopyLuid(&AccessToken
->AuthenticationId
, AuthenticationId
);
1404 AccessToken
->ExpirationTime
= *ExpirationTime
;
1405 RtlCopyLuid(&AccessToken
->ModifiedId
, &ModifiedId
);
1407 AccessToken
->UserAndGroupCount
= TokenGroups
->GroupCount
+ 1;
1408 AccessToken
->PrivilegeCount
= TokenPrivileges
->PrivilegeCount
;
1409 AccessToken
->UserAndGroups
= 0;
1410 AccessToken
->Privileges
= 0;
1412 AccessToken
->TokenType
= TokenType
;
1413 AccessToken
->ImpersonationLevel
= ObjectAttributes
->SecurityQualityOfService
->ImpersonationLevel
;
1416 * Normally we would just point these members into the variable information
1417 * area; however, our ObCreateObject() call can't allocate a variable information
1418 * area, so we allocate them seperately and provide a destroy function.
1421 uLength
= sizeof(SID_AND_ATTRIBUTES
) * AccessToken
->UserAndGroupCount
;
1422 uLength
+= RtlLengthSid(TokenUser
->User
.Sid
);
1423 for (i
= 0; i
< TokenGroups
->GroupCount
; i
++)
1424 uLength
+= RtlLengthSid(TokenGroups
->Groups
[i
].Sid
);
1426 AccessToken
->UserAndGroups
=
1427 (PSID_AND_ATTRIBUTES
)ExAllocatePoolWithTag(NonPagedPool
,
1429 TAG('T', 'O', 'K', 'u'));
1431 EndMem
= &AccessToken
->UserAndGroups
[AccessToken
->UserAndGroupCount
];
1433 Status
= RtlCopySidAndAttributesArray(1,
1436 AccessToken
->UserAndGroups
,
1440 if (NT_SUCCESS(Status
))
1442 Status
= RtlCopySidAndAttributesArray(TokenGroups
->GroupCount
,
1443 TokenGroups
->Groups
,
1445 &AccessToken
->UserAndGroups
[1],
1451 if (NT_SUCCESS(Status
))
1453 Status
= SepFindPrimaryGroupAndDefaultOwner(
1455 TokenPrimaryGroup
->PrimaryGroup
,
1459 if (NT_SUCCESS(Status
))
1461 uLength
= TokenPrivileges
->PrivilegeCount
* sizeof(LUID_AND_ATTRIBUTES
);
1462 AccessToken
->Privileges
=
1463 (PLUID_AND_ATTRIBUTES
)ExAllocatePoolWithTag(NonPagedPool
,
1465 TAG('T', 'O', 'K', 'p'));
1467 for (i
= 0; i
< TokenPrivileges
->PrivilegeCount
; i
++)
1469 Status
= MmCopyFromCaller(&AccessToken
->Privileges
[i
],
1470 &TokenPrivileges
->Privileges
[i
],
1471 sizeof(LUID_AND_ATTRIBUTES
));
1472 if (!NT_SUCCESS(Status
))
1477 if (NT_SUCCESS(Status
))
1479 AccessToken
->DefaultDacl
=
1480 (PACL
) ExAllocatePoolWithTag(NonPagedPool
,
1481 TokenDefaultDacl
->DefaultDacl
->AclSize
,
1482 TAG('T', 'O', 'K', 'd'));
1483 memcpy(AccessToken
->DefaultDacl
,
1484 TokenDefaultDacl
->DefaultDacl
,
1485 TokenDefaultDacl
->DefaultDacl
->AclSize
);
1488 ObDereferenceObject(AccessToken
);
1490 if (NT_SUCCESS(Status
))
1492 Status
= MmCopyToCaller(UnsafeTokenHandle
,
1497 if (!NT_SUCCESS(Status
))
1499 ZwClose(TokenHandle
);
1503 return(STATUS_SUCCESS
);
1511 SeQueryAuthenticationIdToken(IN PACCESS_TOKEN Token
,
1514 LogonId
->LowPart
= Token
->AuthenticationId
.LowPart
;
1515 LogonId
->HighPart
= Token
->AuthenticationId
.HighPart
;
1517 return STATUS_SUCCESS
;
1524 SECURITY_IMPERSONATION_LEVEL STDCALL
1525 SeTokenImpersonationLevel(IN PACCESS_TOKEN Token
)
1527 return Token
->ImpersonationLevel
;
1535 SeTokenType(IN PACCESS_TOKEN Token
)
1537 return Token
->TokenType
;