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.
Embora o Nikto possa facilmente escanear sites HTTP padrão, escanear sites que usam SSL/TLS (HTTPS) requer uma opção específica. Neste laboratório, você aprenderá como usar o Nikto para escanear um site habilitado para SSL/TLS. Usaremos um servidor web seguro hospedado localmente para fins de teste. Você aprenderá como iniciar um escaneamento SSL, direcioná-lo para uma porta específica e interpretar as informações relacionadas ao SSL nos resultados do escaneamento.
Identificar um site alvo usando HTTPS
Nesta etapa, confirmaremos que nosso servidor web seguro alvo está em execução e acessível. O script de configuração para este laboratório já iniciou um servidor web Python simples que usa SSL/TLS. Ele está escutando em localhost na porta 4433.
Para verificar se o servidor está em execução, podemos usar o comando curl. Como nosso servidor usa um certificado autoassinado (que não é confiável por uma Autoridade Certificadora), devemos usar a flag -k ou --insecure com o curl para instruí-lo a prosseguir, apesar do certificado não confiável.
Execute o seguinte comando em seu terminal:
curl -k https://localhost:4433
Você deverá ver o conteúdo HTML da página principal do servidor, o que confirma que o servidor está ativo e servindo conteúdo via HTTPS.
<html><body><h1>Welcome to the Secure Test Server!</h1></body></html>
Agora que confirmamos que nosso alvo está operacional, podemos prosseguir com o escaneamento.
Usar a flag -ssl para habilitar o modo SSL
Nesta etapa, aprenderemos por que a flag -ssl é essencial para escanear sites HTTPS. Por padrão, o Nikto tenta escanear alvos via HTTP padrão na porta 80. Se você apontá-lo para uma porta que espera uma conexão SSL/TLS sem especificar o uso de SSL, o escaneamento falhará porque o handshake de comunicação inicial está incorreto.
Vamos tentar executar o Nikto contra nosso servidor seguro na porta 4433 sem a flag -ssl para observar esse comportamento.
nikto -h localhost -p 4433
Você verá uma saída indicando que nenhum servidor web foi encontrado, ou poderá ver uma mensagem de erro. Isso ocorre porque o Nikto está tentando se comunicar em HTTP com uma porta que está escutando para HTTPS.
- Nikto v2.5.0
---------------------------------------------------------------------------
+ Target IP: 127.0.0.1
+ Target Hostname: localhost
+ Target Port: 4433
---------------------------------------------------------------------------
+ Start Time: ...
---------------------------------------------------------------------------
+ ERROR: No web server found on localhost:4433
---------------------------------------------------------------------------
+ 0 host(s) tested
Isso demonstra a necessidade da flag -ssl. Essa flag instrui explicitamente o Nikto a encapsular suas requisições web em uma camada SSL/TLS, permitindo que ele se comunique com servidores seguros. Na próxima etapa, usaremos essa flag para realizar um escaneamento adequado.
Executar o escaneamento contra o alvo HTTPS
Nesta etapa, você realizará um escaneamento de vulnerabilidade adequado contra nosso servidor web seguro usando a flag -ssl. Ao combinar as flags -h (host), -p (porta) e -ssl, podemos instruir o Nikto a se conectar ao host e porta corretos, e a usar uma conexão SSL/TLS.
Execute o seguinte comando em seu terminal para iniciar o escaneamento:
nikto -h localhost -p 4433 -ssl
O Nikto iniciará o escaneamento. Como nosso servidor está usando um certificado autoassinado, o Nikto provavelmente exibirá um aviso sobre o emissor do certificado não ser confiável, o que é esperado neste caso. O escaneamento prosseguirá.
A saída será semelhante a esta:
- Nikto v2.5.0
---------------------------------------------------------------------------
+ Target IP: 127.0.0.1
+ Target Hostname: localhost
+ Target Port: 4433
+ SSL Info: Self-signed certificate.
+ Start Time: ...
---------------------------------------------------------------------------
+ Server: SimpleHTTP/0.6 Python/3.10.12
+ 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
...
+ 1 host(s) tested
Você agora escaneou com sucesso um site habilitado para SSL com o Nikto.
Observar verificações específicas de SSL na saída
Nesta etapa, analisaremos a saída do escaneamento anterior para identificar informações específicas de conexões SSL/TLS. Quando a flag -ssl é usada, o Nikto não apenas escaneia vulnerabilidades web gerais, mas também fornece detalhes sobre o certificado e a configuração SSL/TLS do servidor.
Se você rolar para trás na saída do comando da etapa anterior, encontrará informações relacionadas ao certificado SSL. Para isolar essas informações, você pode executar o escaneamento novamente e usar grep para filtrar a saída. Vamos procurar pela linha "Subject" do certificado.
nikto -h localhost -p 4433 -ssl | grep "Subject"
Este comando executará o escaneamento novamente, mas exibirá apenas as linhas que contêm a palavra "Subject".
+ Subject: C=US, ST=California, L=MountainView, O=LabEx, OU=IT, CN=localhost
Esta linha mostra os detalhes incorporados no certificado SSL do servidor, como País (C), Estado (ST) e Nome Comum (CN). Essas informações podem ser úteis para verificar a identidade de um servidor durante uma avaliação de segurança. O Nikto também verifica informações de cifra e outras vulnerabilidades relacionadas a SSL, fornecendo uma imagem mais completa da configuração do servidor seguro.
Forçar o modo SSL em uma porta não padrão
Nesta etapa, exploraremos como "forçar" o Nikto a usar SSL em qualquer porta, mesmo em uma que normalmente lida com tráfego não criptografado. Isso é útil para identificar serviços mal configurados que podem estar executando HTTPS em uma porta incomum, como a 8080.
Primeiro, precisamos parar o servidor existente e iniciar um novo na porta 8080.
## Stop the previous server
pkill -f "python3 /home/labex/project/https_server/server.py"
## Create a new server configuration for port 8080
cat << EOF > /home/labex/project/https_server/server_8080.py
import http.server
import ssl
import os
os.chdir(os.path.dirname(os.path.abspath(__file__)))
server_address = ('0.0.0.0', 8080)
httpd = http.server.HTTPServer(server_address, http.server.SimpleHTTPRequestHandler)
httpd.socket = ssl.wrap_socket(httpd.socket,
server_side=True,
certfile='cert.pem',
keyfile='key.pem',
ssl_version=ssl.PROTOCOL_TLS)
httpd.serve_forever()
EOF
## Start the new server in the background and wait a moment
python3 /home/labex/project/https_server/server_8080.py &> /dev/null &
sleep 3
Agora, nosso servidor seguro está rodando na porta 8080. Sem a flag -ssl, o Nikto assumiria que esta é uma porta HTTP padrão. Ao incluir -ssl, o forçamos a iniciar um handshake TLS.
Execute o escaneamento contra a porta 8080:
nikto -h localhost -p 8080 -ssl
A saída será semelhante aos escaneamentos anteriores, confirmando que o Nikto se conectou com sucesso usando SSL/TLS a uma porta não padrão e realizou seus testes.
- Nikto v2.5.0
---------------------------------------------------------------------------
+ Target IP: 127.0.0.1
+ Target Hostname: localhost
+ Target Port: 8080
+ SSL Info: Self-signed certificate.
...
Isso confirma sua capacidade de usar o Nikto para escanear serviços SSL/TLS em qualquer porta arbitrária.
Resumo
Neste laboratório, você aprendeu o processo fundamental de escanear websites com SSL/TLS ativado usando o Nikto. Você começou identificando e verificando um servidor HTTPS alvo. Em seguida, viu em primeira mão por que simplesmente apontar o Nikto para uma porta HTTPS falha e aprendeu que a flag -ssl é necessária para habilitar a comunicação SSL/TLS.
Você executou com sucesso um escaneamento contra um servidor seguro, analisou a saída para informações específicas de SSL, como detalhes do certificado, e, finalmente, aprendeu como forçar o modo SSL em uma porta não padrão. Essa habilidade é crucial para realizar avaliações de segurança completas em aplicações web modernas que dependem de HTTPS para segurança.
