我的应用程序有 2 个进程，一个需要提升，另一个不需要，但是它们在同一桌面上的同一用户帐户下运行。

我需要在从文件读取的提升进程中创建一个文件(不在磁盘上，其他类型的文件)，但让我的非提升进程对该文件具有写访问权限。

使用 nullptr SECURITY_ATTRIBUTES，非提升进程无法打开文件，CreateFile 失败并显示拒绝访问代码。这是预期的，SetSecurityDescriptorDacl 解决方法类似于 this answer工作正常。

但是，我不喜欢这种解决方法。我不想将对该文件的写入权限授予所有人。我只想授予当前用户访问权限。这有点敏感，提升的读取器进程将运行数小时，我不希望每个人都能够写入该文件。

我如何获取/构建 SECURITY_ATTRIBUTES，这将成为在同一桌面上运行的非提升进程的默认安全性？

最佳答案

如果我们运行提升的进程(由管理员用户) - 它没有提升链接 session 。 (并且非提升的进程具有提升的链接 session )您需要:

1. 打开进程 token
2. 通过 TokenLinkedToken 查询此 token 的链接 session token
3. 通过 TokenDefaultDacl 查询此链接 token 的默认 dacl
4. 使用此 DACL 初始化安全描述符

为未提升的 session 获取默认 dacl 的代码:

ULONG BOOL_TO_ERROR(BOOL f)
{
    return f ? 0 : GetLastError();
}

ULONG GetNotElevatedDefaultDacl(PTOKEN_DEFAULT_DACL* DefaultDacl)
{
    HANDLE hToken;
    ULONG err = BOOL_TO_ERROR(OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken));

    if (!err)
    {
    ULONG cb;
        union {
            TOKEN_LINKED_TOKEN tlt;
            TOKEN_ELEVATION_TYPE tet;
        };

        err = BOOL_TO_ERROR(GetTokenInformation(hToken, TokenElevationType, &tet, sizeof(tet), &cb));

        if (!err)
        {
            if (tet == TokenElevationTypeFull)
            {
                err = BOOL_TO_ERROR(GetTokenInformation(hToken, TokenLinkedToken, &tlt, sizeof(tlt), &cb));
            }
            else
            {
                err = ERROR_ELEVATION_REQUIRED;
            }
        }
        CloseHandle(hToken);

        if (!err)
        {
            union {
                PTOKEN_DEFAULT_DACL p;
                PVOID buf;
            };

            cb = 0x100;

            do 
            {
                if (buf = LocalAlloc(0, cb))
                {
                    if (err = BOOL_TO_ERROR(GetTokenInformation(
                        tlt.LinkedToken, TokenDefaultDacl, buf, cb, &cb)))
                    {
                        LocalFree(buf);
                    }
                    else
                    {
                        *DefaultDacl = p;
                    }
                }
                else
                {
                    err = GetLastError();
                    break;
                }

            } while (err == ERROR_INSUFFICIENT_BUFFER);

            CloseHandle(tlt.LinkedToken);
        }
    }

    return err;
}

并使用它(这适用于在创建时采用 SECURITY_ATTRIBUTES 的任何对象)

PTOKEN_DEFAULT_DACL DefaultDacl;
ULONG err = GetNotElevatedDefaultDacl(&DefaultDacl);

SECURITY_DESCRIPTOR sd;
SECURITY_ATTRIBUTES sa = { sizeof(sa), &sd, FALSE };

InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION);

if (!err)
{
    SetSecurityDescriptorDacl(&sd, TRUE, DefaultDacl->DefaultDacl, FALSE);
}

HANDLE hObject = CreateMailslot(
        L"\\\\?\\Global\\MailSlot\\12345678", 0, MAILSLOT_WAIT_FOREVER, &sa);

if (!err)
{
    LocalFree(DefaultDacl);
}

if (hObject)
{
    // CheckObjectSD(hObject);
    CloseHandle(hObject);
}

如果使用默认 dacl 从提升的进程创建对象(在本例中为邮槽)- 安全 DACL 将如下所示:

T FL AcessMsK Sid
A 00 001F01FF S-1-5-32-544 'Administrators'
A 00 001F01FF S-1-5-18 'SYSTEM'
A 00 001200A9 S-1-5-5-0-x 'LogonSessionId_0_x'

SYSTEM 和 Administrators 的所有访问权限以及当前登录 session 的读取+执行访问权限。结果，同一登录 session 中未提升的进程只有读取权限。

如果使用未提升 session 的显式 DACL - 结果:

T FL AcessMsK Sid
A 00 001F01FF S-1-5-21-a-b-c-d 'SomeUser'
A 00 001F01FF S-1-5-18 'SYSTEM'
A 00 001200A9 S-1-5-5-0-x 'LogonSessionId_0_x'

