security.c File Reference

#include "btrfs_drv.h"

Include dependency graph for security.c:

Go to the source code of this file.

Classes
struct	sid_header
struct	dacl

Macros
#define	SEF_DACL_AUTO_INHERIT   0x01
#define	SEF_SACL_AUTO_INHERIT   0x02

Functions
void	add_user_mapping (WCHAR *sidstring, ULONG sidstringlength, uint32_t uid)
void	add_group_mapping (WCHAR *sidstring, ULONG sidstringlength, uint32_t gid)
NTSTATUS	uid_to_sid (uint32_t uid, PSID *sid)
uint32_t	sid_to_uid (PSID sid)
static void	gid_to_sid (uint32_t gid, PSID *sid)
static ACL *	load_default_acl ()
static void	get_top_level_sd (fcb *fcb)
void	fcb_get_sd (fcb *fcb, struct _fcb *parent, bool look_for_xattr, PIRP Irp)
static NTSTATUS	get_file_security (PFILE_OBJECT FileObject, SECURITY_DESCRIPTOR *relsd, ULONG *buflen, SECURITY_INFORMATION flags)
	_Dispatch_type_ (IRP_MJ_QUERY_SECURITY)
static NTSTATUS	set_file_security (device_extension *Vcb, PFILE_OBJECT FileObject, SECURITY_DESCRIPTOR *sd, PSECURITY_INFORMATION flags, PIRP Irp)
	_Dispatch_type_ (IRP_MJ_SET_SECURITY)
static bool	search_for_gid (fcb *fcb, PSID sid)
void	find_gid (struct _fcb *fcb, struct _fcb *parfcb, PSECURITY_SUBJECT_CONTEXT subjcont)
NTSTATUS	fcb_get_new_sd (fcb *fcb, file_ref *parfileref, ACCESS_STATE *as)

Variables
static sid_header	sid_BA = { 1, 2, SECURITY_NT_AUTHORITY, {32, 544}}
static sid_header	sid_SY = { 1, 1, SECURITY_NT_AUTHORITY, {18}}
static sid_header	sid_BU = { 1, 2, SECURITY_NT_AUTHORITY, {32, 545}}
static sid_header	sid_AU = { 1, 1, SECURITY_NT_AUTHORITY, {11}}
static dacl	def_dacls []
LIST_ENTRY	uid_map_list
LIST_ENTRY	gid_map_list
ERESOURCE	mapping_lock

Macro Definition Documentation

SEF_DACL_AUTO_INHERIT

#define SEF_DACL_AUTO_INHERIT   0x01

Definition at line 20 of file security.c.

SEF_SACL_AUTO_INHERIT

#define SEF_SACL_AUTO_INHERIT   0x02

Definition at line 21 of file security.c.

Function Documentation

_Dispatch_type_() [1/2]

_Dispatch_type_

(

IRP_MJ_QUERY_SECURITY

)

