C# 从“使用WNetAddConnection2映射网络驱动器”；“以管理员身份运行”；这个过程不起作用

我有一个应用程序，它调用

wnetadconnection2

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

这里发生的事情似乎有两个上下文，一个是管理上下文，我的程序在其中运行，另一个是用户上下文，windows资源管理器在其中运行，我正在查找映射的驱动器。我认为驱动器映射在“管理上下文”中成功，但在“用户上下文”中不可见

当我以管理员身份运行时，

Environment.GetLogicalDrives（）

包含我试图映射的驱动器号，使我认为映射在“管理上下文”中成功

如果我在多种情况下完全理解错误，我会道歉，但这似乎是对我所看到的最好的解释

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

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

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

1）驱动器将仅在登录会话中可见，LUID与您的令牌相同

将在

\Sessions\0\DosDevices\\：

下创建符号链接对象，指向

\Device\lanmamdirector\；：\服务器\share

作为结果驱动器

：

仅对在

会话中运行的进程可见。和以“管理员”身份运行的进程有不同的

比较以“管理员”身份运行的进程

2） 在调用

NetUseAdd

或

wnetadconnection2

之前，您需要模拟另一个上下文

例如，您可以枚举进程，找到具有相同终端

SessionId

（不要与登录会话混淆）的资源管理器，并模拟它（打开它、复制和模拟）。或更一般的方法：在与进程相同的终端会话中打开每个进程令牌，查询它的令牌

tokenlevationtype

（），如果它

tokenlevationtypelimited

，则在调用

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;
}

#包括
#定义BOOL_TO_ERR（b）（（b）？NOERROR:GetLastError（）
ULONG RunNonElevated（PCWSTR lpApplicationName，PWSTR lpCommandLine）
{
拉赫托肯；
ULONG err=BOOL_TO_err（OpenProcessToken（NtCurrentProcess（），TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES，&hToken））；
如果（错误！=无错误）
{
返回错误；
}
德沃德cb，rcb；
联合{
标记\高程\类型tet；
令牌链接令牌tlt；
};
令牌统计；
LUID AuthenticationId={}；
boolbsearchtoken=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））；
闭合手柄（tlt.LinkedToken）；
如果（bSearchToken=（err==NOERROR））
{
AuthenticationId.LowPart=ts.AuthenticationId.LowPart；
AuthenticationId.HighPart=ts.AuthenticationId.HighPart；
令牌\u特权tp={
1，{{{SE_DEBUG_PRIVILEGE}，SE_PRIVILEGE_ENABLED}
};
AdjustTokenPrivileges（hToken、FALSE和tp、sizeof（tp）、NULL、NULL）；
}
}
}
}
闭合手柄（hToken）；
STARTUPINFO si={sizeof（si）}；
处理信息；
如果（b搜索托克）
{
HANDLE hSnapshot=CreateToolhelp32Snapshot（TH32CS\u SNAPPROCESS，0）；
if（hSnapshot！=无效的\u句柄\u值）
{
PROCESSENTRY32W pe={sizeof（pe）}；
静态挥发性UCHAR-guz；
PVOID stack=alloca（guz）；
cb=0，rcb=FIELD_OFFSET（令牌特权，特权[SE_MAX_WELL_KNOWN_PRIVILEGE]）；
联合{
pvoidbuf；
PTOKEN_特权ptp；
};
BOOL fHavePrivs=假；
if（Process32FirstW（hSnapshot和pe））
{
做
{
if（HANDLE hProcess=OpenProcess（PROCESS\u QUERY\u LIMITED\u INFORMATION，FALSE，pe.th32ProcessID））
{
if（OpenProcessToken（hProcess、TOKEN\u QUERY、TOKEN\u DUPLICATE和hToken））
{
如果（！fHavePrivs）执行
{
如果（cbprivilegecont）
{
int n=3；
BOOL fAdjust=FALSE；
PLUID_和_属性Privileges=ptp->Privileges；
做
{
开关（特权->Luid.LowPart）
{