sizeof(SECURITY_DESCRIPTOR), TAG_SD);
if (SePublicDefaultSd == NULL)
return FALSE;
-
+
RtlCreateSecurityDescriptor(SePublicDefaultSd,
SECURITY_DESCRIPTOR_REVISION);
RtlSetDaclSecurityDescriptor(SePublicDefaultSd,
TRUE,
SePublicDefaultDacl,
FALSE);
-
+
/* Create PublicDefaultUnrestrictedSd */
SePublicDefaultUnrestrictedSd = ExAllocatePoolWithTag(PagedPool,
sizeof(SECURITY_DESCRIPTOR), TAG_SD);
if (SePublicDefaultUnrestrictedSd == NULL)
return FALSE;
-
+
RtlCreateSecurityDescriptor(SePublicDefaultUnrestrictedSd,
SECURITY_DESCRIPTOR_REVISION);
RtlSetDaclSecurityDescriptor(SePublicDefaultUnrestrictedSd,
TRUE,
SePublicDefaultUnrestrictedDacl,
FALSE);
-
+
/* Create PublicOpenSd */
SePublicOpenSd = ExAllocatePoolWithTag(PagedPool,
sizeof(SECURITY_DESCRIPTOR), TAG_SD);
if (SePublicOpenSd == NULL)
return FALSE;
-
+
RtlCreateSecurityDescriptor(SePublicOpenSd,
SECURITY_DESCRIPTOR_REVISION);
RtlSetDaclSecurityDescriptor(SePublicOpenSd,
TRUE,
SePublicOpenDacl,
FALSE);
-
+
/* Create PublicOpenUnrestrictedSd */
SePublicOpenUnrestrictedSd = ExAllocatePoolWithTag(PagedPool,
sizeof(SECURITY_DESCRIPTOR), TAG_SD);
if (SePublicOpenUnrestrictedSd == NULL)
return FALSE;
-
+
RtlCreateSecurityDescriptor(SePublicOpenUnrestrictedSd,
SECURITY_DESCRIPTOR_REVISION);
RtlSetDaclSecurityDescriptor(SePublicOpenUnrestrictedSd,
TRUE,
SePublicOpenUnrestrictedDacl,
FALSE);
-
+
/* Create SystemDefaultSd */
SeSystemDefaultSd = ExAllocatePoolWithTag(PagedPool,
sizeof(SECURITY_DESCRIPTOR), TAG_SD);
if (SeSystemDefaultSd == NULL)
return FALSE;
-
+
RtlCreateSecurityDescriptor(SeSystemDefaultSd,
SECURITY_DESCRIPTOR_REVISION);
RtlSetDaclSecurityDescriptor(SeSystemDefaultSd,
TRUE,
SeSystemDefaultDacl,
FALSE);
-
+
/* Create UnrestrictedSd */
SeUnrestrictedSd = ExAllocatePoolWithTag(PagedPool,
sizeof(SECURITY_DESCRIPTOR), TAG_SD);
if (SeUnrestrictedSd == NULL)
return FALSE;
-
+
RtlCreateSecurityDescriptor(SeUnrestrictedSd,
SECURITY_DESCRIPTOR_REVISION);
RtlSetDaclSecurityDescriptor(SeUnrestrictedSd,
TRUE,
SeUnrestrictedDacl,
FALSE);
-
+
return TRUE;
}
ULONG SdSize;
NTSTATUS Status;
PISECURITY_DESCRIPTOR_RELATIVE SdRel = (PISECURITY_DESCRIPTOR_RELATIVE)SecurityDescriptor;
-
+
DPRINT("SeSetWorldSecurityDescriptor() called\n");
-
+
if (SecurityInformation == 0)
{
return STATUS_ACCESS_DENIED;
}
-
+
/* calculate the minimum size of the buffer */
SidSize = RtlLengthSid(SeWorldSid);
SdSize = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
{
SdSize += sizeof(ACL) + sizeof(ACE) + SidSize;
}
-
+
if (*BufferLength < SdSize)
{
*BufferLength = SdSize;
return STATUS_BUFFER_TOO_SMALL;
}
-
+
*BufferLength = SdSize;
-
+
Status = RtlCreateSecurityDescriptorRelative(SdRel,
SECURITY_DESCRIPTOR_REVISION);
if (!NT_SUCCESS(Status))
{
return Status;
}
-
+
Current = (ULONG_PTR)(SdRel + 1);
-
+
if (SecurityInformation & OWNER_SECURITY_INFORMATION)
{
RtlCopyMemory((PVOID)Current,
SdRel->Owner = (ULONG)((ULONG_PTR)Current - (ULONG_PTR)SdRel);
Current += SidSize;
}
-
+
if (SecurityInformation & GROUP_SECURITY_INFORMATION)
{
RtlCopyMemory((PVOID)Current,
SdRel->Group = (ULONG)((ULONG_PTR)Current - (ULONG_PTR)SdRel);
Current += SidSize;
}
-
+
if (SecurityInformation & DACL_SECURITY_INFORMATION)
{
PACL Dacl = (PACL)Current;
SdRel->Control |= SE_DACL_PRESENT;
-
+
Status = RtlCreateAcl(Dacl,
sizeof(ACL) + sizeof(ACE) + SidSize,
ACL_REVISION);
if (!NT_SUCCESS(Status))
return Status;
-
+
Status = RtlAddAccessAllowedAce(Dacl,
ACL_REVISION,
GENERIC_ALL,
SeWorldSid);
if (!NT_SUCCESS(Status))
return Status;
-
+
SdRel->Dacl = (ULONG)((ULONG_PTR)Current - (ULONG_PTR)SdRel);
}
-
+
if (SecurityInformation & SACL_SECURITY_INFORMATION)
{
/* FIXME - SdRel->Control |= SE_SACL_PRESENT; */
}
-
+
return STATUS_SUCCESS;
}
{
PSECURITY_QUALITY_OF_SERVICE CapturedQos;
NTSTATUS Status = STATUS_SUCCESS;
-
+
PAGED_CODE();
-
+
ASSERT(CapturedSecurityQualityOfService);
ASSERT(Present);
-
- if(ObjectAttributes != NULL)
+
+ if (ObjectAttributes != NULL)
{
- if(AccessMode != KernelMode)
+ if (AccessMode != KernelMode)
{
SECURITY_QUALITY_OF_SERVICE SafeQos;
-
+
_SEH2_TRY
{
ProbeForRead(ObjectAttributes,
sizeof(OBJECT_ATTRIBUTES),
sizeof(ULONG));
- if(ObjectAttributes->Length == sizeof(OBJECT_ATTRIBUTES))
+ if (ObjectAttributes->Length == sizeof(OBJECT_ATTRIBUTES))
{
- if(ObjectAttributes->SecurityQualityOfService != NULL)
+ if (ObjectAttributes->SecurityQualityOfService != NULL)
{
ProbeForRead(ObjectAttributes->SecurityQualityOfService,
sizeof(SECURITY_QUALITY_OF_SERVICE),
sizeof(ULONG));
- if(((PSECURITY_QUALITY_OF_SERVICE)ObjectAttributes->SecurityQualityOfService)->Length ==
- sizeof(SECURITY_QUALITY_OF_SERVICE))
+ if (((PSECURITY_QUALITY_OF_SERVICE)ObjectAttributes->SecurityQualityOfService)->Length ==
+ sizeof(SECURITY_QUALITY_OF_SERVICE))
{
- /* don't allocate memory here because ExAllocate should bugcheck
- the system if it's buggy, SEH would catch that! So make a local
- copy of the qos structure.*/
+ /*
+ * Don't allocate memory here because ExAllocate should bugcheck
+ * the system if it's buggy, SEH would catch that! So make a local
+ * copy of the qos structure.
+ */
RtlCopyMemory(&SafeQos,
ObjectAttributes->SecurityQualityOfService,
sizeof(SECURITY_QUALITY_OF_SERVICE));
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
-
- if(NT_SUCCESS(Status))
+
+ if (NT_SUCCESS(Status))
{
- if(*Present)
+ if (*Present)
{
CapturedQos = ExAllocatePool(PoolType,
sizeof(SECURITY_QUALITY_OF_SERVICE));
- if(CapturedQos != NULL)
+ if (CapturedQos != NULL)
{
RtlCopyMemory(CapturedQos,
&SafeQos,
}
else
{
- if(ObjectAttributes->Length == sizeof(OBJECT_ATTRIBUTES))
+ if (ObjectAttributes->Length == sizeof(OBJECT_ATTRIBUTES))
{
- if(CaptureIfKernel)
+ if (CaptureIfKernel)
{
- if(ObjectAttributes->SecurityQualityOfService != NULL)
+ if (ObjectAttributes->SecurityQualityOfService != NULL)
{
- if(((PSECURITY_QUALITY_OF_SERVICE)ObjectAttributes->SecurityQualityOfService)->Length ==
- sizeof(SECURITY_QUALITY_OF_SERVICE))
+ if (((PSECURITY_QUALITY_OF_SERVICE)ObjectAttributes->SecurityQualityOfService)->Length ==
+ sizeof(SECURITY_QUALITY_OF_SERVICE))
{
CapturedQos = ExAllocatePool(PoolType,
sizeof(SECURITY_QUALITY_OF_SERVICE));
- if(CapturedQos != NULL)
+ if (CapturedQos != NULL)
{
RtlCopyMemory(CapturedQos,
ObjectAttributes->SecurityQualityOfService,
*CapturedSecurityQualityOfService = NULL;
*Present = FALSE;
}
-
+
return Status;
}
IN BOOLEAN CaptureIfKernel)
{
PAGED_CODE();
-
- if(CapturedSecurityQualityOfService != NULL &&
- (AccessMode != KernelMode || CaptureIfKernel))
+
+ if (CapturedSecurityQualityOfService != NULL &&
+ (AccessMode != KernelMode || CaptureIfKernel))
{
ExFreePool(CapturedSecurityQualityOfService);
}
ULONG SaclSize = 0, DaclSize = 0;
ULONG DescriptorSize = 0;
NTSTATUS Status;
-
- if(OriginalSecurityDescriptor != NULL)
+
+ if (OriginalSecurityDescriptor != NULL)
{
- if(CurrentMode != KernelMode)
+ if (CurrentMode != KernelMode)
{
RtlZeroMemory(&DescriptorCopy, sizeof(DescriptorCopy));
-
+
_SEH2_TRY
{
- /* first only probe and copy until the control field of the descriptor
- to determine whether it's a self-relative descriptor */
+ /*
+ * First only probe and copy until the control field of the descriptor
+ * to determine whether it's a self-relative descriptor
+ */
DescriptorSize = FIELD_OFFSET(SECURITY_DESCRIPTOR,
Owner);
ProbeForRead(OriginalSecurityDescriptor,
DescriptorSize,
sizeof(ULONG));
-
- if(OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
+
+ if (OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
{
_SEH2_YIELD(return STATUS_UNKNOWN_REVISION);
}
-
- /* make a copy on the stack */
+
+ /* Make a copy on the stack */
DescriptorCopy.Revision = OriginalSecurityDescriptor->Revision;
DescriptorCopy.Sbz1 = OriginalSecurityDescriptor->Sbz1;
DescriptorCopy.Control = OriginalSecurityDescriptor->Control;
DescriptorSize = ((DescriptorCopy.Control & SE_SELF_RELATIVE) ?
sizeof(SECURITY_DESCRIPTOR_RELATIVE) : sizeof(SECURITY_DESCRIPTOR));
-
- /* probe and copy the entire security descriptor structure. The SIDs
- and ACLs will be probed and copied later though */
+
+ /*
+ * Probe and copy the entire security descriptor structure. The SIDs
+ * and ACLs will be probed and copied later though
+ */
ProbeForRead(OriginalSecurityDescriptor,
DescriptorSize,
sizeof(ULONG));
- if(DescriptorCopy.Control & SE_SELF_RELATIVE)
+ if (DescriptorCopy.Control & SE_SELF_RELATIVE)
{
PISECURITY_DESCRIPTOR_RELATIVE RelSD = (PISECURITY_DESCRIPTOR_RELATIVE)OriginalSecurityDescriptor;
-
+
DescriptorCopy.Owner = (PSID)RelSD->Owner;
DescriptorCopy.Group = (PSID)RelSD->Group;
DescriptorCopy.Sacl = (PACL)RelSD->Sacl;
}
_SEH2_END;
}
- else if(!CaptureIfKernel)
+ else if (!CaptureIfKernel)
{
- if(OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
+ if (OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
{
return STATUS_UNKNOWN_REVISION;
}
-
+
*CapturedSecurityDescriptor = OriginalSecurityDescriptor;
return STATUS_SUCCESS;
}
else
{
- if(OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
+ if (OriginalSecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
{
return STATUS_UNKNOWN_REVISION;
}
-
- /* make a copy on the stack */
+
+ /* Make a copy on the stack */
DescriptorCopy.Revision = OriginalSecurityDescriptor->Revision;
DescriptorCopy.Sbz1 = OriginalSecurityDescriptor->Sbz1;
DescriptorCopy.Control = OriginalSecurityDescriptor->Control;
DescriptorSize = ((DescriptorCopy.Control & SE_SELF_RELATIVE) ?
sizeof(SECURITY_DESCRIPTOR_RELATIVE) : sizeof(SECURITY_DESCRIPTOR));
- if(DescriptorCopy.Control & SE_SELF_RELATIVE)
+ if (DescriptorCopy.Control & SE_SELF_RELATIVE)
{
PISECURITY_DESCRIPTOR_RELATIVE RelSD = (PISECURITY_DESCRIPTOR_RELATIVE)OriginalSecurityDescriptor;
-
+
DescriptorCopy.Owner = (PSID)RelSD->Owner;
DescriptorCopy.Group = (PSID)RelSD->Group;
DescriptorCopy.Sacl = (PACL)RelSD->Sacl;
DescriptorCopy.Dacl = OriginalSecurityDescriptor->Dacl;
}
}
-
- if(DescriptorCopy.Control & SE_SELF_RELATIVE)
+
+ if (DescriptorCopy.Control & SE_SELF_RELATIVE)
{
- /* in case we're dealing with a self-relative descriptor, do a basic convert
- to an absolute descriptor. We do this so we can simply access the data
- using the pointers without calculating them again. */
+ /*
+ * In case we're dealing with a self-relative descriptor, do a basic convert
+ * to an absolute descriptor. We do this so we can simply access the data
+ * using the pointers without calculating them again.
+ */
DescriptorCopy.Control &= ~SE_SELF_RELATIVE;
- if(DescriptorCopy.Owner != NULL)
+ if (DescriptorCopy.Owner != NULL)
{
DescriptorCopy.Owner = (PSID)((ULONG_PTR)OriginalSecurityDescriptor + (ULONG_PTR)DescriptorCopy.Owner);
}
- if(DescriptorCopy.Group != NULL)
+ if (DescriptorCopy.Group != NULL)
{
DescriptorCopy.Group = (PSID)((ULONG_PTR)OriginalSecurityDescriptor + (ULONG_PTR)DescriptorCopy.Group);
}
- if(DescriptorCopy.Dacl != NULL)
+ if (DescriptorCopy.Dacl != NULL)
{
DescriptorCopy.Dacl = (PACL)((ULONG_PTR)OriginalSecurityDescriptor + (ULONG_PTR)DescriptorCopy.Dacl);
}
- if(DescriptorCopy.Sacl != NULL)
+ if (DescriptorCopy.Sacl != NULL)
{
DescriptorCopy.Sacl = (PACL)((ULONG_PTR)OriginalSecurityDescriptor + (ULONG_PTR)DescriptorCopy.Sacl);
}
}
-
- /* determine the size of the SIDs */
+
+ /* Determine the size of the SIDs */
#define DetermineSIDSize(SidType) \
do { \
if(DescriptorCopy.SidType != NULL) \
\
if(CurrentMode != KernelMode) \
{ \
-/* securely access the buffers! */ \
+/* Securely access the buffers! */ \
_SEH2_TRY \
{ \
SidType##SAC = ProbeForReadUchar(&SidType->SubAuthorityCount); \
} \
} \
} while(0)
-
+
DetermineSIDSize(Owner);
DetermineSIDSize(Group);
-
+
#undef DetermineSIDSize
-
- /* determine the size of the ACLs */
+
+ /* Determine the size of the ACLs */
#define DetermineACLSize(AclType, AclFlag) \
do { \
if((DescriptorCopy.Control & SE_##AclFlag##_PRESENT) && \
\
if(CurrentMode != KernelMode) \
{ \
-/* securely access the buffers! */ \
+/* Securely access the buffers! */ \
_SEH2_TRY \
{ \
AclType##Size = ProbeForReadUshort(&AclType->AclSize); \
DescriptorCopy.AclType = NULL; \
} \
} while(0)
-
+
DetermineACLSize(Sacl, SACL);
DetermineACLSize(Dacl, DACL);
-
+
#undef DetermineACLSize
-
- /* allocate enough memory to store a complete copy of a self-relative
- security descriptor */
+
+ /*
+ * Allocate enough memory to store a complete copy of a self-relative
+ * security descriptor
+ */
NewDescriptor = ExAllocatePoolWithTag(PoolType,
DescriptorSize,
TAG_SD);
- if(NewDescriptor != NULL)
+ if (NewDescriptor != NULL)
{
ULONG_PTR Offset = sizeof(SECURITY_DESCRIPTOR);
-
+
RtlZeroMemory(NewDescriptor, DescriptorSize);
NewDescriptor->Revision = DescriptorCopy.Revision;
NewDescriptor->Sbz1 = DescriptorCopy.Sbz1;
NewDescriptor->Control = DescriptorCopy.Control | SE_SELF_RELATIVE;
-
+
_SEH2_TRY
{
- /* setup the offsets and copy the SIDs and ACLs to the new
- self-relative security descriptor. Probing the pointers is not
- neccessary anymore as we did that when collecting the sizes!
- Make sure to validate the SIDs and ACLs *again* as they could have
- been modified in the meanwhile! */
+ /*
+ * Setup the offsets and copy the SIDs and ACLs to the new
+ * self-relative security descriptor. Probing the pointers is not
+ * neccessary anymore as we did that when collecting the sizes!
+ * Make sure to validate the SIDs and ACLs *again* as they could have
+ * been modified in the meanwhile!
+ */
#define CopySID(Type) \
do { \
if(DescriptorCopy.Type != NULL) \
Offset += ROUND_UP(Type##Size, sizeof(ULONG)); \
} \
} while(0)
-
+
CopySID(Owner);
CopySID(Group);
-
+
#undef CopySID
-
+
#define CopyACL(Type) \
do { \
if(DescriptorCopy.Type != NULL) \
Offset += ROUND_UP(Type##Size, sizeof(ULONG)); \
} \
} while(0)
-
+
CopyACL(Sacl);
CopyACL(Dacl);
-
+
#undef CopyACL
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- /* we failed to copy the data to the new descriptor */
+ /* We failed to copy the data to the new descriptor */
ExFreePool(NewDescriptor);
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
-
- /* we're finally done! copy the pointer to the captured descriptor to
- to the caller */
+
+ /*
+ * We're finally done!
+ * Copy the pointer to the captured descriptor to to the caller.
+ */
*CapturedSecurityDescriptor = NewDescriptor;
return STATUS_SUCCESS;
-
}
else
{
}
else
{
- /* nothing to do... */
+ /* Nothing to do... */
*CapturedSecurityDescriptor = NULL;
}
-
+
return Status;
}
ULONG Control = 0;
ULONG_PTR Current;
ULONG SdLength;
-
+
RelSD = (PISECURITY_DESCRIPTOR_RELATIVE)SecurityDescriptor;
-
+
if (*ObjectsSecurityDescriptor == NULL)
{
if (*Length < sizeof(SECURITY_DESCRIPTOR_RELATIVE))
*Length = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
return STATUS_BUFFER_TOO_SMALL;
}
-
+
*Length = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
RtlCreateSecurityDescriptorRelative(RelSD,
SECURITY_DESCRIPTOR_REVISION);
return STATUS_SUCCESS;
}
-
+
ObjectSd = *ObjectsSecurityDescriptor;
-
+
/* Calculate the required security descriptor length */
Control = SE_SELF_RELATIVE;
if ((*SecurityInformation & OWNER_SECURITY_INFORMATION) &&
OwnerLength = ROUND_UP(RtlLengthSid(Owner), 4);
Control |= (ObjectSd->Control & SE_OWNER_DEFAULTED);
}
-
+
if ((*SecurityInformation & GROUP_SECURITY_INFORMATION) &&
(ObjectSd->Group != NULL))
{
GroupLength = ROUND_UP(RtlLengthSid(Group), 4);
Control |= (ObjectSd->Control & SE_GROUP_DEFAULTED);
}
-
+
if ((*SecurityInformation & DACL_SECURITY_INFORMATION) &&
(ObjectSd->Control & SE_DACL_PRESENT))
{
Dacl = (PACL)((ULONG_PTR)ObjectSd->Dacl + (ULONG_PTR)ObjectSd);
DaclLength = ROUND_UP((ULONG)Dacl->AclSize, 4);
}
+
Control |= (ObjectSd->Control & (SE_DACL_DEFAULTED | SE_DACL_PRESENT));
}
-
+
if ((*SecurityInformation & SACL_SECURITY_INFORMATION) &&
(ObjectSd->Control & SE_SACL_PRESENT))
{
Sacl = (PACL)((ULONG_PTR)ObjectSd->Sacl + (ULONG_PTR)ObjectSd);
SaclLength = ROUND_UP(Sacl->AclSize, 4);
}
+
Control |= (ObjectSd->Control & (SE_SACL_DEFAULTED | SE_SACL_PRESENT));
}
-
+
SdLength = OwnerLength + GroupLength + DaclLength +
SaclLength + sizeof(SECURITY_DESCRIPTOR_RELATIVE);
if (*Length < SdLength)
*Length = SdLength;
return STATUS_BUFFER_TOO_SMALL;
}
-
+
/* Build the new security descrtiptor */
RtlCreateSecurityDescriptorRelative(RelSD,
SECURITY_DESCRIPTOR_REVISION);
RelSD->Control = (USHORT)Control;
-
+
Current = (ULONG_PTR)(RelSD + 1);
-
+
if (OwnerLength != 0)
{
RtlCopyMemory((PVOID)Current,
RelSD->Owner = (ULONG)(Current - (ULONG_PTR)SecurityDescriptor);
Current += OwnerLength;
}
-
+
if (GroupLength != 0)
{
RtlCopyMemory((PVOID)Current,
RelSD->Group = (ULONG)(Current - (ULONG_PTR)SecurityDescriptor);
Current += GroupLength;
}
-
+
if (DaclLength != 0)
{
RtlCopyMemory((PVOID)Current,
RelSD->Dacl = (ULONG)(Current - (ULONG_PTR)SecurityDescriptor);
Current += DaclLength;
}
-
+
if (SaclLength != 0)
{
RtlCopyMemory((PVOID)Current,
RelSD->Sacl = (ULONG)(Current - (ULONG_PTR)SecurityDescriptor);
Current += SaclLength;
}
-
+
*Length = SdLength;
-
+
return STATUS_SUCCESS;
}
IN BOOLEAN CaptureIfKernelMode)
{
PAGED_CODE();
-
- /* WARNING! You need to call this function with the same value for CurrentMode
- and CaptureIfKernelMode that you previously passed to
- SeCaptureSecurityDescriptor() in order to avoid memory leaks! */
- if(CapturedSecurityDescriptor != NULL &&
- (CurrentMode != KernelMode ||
- (CurrentMode == KernelMode && CaptureIfKernelMode)))
- {
- /* only delete the descriptor when SeCaptureSecurityDescriptor() allocated one! */
+
+ /*
+ * WARNING! You need to call this function with the same value for CurrentMode
+ * and CaptureIfKernelMode that you previously passed to
+ * SeCaptureSecurityDescriptor() in order to avoid memory leaks!
+ */
+ if (CapturedSecurityDescriptor != NULL &&
+ (CurrentMode != KernelMode ||
+ (CurrentMode == KernelMode && CaptureIfKernelMode)))
+ {
+ /* Only delete the descriptor when SeCaptureSecurityDescriptor() allocated one! */
ExFreePoolWithTag(CapturedSecurityDescriptor, TAG_SD);
}
-
+
return STATUS_SUCCESS;
}
ULONG Control = 0;
ULONG_PTR Current;
SECURITY_INFORMATION SecurityInformation;
-
+
ObjectSd = *ObjectsSecurityDescriptor;
-
+
+ /* The object does not have a security descriptor. */
if (!ObjectSd)
- return STATUS_NO_SECURITY_ON_OBJECT; // The object does not have a security descriptor.
-
+ return STATUS_NO_SECURITY_ON_OBJECT;
+
SecurityInformation = *_SecurityInformation;
-
+
/* Get owner and owner size */
if (SecurityInformation & OWNER_SECURITY_INFORMATION)
{
if (SecurityDescriptor->Owner != NULL)
{
- if( SecurityDescriptor->Control & SE_SELF_RELATIVE )
+ if (SecurityDescriptor->Control & SE_SELF_RELATIVE)
Owner = (PSID)((ULONG_PTR)SecurityDescriptor->Owner +
(ULONG_PTR)SecurityDescriptor);
else
Owner = (PSID)SecurityDescriptor->Owner;
OwnerLength = ROUND_UP(RtlLengthSid(Owner), 4);
}
+
Control |= (SecurityDescriptor->Control & SE_OWNER_DEFAULTED);
}
else
Owner = (PSID)((ULONG_PTR)ObjectSd->Owner + (ULONG_PTR)ObjectSd);
OwnerLength = ROUND_UP(RtlLengthSid(Owner), 4);
}
+
Control |= (ObjectSd->Control & SE_OWNER_DEFAULTED);
}
Group = (PSID)SecurityDescriptor->Group;
GroupLength = ROUND_UP(RtlLengthSid(Group), 4);
}
+
Control |= (SecurityDescriptor->Control & SE_GROUP_DEFAULTED);
}
else
Group = (PSID)((ULONG_PTR)ObjectSd->Group + (ULONG_PTR)ObjectSd);
GroupLength = ROUND_UP(RtlLengthSid(Group), 4);
}
+
Control |= (ObjectSd->Control & SE_GROUP_DEFAULTED);
}
-
+
/* Get DACL and DACL size */
if (SecurityInformation & DACL_SECURITY_INFORMATION)
{
(ULONG_PTR)SecurityDescriptor);
else
Dacl = (PACL)SecurityDescriptor->Dacl;
-
+
DaclLength = ROUND_UP((ULONG)Dacl->AclSize, 4);
}
+
Control |= (SecurityDescriptor->Control & (SE_DACL_DEFAULTED | SE_DACL_PRESENT));
}
else
Dacl = (PACL)((ULONG_PTR)ObjectSd->Dacl + (ULONG_PTR)ObjectSd);
DaclLength = ROUND_UP((ULONG)Dacl->AclSize, 4);
}
+
Control |= (ObjectSd->Control & (SE_DACL_DEFAULTED | SE_DACL_PRESENT));
}
Sacl = (PACL)SecurityDescriptor->Sacl;
SaclLength = ROUND_UP((ULONG)Sacl->AclSize, 4);
}
+
Control |= (SecurityDescriptor->Control & (SE_SACL_DEFAULTED | SE_SACL_PRESENT));
}
else
Sacl = (PACL)((ULONG_PTR)ObjectSd->Sacl + (ULONG_PTR)ObjectSd);
SaclLength = ROUND_UP((ULONG)Sacl->AclSize, 4);
}
+
Control |= (ObjectSd->Control & (SE_SACL_DEFAULTED | SE_SACL_PRESENT));
}
-
+
NewSd = ExAllocatePool(NonPagedPool,
sizeof(SECURITY_DESCRIPTOR) + OwnerLength + GroupLength +
DaclLength + SaclLength);
ObDereferenceObject(Object);
return STATUS_INSUFFICIENT_RESOURCES;
}
-
+
RtlCreateSecurityDescriptor(NewSd,
SECURITY_DESCRIPTOR_REVISION1);
+
/* We always build a self-relative descriptor */
NewSd->Control = (USHORT)Control | SE_SELF_RELATIVE;
-
+
Current = (ULONG_PTR)NewSd + sizeof(SECURITY_DESCRIPTOR);
-
+
if (OwnerLength != 0)
{
RtlCopyMemory((PVOID)Current,
NewSd->Owner = (PSID)(Current - (ULONG_PTR)NewSd);
Current += OwnerLength;
}
-
+
if (GroupLength != 0)
{
RtlCopyMemory((PVOID)Current,
NewSd->Group = (PSID)(Current - (ULONG_PTR)NewSd);
Current += GroupLength;
}
-
+
if (DaclLength != 0)
{
RtlCopyMemory((PVOID)Current,
NewSd->Dacl = (PACL)(Current - (ULONG_PTR)NewSd);
Current += DaclLength;
}
-
+
if (SaclLength != 0)
{
RtlCopyMemory((PVOID)Current,
SaclLength);
NewSd->Sacl = (PACL)(Current - (ULONG_PTR)NewSd);
Current += SaclLength;
- }
-
+ }
+
*ObjectsSecurityDescriptor = NewSd;
return STATUS_SUCCESS;
}
IN PGENERIC_MAPPING GenericMapping)
{
PISECURITY_DESCRIPTOR ObjectSd = *ObjectsSecurityDescriptor;
-
+
+ /* The object does not have a security descriptor. */
if (!ObjectSd)
- return STATUS_NO_SECURITY_ON_OBJECT; // The object does not have a security descriptor.
-
- UNIMPLEMENTED;
- return STATUS_NOT_IMPLEMENTED;
+ return STATUS_NO_SECURITY_ON_OBJECT;
+
+ UNIMPLEMENTED;
+ return STATUS_NOT_IMPLEMENTED;
}
PISID Sid;
PACL Acl;
PISECURITY_DESCRIPTOR SecurityDescriptor = _SecurityDescriptor;
-
+
if (Length < SECURITY_DESCRIPTOR_MIN_LENGTH)
{
DPRINT1("Invalid Security Descriptor revision\n");
return FALSE;
}
-
+
if (SecurityDescriptor->Revision != SECURITY_DESCRIPTOR_REVISION1)
{
DPRINT1("Invalid Security Descriptor revision\n");
return FALSE;
}
-
+
if (!(SecurityDescriptor->Control & SE_SELF_RELATIVE))
{
DPRINT1("No self-relative Security Descriptor\n");
return FALSE;
}
-
+
SdLength = sizeof(SECURITY_DESCRIPTOR);
-
+
/* Check Owner SID */
if (SecurityDescriptor->Owner == NULL)
{
DPRINT1("No Owner SID\n");
return FALSE;
}
-
+
if ((ULONG_PTR)SecurityDescriptor->Owner % sizeof(ULONG))
{
DPRINT1("Invalid Owner SID alignment\n");
return FALSE;
}
-
+
Sid = (PISID)((ULONG_PTR)SecurityDescriptor + (ULONG_PTR)SecurityDescriptor->Owner);
if (Sid->Revision != SID_REVISION)
{
DPRINT1("Invalid Owner SID revision\n");
return FALSE;
}
-
+
SdLength += (sizeof(SID) + (Sid->SubAuthorityCount - 1) * sizeof(ULONG));
if (Length < SdLength)
{
DPRINT1("Invalid Owner SID size\n");
return FALSE;
}
-
+
/* Check Group SID */
if (SecurityDescriptor->Group != NULL)
{
DPRINT1("Invalid Group SID alignment\n");
return FALSE;
}
-
+
Sid = (PSID)((ULONG_PTR)SecurityDescriptor + (ULONG_PTR)SecurityDescriptor->Group);
if (Sid->Revision != SID_REVISION)
{
DPRINT1("Invalid Group SID revision\n");
return FALSE;
}
-
+
SdLength += (sizeof(SID) + (Sid->SubAuthorityCount - 1) * sizeof(ULONG));
if (Length < SdLength)
{
return FALSE;
}
}
-
+
/* Check DACL */
if (SecurityDescriptor->Dacl != NULL)
{
DPRINT1("Invalid DACL alignment\n");
return FALSE;
}
-
+
Acl = (PACL)((ULONG_PTR)SecurityDescriptor + (ULONG_PTR)SecurityDescriptor->Dacl);
if ((Acl->AclRevision < MIN_ACL_REVISION) &&
(Acl->AclRevision > MAX_ACL_REVISION))
DPRINT1("Invalid DACL revision\n");
return FALSE;
}
-
+
SdLength += Acl->AclSize;
if (Length < SdLength)
{
return FALSE;
}
}
-
+
/* Check SACL */
if (SecurityDescriptor->Sacl != NULL)
{
DPRINT1("Invalid SACL alignment\n");
return FALSE;
}
-
+
Acl = (PACL)((ULONG_PTR)SecurityDescriptor + (ULONG_PTR)SecurityDescriptor->Sacl);
if ((Acl->AclRevision < MIN_ACL_REVISION) ||
(Acl->AclRevision > MAX_ACL_REVISION))
DPRINT1("Invalid SACL revision\n");
return FALSE;
}
-
+
SdLength += Acl->AclSize;
if (Length < SdLength)
{
return FALSE;
}
}
-
+
return TRUE;
}
SeDeassignSecurity(PSECURITY_DESCRIPTOR *SecurityDescriptor)
{
PAGED_CODE();
-
+
if (*SecurityDescriptor != NULL)
{
ExFreePool(*SecurityDescriptor);
*SecurityDescriptor = NULL;
}
-
+
return STATUS_SUCCESS;
}
PSID Group = NULL;
PACL Dacl = NULL;
PACL Sacl = NULL;
-
+
PAGED_CODE();
-
+
/* Lock subject context */
SeLockSubjectContext(SubjectContext);
-
+
if (SubjectContext->ClientToken != NULL)
{
Token = SubjectContext->ClientToken;
{
Token = SubjectContext->PrimaryToken;
}
-
-
+
/* Inherit the Owner SID */
if (ExplicitDescriptor != NULL && ExplicitDescriptor->Owner != NULL)
{
DPRINT("Use explicit owner sid!\n");
Owner = ExplicitDescriptor->Owner;
-
+
if (ExplicitDescriptor->Control & SE_SELF_RELATIVE)
{
Owner = (PSID)(((ULONG_PTR)Owner) + (ULONG_PTR)ExplicitDescriptor);
-
}
}
else
DPRINT("Use default owner sid!\n");
Owner = SeLocalSystemSid;
}
-
+
Control |= SE_OWNER_DEFAULTED;
}
-
+
OwnerLength = ROUND_UP(RtlLengthSid(Owner), 4);
-
-
+
/* Inherit the Group SID */
if (ExplicitDescriptor != NULL && ExplicitDescriptor->Group != NULL)
{
DPRINT("Use default group sid!\n");
Group = SeLocalSystemSid;
}
-
+
Control |= SE_OWNER_DEFAULTED;
}
-
+
GroupLength = ROUND_UP(RtlLengthSid(Group), 4);
-
-
+
/* Inherit the DACL */
if (ExplicitDescriptor != NULL &&
(ExplicitDescriptor->Control & SE_DACL_PRESENT) &&
{
Dacl = (PACL)(((ULONG_PTR)Dacl) + (ULONG_PTR)ExplicitDescriptor);
}
-
+
Control |= SE_DACL_PRESENT;
}
else if (ParentDescriptor != NULL &&
{
Dacl = (PACL)(((ULONG_PTR)Dacl) + (ULONG_PTR)ParentDescriptor);
}
+
Control |= (SE_DACL_PRESENT | SE_DACL_DEFAULTED);
}
else if (Token != NULL && Token->DefaultDacl != NULL)
Dacl = NULL;
Control |= (SE_DACL_PRESENT | SE_DACL_DEFAULTED);
}
-
+
DaclLength = (Dacl != NULL) ? ROUND_UP(Dacl->AclSize, 4) : 0;
-
-
+
/* Inherit the SACL */
if (ExplicitDescriptor != NULL &&
(ExplicitDescriptor->Control & SE_SACL_PRESENT) &&
{
Sacl = (PACL)(((ULONG_PTR)Sacl) + (ULONG_PTR)ExplicitDescriptor);
}
-
+
Control |= SE_SACL_PRESENT;
}
else if (ParentDescriptor != NULL &&
{
Sacl = (PACL)(((ULONG_PTR)Sacl) + (ULONG_PTR)ParentDescriptor);
}
+
Control |= (SE_SACL_PRESENT | SE_SACL_DEFAULTED);
}
-
+
SaclLength = (Sacl != NULL) ? ROUND_UP(Sacl->AclSize, 4) : 0;
-
-
+
/* Allocate and initialize the new security descriptor */
Length = sizeof(SECURITY_DESCRIPTOR) +
OwnerLength + GroupLength + DaclLength + SaclLength;
-
+
DPRINT("L: sizeof(SECURITY_DESCRIPTOR) %d OwnerLength %d GroupLength %d DaclLength %d SaclLength %d\n",
sizeof(SECURITY_DESCRIPTOR),
OwnerLength,
GroupLength,
DaclLength,
SaclLength);
-
+
Descriptor = ExAllocatePoolWithTag(PagedPool,
Length,
TAG_SD);
/* FIXME: Unlock subject context */
return STATUS_INSUFFICIENT_RESOURCES;
}
-
+
RtlZeroMemory( Descriptor, Length );
RtlCreateSecurityDescriptor(Descriptor,
SECURITY_DESCRIPTOR_REVISION);
-
+
Descriptor->Control = (USHORT)Control | SE_SELF_RELATIVE;
-
+
Current = (ULONG_PTR)Descriptor + sizeof(SECURITY_DESCRIPTOR);
-
+
if (SaclLength != 0)
{
RtlCopyMemory((PVOID)Current,
Descriptor->Sacl = (PACL)((ULONG_PTR)Current - (ULONG_PTR)Descriptor);
Current += SaclLength;
}
-
+
if (DaclLength != 0)
{
RtlCopyMemory((PVOID)Current,
Descriptor->Dacl = (PACL)((ULONG_PTR)Current - (ULONG_PTR)Descriptor);
Current += DaclLength;
}
-
+
if (OwnerLength != 0)
{
RtlCopyMemory((PVOID)Current,
DPRINT("Owner of %x at %x\n", Descriptor, Descriptor->Owner);
}
else
+ {
DPRINT("Owner of %x is zero length\n", Descriptor);
-
+ }
+
if (GroupLength != 0)
{
memmove((PVOID)Current,
GroupLength);
Descriptor->Group = (PSID)((ULONG_PTR)Current - (ULONG_PTR)Descriptor);
}
-
+
/* Unlock subject context */
SeUnlockSubjectContext(SubjectContext);
-
+
*NewDescriptor = Descriptor;
-
+
DPRINT("Descrptor %x\n", Descriptor);
ASSERT(RtlLengthSecurityDescriptor(Descriptor));
-
+
return STATUS_SUCCESS;
}
projects / reactos.git / blobdiff