|
|
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
sepriv.c
Abstract:
Security Runtime Library Privilege Routines
(Temporary copy of \nt\private\ntos\rtl\sepriv.c to allow ntdailybld version of ntdll.dll to be used)
These routines perform operations with privilege sets
Author:
Scott Birrell (ScottBi) June 17, 1991
Environment:
Revision History: Pete Skelly (petesk) Modified LsapRtlAddPrivileges to work within a preallocated buffer for performance reasons
--*/#include <lsapch2.h>
#include <string.h>
#define LsapRtlEqualPrivileges(FirstPrivilege, SecondPrivilege) \
(RtlEqualLuid(&(FirstPrivilege)->Luid, &(SecondPrivilege)->Luid))
#define PRIVILEGE_SET_STEP_SIZE 20
NTSTATUSLsapRtlAddPrivileges( IN OUT PPRIVILEGE_SET * RunningPrivileges, IN OUT PULONG MaxRunningPrivileges, IN PPRIVILEGE_SET PrivilegesToAdd, IN ULONG Options, OUT OPTIONAL BOOLEAN * Changed )
/*++
Routine Description:
This function adds and/or updates privileges in a privilege set. The existing privilege set is unaltered, a new privilege set being generated. Existing privileges and Udpate privilege sets may point to the same location. The memory for the new privilege set must already be allocated by the caller. To assist in calculating the size of buffer required, the routine may be called in 'query' mode by supplying buffer size of 0. In this mode, the amount of memory required is returned and no copying takes place.
WARNING: Privileges within each privilege set must all be distinct, that is, there must not be two privileges in the same set having the same LUID.
Arguments:
RunningPrivileges - Pointer to a pointer pointing to a running privilege set.
MaxRunningPrivileges - maximum number of privileges that can be copied into the current privilege set before it must be grown.
PrivilegesToAdd - Pointer to privilege set specifying privileges to be added. The attributes of privileges in this set that also exist in the ExistingPrivileges set supersede the attributes therein.
Options - Specifies optional actions.
RTL_COMBINE_PRIVILEGE_ATTRIBUTES - If the two privilege sets have privileges in common, combine the attributes
RTL_SUPERSEDE_PRIVILEGE_ATTRIBUTES - If the two privilege sets have privileges in common, supersede the existing attributes with those specified in PrivilegesToAdd.
Changed - Used to indicate whether any change has been made
Return Value:
NTSTATUS - Standard Nt Result Code
STATUS_INVALID_PARAMETER
STATUS_INSUFFICIENT_RESOURCES
Environment:
User or Kernel modes.
--*/
{ PLUID_AND_ATTRIBUTES Privilege; ULONG AddIndex = 0L; NTSTATUS Status = STATUS_SUCCESS; ULONG CurrentPrivilegeCount = 0; DWORD OldPrivilegeSetSize = 0;
//
// Verify that mandatory parameters have been specified.
// specified.
//
if (RunningPrivileges == NULL || MaxRunningPrivileges == NULL) {
return STATUS_INVALID_PARAMETER; }
//
// Validate the Options parameter.
//
if ((Options != RTL_SUPERSEDE_PRIVILEGE_ATTRIBUTES) && (Options != RTL_COMBINE_PRIVILEGE_ATTRIBUTES)) {
return STATUS_INVALID_PARAMETER; }
if ( Changed ) {
*Changed = FALSE; }
if((PrivilegesToAdd == NULL) || (PrivilegesToAdd->PrivilegeCount == 0)) { return STATUS_SUCCESS; }
if(*RunningPrivileges == NULL) { PPRIVILEGE_SET UpdatedPrivileges = NULL;
ASSERT(PrivilegesToAdd->PrivilegeCount > 0);
OldPrivilegeSetSize = sizeof (PRIVILEGE_SET) + sizeof(LUID_AND_ATTRIBUTES)* (PrivilegesToAdd->PrivilegeCount - ANYSIZE_ARRAY);
// We need to grow our privilege set
UpdatedPrivileges = (PPRIVILEGE_SET)MIDL_user_allocate( OldPrivilegeSetSize + sizeof(LUID_AND_ATTRIBUTES)* PRIVILEGE_SET_STEP_SIZE);
if (UpdatedPrivileges == NULL) {
return STATUS_INSUFFICIENT_RESOURCES; }
RtlCopyMemory(UpdatedPrivileges, PrivilegesToAdd, OldPrivilegeSetSize); *RunningPrivileges = UpdatedPrivileges; *MaxRunningPrivileges = PrivilegesToAdd->PrivilegeCount + PRIVILEGE_SET_STEP_SIZE;
if ( Changed ) {
*Changed = TRUE; }
return STATUS_SUCCESS; }
CurrentPrivilegeCount = (*RunningPrivileges)->PrivilegeCount;
//
// For each privilege to add, see if it's in the running privilege list,
// set the attributes if it is, append it if it isn't.
//
//
// Note, we dont' modify the count of RunningPrivileges until the end, so we don't
// inefficiently search things we are currently adding (there should be no duplicates in what
// we're currently adding);
//
for(AddIndex = 0; AddIndex < PrivilegesToAdd->PrivilegeCount; AddIndex++) {
Privilege = NULL;
if ((Privilege = LsapRtlGetPrivilege( &PrivilegesToAdd->Privilege[AddIndex], *RunningPrivileges )) != NULL) {
if( Options & RTL_SUPERSEDE_PRIVILEGE_ATTRIBUTES && Privilege->Attributes != PrivilegesToAdd->Privilege[AddIndex].Attributes ) {
if ( Changed ) {
*Changed = TRUE; }
Privilege->Attributes = PrivilegesToAdd->Privilege[AddIndex].Attributes; } } else { // This is a new privilege, so add it to the end
ASSERT(*MaxRunningPrivileges >= CurrentPrivilegeCount); if((CurrentPrivilegeCount+1) > *MaxRunningPrivileges) {
// We need to grow our privilege set
PPRIVILEGE_SET UpdatedPrivileges = (PPRIVILEGE_SET)MIDL_user_allocate( sizeof (PRIVILEGE_SET) + sizeof(LUID_AND_ATTRIBUTES)* (*MaxRunningPrivileges + PRIVILEGE_SET_STEP_SIZE - 1));
if (UpdatedPrivileges == NULL) {
return STATUS_INSUFFICIENT_RESOURCES; } if(*MaxRunningPrivileges > 0) { RtlCopyMemory(UpdatedPrivileges, *RunningPrivileges, sizeof (PRIVILEGE_SET) + sizeof(LUID_AND_ATTRIBUTES)* (*MaxRunningPrivileges - 1)); } else { RtlCopyMemory(UpdatedPrivileges, *RunningPrivileges, sizeof (PRIVILEGE_SET)); } MIDL_user_free(*RunningPrivileges); *RunningPrivileges = UpdatedPrivileges; *MaxRunningPrivileges += PRIVILEGE_SET_STEP_SIZE; }
(*RunningPrivileges)->Privilege[CurrentPrivilegeCount++] = PrivilegesToAdd->Privilege[AddIndex];
if ( Changed ) {
*Changed = TRUE; } } }
(*RunningPrivileges)->PrivilegeCount = CurrentPrivilegeCount;
return Status;}
NTSTATUSLsapRtlRemovePrivileges( IN OUT PPRIVILEGE_SET ExistingPrivileges, IN PPRIVILEGE_SET PrivilegesToRemove )
/*++
Routine Description:
This function removes privileges in a privilege set. The existing privilege set is unaltered, a new privilege set being generated.
WARNING: Privileges within each privilege set must all be distinct, that is, there must not be two privileges in the same set having the same LUID.
Arguments:
ExistingPrivileges - Pointer to existing privilege set
PrivilegesToRemove - Pointer to privilege set specifying privileges to be removed. The privilege attributes are ignored. Privileges in the PrivilegesToRemove set that are not present in the ExistingPrivileges set will be ignored.
UpdatedPrivileges - Pointer to buffer that will receive the updated privilege set. Care must be taken to ensure that UpdatedPrivileges occupies memory disjoint from that occupied by ExistingPrivileges and PrivilegesToChange.
UpdatedPrivilegesSize - Pointer to variable that contains a size. On input, the size is the size of the UpdatedPrivileges buffer (if any). On output, the size is the size needed/used for the updated privilege set. If the updated privilege set will be NULL, 0 is returned.
Return Value:
NTSTATUS - Standard Nt Result Code
- STATUS_INVALID_PARAMETER - Invalid parameter(s) Mandatory parameters not specified UpdatedPrivileges buffer not specified (except on query-only calls
- STATUS_INSUFFICIENT_RESOURCES - Ran out of memory
Environment:
User or Kernel modes.
--*/
{ NTSTATUS Status = STATUS_SUCCESS; ULONG ExistingIndex = 0; ULONG ExistingNew = 0; ULONG RemoveIndex;
//
// Verify that mandatory parameters have been specified.
//
if (ExistingPrivileges == NULL || PrivilegesToRemove == NULL) {
return STATUS_INVALID_PARAMETER; }
//
// Scan through the privileges in the existing privilege set. Look up
// each privilege in the list of privileges to be removed. If the
// privilege is not found there, it is to be retained, so copy it
// to the output buffer/count it.
//
for (ExistingIndex = 0, ExistingNew = 0; ExistingIndex < ExistingPrivileges->PrivilegeCount; ExistingIndex++) {
//
// If the next privilege is not in the set to be deleted,
// copy it to output/count it
//
for(RemoveIndex = 0; RemoveIndex < PrivilegesToRemove->PrivilegeCount; RemoveIndex++) { if(LsapRtlEqualPrivileges( &(ExistingPrivileges->Privilege[ExistingIndex]), &(PrivilegesToRemove->Privilege[RemoveIndex]))) { break; } } if(RemoveIndex == PrivilegesToRemove->PrivilegeCount) { // We don't need to remove this one, so move it if necessary
if(ExistingIndex != ExistingNew) { ExistingPrivileges->Privilege[ExistingNew] = ExistingPrivileges->Privilege[ExistingIndex]; } ExistingNew++; } }
ExistingPrivileges->PrivilegeCount = ExistingNew; return Status;}
PLUID_AND_ATTRIBUTESLsapRtlGetPrivilege( IN PLUID_AND_ATTRIBUTES Privilege, IN PPRIVILEGE_SET Privileges )
/*++
Routine Description:
WARNING: THIS ROUTINE IS NOT YET AVAILABLE
This function locates a privilege in a privilege set. If found, a pointer to the privilege wihtin the set is returned, otherwise NULL is returned.
Arguments:
Privilege - Pointer to the privilege to be looked up.
Privileges - Pointer to the privilege set to be scanned.
Return Value:
PLUID_AND_ATTRIBUTES - If the privilege is found, a pointer to its LUID and ATTRIBUTES structure within the privilege set is returned, otherwise NULL is returned.
Environment:
User or Kernel modes.
--*/
{ ULONG PrivilegeIndex;
for (PrivilegeIndex = 0; PrivilegeIndex < Privileges->PrivilegeCount; PrivilegeIndex++) {
if (LsapRtlEqualPrivileges( Privilege, &(Privileges->Privilege[PrivilegeIndex]) )) {
return &(Privileges->Privilege[PrivilegeIndex]); } }
//
// The privilege was no found. Return NULL
//
return NULL;}
|