SYSTEM 和 SomeUser 的所有访问权限以及当前登录 session 的读取+执行访问权限。

请注意，因为提升的进程将 SomeUser 作为 TokenUser，他拥有该对象的所有访问权限

对于检查对象安全描述符，我们可以使用例如下一个代码:

void CheckObjectSD(HANDLE hObject)
{
    union {
        PSECURITY_DESCRIPTOR psd;
        PVOID buf;
    };

    ULONG cb = 0, rcb = 0x30;
    volatile static UCHAR guz;
    buf = alloca(guz);
    PVOID stack = alloca(guz);

    ULONG err;
    do 
    {
        if (cb < rcb)
        {
            cb = (ULONG)((ULONG_PTR)stack - (ULONG_PTR)(buf = alloca(rcb - cb)));
        }

        if (!(err = BOOL_TO_ERROR(GetKernelObjectSecurity(hObject, 
            DACL_SECURITY_INFORMATION|LABEL_SECURITY_INFORMATION|OWNER_SECURITY_INFORMATION, psd, cb, &rcb))))
        {
            PWSTR psz;
            if (ConvertSecurityDescriptorToStringSecurityDescriptorW(psd, SDDL_REVISION, 
                DACL_SECURITY_INFORMATION|LABEL_SECURITY_INFORMATION|OWNER_SECURITY_INFORMATION, &psz, 0))
            {
                DbgPrint("%S\n", psz);
                LocalFree(psz);
            }
        }

    } while (err == ERROR_INSUFFICIENT_BUFFER);
}

如果我们没有管理员用户帐户，则提升是通过另一个用户帐户进行的。在这种情况下，提升的进程没有更多链接 session (如果我们尝试查询链接 token ，我们会收到错误 - 指定的登录 session 不存在。它可能已经终止。)。接下来可能的解决方案(在一般情况下也是如此):

对于用户进程，默认 DACL 通常为 System 和 UserSid 授予 GENERIC_ALL 和 GENERIC_READ | GENERIC_EXECUTE 用于登录 session SID。我们可以查询进程 token ，获取它的默认 DACL，在 DACL 中找到 LogonSession SID 并将其访问掩码更改为 GENERIC_ALL。这可以通过下一个代码来完成:

ULONG GetDaclForLogonSession(HANDLE hToken, PTOKEN_DEFAULT_DACL* DefaultDacl)
{
    ULONG err;

    ULONG cb = 0x100;

    union {
        PTOKEN_DEFAULT_DACL p;
        PVOID buf;
    };

    do 
    {
        if (buf = LocalAlloc(0, cb))
        {
            if (!(err = BOOL_TO_ERROR(GetTokenInformation(hToken, TokenDefaultDacl, buf, cb, &cb))))
            {
                err = ERROR_NOT_FOUND;

                if (PACL Dacl = p->DefaultDacl)
                {
                    if (USHORT AceCount = Dacl->AceCount)
                    {
                        union {
                            PVOID pv;
                            PBYTE pb;
                            PACE_HEADER pah;
                            PACCESS_ALLOWED_ACE paaa;
                        };

                        pv = Dacl + 1;

                        static const SID_IDENTIFIER_AUTHORITY NtAuth = SECURITY_NT_AUTHORITY;
                        do 
                        {
                            switch (pah->AceType)
                            {
                            case ACCESS_ALLOWED_ACE_TYPE:
                                PSID Sid = &paaa->SidStart;
                                if (*GetSidSubAuthorityCount(Sid) == SECURITY_LOGON_IDS_RID_COUNT &&
                                    *GetSidSubAuthority(Sid, 0) == SECURITY_LOGON_IDS_RID &&
                                    !memcmp(GetSidIdentifierAuthority(Sid), &NtAuth, sizeof(NtAuth)))
                                {
                                    paaa->Mask = GENERIC_ALL;
                                    *DefaultDacl = p;
                                    return 0;
                                }

                                break;
                            }
                            pb += pah->AceSize;

                        } while (--AceCount);
                    }
                }
            }

            LocalFree(buf);
        }
        else
        {
            return GetLastError();
        }

    } while (err == ERROR_INSUFFICIENT_BUFFER);

    return err;
}

ULONG GetDaclForLogonSession(PTOKEN_DEFAULT_DACL* DefaultDacl)
{
    HANDLE hToken;
    ULONG err = BOOL_TO_ERROR(OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken));

    if (!err)
    {
        err = GetDaclForLogonSession(hToken, DefaultDacl);

        CloseHandle(hToken);
    }

    return err;
}

作为我们得到 DACL 的结果，我们授予对当前登录 session 的所有访问权限。用法相同 - 只需将调用从 GetNotElevatedDefaultDacl 替换为 GetDaclForLogonSession

关于c++ - 默认安全描述符，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/52138913/