Definition at line 662 of file security.c.

                                                                                   {
    NTSTATUS Status;
    SECURITY_DESCRIPTOR* sd;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    device_extension* Vcb = DeviceObject->DeviceExtension;
    ULONG buflen;
    bool top_level;
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
 
    FsRtlEnterFileSystem();
 
    TRACE("query security\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (!ccb) {
        ERR("no ccb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (Irp->RequestorMode == UserMode && !(ccb->access & READ_CONTROL)) {
        WARN("insufficient permissions\n");
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }
 
    Status = STATUS_SUCCESS;
 
    Irp->IoStatus.Information = 0;
 
    if (IrpSp->Parameters.QuerySecurity.SecurityInformation & OWNER_SECURITY_INFORMATION)
        TRACE("OWNER_SECURITY_INFORMATION\n");
 
    if (IrpSp->Parameters.QuerySecurity.SecurityInformation & GROUP_SECURITY_INFORMATION)
        TRACE("GROUP_SECURITY_INFORMATION\n");
 
    if (IrpSp->Parameters.QuerySecurity.SecurityInformation & DACL_SECURITY_INFORMATION)
        TRACE("DACL_SECURITY_INFORMATION\n");
 
    if (IrpSp->Parameters.QuerySecurity.SecurityInformation & SACL_SECURITY_INFORMATION)
        TRACE("SACL_SECURITY_INFORMATION\n");
 
    TRACE("length = %lu\n", IrpSp->Parameters.QuerySecurity.Length);
 
    sd = map_user_buffer(Irp, NormalPagePriority);
    TRACE("sd = %p\n", sd);
 
    if (Irp->MdlAddress && !sd) {
        ERR("MmGetSystemAddressForMdlSafe returned NULL\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto end;
    }
 
    buflen = IrpSp->Parameters.QuerySecurity.Length;
 
    Status = get_file_security(IrpSp->FileObject, sd, &buflen, IrpSp->Parameters.QuerySecurity.SecurityInformation);
 
    if (NT_SUCCESS(Status))
        Irp->IoStatus.Information = IrpSp->Parameters.QuerySecurity.Length;
    else if (Status == STATUS_BUFFER_TOO_SMALL) {
        Irp->IoStatus.Information = buflen;
        Status = STATUS_BUFFER_OVERFLOW;
    } else
        Irp->IoStatus.Information = 0;
 
end:
    TRACE("Irp->IoStatus.Information = %Iu\n", Irp->IoStatus.Information);
 
    Irp->IoStatus.Status = Status;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    TRACE("returning %08lx\n", Status);
 
    FsRtlExitFileSystem();
 
    return Status;
}

_Dispatch_type_() [2/2]

_Dispatch_type_

(

IRP_MJ_SET_SECURITY

)

Definition at line 827 of file security.c.

                                                                                 {
    NTSTATUS Status;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    ccb* ccb = FileObject ? FileObject->FsContext2 : NULL;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    ULONG access_req = 0;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    TRACE("set security\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    if (!ccb) {
        ERR("no ccb\n");
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    Status = STATUS_SUCCESS;
 
    Irp->IoStatus.Information = 0;
 
    if (IrpSp->Parameters.SetSecurity.SecurityInformation & OWNER_SECURITY_INFORMATION) {
        TRACE("OWNER_SECURITY_INFORMATION\n");
        access_req |= WRITE_OWNER;
    }
 
    if (IrpSp->Parameters.SetSecurity.SecurityInformation & GROUP_SECURITY_INFORMATION) {
        TRACE("GROUP_SECURITY_INFORMATION\n");
        access_req |= WRITE_OWNER;
    }
 
    if (IrpSp->Parameters.SetSecurity.SecurityInformation & DACL_SECURITY_INFORMATION) {
        TRACE("DACL_SECURITY_INFORMATION\n");
        access_req |= WRITE_DAC;
    }
 
    if (IrpSp->Parameters.SetSecurity.SecurityInformation & SACL_SECURITY_INFORMATION) {
        TRACE("SACL_SECURITY_INFORMATION\n");
        access_req |= ACCESS_SYSTEM_SECURITY;
    }
 
    if (Irp->RequestorMode == UserMode && (ccb->access & access_req) != access_req) {
        Status = STATUS_ACCESS_DENIED;
        WARN("insufficient privileges\n");
        goto end;
    }
 
    Status = set_file_security(DeviceObject->DeviceExtension, FileObject, IrpSp->Parameters.SetSecurity.SecurityDescriptor,
                               &IrpSp->Parameters.SetSecurity.SecurityInformation, Irp);
 
end:
    Irp->IoStatus.Status = Status;
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    TRACE("returning %08lx\n", Status);
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

add_group_mapping()

void add_group_mapping	(	WCHAR *	sidstring,
		ULONG	sidstringlength,
		uint32_t	gid
	)

Definition at line 145 of file security.c.

                                                                              {
    unsigned int i, np;
    uint8_t numdashes;
    uint64_t val;
    ULONG sidsize;
    sid_header* sid;
    gid_map* gm;
 
    if (sidstringlength < 4 || sidstring[0] != 'S' || sidstring[1] != '-' || sidstring[2] != '1' || sidstring[3] != '-') {
        ERR("invalid SID\n");
        return;
    }
 
    sidstring = &sidstring[4];
    sidstringlength -= 4;
 
    numdashes = 0;
    for (i = 0; i < sidstringlength; i++) {
        if (sidstring[i] == '-') {
            numdashes++;
            sidstring[i] = 0;
        }
    }
 
    sidsize = 8 + (numdashes * 4);
    sid = ExAllocatePoolWithTag(PagedPool, sidsize, ALLOC_TAG);
    if (!sid) {
        ERR("out of memory\n");
        return;
    }
 
    sid->revision = 0x01;
    sid->elements = numdashes;
 
    np = 0;
    while (sidstringlength > 0) {
        val = 0;
        i = 0;
        while (i < sidstringlength && sidstring[i] != '-') {
            if (sidstring[i] >= '0' && sidstring[i] <= '9') {
                val *= 10;
                val += sidstring[i] - '0';
            } else
                break;
 
            i++;
        }
 
        i++;
        TRACE("val = %u, i = %u, ssl = %lu\n", (uint32_t)val, i, sidstringlength);
 
        if (np == 0) {
            sid->auth[0] = (uint8_t)((val & 0xff0000000000) >> 40);
            sid->auth[1] = (uint8_t)((val & 0xff00000000) >> 32);
            sid->auth[2] = (uint8_t)((val & 0xff000000) >> 24);
            sid->auth[3] = (uint8_t)((val & 0xff0000) >> 16);
            sid->auth[4] = (uint8_t)((val & 0xff00) >> 8);
            sid->auth[5] = val & 0xff;
        } else
            sid->nums[np-1] = (uint32_t)val;
 
        np++;
 
        if (sidstringlength > i) {
            sidstringlength -= i;
 
            sidstring = &sidstring[i];
        } else
            break;
    }
 
    gm = ExAllocatePoolWithTag(PagedPool, sizeof(gid_map), ALLOC_TAG);
    if (!gm) {
        ERR("out of memory\n");
        ExFreePool(sid);
        return;
    }
 
    gm->sid = sid;
    gm->gid = gid;
 
    InsertTailList(&gid_map_list, &gm->listentry);
}

Referenced by read_group_mappings().

add_user_mapping()

void add_user_mapping	(	WCHAR *	sidstring,
		ULONG	sidstringlength,
		uint32_t	uid
	)

Definition at line 56 of file security.c.

                                                                             {
    unsigned int i, np;
    uint8_t numdashes;
    uint64_t val;
    ULONG sidsize;
    sid_header* sid;
    uid_map* um;
 
    if (sidstringlength < 4 ||
        sidstring[0] != 'S' ||
        sidstring[1] != '-' ||
        sidstring[2] != '1' ||
        sidstring[3] != '-') {
        ERR("invalid SID\n");
        return;
    }
 
    sidstring = &sidstring[4];
    sidstringlength -= 4;
 
    numdashes = 0;
    for (i = 0; i < sidstringlength; i++) {
        if (sidstring[i] == '-') {
            numdashes++;
            sidstring[i] = 0;
        }
    }
 
    sidsize = 8 + (numdashes * 4);
    sid = ExAllocatePoolWithTag(PagedPool, sidsize, ALLOC_TAG);
    if (!sid) {
        ERR("out of memory\n");
        return;
    }
 
    sid->revision = 0x01;
    sid->elements = numdashes;
 
    np = 0;
    while (sidstringlength > 0) {
        val = 0;
        i = 0;
        while (sidstring[i] != '-' && i < sidstringlength) {
            if (sidstring[i] >= '0' && sidstring[i] <= '9') {
                val *= 10;
                val += sidstring[i] - '0';
            } else
                break;
 
            i++;
        }
 
        i++;
        TRACE("val = %u, i = %u, ssl = %lu\n", (uint32_t)val, i, sidstringlength);
 
        if (np == 0) {
            sid->auth[0] = (uint8_t)((val & 0xff0000000000) >> 40);
            sid->auth[1] = (uint8_t)((val & 0xff00000000) >> 32);
            sid->auth[2] = (uint8_t)((val & 0xff000000) >> 24);
            sid->auth[3] = (uint8_t)((val & 0xff0000) >> 16);
            sid->auth[4] = (uint8_t)((val & 0xff00) >> 8);
            sid->auth[5] = val & 0xff;
        } else {
            sid->nums[np-1] = (uint32_t)val;
        }
 
        np++;
 
        if (sidstringlength > i) {
            sidstringlength -= i;
 
            sidstring = &sidstring[i];
        } else
            break;
    }
 
    um = ExAllocatePoolWithTag(PagedPool, sizeof(uid_map), ALLOC_TAG);
    if (!um) {
        ERR("out of memory\n");
        ExFreePool(sid);
        return;
    }
 
    um->sid = sid;
    um->uid = uid;
 
    InsertTailList(&uid_map_list, &um->listentry);
}

Referenced by read_mappings().

fcb_get_new_sd()

NTSTATUS fcb_get_new_sd	(	fcb *	fcb,
		file_ref *	parfileref,
		ACCESS_STATE *	as
	)

Definition at line 988 of file security.c.

                                                                          {
    NTSTATUS Status;
    PSID owner;
    BOOLEAN defaulted;
 
    Status = SeAssignSecurityEx(parfileref ? parfileref->fcb->sd : NULL, as->SecurityDescriptor, (void**)&fcb->sd, NULL, fcb->type == BTRFS_TYPE_DIRECTORY,
                                SEF_SACL_AUTO_INHERIT, &as->SubjectSecurityContext, IoGetFileObjectGenericMapping(), PagedPool);
 
    if (!NT_SUCCESS(Status)) {
        ERR("SeAssignSecurityEx returned %08lx\n", Status);
        return Status;
    }
 
    Status = RtlGetOwnerSecurityDescriptor(fcb->sd, &owner, &defaulted);
    if (!NT_SUCCESS(Status)) {
        ERR("RtlGetOwnerSecurityDescriptor returned %08lx\n", Status);
        fcb->inode_item.st_uid = UID_NOBODY;
    } else {
        fcb->inode_item.st_uid = sid_to_uid(owner);
    }
 
    find_gid(fcb, parfileref ? parfileref->fcb : NULL, &as->SubjectSecurityContext);
 
    return STATUS_SUCCESS;
}

Referenced by file_create2().

fcb_get_sd()

void fcb_get_sd	(	fcb *	fcb,
		struct _fcb *	parent,
		bool	look_for_xattr,
		PIRP	Irp
	)

Definition at line 511 of file security.c.

                                                                              {
    NTSTATUS Status;
    PSID usersid = NULL, groupsid = NULL;
    SECURITY_SUBJECT_CONTEXT subjcont;
    ULONG buflen;
    PSECURITY_DESCRIPTOR* abssd;
    PSECURITY_DESCRIPTOR newsd;
    PACL dacl, sacl;
    PSID owner, group;
    ULONG abssdlen = 0, dacllen = 0, sacllen = 0, ownerlen = 0, grouplen = 0;
    uint8_t* buf;
 
    if (look_for_xattr && get_xattr(fcb->Vcb, fcb->subvol, fcb->inode, EA_NTACL, EA_NTACL_HASH, (uint8_t**)&fcb->sd, (uint16_t*)&buflen, Irp))
        return;
 
    if (!parent) {
        get_top_level_sd(fcb);
        return;
    }
 
    SeCaptureSubjectContext(&subjcont);
 
    Status = SeAssignSecurityEx(parent->sd, NULL, (void**)&fcb->sd, NULL, fcb->type == BTRFS_TYPE_DIRECTORY, SEF_DACL_AUTO_INHERIT,
                                &subjcont, IoGetFileObjectGenericMapping(), PagedPool);
    if (!NT_SUCCESS(Status)) {
        ERR("SeAssignSecurityEx returned %08lx\n", Status);
        return;
    }
 
    Status = RtlSelfRelativeToAbsoluteSD(fcb->sd, NULL, &abssdlen, NULL, &dacllen, NULL, &sacllen, NULL, &ownerlen,
                                         NULL, &grouplen);
    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL) {
        ERR("RtlSelfRelativeToAbsoluteSD returned %08lx\n", Status);
        return;
    }
 
    if (abssdlen + dacllen + sacllen + ownerlen + grouplen == 0) {
        ERR("RtlSelfRelativeToAbsoluteSD returned zero lengths\n");
        return;
    }
 
    buf = (uint8_t*)ExAllocatePoolWithTag(PagedPool, abssdlen + dacllen + sacllen + ownerlen + grouplen, ALLOC_TAG);
    if (!buf) {
        ERR("out of memory\n");
        return;
    }
 
    abssd = (PSECURITY_DESCRIPTOR)buf;
    dacl = (PACL)(buf + abssdlen);
    sacl = (PACL)(buf + abssdlen + dacllen);
    owner = (PSID)(buf + abssdlen + dacllen + sacllen);
    group = (PSID)(buf + abssdlen + dacllen + sacllen + ownerlen);
 
    Status = RtlSelfRelativeToAbsoluteSD(fcb->sd, abssd, &abssdlen, dacl, &dacllen, sacl, &sacllen, owner, &ownerlen,
                                         group, &grouplen);
    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL) {
        ERR("RtlSelfRelativeToAbsoluteSD returned %08lx\n", Status);
        ExFreePool(buf);
        return;
    }
 
    Status = uid_to_sid(fcb->inode_item.st_uid, &usersid);
    if (!NT_SUCCESS(Status)) {
        ERR("uid_to_sid returned %08lx\n", Status);
        ExFreePool(buf);
        return;
    }
 
    RtlSetOwnerSecurityDescriptor(abssd, usersid, false);
 
    gid_to_sid(fcb->inode_item.st_gid, &groupsid);
    if (!groupsid) {
        ERR("out of memory\n");
        ExFreePool(usersid);
        ExFreePool(buf);
        return;
    }
 
    RtlSetGroupSecurityDescriptor(abssd, groupsid, false);
 
    buflen = 0;
 
    Status = RtlAbsoluteToSelfRelativeSD(abssd, NULL, &buflen);
    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL) {
        ERR("RtlAbsoluteToSelfRelativeSD returned %08lx\n", Status);
        ExFreePool(usersid);
        ExFreePool(groupsid);
        ExFreePool(buf);
        return;
    }
 
    if (buflen == 0) {
        ERR("RtlAbsoluteToSelfRelativeSD returned a buffer size of 0\n");
        ExFreePool(usersid);
        ExFreePool(groupsid);
        ExFreePool(buf);
        return;
    }
 
    newsd = ExAllocatePoolWithTag(PagedPool, buflen, ALLOC_TAG);
    if (!newsd) {
        ERR("out of memory\n");
        ExFreePool(usersid);
        ExFreePool(groupsid);
        ExFreePool(buf);
        return;
    }
 
    Status = RtlAbsoluteToSelfRelativeSD(abssd, newsd, &buflen);
    if (!NT_SUCCESS(Status)) {
        ERR("RtlAbsoluteToSelfRelativeSD returned %08lx\n", Status);
        ExFreePool(usersid);
        ExFreePool(groupsid);
        ExFreePool(buf);
        return;
    }
 
    ExFreePool(fcb->sd);
    fcb->sd = newsd;
 
    ExFreePool(usersid);
    ExFreePool(groupsid);
    ExFreePool(buf);
}

Referenced by fsctl_set_xattr(), and mount_vol().

find_gid()

void find_gid	(	struct _fcb *	fcb,
		struct _fcb *	parfcb,
		PSECURITY_SUBJECT_CONTEXT	subjcont
	)

Definition at line 924 of file security.c.

                                                                                         {
    NTSTATUS Status;
    TOKEN_OWNER* to;
    TOKEN_PRIMARY_GROUP* tpg;
    TOKEN_GROUPS* tg;
 
    if (parfcb && parfcb->inode_item.st_mode & S_ISGID) {
        fcb->inode_item.st_gid = parfcb->inode_item.st_gid;
        return;
    }
 
    ExAcquireResourceSharedLite(&mapping_lock, true);
 
    if (!subjcont || !subjcont->PrimaryToken || IsListEmpty(&gid_map_list)) {
        ExReleaseResourceLite(&mapping_lock);
        return;
    }
 
    Status = SeQueryInformationToken(subjcont->PrimaryToken, TokenOwner, (void**)&to);
    if (!NT_SUCCESS(Status))
        ERR("SeQueryInformationToken returned %08lx\n", Status);
    else {
        if (search_for_gid(fcb, to->Owner)) {
            ExReleaseResourceLite(&mapping_lock);
            ExFreePool(to);
            return;
        }
 
        ExFreePool(to);
    }
 
    Status = SeQueryInformationToken(subjcont->PrimaryToken, TokenPrimaryGroup, (void**)&tpg);
    if (!NT_SUCCESS(Status))
        ERR("SeQueryInformationToken returned %08lx\n", Status);
    else {
        if (search_for_gid(fcb, tpg->PrimaryGroup)) {
            ExReleaseResourceLite(&mapping_lock);
            ExFreePool(tpg);
            return;
        }
 
        ExFreePool(tpg);
    }
 
    Status = SeQueryInformationToken(subjcont->PrimaryToken, TokenGroups, (void**)&tg);
    if (!NT_SUCCESS(Status))
        ERR("SeQueryInformationToken returned %08lx\n", Status);
    else {
        ULONG i;
 
        for (i = 0; i < tg->GroupCount; i++) {
            if (search_for_gid(fcb, tg->Groups[i].Sid)) {
                ExReleaseResourceLite(&mapping_lock);
                ExFreePool(tg);
                return;
            }
        }
 
        ExFreePool(tg);
    }
 
    ExReleaseResourceLite(&mapping_lock);
}

Referenced by create_directory_fcb(), create_subvol(), fcb_get_new_sd(), and mknod().

get_file_security()

static NTSTATUS get_file_security ( PFILE_OBJECT  FileObject, SECURITY_DESCRIPTOR *  relsd, ULONG *  buflen, SECURITY_INFORMATION  flags  )

static

Definition at line 636 of file security.c.

                                                                                                                                  {
    NTSTATUS Status;
    fcb* fcb = FileObject->FsContext;
    ccb* ccb = FileObject->FsContext2;
    file_ref* fileref = ccb ? ccb->fileref : NULL;
 
    if (fcb->ads) {
        if (fileref && fileref->parent)
            fcb = fileref->parent->fcb;
        else {
            ERR("could not get parent fcb for stream\n");
            return STATUS_INTERNAL_ERROR;
        }
    }
 
    // Why (void**)? Is this a bug in mingw?
    Status = SeQuerySecurityDescriptorInfo(&flags, relsd, buflen, (void**)&fcb->sd);
 
    if (Status == STATUS_BUFFER_TOO_SMALL)
        TRACE("SeQuerySecurityDescriptorInfo returned %08lx\n", Status);
    else if (!NT_SUCCESS(Status))
        ERR("SeQuerySecurityDescriptorInfo returned %08lx\n", Status);
 
    return Status;
}

Referenced by _Dispatch_type_().

get_top_level_sd()

static void get_top_level_sd ( fcb *  fcb )

static

Definition at line 415 of file security.c.

                                       {
    NTSTATUS Status;
    SECURITY_DESCRIPTOR sd;
    ULONG buflen;
    ACL* acl = NULL;
    PSID usersid = NULL, groupsid = NULL;
 
    Status = RtlCreateSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);
 
    if (!NT_SUCCESS(Status)) {
        ERR("RtlCreateSecurityDescriptor returned %08lx\n", Status);
        goto end;
    }
 
    Status = uid_to_sid(fcb->inode_item.st_uid, &usersid);
    if (!NT_SUCCESS(Status)) {
        ERR("uid_to_sid returned %08lx\n", Status);
        goto end;
    }
 
    Status = RtlSetOwnerSecurityDescriptor(&sd, usersid, false);
 
    if (!NT_SUCCESS(Status)) {
        ERR("RtlSetOwnerSecurityDescriptor returned %08lx\n", Status);
        goto end;
    }
 
    gid_to_sid(fcb->inode_item.st_gid, &groupsid);
    if (!groupsid) {
        ERR("out of memory\n");
        goto end;
    }
 
    Status = RtlSetGroupSecurityDescriptor(&sd, groupsid, false);
 
    if (!NT_SUCCESS(Status)) {
        ERR("RtlSetGroupSecurityDescriptor returned %08lx\n", Status);
        goto end;
    }
 
    acl = load_default_acl();
 
    if (!acl) {
        ERR("out of memory\n");
        goto end;
    }
 
    Status = RtlSetDaclSecurityDescriptor(&sd, true, acl, false);
 
    if (!NT_SUCCESS(Status)) {
        ERR("RtlSetDaclSecurityDescriptor returned %08lx\n", Status);
        goto end;
    }
 
    // FIXME - SACL_SECURITY_INFORMATION
 
    buflen = 0;
 
    // get sd size
    Status = RtlAbsoluteToSelfRelativeSD(&sd, NULL, &buflen);
    if (Status != STATUS_SUCCESS && Status != STATUS_BUFFER_TOO_SMALL) {
        ERR("RtlAbsoluteToSelfRelativeSD 1 returned %08lx\n", Status);
        goto end;
    }
 
    if (buflen == 0 || Status == STATUS_SUCCESS) {
        TRACE("RtlAbsoluteToSelfRelativeSD said SD is zero-length\n");
        goto end;
    }
 
    fcb->sd = ExAllocatePoolWithTag(PagedPool, buflen, ALLOC_TAG);
    if (!fcb->sd) {
        ERR("out of memory\n");
        goto end;
    }
 
    Status = RtlAbsoluteToSelfRelativeSD(&sd, fcb->sd, &buflen);
 
    if (!NT_SUCCESS(Status)) {
        ERR("RtlAbsoluteToSelfRelativeSD 2 returned %08lx\n", Status);
        ExFreePool(fcb->sd);
        fcb->sd = NULL;
        goto end;
    }
 
end:
    if (acl)
        ExFreePool(acl);
 
    if (usersid)
        ExFreePool(usersid);
 
    if (groupsid)
        ExFreePool(groupsid);
}

