Introdução
Neste laboratório, você aprenderá como simular várias condições de rede usando o Nmap. Isso inclui simular checksums ruins e manipular a Unidade Máxima de Transmissão (MTU - Maximum Transmission Unit) para entender seu impacto na varredura de rede.
Você explorará comandos como nmap --badsum 192.168.1.1 para enviar pacotes com checksums corrompidos, nmap --mtu 1400 127.0.0.1 para definir uma MTU específica e combinações desses comandos. Você também aprenderá a adicionar verbosidade com -v e salvar os resultados em um arquivo usando -oN. Finalmente, você analisará os efeitos dessas simulações no terminal Xfce.
Simular checksum ruim com nmap --badsum 192.168.1.1
Nesta etapa, exploraremos como simular um checksum ruim usando o Nmap. Checksums são usados para verificar a integridade dos dados transmitidos por uma rede. Um checksum ruim indica que os dados foram corrompidos durante a transmissão. Simular um checksum ruim pode ser útil para testar como um sistema lida com pacotes corrompidos.
Primeiro, vamos entender a sintaxe básica do comando:
nmap --badsum <target_ip>
Aqui, --badsum é a opção que informa ao Nmap para gerar pacotes com um checksum inválido. <target_ip> é o endereço IP do alvo que você deseja escanear.
Antes de executar o comando, é importante entender que o envio de pacotes com checksums ruins pode ser interpretado como atividade maliciosa por alguns dispositivos de rede ou sistemas de segurança. Portanto, é melhor usar esta opção em uma rede de teste ou contra um alvo para o qual você tem permissão explícita para escanear.
Agora, vamos executar o comando. Vamos direcionar o endereço IP 192.168.1.1. Certifique-se de ter as permissões necessárias e que a varredura deste IP seja permitida.
Abra seu terminal Xfce e execute o seguinte comando:
sudo nmap --badsum 192.168.1.1
Você provavelmente verá uma saída indicando que o Nmap está enviando pacotes com um checksum ruim. A saída exata dependerá do sistema alvo e da configuração da rede.
Exemplo de saída (pode variar):
Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for 192.168.1.1
Host is up (0.00043s latency).
All 1000 scanned ports on 192.168.1.1 are filtered
Nmap done: 1 IP address (1 host up) scanned in 4.63 seconds
Observação: A saída mostra que todas as portas estão filtradas. Este é apenas um exemplo, e o resultado real depende do alvo. A parte importante é que o Nmap executou a varredura com a opção --badsum.
Este comando envia pacotes para 192.168.1.1 com checksums deliberadamente corrompidos. Isso pode ser usado para testar como um sistema lida com pacotes inválidos.
Definir MTU com nmap --mtu 1400 127.0.0.1
Nesta etapa, aprenderemos como definir o tamanho da Unidade Máxima de Transmissão (MTU - Maximum Transmission Unit) usando o Nmap. A MTU é o maior tamanho de pacote (em bytes) que uma interface de rede pode transmitir. Por padrão, o Nmap descobre automaticamente a MTU da sua rede. No entanto, você pode definir manualmente o valor da MTU para fins de teste.
O comando que usaremos é:
nmap --mtu <mtu_value> <target_ip>
Aqui, --mtu especifica o valor da MTU a ser usado para a varredura, e <target_ip> é o endereço IP do alvo.
Neste caso específico, definiremos a MTU como 1400 e direcionaremos o endereço de loopback 127.0.0.1. O endereço de loopback é um endereço IP especial que sempre se refere à máquina local. Isso nos permite testar a configuração da MTU do Nmap sem enviar pacotes por uma rede.
Abra seu terminal Xfce e execute o seguinte comando:
sudo nmap --mtu 1400 127.0.0.1
Você verá a saída do Nmap indicando que ele está escaneando o endereço de loopback. A saída também mostrará que a MTU está definida como 1400.
Exemplo de saída (pode variar):
Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for localhost (127.0.0.1)
Host is up (0.0000090s latency).
All 1000 scanned ports on localhost (127.0.0.1) are closed
Nmap done: 1 IP address (1 host up) scanned in 0.02 seconds
Este comando informa ao Nmap para usar uma MTU de 1400 ao enviar pacotes para 127.0.0.1. Isso pode ser útil para testar como um sistema lida com pacotes de um tamanho específico.
Combinar MTU e scan com nmap -sS --mtu 1000 192.168.1.1
Nesta etapa, combinaremos a configuração da MTU com um tipo de varredura específico. Usaremos a varredura SYN (-sS) junto com a opção --mtu para realizar uma varredura com um tamanho de MTU especificado.
A varredura SYN (-sS) é uma varredura furtiva que envia apenas pacotes SYN para o alvo. É mais rápida e menos detectável do que uma varredura de conexão TCP completa.
O comando que usaremos é:
nmap -sS --mtu <mtu_value> <target_ip>
Aqui, -sS especifica o tipo de varredura SYN, --mtu define o valor da MTU e <target_ip> é o endereço IP do alvo.
Neste caso específico, definiremos a MTU como 1000 e direcionaremos o endereço IP 192.168.1.1. Certifique-se de ter as permissões necessárias e que a varredura deste IP seja permitida.
Abra seu terminal Xfce e execute o seguinte comando:
sudo nmap -sS --mtu 1000 192.168.1.1
Você verá a saída do Nmap indicando que ele está realizando uma varredura SYN com uma MTU de 1000. A saída exata dependerá do sistema alvo e da configuração da rede.
Exemplo de saída (pode variar):
Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for 192.168.1.1
Host is up (0.00043s latency).
All 1000 scanned ports on 192.168.1.1 are filtered
Nmap done: 1 IP address (1 host up) scanned in 4.63 seconds
Observação: A saída mostra que todas as portas estão filtradas. Este é apenas um exemplo, e o resultado real depende do alvo. A parte importante é que o Nmap executou a varredura SYN com a opção --mtu.
Este comando combina uma varredura SYN com um tamanho de MTU específico. Isso pode ser útil para testar como um sistema responde a diferentes tamanhos de pacotes durante uma varredura.
Adicionar verbosidade com nmap -v --badsum 127.0.0.1
Nesta etapa, adicionaremos verbosidade ao comando Nmap. A verbosidade aumenta a quantidade de informações exibidas durante a varredura, o que pode ser útil para depurar e entender o que o Nmap está fazendo.
A opção -v aumenta o nível de verbosidade. Você pode usá-la várias vezes (por exemplo, -vv) para obter uma saída ainda mais detalhada.
Combinaremos a opção de verbosidade com a opção --badsum, que usamos na primeira etapa, direcionando o endereço de loopback 127.0.0.1.
Abra seu terminal Xfce e execute o seguinte comando:
sudo nmap -v --badsum 127.0.0.1
Você verá uma saída mais detalhada do Nmap em comparação com os comandos anteriores. A saída incluirá informações sobre os pacotes sendo enviados, as respostas recebidas e o progresso da varredura.
Exemplo de saída (pode variar):
Starting Nmap 7.80 ( https://nmap.org )
NSE: Loaded 0 scripts for scanning.
Initiating Ping Scan at 15:00
Scanning localhost (127.0.0.1) [4 ports]
Completed Ping Scan at 15:00, 0.00s elapsed (1 total hosts)
Host localhost (127.0.0.1) appears to be up ... good.
Initiating Connect Scan at 15:00
Scanning localhost (127.0.0.1) [1000 ports]
Connect Scan Timing: About 0.00% done; ETC: 15:00 (0:00:00 remaining)
Completed Connect Scan at 15:00, 0.01s elapsed (1000 total ports)
Nmap scan report for localhost (127.0.0.1)
Host is up (0.0000090s latency).
All 1000 scanned ports on localhost (127.0.0.1) are closed
Read data files from: /usr/bin/../share/nmap
Nmap done: 1 IP address (1 host up) scanned in 0.02 seconds
A opção -v fornece mais informações sobre o processo de varredura, tornando mais fácil entender o que o Nmap está fazendo e solucionar quaisquer problemas.
Salvar resultados com nmap --mtu 1200 -oN sim.txt 192.168.1.1
Nesta etapa, salvaremos os resultados da varredura Nmap em um arquivo. Isso é útil para análise posterior ou para compartilhar os resultados com outras pessoas.
A opção -oN especifica que a saída deve ser salva em formato normal no arquivo especificado.
O comando que usaremos é:
nmap --mtu <mtu_value> -oN <output_file> <target_ip>
Aqui, --mtu define o valor da MTU, -oN especifica o arquivo de saída em formato normal, <output_file> é o nome do arquivo para salvar os resultados e <target_ip> é o endereço IP do alvo.
Neste caso específico, definiremos a MTU como 1200, salvaremos a saída em um arquivo chamado sim.txt no diretório ~/project e direcionaremos o endereço IP 192.168.1.1. Certifique-se de ter as permissões necessárias e que a varredura deste IP seja permitida.
Abra seu terminal Xfce e execute o seguinte comando:
sudo nmap --mtu 1200 -oN sim.txt 192.168.1.1
Após a conclusão da varredura, um arquivo chamado sim.txt será criado em seu diretório ~/project. Este arquivo conterá os resultados da varredura Nmap em um formato legível por humanos.
Para verificar se o arquivo foi criado e contém os resultados da varredura, você pode usar o comando cat para exibir o conteúdo do arquivo:
cat sim.txt
Você deve ver os resultados da varredura Nmap impressos no terminal.
Exemplo de saída (pode variar):
## Nmap 7.80 scan initiated Mon Oct 26 15:05:05 2020
Nmap scan report for 192.168.1.1
Host is up (0.00043s latency).
All 1000 scanned ports on 192.168.1.1 are filtered
## Nmap done: 1 IP address (1 host up) scanned in 4.63 seconds
Este comando salva os resultados da varredura Nmap em um arquivo, permitindo que você revise e analise os resultados posteriormente.
Analisar os efeitos da simulação no terminal Xfce
Nesta etapa, analisaremos os efeitos das simulações que realizamos usando o Nmap. Examinaremos a saída das etapas anteriores para entender como as opções --badsum e --mtu afetaram os resultados da varredura.
Primeiro, vamos revisar o arquivo sim.txt que criamos na etapa anterior. Abra seu terminal Xfce e use o comando cat para exibir o conteúdo do arquivo:
cat sim.txt
Examine a saída. Observe o endereço IP de destino, as portas que foram varridas e o status dessas portas (por exemplo, aberto, fechado, filtrado).
Em seguida, vamos considerar a opção --badsum. Esta opção corrompe intencionalmente a soma de verificação (checksum) dos pacotes Nmap. Em um cenário do mundo real, isso provavelmente faria com que os pacotes fossem descartados pela rede ou pelo host de destino. No entanto, o Nmap ainda pode fornecer algumas informações, mesmo com pacotes corrompidos.
Recorde o comando que usamos com --badsum:
sudo nmap --badsum 192.168.1.1
A saída deste comando (se você não a salvou em um arquivo) teria mostrado como o Nmap tentou varrer o destino, apesar dos erros de soma de verificação.
Agora, vamos considerar a opção --mtu. Esta opção define a Unidade Máxima de Transmissão (MTU - Maximum Transmission Unit) para os pacotes Nmap. A MTU é o maior tamanho de pacote que pode ser transmitido por uma rede. Se a MTU for definida muito alta, os pacotes podem ser fragmentados, o que pode afetar os resultados da varredura. Se a MTU for definida muito baixa, a varredura pode ser mais lenta.
Recorde o comando que usamos com --mtu:
sudo nmap --mtu 1200 -oN sim.txt 192.168.1.1
Ao definir a MTU como 1200, potencialmente influenciamos como o host de destino recebeu e processou os pacotes Nmap. O arquivo sim.txt contém os resultados desta varredura, que você deve comparar com uma varredura sem a opção --mtu para ver as diferenças.
Para analisar ainda mais os efeitos, você pode tentar executar varreduras Nmap com diferentes valores de MTU e comparar os resultados. Por exemplo, tente um valor de MTU que seja menor que o padrão (geralmente 1500) e um que seja maior.
Em resumo, ao usar as opções --badsum e --mtu, simulamos condições de rede que podem afetar as varreduras Nmap. Analisar os resultados dessas simulações nos ajuda a entender como o Nmap se comporta em diferentes circunstâncias e como interpretar os resultados da varredura de acordo.
Esta etapa é principalmente sobre entender o impacto dos comandos anteriores. Não há nenhum comando específico a ser executado nesta etapa, além de revisar as saídas das etapas anteriores.
Resumo
Neste laboratório, exploramos como simular condições de rede usando o Nmap. Especificamente, aprendemos como usar a opção --badsum para enviar pacotes com somas de verificação inválidas para um endereço IP de destino, permitindo-nos testar como um sistema lida com dados corrompidos. Também praticamos a definição do tamanho da Unidade Máxima de Transmissão (MTU - Maximum Transmission Unit) usando a opção --mtu para controlar o tamanho dos pacotes enviados durante uma varredura.
Além disso, combinamos a opção --mtu com um tipo de varredura e exploramos a adição de verbosidade com a flag -v para uma saída mais detalhada. Finalmente, aprendemos como salvar os resultados da varredura em um arquivo usando a opção -oN para análise posterior, e fomos instruídos a analisar os efeitos dessas simulações no terminal Xfce.
