使用“以管理员身份运行”过程中的 WNetAddConnection2 映射网络驱动器不起作用

Question

我有一个应用程序调用WNetAddConnection2 来映射网络驱动器。这非常有效，除非我以管理员身份运行应用程序（右键单击 - 以管理员身份运行），在这种情况下，函数返回 0（成功）但映射的驱动器不出现。

这里似乎发生了两个上下文，一个是我的程序在其中运行的管理员，另一个是在其中运行 Windows 资源管理器的用户，我正在寻找映射的驱动器.我认为驱动器映射在 “Admin Context” 中成功，但在 “User context” 中不可见。

当我以管理员身份运行时，Environment.GetLogicalDrives() 包含我尝试映射的驱动器号，这让我认为映射在 “Admin Context” 中成功。

抱歉，如果我在多个上下文中完全理解错误，但这似乎是对我所看到的最好的解释。

这个问题有两个可能的答案：

1) 如何映射驱动器以使其在所有上下文中都可见？

2) 我如何从没有管理员权限的“以管理员身份运行”进程（即在“用户上下文”中）执行某些操作（进程/线程/API 调用）？

Answer 1

1) 驱动器仅在登录会话中可见，LUID 与您的令牌 TOKEN_STATISTICS.AuthenticationId 相同

将在 \Sessions\0\DosDevices\<LogonId>\<X>: 下创建符号链接对象到 \Device\LanmamRedirector\;<X>:<LogonId>\server\share，因为结果驱动器 <X>: 将仅对在 @987654328 中运行的进程可见@ 会话。并且以“管理员身份”运行的进程具有不同的<LogonId>比较不是“以管理员身份”运行的进程

2) 在调用NetUseAdd 或WNetAddConnection2 之前，您需要模拟另一个上下文。

例如，您可以枚举进程，找到具有相同终端 SessionId 的资源管理器（不会与登录会话混淆）并模拟它（打开它的令牌、复制和模拟）。或更一般地，在与您的进程相同的终端会话中打开每个进程令牌，查询它的令牌 TokenElevationType (TOKEN_ELEVATION_TYPE)，如果它是 TokenElevationTypeLimited - 复制并模拟此令牌，然后调用 NetUseAdd

---

如何从“运行”中执行某些内容（进程/线程/API 调用） 作为管理员”进程没有管理员权限（即在“用户 上下文”）？

工作代码示例：

#include <TlHelp32.h>

#define BOOL_TO_ERR(b) ((b) ? NOERROR : GetLastError())