Referenced by fcb_get_sd().

gid_to_sid()

static void gid_to_sid ( uint32_t  gid, PSID *  sid  )

static

Definition at line 341 of file security.c.

                                                {
    sid_header* sh;
    UCHAR els;
 
    // FIXME - do this properly?
 
    // fallback to S-1-22-2-X, Samba's SID scheme
    els = 2;
    sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(uint32_t)), ALLOC_TAG);
    if (!sh) {
        ERR("out of memory\n");
        *sid = NULL;
        return;
    }
 
    sh->revision = 1;
    sh->elements = els;
 
    sh->auth[0] = 0;
    sh->auth[1] = 0;
    sh->auth[2] = 0;
    sh->auth[3] = 0;
    sh->auth[4] = 0;
    sh->auth[5] = 22;
 
    sh->nums[0] = 2;
    sh->nums[1] = gid;
 
    *sid = sh;
}

Referenced by fcb_get_sd(), and get_top_level_sd().

load_default_acl()

static ACL * load_default_acl ( )

static

Definition at line 372 of file security.c.

                               {
    uint16_t size, i;
    ACL* acl;
    ACCESS_ALLOWED_ACE* aaa;
 
    size = sizeof(ACL);
    i = 0;
    while (def_dacls[i].sid) {
        size += sizeof(ACCESS_ALLOWED_ACE);
        size += 8 + (def_dacls[i].sid->elements * sizeof(uint32_t)) - sizeof(ULONG);
        i++;
    }
 
    acl = ExAllocatePoolWithTag(PagedPool, size, ALLOC_TAG);
    if (!acl) {
        ERR("out of memory\n");
        return NULL;
    }
 
    acl->AclRevision = ACL_REVISION;
    acl->Sbz1 = 0;
    acl->AclSize = size;
    acl->AceCount = i;
    acl->Sbz2 = 0;
 
    aaa = (ACCESS_ALLOWED_ACE*)&acl[1];
    i = 0;
    while (def_dacls[i].sid) {
        aaa->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
        aaa->Header.AceFlags = def_dacls[i].flags;
        aaa->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) - sizeof(ULONG) + 8 + (def_dacls[i].sid->elements * sizeof(uint32_t));
        aaa->Mask = def_dacls[i].mask;
 
        RtlCopyMemory(&aaa->SidStart, def_dacls[i].sid, 8 + (def_dacls[i].sid->elements * sizeof(uint32_t)));
 
        aaa = (ACCESS_ALLOWED_ACE*)((uint8_t*)aaa + aaa->Header.AceSize);
 
        i++;
    }
 
    return acl;
}

