Use um Proxy para Scans com Nikto | Análise de Tráfego Web

Introdução

Nikto é um popular scanner de servidores web de código aberto que realiza testes abrangentes contra servidores web para vários itens, incluindo mais de 6700 arquivos/programas potencialmente perigosos, verifica versões desatualizadas de mais de 1250 servidores e problemas específicos de versão em mais de 270 servidores.

Um proxy, neste contexto, é um servidor intermediário que fica entre sua ferramenta (Nikto) e o servidor de destino. Ferramentas como Burp Suite, OWASP ZAP ou mitmproxy são comumente usadas para isso. Roteamento do tráfego do Nikto através de um proxy é uma técnica poderosa para profissionais de segurança. Ela permite que você veja exatamente quais requisições o scanner está enviando e quais respostas ele recebe. Isso é inestimável para depurar scans, entender o comportamento de um scanner e até mesmo modificar o tráfego em tempo real para contornar medidas de segurança.

Neste laboratório, você aprenderá como configurar um proxy local, configurar o Nikto para usá-lo, executar um scan e analisar o tráfego interceptado. Usaremos o mitmproxy como nosso proxy e um servidor web Python local simples como nosso alvo.

Configurar um proxy local como Burp Suite ou OWASP ZAP

Nesta etapa, você iniciará um servidor web simples para atuar como nosso alvo de scan e, em seguida, iniciará o mitmproxy, um proxy leve e de linha de comando, para interceptar nosso tráfego. Todas as operações serão feitas no terminal.

Primeiro, vamos iniciar um servidor web Python básico. Este servidor hospedará um arquivo simples index.html do nosso diretório atual, ~/project. Vamos executá-lo na porta 8000 em segundo plano para que possamos continuar usando o mesmo terminal.

Execute o seguinte comando:

python3 -m http.server 8000 &

O & no final do comando executa o processo em segundo plano. Você deverá ver uma saída indicando o ID do processo.

Em seguida, vamos iniciar nosso proxy. Usaremos o mitmweb, que é a interface baseada na web para o mitmproxy. Isso fornece uma maneira amigável de visualizar o tráfego capturado. Ele escuta o tráfego do proxy na porta 8080 por padrão e serve sua interface web na porta 8081.

Execute o seguinte comando para iniciar o mitmweb, também em segundo plano:

mitmweb --web-host 0.0.0.0 &

Você verá alguma saída enquanto o mitmweb é iniciado. Agora você tem um servidor de destino rodando na porta 8000 e um proxy rodando na porta 8080. Você pode visualizar o tráfego do proxy abrindo um navegador no ambiente do laboratório e navegando para http://127.0.0.1:8081. Por enquanto, estará vazio.

Configurar o Nikto para usar o proxy com -useproxy

Nesta etapa, você aprenderá como instruir o Nikto a enviar seu tráfego através da instância do mitmproxy que acabamos de iniciar. O Nikto possui uma opção de linha de comando dedicada, -useproxy, para este propósito.

A sintaxe para esta opção é -useproxy http://<proxy_host>:<proxy_port>. Como nosso mitmproxy está rodando na máquina local (127.0.0.1) na porta 8080, a URL correta será http://127.0.0.1:8080.

Antes de executar um scan completo, vamos realizar um teste simples para garantir que o Nikto possa se conectar ao servidor de destino através do proxy. Usaremos a opção -Plugins '@@NONE', que instrui o Nikto a se conectar e exibir o banner do servidor, mas sem executar nenhum teste de vulnerabilidade. Esta é uma maneira rápida e eficaz de verificar nossa configuração de proxy.

Execute o seguinte comando em seu terminal:

nikto -h 127.0.0.1 -p 8000 -useproxy http://127.0.0.1:8080 -Plugins '@@NONE'

Você deverá ver uma saída semelhante a esta, mostrando o banner do Nikto e informações sobre o servidor de destino:

- Nikto v2.x.x
---------------------------------------------------------------------------
+ Target IP:          127.0.0.1
+ Target Hostname:    127.0.0.1
+ Target Port:        8000
+ Start Time:         ...
---------------------------------------------------------------------------
+ Server: SimpleHTTP/0.6 Python/3.10.6
+ END TIME:           ...
---------------------------------------------------------------------------
+ 1 host(s) tested

Agora, se você verificar a interface do mitmweb em seu navegador em http://127.0.0.1:8081, verá a primeira requisição capturada do Nikto. Isso confirma que a configuração do proxy está funcionando corretamente.

Executar um scan direcionado através do proxy configurado

Nesta etapa, com a configuração do proxy verificada, você realizará um scan de vulnerabilidade real com o Nikto. Isso gerará uma quantidade significativa de tráfego, todo o qual será roteado e registrado pelo mitmproxy.

Para manter o tempo de scan razoável para este laboratório, usaremos a opção -Tuning 1. A opção de tuning no Nikto controla os tipos de testes realizados. -Tuning 1 foca em verificações de "Arquivo Interessante / Visto no Log" (Interesting File / Seen in Log), que é um bom ponto de partida.

Execute o seguinte comando para iniciar o scan:

nikto -h 127.0.0.1 -p 8000 -useproxy http://127.0.0.1:8080 -Tuning 1

O Nikto começará a escanear o servidor de destino. Você verá seu progresso e quaisquer descobertas diretamente em seu terminal. A saída pode se parecer com algo assim, dependendo das descobertas:

- Nikto v2.x.x
---------------------------------------------------------------------------
+ Target IP:          127.0.0.1
+ Target Hostname:    127.0.0.1
+ Target Port:        8000
+ Start Time:         ...
---------------------------------------------------------------------------
+ Server: SimpleHTTP/0.6 Python/3.10.6
+ The anti-clickjacking X-Frame-Options header is not present.
+ The X-XSS-Protection header is not defined. This header can hint to the user agent to protect against some forms of XSS
+ The X-Content-Type-Options header is not set. This could allow the user agent to render the content of the site in a different fashion to the MIME type
...
+ /: The server returns the following message when a request for a non-existent page is made: b'<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"\n        "http://www.w3.org/TR/html4/strict.dtd">\n<html>\n    <head>\n        <meta http-equiv="Content-Type" content="text/html;charset=utf-8">\n        <title>Error response</title>\n    </head>\n    <body>\n        <h1>Error response</h1>\n        <p>Error code: 404.</p>\n        <p>Message: File not found.</p>\n        <p>Error code explanation: 404 - Nothing matches the given URI.</p>\n    </body>\n</html>'
...
+ END TIME:           ...
---------------------------------------------------------------------------
+ 1 host(s) tested

Enquanto o scan estiver em execução, você pode alternar para a aba do navegador do mitmweb e observar as requisições aparecerem em tempo real.

Observar o tráfego do Nikto no histórico HTTP do proxy

Nesta etapa, você se concentrará na análise do tráfego capturado pelo mitmproxy. É aqui que o valor real de usar um proxy se torna evidente. Nenhum comando novo é necessário para esta etapa; você usará a interface do mitmweb em seu navegador.

Navegue até a aba do navegador que está executando o mitmweb em http://127.0.0.1:8081. Você deverá ver uma longa lista de requisições web. Cada entrada nesta lista é um teste específico que o Nikto realizou contra o servidor de destino.

Clique em qualquer uma das requisições na lista à esquerda. O painel direito será atualizado para mostrar os detalhes dessa requisição específica e sua resposta correspondente.

Explore a interface:

Aba Request (Requisição): Aqui você pode ver a requisição HTTP exata enviada pelo Nikto. Preste atenção em:
- A linha de requisição (por exemplo, GET /some/test/file.html HTTP/1.1).
- O cabeçalho Host, que aponta para o nosso servidor de destino.
- O cabeçalho User-Agent, que identificará o cliente como Nikto.
Aba Response (Resposta): Esta aba mostra a resposta completa do servidor. Você pode ver o código de status HTTP (por exemplo, 200 OK ou 404 Not Found), os cabeçalhos de resposta e o corpo da resposta.

Dedique alguns minutos para clicar em diferentes requisições. Você verá o Nikto tentando acessar diretórios administrativos comuns (como /admin/), verificando arquivos de backup (como /index.html.bak) e realizando outras verificações padrão. Ao observar este tráfego, você obtém uma compreensão profunda de como um scanner de vulnerabilidades opera.

Analisar como o proxy afeta os resultados do scan

Nesta etapa, você analisará como o uso de um proxy pode potencialmente afetar um scan. Para fazer isso, você precisa de uma linha de base para comparação. Você executará o mesmo scan do Nikto novamente, mas desta vez sem o proxy.

Execute o mesmo comando de scan da Etapa 3, mas omita a opção -useproxy:

nikto -h 127.0.0.1 -p 8000 -Tuning 1

Observe a saída em seu terminal. Agora, compare os resultados deste scan com os resultados do scan com proxy da Etapa 3. Em nosso ambiente de laboratório simples, sem firewalls ou outros sistemas de segurança em vigor, os resultados devem ser idênticos.

Então, qual é o objetivo do proxy?

Visibilidade (Debugging): Como você viu na etapa anterior, o benefício principal é a visibilidade. Se um scan estivesse falhando ou produzindo resultados inesperados, o proxy seria o primeiro lugar a ser verificado para entender o que está dando errado. Você pode ver as requisições e respostas brutas, o que é crucial para a solução de problemas.
Desempenho: Um proxy adiciona um "salto" extra para o tráfego de rede, o que pode introduzir uma pequena quantidade de latência. Para scans muito grandes, isso poderia aumentar ligeiramente o tempo total do scan.
Modificação (Avançado): Proxies avançados podem ser configurados para modificar o tráfego. Por exemplo, você poderia configurar uma regra para alterar automaticamente o User-Agent de "Nikto" para uma string de navegador comum. Isso poderia ser usado para evadir um Web Application Firewall (WAF) simples que bloqueia requisições com base no user agent do Nikto. Embora não estejamos realizando modificações neste laboratório, entender essa capacidade é fundamental.

Em resumo, para este laboratório, o principal efeito do proxy foi lhe dar uma visão "man-in-the-middle" do processo de escaneamento, que é uma habilidade fundamental para testes de segurança.

Resumo

Neste laboratório, você aprendeu com sucesso como utilizar um proxy ao realizar um scan de vulnerabilidades web com o Nikto.

Você começou configurando o ambiente necessário, incluindo um servidor web Python simples como alvo e o mitmproxy como seu proxy de interceptação. Em seguida, aprendeu a usar a opção de linha de comando -useproxy do Nikto para rotear todo o seu tráfego de scan através do proxy.

Ao executar um scan e observar o tráfego na interface do mitmweb, você obteve insights diretos sobre os tipos de requisições que o Nikto envia e as respostas que recebe. Finalmente, ao executar um scan comparativo sem o proxy, você analisou como um proxy pode afetar um scan, concluindo que seu papel principal neste contexto é fornecer visibilidade crítica para análise e depuração. Esta é uma técnica fundamental utilizada por profissionais de segurança para entender e controlar melhor suas ferramentas de teste.