ULONG RunNonElevated(PCWSTR lpApplicationName, PWSTR lpCommandLine)
{
    HANDLE hToken;

    ULONG err = BOOL_TO_ERR(OpenProcessToken(NtCurrentProcess(), TOKEN_QUERY|TOKEN_ADJUST_PRIVILEGES, &hToken));

    if (err != NOERROR)
    {
        return err;
    }

    DWORD cb, rcb;

    union {
        TOKEN_ELEVATION_TYPE tet;
        TOKEN_LINKED_TOKEN tlt;
    };

    TOKEN_STATISTICS ts;
    LUID AuthenticationId = {};

    BOOL bSearchToken = FALSE, bFound = FALSE;

    err = BOOL_TO_ERR(GetTokenInformation(hToken, TokenElevationType, &tet, sizeof(tet), &rcb));

    if (err == NOERROR)
    {
        if (tet == TokenElevationTypeFull)
        {
            err = BOOL_TO_ERR(GetTokenInformation(hToken, TokenLinkedToken, &tlt, sizeof(tlt), &rcb));

            if (err == NOERROR)
            {
                err = BOOL_TO_ERR(GetTokenInformation(tlt.LinkedToken, TokenStatistics, &ts, sizeof(ts), &rcb));

                CloseHandle(tlt.LinkedToken);

                if (bSearchToken = (err == NOERROR))
                {
                    AuthenticationId.LowPart = ts.AuthenticationId.LowPart;
                    AuthenticationId.HighPart = ts.AuthenticationId.HighPart;

                    TOKEN_PRIVILEGES tp = {
                        1, { { { SE_DEBUG_PRIVILEGE } , SE_PRIVILEGE_ENABLED } }
                    };

                    AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
                }
            }
        }
    }

    CloseHandle(hToken);

    STARTUPINFO si = { sizeof (si) };
    PROCESS_INFORMATION pi;

    if (bSearchToken)
    {
        HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

        if (hSnapshot != INVALID_HANDLE_VALUE)
        {
            PROCESSENTRY32W pe = { sizeof(pe) };

            static volatile UCHAR guz;

            PVOID stack = alloca(guz);

            cb = 0, rcb = FIELD_OFFSET(TOKEN_PRIVILEGES, Privileges[SE_MAX_WELL_KNOWN_PRIVILEGE]);

            union {
                PVOID buf;
                PTOKEN_PRIVILEGES ptp;
            };

            BOOL fHavePrivs = FALSE;

            if (Process32FirstW(hSnapshot, &pe))
            {
                do 
                {
                    if (HANDLE hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pe.th32ProcessID))
                    {
                        if (OpenProcessToken(hProcess, TOKEN_QUERY|TOKEN_DUPLICATE, &hToken))
                        {

                            if (!fHavePrivs) do 
                            {
                                if (cb < rcb)
                                {
                                    cb = RtlPointerToOffset(buf = alloca(rcb - cb), stack);
                                }

                                if (GetTokenInformation(hToken, TokenPrivileges, buf, cb, &rcb))
                                {
                                    if (ULONG PrivilegeCount = ptp->PrivilegeCount)
                                    {
                                        int n = 3;
                                        BOOL fAdjust = FALSE;

                                        PLUID_AND_ATTRIBUTES Privileges = ptp->Privileges;
                                        do 
                                        {
                                            switch (Privileges->Luid.LowPart)
                                            {
                                            case SE_ASSIGNPRIMARYTOKEN_PRIVILEGE:
                                            case SE_INCREASE_QUOTA_PRIVILEGE:
                                            case SE_DEBUG_PRIVILEGE:
                                                if (!(Privileges->Attributes & SE_PRIVILEGE_ENABLED))
                                                {
                                                    Privileges->Attributes |= SE_PRIVILEGE_ENABLED;
                                                    fAdjust = TRUE;
                                                }

                                                if (!--n)
                                                {
                                                    if (DuplicateTokenEx(hToken, 
                                                        TOKEN_ADJUST_PRIVILEGES|TOKEN_IMPERSONATE, 
                                                        0, SecurityImpersonation, TokenImpersonation, 
                                                        &tlt.LinkedToken))
                                                    {
                                                        if (fAdjust)
                                                        {
                                                            AdjustTokenPrivileges(tlt.LinkedToken, FALSE, ptp, rcb, NULL, NULL);
                                                        }
                                                        fHavePrivs = SetThreadToken(0, tlt.LinkedToken);
                                                        CloseHandle(tlt.LinkedToken);
                                                    }
                                                    goto __1;
                                                }
                                            }
                                        } while (Privileges++, --PrivilegeCount);
                                    }
                                    break;
                                }

                            } while (GetLastError() == ERROR_INSUFFICIENT_BUFFER);

__1:
                            if (fHavePrivs &&
                                GetTokenInformation(hToken, TokenStatistics, &ts, sizeof(ts), &rcb) &&
                                ts.AuthenticationId.LowPart == AuthenticationId.LowPart &&
                                ts.AuthenticationId.HighPart == AuthenticationId.HighPart)
                            {
                                bFound = DuplicateTokenEx(hToken, 
                                    TOKEN_QUERY|TOKEN_DUPLICATE|TOKEN_ASSIGN_PRIMARY, 
                                    0, SecurityImpersonation, TokenPrimary, &tlt.LinkedToken);
                            }
                            CloseHandle(hToken);
                        }
                        CloseHandle(hProcess);
                    }
                } while (!bFound && Process32NextW(hSnapshot, &pe));
            }
            CloseHandle(hSnapshot);

            if (bFound)
            {
                err = BOOL_TO_ERR(CreateProcessAsUserW(tlt.LinkedToken, lpApplicationName, lpCommandLine, 
                    NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi));

                CloseHandle(tlt.LinkedToken);

                if (err == NOERROR)
                {
                    CloseHandle(pi.hThread);
                    CloseHandle(pi.hProcess);
                }
            }
        }
    }
    else if (err == NOERROR)
    {
        if ((err = BOOL_TO_ERR(CreateProcessW(lpApplicationName, lpCommandLine,
            NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))) == NOERROR)
        {
            CloseHandle(pi.hThread);
            CloseHandle(pi.hProcess);
        }
    }

    return err;
}