Referenced by get_top_level_sd().

search_for_gid()

static bool search_for_gid ( fcb *  fcb, PSID  sid  )

static

Definition at line 906 of file security.c.

                                               {
    LIST_ENTRY* le;
 
    le = gid_map_list.Flink;
    while (le != &gid_map_list) {
        gid_map* gm = CONTAINING_RECORD(le, gid_map, listentry);
 
        if (RtlEqualSid(sid, gm->sid)) {
            fcb->inode_item.st_gid = gm->gid;
            return true;
        }
 
        le = le->Flink;
    }
 
    return false;
}

Referenced by find_gid().

set_file_security()

static NTSTATUS set_file_security ( device_extension *  Vcb, PFILE_OBJECT  FileObject, SECURITY_DESCRIPTOR *  sd, PSECURITY_INFORMATION  flags, PIRP  Irp  )

static

Definition at line 756 of file security.c.

                                                                                                                                                  {
    NTSTATUS Status;
    fcb* fcb = FileObject->FsContext;
    ccb* ccb = FileObject->FsContext2;
    file_ref* fileref = ccb ? ccb->fileref : NULL;
    SECURITY_DESCRIPTOR* oldsd;
    LARGE_INTEGER time;
    BTRFS_TIME now;
 
    TRACE("(%p, %p, %p, %lx)\n", Vcb, FileObject, sd, *flags);
 
    if (Vcb->readonly)
        return STATUS_MEDIA_WRITE_PROTECTED;
 
    if (fcb->ads) {
        if (fileref && fileref->parent)
            fcb = fileref->parent->fcb;
        else {
            ERR("could not find parent fcb for stream\n");
            return STATUS_INTERNAL_ERROR;
        }
    }
 
    if (!fcb || !ccb)
        return STATUS_INVALID_PARAMETER;
 
    ExAcquireResourceExclusiveLite(fcb->Header.Resource, true);
 
    if (is_subvol_readonly(fcb->subvol, Irp)) {
        Status = STATUS_ACCESS_DENIED;
        goto end;
    }
 
    oldsd = fcb->sd;
 
    Status = SeSetSecurityDescriptorInfo(NULL, flags, sd, (void**)&fcb->sd, PagedPool, IoGetFileObjectGenericMapping());
 
    if (!NT_SUCCESS(Status)) {
        ERR("SeSetSecurityDescriptorInfo returned %08lx\n", Status);
        goto end;
    }
 
    ExFreePool(oldsd);
 
    KeQuerySystemTime(&time);
    win_time_to_unix(time, &now);
 
    fcb->inode_item.transid = Vcb->superblock.generation;
 
    if (!ccb->user_set_change_time)
        fcb->inode_item.st_ctime = now;
 
    fcb->inode_item.sequence++;
 
    fcb->sd_dirty = true;
    fcb->sd_deleted = false;
    fcb->inode_item_changed = true;
 
    fcb->subvol->root_item.ctransid = Vcb->superblock.generation;
    fcb->subvol->root_item.ctime = now;
 
    mark_fcb_dirty(fcb);
 
    queue_notification_fcb(fileref, FILE_NOTIFY_CHANGE_SECURITY, FILE_ACTION_MODIFIED, NULL);
 
end:
    ExReleaseResourceLite(fcb->Header.Resource);
 
    return Status;
}

