secursup.cpp File Reference

#include "udffs.h"

Include dependency graph for secursup.cpp:

Go to the source code of this file.

Macros
#define	UDF_BUG_CHECK_ID   UDF_FILE_SECURITY

Functions
NTSTATUS	UDFReadSecurity (IN PVCB Vcb, IN PtrUDFFCB Fcb, IN PSECURITY_DESCRIPTOR *SecurityDesc)
NTSTATUS	UDFAssignAcl (IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN PtrUDFFCB Fcb, IN PtrUDFNTRequiredFCB NtReqFcb)
VOID	UDFDeassignAcl (IN PtrUDFNTRequiredFCB NtReqFcb, IN BOOLEAN AutoInherited)
NTSTATUS	UDFWriteSecurity (IN PVCB Vcb, IN PtrUDFFCB Fcb, IN PSECURITY_DESCRIPTOR *SecurityDesc)
PSECURITY_DESCRIPTOR	UDFLookUpAcl (IN PVCB Vcb, PFILE_OBJECT FileObject, IN PtrUDFFCB Fcb)
NTSTATUS	UDFCheckAccessRights (PFILE_OBJECT FileObject, PACCESS_STATE AccessState, PtrUDFFCB Fcb, PtrUDFCCB Ccb, ACCESS_MASK DesiredAccess, USHORT ShareAccess)
NTSTATUS	UDFSetAccessRights (PFILE_OBJECT FileObject, PACCESS_STATE AccessState, PtrUDFFCB Fcb, PtrUDFCCB Ccb, ACCESS_MASK DesiredAccess, USHORT ShareAccess)

Macro Definition Documentation

UDF_BUG_CHECK_ID

#define UDF_BUG_CHECK_ID   UDF_FILE_SECURITY

Definition at line 20 of file secursup.cpp.

Function Documentation

UDFAssignAcl()

NTSTATUS UDFAssignAcl	(	IN PVCB	Vcb,
		IN PFILE_OBJECT	FileObject,
		IN PtrUDFFCB	Fcb,
		IN PtrUDFNTRequiredFCB	NtReqFcb
	)

Definition at line 706 of file secursup.cpp.

{
    NTSTATUS RC = STATUS_SUCCESS;
#ifdef UDF_ENABLE_SECURITY
//    SECURITY_INFORMATION SecurityInformation;
 
//    UDFPrint(("  UDFAssignAcl\n"));
    if(!NtReqFcb->SecurityDesc) {
 
        PSECURITY_DESCRIPTOR ExplicitSecurity = NULL;
 
        if(UDFIsAStreamDir(Fcb->FileInfo) || UDFIsAStream(Fcb->FileInfo)) {
            // Stream/SDir security
            NtReqFcb->SecurityDesc = Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc;
            return STATUS_SUCCESS;
        } else
        if(!Fcb->FileInfo) {
            // Volume security
            if(Vcb->RootDirFCB &&
               Vcb->RootDirFCB->FileInfo &&
               Vcb->RootDirFCB->FileInfo->Dloc &&
               Vcb->RootDirFCB->FileInfo->Dloc->CommonFcb) {
                RC = UDFInheritAcl(Vcb, &(Vcb->RootDirFCB->FileInfo->Dloc->CommonFcb->SecurityDesc), &ExplicitSecurity);
            } else {
                NtReqFcb->SecurityDesc = NULL;
                RC = STATUS_NO_SECURITY_ON_OBJECT;
            }
            return RC;
        }
 
        RC = UDFReadSecurity(Vcb, Fcb, &ExplicitSecurity);
        if(RC == STATUS_NO_SECURITY_ON_OBJECT) {
            if(!Fcb->FileInfo->ParentFile) {
                RC = UDFBuildFullControlAcl(Vcb, &ExplicitSecurity);
            } else {
                RC = UDFInheritAcl(Vcb, &(Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc), &ExplicitSecurity);
            }
/*            if(NT_SUCCESS(RC)) {
                NtReqFcb->NtReqFCBFlags |= UDF_NTREQ_FCB_SD_MODIFIED;
            }*/
        }
        if(NT_SUCCESS(RC)) {
 
//            SecurityInformation = FULL_SECURITY_INFORMATION;
            NtReqFcb->SecurityDesc = ExplicitSecurity;
 
/*            RC = SeSetSecurityDescriptorInfo(FileObject,
                                          &SecurityInformation,
                                          ExplicitSecurity,
                                          &(NtReqFcb->SecurityDesc),
                                          NonPagedPool,
                                          IoGetFileObjectGenericMapping() );*/
 
        }
    }
#endif //UDF_ENABLE_SECURITY
    return RC;
} // end UDFAssignAcl()

