> For the complete documentation index, see [llms.txt](https://nicollaslopes.gitbook.io/estudos/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://nicollaslopes.gitbook.io/estudos/master/scanning/nmap-the-network-mapper.md). # Nmap: the network mapper O Nmap, é um software open source que realiza ports scan em uma rede. É o port scan mais utilizado e de longe a melhor ferramenta para ser utilizada nesse quesito. Para identificarmos hosts ativos em uma rede, utilizamos **nmap -sn \** ou passar um bloco de ip como por exemplo 1-254. O resultado será salvo no arquivo chamado **ativos.txt** ``` ┌──(user㉿kali)-[~/Desktop] └─$ sudo nmap -sn 37.59.172.224-239 -oG ativos.txt ``` Podemos utilizar também passando a máscara para scanear a rede inteira. ``` sudo nmap -sn 192.168.1.0/24 ``` Para identificar se uma porta em um host está aberta, é necessário estabelecer o three-way-handshake. Funciona da seguinte forma, o cliente envia uma flag SYN, o servidor responde com um SYN/ACK e o cliente finaliza com uma flag ACK, uma troca de dados TCP é dessa forma. Com isso, a conexão é bem sucedida. O ACK irá fechar o 3WH para estabelecer a conexão, mas a partir do momento que você recebe o SYN/ACK, o serviço está ativo (a porta está aberta). Quando o serviço está inativo, o cliente envia uma flag SYN e o servidor envia uma flag RST/ACK como resposta. Ou seja, a porta está fechada. ![](/files/-MWGcHIRorHXZG_c8LPk) ### Diferenças entre os tipos de scan O TCP connect, consome muito tráfego em uma rede, visto que é necessário completar o three-way-handshake cada vez que for se comunicar, então acaba sendo muito barulhento. O Half Open / Syn Scan já consome menos tráfego numa rede, visto que ao invés de estabelecer o 3WH, ele envia no final uma flag RST encerrando a comunicação, sendo assim bem menos barulhento e consumindo menos tráfego em uma rede. Veremos isso na prática. Para isso, abri a porta 4444 em minha máquina para realizar os testes de scan. Scaneando nessa porta utilizando o tcp connect. ``` ┌──(user㉿kali)-[~/Desktop] └─$ sudo nmap -sT -p 4444 192.168.2.134 Starting Nmap 7.91 ( https://nmap.org ) at 2021-07-31 09:47 EDT Nmap scan report for 192.168.2.134 Host is up (0.00020s latency). PORT STATE SERVICE 4444/tcp open krb524 Nmap done: 1 IP address (1 host up) scanned in 0.26 seconds ``` Assim que o scan termina, percebe-se que a conexão foi encerrada. ``` ┌──(user㉿kali)-[~/Desktop] └─$ nc -nlvp 4444 listening on [any] 4444 ... connect to [192.168.2.134] from (UNKNOWN) [192.168.2.134] 60814 ┌──(user㉿kali)-[~/Desktop] └─$ ``` Agora, abrindo a porta novamente e realizando um Syn Scan. ``` ┌──(user㉿kali)-[~/Desktop] └─$ sudo nmap -sS -p 4444 192.168.2.134 Starting Nmap 7.91 ( https://nmap.org ) at 2021-07-31 09:49 EDT Nmap scan report for 192.168.2.134 Host is up (0.000082s latency). PORT STATE SERVICE 4444/tcp open krb524 Nmap done: 1 IP address (1 host up) scanned in 0.06 seconds ``` Percebe-se que a conexão não foi finalizada e não foi gerado log. ``` ┌──(user㉿kali)-[~/Desktop] └─$ nc -nlvp 4444 listening on [any] 4444 ... ``` Com isso percebemos a diferença, o syn scan para realizar scan é mais silencioso. ### Analisando o consumo de um scan Ao realizarmos um scan, temos que ficar atento a quantidade que ele irá consumir de uma rede, é ideal que o quanto menos for, melhor. Para isso, podemos utilizar o iptables para analisar a quantidade de pacotes que será enviado/recebido em um scan. Temos que configurar para visualizar os pacotes que entram e sai da própria máquina. Aplicando a regra para aceitar a entrada e saída e logo após isso exibindo as informações. ``` ┌──(root💀kali)-[/home/user/Desktop] └─# iptables -A INPUT -s 192.168.2.134 -j ACCEPT ┌──(root💀kali)-[/home/user/Desktop] └─# iptables -A OUTPUT -d 192.168.2.134 -j ACCEPT ┌──(root💀kali)-[/home/user/Desktop] └─# iptables -nvL Chain INPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 0 0 ACCEPT all -- * * 192.168.2.134 0.0.0.0/0 Chain FORWARD (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 0 0 ACCEPT all -- * * 0.0.0.0/0 192.168.2.134 ``` Com isso, podemos fazer o scan para realizar o teste. Vamos começar com o TCP connect. ``` ┌──(user㉿kali)-[~/Desktop] └─$ sudo nmap -sT -p 80 -Pn 192.168.2.134 Host discovery disabled (-Pn). All addresses will be marked 'up' and scan times will be slower. Starting Nmap 7.91 ( https://nmap.org ) at 2021-07-31 09:55 EDT Nmap scan report for 192.168.2.134 Host is up (0.000068s latency). PORT STATE SERVICE 80/tcp open http Nmap done: 1 IP address (1 host up) scanned in 0.06 seconds ``` ``` ┌──(root💀kali)-[/home/user/Desktop] └─# iptables -nvL Chain INPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 4 224 ACCEPT all -- * * 192.168.2.134 0.0.0.0/0 Chain FORWARD (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 4 224 ACCEPT all -- * * 0.0.0.0/0 192.168.2.134 ``` Foram enviados 4 pacotes, com tamanho de 224 bytes. Para continuar os testes, precisamos zerar as configurações porque ele irá somar as quantidades anteriores. Utilizamos **iptables -Z** para zerar. Agora, vamos utilizar o Syn Scan, ou Half Open. ``` ┌──(user㉿kali)-[~/Desktop] └─$ sudo nmap -sS -p 80 -Pn 192.168.2.134 Host discovery disabled (-Pn). All addresses will be marked 'up' and scan times will be slower. Starting Nmap 7.91 ( https://nmap.org ) at 2021-07-31 09:56 EDT Nmap scan report for 192.168.2.134 Host is up (0.000038s latency). PORT STATE SERVICE 80/tcp open http Nmap done: 1 IP address (1 host up) scanned in 0.05 seconds ``` ``` ┌──(root💀kali)-[/home/user/Desktop] └─# iptables -nvL Chain INPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 3 128 ACCEPT all -- * * 192.168.2.134 0.0.0.0/0 Chain FORWARD (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 3 128 ACCEPT all -- * * 0.0.0.0/0 192.168.2.134 ``` Foram enviados 3 pacotes, com mesmo tamanho de 128 bytes. Agora, vamos fazer um scan em todas as portas de um host. (O parâmetro **-p-** significa todas as portas). Primeiro com TCP connect. ``` ┌──(root💀kali)-[/home/user/Desktop] └─# nmap -sT -p- -Pn 192.168.2.134 Host discovery disabled (-Pn). All addresses will be marked 'up' and scan times will be slower. Starting Nmap 7.91 ( https://nmap.org ) at 2021-07-31 10:16 EDT Nmap scan report for 192.168.2.134 Host is up (0.000079s latency). Not shown: 65534 closed ports PORT STATE SERVICE 80/tcp open http Nmap done: 1 IP address (1 host up) scanned in 2.06 seconds ``` ``` ┌──(root💀kali)-[/home/user/Desktop] └─# iptables -nvL Chain INPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 131K 6554K ACCEPT all -- * * 192.168.2.134 0.0.0.0/0 Chain FORWARD (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 131K 6554K ACCEPT all -- * * 0.0.0.0/0 192.168.2.134 ``` Esse foi o consumo. Agora faremos com o Syn Scan. ``` ┌──(root💀kali)-[/home/user/Desktop] └─# nmap -sS -p- -Pn 192.168.2.134 Host discovery disabled (-Pn). All addresses will be marked 'up' and scan times will be slower. Starting Nmap 7.91 ( https://nmap.org ) at 2021-07-31 10:17 EDT Nmap scan report for 192.168.2.134 Host is up (0.0000030s latency). Not shown: 65534 closed ports PORT STATE SERVICE 80/tcp open http Nmap done: 1 IP address (1 host up) scanned in 0.66 seconds ``` ``` ┌──(root💀kali)-[/home/user/Desktop] └─# iptables -nvL Chain INPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 131K 5505K ACCEPT all -- * * 192.168.2.134 0.0.0.0/0 Chain FORWARD (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes) pkts bytes target prot opt in out source destination 131K 5505K ACCEPT all -- * * 0.0.0.0/0 192.168.2.134 ``` Esse foi o consumo. Podemos ver uma diferença na quantidade de bytes. Podemos perceber que dependendo não é vantajoso utilizar um scan dessa forma. O mais ideal seria criar um personalizado com determinadas portas. ``` # nmap -sS -p 21,25,80,443,8080,3306 -Pn ``` Assim haverá bem menos tráfego e será enviado uma quantidade muito menor de bytes :) Quando formos fazer um scan em um host, temos que ficar atento para fazer um scan completo, visto que uma porta pode ter seu número alterado e por padrão, o nmap só varre as 1000 principais. Com isso, se não especificarmos com o parâmetro **-p- ou -p 1-65535**, ele não irá achar uma porta específica. Ex: alterando a porta do SSH para 22999, com o scan padrão ele não irá encontrar. Também é interessante fazer uma varredura por UDP, porque pode haver alguns recursos que estão rodando por UDP. ![](/files/-MWH54JTtmjeThYdJ77q) Mas há uma ambiguidade no UDP, porque como vemos na imagem, quando enviamos um pacote para a porta UDP e ela estiver aberta, vai ter o mesmo comportamento quando ela está configurada em DROP no firewall. Caso ela esteja fechada, terá o mesmo comportamento se estiver configurada em REJECT no firewall. Como podemos ter certeza então se está aberta ou não? Podemos então, ao scanear com o nmap, passar o parâmetro -V para interagir e enumerar os serviços, rodando os scripts NSE que ele possui. ``` # nmap -v -sUV -p 161 ```