Referenced by _Dispatch_type_().

sid_to_uid()

uint32_t sid_to_uid

(

PSID

sid

)

Definition at line 310 of file security.c.

                              {
    LIST_ENTRY* le;
    sid_header* sh = sid;
 
    ExAcquireResourceSharedLite(&mapping_lock, true);
 
    le = uid_map_list.Flink;
    while (le != &uid_map_list) {
        uid_map* um = CONTAINING_RECORD(le, uid_map, listentry);
 
        if (RtlEqualSid(sid, um->sid)) {
            ExReleaseResourceLite(&mapping_lock);
            return um->uid;
        }
 
        le = le->Flink;
    }
 
    ExReleaseResourceLite(&mapping_lock);
 
    if (RtlEqualSid(sid, &sid_SY))
        return 0; // root
 
    // Samba's SID scheme: S-1-22-1-X
    if (sh->revision == 1 && sh->elements == 2 && sh->auth[0] == 0 && sh->auth[1] == 0 && sh->auth[2] == 0 && sh->auth[3] == 0 &&
        sh->auth[4] == 0 && sh->auth[5] == 22 && sh->nums[0] == 1)
        return sh->nums[1];
 
    return UID_NOBODY;
}

Referenced by create_directory_fcb(), create_subvol(), fcb_get_new_sd(), and mknod().