Referenced by UDFCompleteMount(), and UDFLookUpAcl().

UDFCheckAccessRights()

NTSTATUS UDFCheckAccessRights	(	PFILE_OBJECT	FileObject,
		PACCESS_STATE	AccessState,
		PtrUDFFCB	Fcb,
		PtrUDFCCB	Ccb,
		ACCESS_MASK	DesiredAccess,
		USHORT	ShareAccess
	)

Definition at line 927 of file secursup.cpp.

{
    NTSTATUS RC;
    BOOLEAN ROCheck = FALSE;
#ifdef UDF_ENABLE_SECURITY
    BOOLEAN SecurityCheck;
    PSECURITY_DESCRIPTOR SecDesc;
    SECURITY_SUBJECT_CONTEXT SubjectContext;
    ACCESS_MASK LocalAccessMask;
#endif //UDF_ENABLE_SECURITY
 
    // Check attr compatibility
    ASSERT(Fcb);
    ASSERT(Fcb->Vcb);
#ifdef UDF_READ_ONLY_BUILD
    goto treat_as_ro;
#endif //UDF_READ_ONLY_BUILD
 
    if(Fcb->FCBFlags & UDF_FCB_READ_ONLY) {
        ROCheck = TRUE;
    } else
    if((Fcb->Vcb->origIntegrityType == INTEGRITY_TYPE_OPEN) &&
        Ccb && !(Ccb->CCBFlags & UDF_CCB_VOLUME_OPEN) &&
       (Fcb->Vcb->CompatFlags & UDF_VCB_IC_DIRTY_RO)) {
        AdPrint(("force R/O on dirty\n"));
        ROCheck = TRUE;
    }
    if(ROCheck) {
#ifdef UDF_READ_ONLY_BUILD
treat_as_ro:
#endif //UDF_READ_ONLY_BUILD
        ACCESS_MASK  DesiredAccessMask = 0;
 
        if(Fcb->Vcb->CompatFlags & UDF_VCB_IC_WRITE_IN_RO_DIR) {
            if(Fcb->FCBFlags & UDF_FCB_DIRECTORY) {
                DesiredAccessMask = (FILE_WRITE_EA |
                                     DELETE);
            } else {
                DesiredAccessMask = (FILE_WRITE_DATA |
                                     FILE_APPEND_DATA |
                                     FILE_WRITE_EA |
                                     DELETE);
            }
        } else {
                DesiredAccessMask = (FILE_WRITE_DATA |
                                     FILE_APPEND_DATA |
                                     FILE_WRITE_EA |
                                     FILE_DELETE_CHILD |
                                     FILE_ADD_SUBDIRECTORY |
                                     FILE_ADD_FILE |
                                     DELETE);
        }
        if(DesiredAccess & DesiredAccessMask)
            return STATUS_ACCESS_DENIED;
    }
#ifdef UDF_ENABLE_SECURITY
    // Check Security
    // NOTE: we should not perform security check if an empty DesiredAccess
    // was specified. AFAIU, SeAccessCheck() will return FALSE in this case.
    SecDesc = UDFLookUpAcl(Fcb->Vcb, FileObject, Fcb);
    if(SecDesc && DesiredAccess) {
        SeCaptureSubjectContext(&SubjectContext);
        SecurityCheck =
            SeAccessCheck(SecDesc,
                          &SubjectContext,
                          FALSE,
                          DesiredAccess,
                          Ccb ? Ccb->PreviouslyGrantedAccess : 0,
                          NULL,
                          IoGetFileObjectGenericMapping(),
                          UserMode,
                          Ccb ? &(Ccb->PreviouslyGrantedAccess) : &LocalAccessMask,
                          &RC);
        SeReleaseSubjectContext(&SubjectContext);
 
        if(!SecurityCheck) {
            return RC;
        } else
#endif //UDF_ENABLE_SECURITY
        if(DesiredAccess & ACCESS_SYSTEM_SECURITY) {
            if (!SeSinglePrivilegeCheck(SeExports->SeSecurityPrivilege, UserMode))
                return STATUS_ACCESS_DENIED;
            Ccb->PreviouslyGrantedAccess |= ACCESS_SYSTEM_SECURITY;
        }
#ifdef UDF_ENABLE_SECURITY
    }
#endif //UDF_ENABLE_SECURITY
    if(FileObject) {
        if (Fcb->OpenHandleCount) {
            // The FCB is currently in use by some thread.
            // We must check whether the requested access/share access
            // conflicts with the existing open operations.
            RC = IoCheckShareAccess(DesiredAccess, ShareAccess, FileObject,
                                            &(Fcb->NTRequiredFCB->FCBShareAccess), TRUE);
#ifndef UDF_ENABLE_SECURITY
            if(Ccb)
                Ccb->PreviouslyGrantedAccess |= DesiredAccess;
            IoUpdateShareAccess(FileObject, &(Fcb->NTRequiredFCB->FCBShareAccess));
#endif //UDF_ENABLE_SECURITY
        } else {
            IoSetShareAccess(DesiredAccess, ShareAccess, FileObject, &(Fcb->NTRequiredFCB->FCBShareAccess));
#ifndef UDF_ENABLE_SECURITY
            if(Ccb)
                Ccb->PreviouslyGrantedAccess = DesiredAccess;
#endif //UDF_ENABLE_SECURITY
            RC = STATUS_SUCCESS;
        }
    } else {
        // we get here if given file was opened for internal purposes
        RC = STATUS_SUCCESS;
    }
    return RC;
} // end UDFCheckAccessRights()