uid_to_sid()

NTSTATUS uid_to_sid	(	uint32_t	uid,
		PSID *	sid
	)

Definition at line 229 of file security.c.

                                             {
    LIST_ENTRY* le;
    sid_header* sh;
    UCHAR els;
 
    ExAcquireResourceSharedLite(&mapping_lock, true);
 
    le = uid_map_list.Flink;
    while (le != &uid_map_list) {
        uid_map* um = CONTAINING_RECORD(le, uid_map, listentry);
 
        if (um->uid == uid) {
            *sid = ExAllocatePoolWithTag(PagedPool, RtlLengthSid(um->sid), ALLOC_TAG);
            if (!*sid) {
                ERR("out of memory\n");
                ExReleaseResourceLite(&mapping_lock);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            RtlCopyMemory(*sid, um->sid, RtlLengthSid(um->sid));
            ExReleaseResourceLite(&mapping_lock);
            return STATUS_SUCCESS;
        }
 
        le = le->Flink;
    }
 
    ExReleaseResourceLite(&mapping_lock);
 
    if (uid == 0) { // root
        // FIXME - find actual Administrator account, rather than SYSTEM (S-1-5-18)
        // (of form S-1-5-21-...-500)
 
        els = 1;
 
        sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header) + ((els - 1) * sizeof(uint32_t)), ALLOC_TAG);
        if (!sh) {
            ERR("out of memory\n");
            *sid = NULL;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        sh->revision = 1;
        sh->elements = els;
 
        sh->auth[0] = 0;
        sh->auth[1] = 0;
        sh->auth[2] = 0;
        sh->auth[3] = 0;
        sh->auth[4] = 0;
        sh->auth[5] = 5;
 
        sh->nums[0] = 18;
    } else {
        // fallback to S-1-22-1-X, Samba's SID scheme
        sh = ExAllocatePoolWithTag(PagedPool, sizeof(sid_header), ALLOC_TAG);
        if (!sh) {
            ERR("out of memory\n");
            *sid = NULL;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        sh->revision = 1;
        sh->elements = 2;
 
        sh->auth[0] = 0;
        sh->auth[1] = 0;
        sh->auth[2] = 0;
        sh->auth[3] = 0;
        sh->auth[4] = 0;
        sh->auth[5] = 22;
 
        sh->nums[0] = 1;
        sh->nums[1] = uid;
    }
 
    *sid = sh;
 
    return STATUS_SUCCESS;
}

Referenced by fcb_get_sd(), and get_top_level_sd().

Variable Documentation

def_dacls

dacl def_dacls[]

static

Initial value:

= {
    { 0, FILE_ALL_ACCESS, &sid_BA },
    { OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE, FILE_ALL_ACCESS, &sid_BA },
    { 0, FILE_ALL_ACCESS, &sid_SY },
    { OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE, FILE_ALL_ACCESS, &sid_SY },
    { OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE, FILE_GENERIC_READ | FILE_GENERIC_EXECUTE, &sid_BU },
    { OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE, FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE, &sid_AU },
    { 0, FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE | DELETE, &sid_AU },
    
    { 0, 0, NULL }
}

Definition at line 41 of file security.c.

Referenced by load_default_acl().

gid_map_list

LIST_ENTRY gid_map_list

Definition at line 53 of file security.c.

Referenced by add_group_mapping(), find_gid(), and search_for_gid().

mapping_lock

ERESOURCE mapping_lock

extern

Definition at line 103 of file btrfs.c.

Referenced by _Function_class_(), find_gid(), sid_to_uid(), and uid_to_sid().

sid_AU

sid_header sid_AU = { 1, 1, SECURITY_NT_AUTHORITY, {11}}

static

Definition at line 33 of file security.c.

sid_BA

sid_header sid_BA = { 1, 2, SECURITY_NT_AUTHORITY, {32, 544}}

static

Definition at line 30 of file security.c.

sid_BU

sid_header sid_BU = { 1, 2, SECURITY_NT_AUTHORITY, {32, 545}}

static

Definition at line 32 of file security.c.

sid_SY

sid_header sid_SY = { 1, 1, SECURITY_NT_AUTHORITY, {18}}

static

Definition at line 31 of file security.c.

Referenced by sid_to_uid().

uid_map_list

LIST_ENTRY uid_map_list

extern

Definition at line 68 of file btrfs.c.

Referenced by _Function_class_(), add_user_mapping(), sid_to_uid(), and uid_to_sid().