Referenced by UDFCommonCreate(), UDFDoesOSAllowFileToBeTargetForRename__(), UDFSetAccessRights(), and UDFSetDispositionInformation().

UDFDeassignAcl()

VOID UDFDeassignAcl	(	IN PtrUDFNTRequiredFCB	NtReqFcb,
		IN BOOLEAN	AutoInherited
	)

Definition at line 772 of file secursup.cpp.

{
#ifdef UDF_ENABLE_SECURITY
//    NTSTATUS RC = STATUS_SUCCESS;
 
//    UDFPrint(("  UDFDeassignAcl\n"));
    if(!NtReqFcb->SecurityDesc)
        return;
 
    if(AutoInherited) {
        NtReqFcb->SecurityDesc = NULL;
        return;
    }
 
    SeDeassignSecurity(&(NtReqFcb->SecurityDesc));
    NtReqFcb->SecurityDesc = NULL; // HA BCRK CLU4
#endif //UDF_ENABLE_SECURITY
    return;
} // end UDFDeassignAcl()

Referenced by UDFCleanUpFcbChain(), and UDFSetAccessRights().

UDFLookUpAcl()

PSECURITY_DESCRIPTOR UDFLookUpAcl	(	IN PVCB	Vcb,
		PFILE_OBJECT	FileObject,
		IN PtrUDFFCB	Fcb
	)

Definition at line 915 of file secursup.cpp.

{
    UDFAssignAcl(Vcb, FileObject, Fcb, Fcb->NTRequiredFCB);
    return (Fcb->NTRequiredFCB->SecurityDesc);
} // end UDFLookUpAcl()

Referenced by UDFCheckAccessRights(), and UDFSetAccessRights().

UDFReadSecurity()

NTSTATUS UDFReadSecurity	(	IN PVCB	Vcb,
		IN PtrUDFFCB	Fcb,
		IN PSECURITY_DESCRIPTOR *	SecurityDesc
	)

Definition at line 420 of file secursup.cpp.

{
#ifdef UDF_ENABLE_SECURITY
    PUDF_FILE_INFO FileInfo = NULL;
    PUDF_FILE_INFO SDirInfo = NULL;
    PUDF_FILE_INFO AclInfo = NULL;
    NTSTATUS RC;
    ULONG NumberBytesRead;
    PERESOURCE Res1 = NULL;
 
    UDFPrint(("UDFReadSecurity\n"));
 
    _SEH2_TRY {
 
        FileInfo = Fcb->FileInfo;
        ASSERT(FileInfo);
        if(!FileInfo) {
            UDFPrint(("  Volume Security\n"));
            try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
        }
        if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
            UDFPrint(("  No Security on blank volume\n"));
            try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
        }
 
        // Open Stream Directory
        RC = UDFOpenStreamDir__(Vcb, FileInfo, &SDirInfo);
 
        if(RC == STATUS_NOT_FOUND)
            try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
        if(!NT_SUCCESS(RC)) {
            if(UDFCleanUpFile__(Vcb, SDirInfo)) {
                if(SDirInfo) MyFreePool__(SDirInfo);
            }
            SDirInfo = NULL;
            try_return(RC);
        }
        // Acquire SDir exclusively if Fcb present
        if(SDirInfo->Fcb) {
            BrutePoint();
            UDF_CHECK_PAGING_IO_RESOURCE(SDirInfo->Fcb->NTRequiredFCB);
            UDFAcquireResourceExclusive(Res1 = &(SDirInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
        }
 
        // Open Acl Stream
        RC = UDFOpenFile__(Vcb,
                           FALSE,TRUE,&(UDFGlobalData.AclName),
                           SDirInfo,&AclInfo,NULL);
        if(RC == STATUS_OBJECT_NAME_NOT_FOUND)
            try_return(RC = STATUS_NO_SECURITY_ON_OBJECT);
        if(!NT_SUCCESS(RC)) {
            if(UDFCleanUpFile__(Vcb, AclInfo)) {
                if(AclInfo) MyFreePool__(AclInfo);
            }
            AclInfo = NULL;
            try_return(RC);
        }
 
        NumberBytesRead = (ULONG)UDFGetFileSize(AclInfo);
        (*SecurityDesc) = DbgAllocatePool(NonPagedPool, NumberBytesRead);
        if(!(*SecurityDesc))
            try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
        RC = UDFReadFile__(Vcb, AclInfo, 0, NumberBytesRead,
                       FALSE, (PCHAR)(*SecurityDesc), &NumberBytesRead);
        if(!NT_SUCCESS(RC))
            try_return(RC);
 
        RC = RtlValidSecurityDescriptor(*SecurityDesc);
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        if(AclInfo) {
            UDFCloseFile__(Vcb, AclInfo);
            if(UDFCleanUpFile__(Vcb, AclInfo))
                MyFreePool__(AclInfo);
        }
 
        if(SDirInfo) {
            UDFCloseFile__(Vcb, SDirInfo);
            if(UDFCleanUpFile__(Vcb, SDirInfo))
                MyFreePool__(SDirInfo);
        }
 
        if(!NT_SUCCESS(RC) && (*SecurityDesc)) {
            DbgFreePool(*SecurityDesc);
            (*SecurityDesc) = NULL;
        }
        if(Res1)
            UDFReleaseResource(Res1);
    }
 
    return RC;
#else
    return STATUS_NO_SECURITY_ON_OBJECT;
#endif //UDF_ENABLE_SECURITY
 
} // end UDFReadSecurity()

Referenced by UDFAssignAcl().

UDFSetAccessRights()

NTSTATUS UDFSetAccessRights	(	PFILE_OBJECT	FileObject,
		PACCESS_STATE	AccessState,
		PtrUDFFCB	Fcb,
		PtrUDFCCB	Ccb,
		ACCESS_MASK	DesiredAccess,
		USHORT	ShareAccess
	)

Definition at line 1049 of file secursup.cpp.

{
#ifndef UDF_ENABLE_SECURITY
    ASSERT(Ccb);
    ASSERT(Fcb->FileInfo);
 
    return UDFCheckAccessRights(FileObject, AccessState, Fcb, Ccb, DesiredAccess, ShareAccess);
 
#else //UDF_ENABLE_SECURITY
 
    NTSTATUS RC;
    // Set Security on Object
    PSECURITY_DESCRIPTOR SecDesc;
    SECURITY_SUBJECT_CONTEXT SubjectContext;
    BOOLEAN AutoInherit;
 
    ASSERT(Ccb);
    ASSERT(Fcb->FileInfo);
 
    SecDesc = UDFLookUpAcl(Fcb->Vcb, FileObject, Fcb);
    AutoInherit = UDFIsAStreamDir(Fcb->FileInfo) || UDFIsAStream(Fcb->FileInfo);
 
    if(SecDesc && !AutoInherit) {
        // Get caller's User/Primary Group info
        SeCaptureSubjectContext(&SubjectContext);
        RC = SeAssignSecurity(
                         Fcb->FileInfo->ParentFile->Dloc->CommonFcb->SecurityDesc,
//                         NULL,
                         AccessState->SecurityDescriptor,
                         &(Fcb->NTRequiredFCB->SecurityDesc),
                         UDFIsADirectory(Fcb->FileInfo),
                         &SubjectContext,
                         IoGetFileObjectGenericMapping(),
                         NonPagedPool);
        SeReleaseSubjectContext(&SubjectContext);
        UDFConvertToSelfRelative(&(Fcb->NTRequiredFCB->SecurityDesc));
 
        if(!NT_SUCCESS(RC)) {
Clean_Up_SD:
            UDFDeassignAcl(Fcb->NTRequiredFCB, AutoInherit);
            return RC;
        }
    }
 
    RC = UDFCheckAccessRights(FileObject, AccessState, Fcb, Ccb, DesiredAccess, ShareAccess);
    if(!NT_SUCCESS(RC))
        goto Clean_Up_SD;
    return RC;
 
#endif //UDF_ENABLE_SECURITY
 
} // end UDFSetAccessRights()

Referenced by UDFCommonCreate().

UDFWriteSecurity()

NTSTATUS UDFWriteSecurity	(	IN PVCB	Vcb,
		IN PtrUDFFCB	Fcb,
		IN PSECURITY_DESCRIPTOR *	SecurityDesc
	)

Definition at line 796 of file secursup.cpp.

{
#ifdef UDF_ENABLE_SECURITY
    PUDF_FILE_INFO FileInfo = NULL;
    PUDF_FILE_INFO SDirInfo = NULL;
    PUDF_FILE_INFO AclInfo = NULL;
    PERESOURCE Res1 = NULL;
    NTSTATUS RC;
    ULONG NumberBytesRead;
 
//    UDFPrint(("UDFWriteSecurity\n"));
 
#if !defined(UDF_READ_ONLY_BUILD)
 
    if(!Vcb->WriteSecurity ||
       (Vcb->VCBFlags & (UDF_VCB_FLAGS_VOLUME_READ_ONLY |
                         UDF_VCB_FLAGS_MEDIA_READ_ONLY)))
 
#endif 
 
        return STATUS_SUCCESS;
 
#if !defined(UDF_READ_ONLY_BUILD)
 
    _SEH2_TRY {
 
        FileInfo = Fcb->FileInfo;
        ASSERT(FileInfo);
        if(!FileInfo) {
            UDFPrint(("  Volume Security\n"));
            try_return(RC = STATUS_SUCCESS);
        }
 
        if(!(Fcb->NTRequiredFCB->NtReqFCBFlags & UDF_NTREQ_FCB_SD_MODIFIED))
            try_return(RC = STATUS_SUCCESS);
 
        // Open Stream Directory
        RC = UDFOpenStreamDir__(Vcb, FileInfo, &SDirInfo);
 
        if(RC == STATUS_NOT_FOUND) {
            RC = UDFCreateStreamDir__(Vcb, FileInfo, &SDirInfo);
        }
        if(!NT_SUCCESS(RC)) {
            if(UDFCleanUpFile__(Vcb, SDirInfo)) {
                if(SDirInfo) MyFreePool__(SDirInfo);
            }
            SDirInfo = NULL;
            try_return(RC);
        }
        // Acquire SDir exclusively if Fcb present
        if(SDirInfo->Fcb) {
            BrutePoint();
            UDF_CHECK_PAGING_IO_RESOURCE(SDirInfo->Fcb->NTRequiredFCB);
            UDFAcquireResourceExclusive(Res1 = &(SDirInfo->Fcb->NTRequiredFCB->MainResource),TRUE);
        }
 
        // Open Acl Stream
        RC = UDFOpenFile__(Vcb,
                           FALSE,TRUE,&(UDFGlobalData.AclName),
                           SDirInfo,&AclInfo,NULL);
        if(RC == STATUS_OBJECT_NAME_NOT_FOUND) {
            RC = UDFCreateFile__(Vcb, FALSE, &(UDFGlobalData.AclName),
                               0, 0, FALSE, FALSE, SDirInfo, &AclInfo);
        }
        if(!NT_SUCCESS(RC)) {
            if(UDFCleanUpFile__(Vcb, AclInfo)) {
                if(AclInfo) MyFreePool__(AclInfo);
            }
            AclInfo = NULL;
            try_return(RC);
        }
 
        if(!(*SecurityDesc)) {
            UDFFlushFile__(Vcb, AclInfo);
            RC = UDFUnlinkFile__(Vcb, AclInfo, TRUE);
            try_return(RC);
        }
        NumberBytesRead = RtlLengthSecurityDescriptor(*SecurityDesc);
 
        RC = UDFWriteFile__(Vcb, AclInfo, 0, NumberBytesRead,
                       FALSE, (PCHAR)(*SecurityDesc), &NumberBytesRead);
        if(!NT_SUCCESS(RC))
            try_return(RC);
 
        Fcb->NTRequiredFCB->NtReqFCBFlags &= ~UDF_NTREQ_FCB_SD_MODIFIED;
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        if(AclInfo) {
            UDFCloseFile__(Vcb, AclInfo);
            if(UDFCleanUpFile__(Vcb, AclInfo))
                MyFreePool__(AclInfo);
        }
 
        if(SDirInfo) {
            UDFCloseFile__(Vcb, SDirInfo);
            if(UDFCleanUpFile__(Vcb, SDirInfo))
                MyFreePool__(SDirInfo);
        }
        if(Res1)
            UDFReleaseResource(Res1);
    }
 
    return RC;
 
#endif 
#endif //UDF_ENABLE_SECURITY
 
    return STATUS_SUCCESS;
 
} // end UDFWriteSecurity()

Referenced by UDFCloseFileInfoChain(), UDFFlushADirectory(), and UDFFlushAFile().