> For the complete documentation index, see [llms.txt](https://mysther.gitbook.io/knowledge-base/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://mysther.gitbook.io/knowledge-base/ataques/tools/nmap.md). # NMAP {% hint style="info" %} **NOTA**: Use sempre o Nmap com permissões de root, pois só assim ele será capaz de montar os pacotes corretamente e trazer melhores resultados. {% endhint %} ### Atualizando o Nmap ```bash nmap --script-updatedb ``` ### NSE (Nmap Scripting Engine) Script automatizados escrito em linguagem Lua, que pode realizar ataques de Brute Force, enumeração de informações, detecção de vulnerabilidades, etc. Todos os scritps NSE estão localizadas em `/usr/share/nmap/scripts/`. #### Descrição do Script ```bash nmap --script-help ``` #### Executando um script ```bash nmap --script= -p ``` ### ### Exibindo as Interfaces Mostra as interfaces de rede e algumas informações adicionais ```bash nmap --iflist ``` ### Definindo a Interface Realiza o scanner especificando qual interface de rede irá utilizar ```bash nmap -e ``` ### Trabalhando com IPv6 A opção `-6` define que é um scanner em IPv6 e o `::1` é o endereço de loopback IPv6 ```bash nmap -6 ::1 ``` ### Utilizando Proxy Caso precise, utilize um proxy para camuflar seu IP ```bash nmap --proxies ``` ### Selecionando as Portas {% hint style="info" %} **OBS.:** Por padrão, o Nmap varre somente até a porta 1024 e portas superiores importantes, como a 3306 do MySQL {% endhint %} ```bash # Varrendo a porta 80 nmap -p80 # Varrendo todas as portas nmap -p1-65535 # ou nmap -p* # ou nmap -p- # Varrendo portas selecionadas nmap -p80,153,443 # Varrendo range de portas nmap -p80-83 # Buscando por todas as portas que trabalham com serviço HTTP nmap -p http* ``` ### Port Spoofing Realiza um `Port Spoofing`, ou seja, o alvo vai pensar que a requisição está partindo da porta 53. Isso é útil para enganar firewall, pois geralmente quando se acessa uma porta, esse acesso é realizado por portas altas (acima de 1024), por exemplo, ao acessarmos o FTP (21), utilizamos uma porta aleatória (ex 50301) e quando forçamos uma porta baixa, dificulta o trabalho do firewall para rastrear um Port Scanner ```bash nmap -p80 -g53 ``` ### ### Spoof MAC No lugar de ``, pode-se colocar também nome de fabricantes como `Dell`, `Apple`, etc, assim o nmap já emula um MAC Address compatível com o fabricante ```bash nmap --spoof-mac ``` ### Decoy (Chamariz) Este sem dúvida é um bom trick para fazer bypass em IDS, pois podemos realizar um scan utilizando IP's aleatórios, a fim de confundir o IDS. Dependendo da situação, nosso IP nem se quer é bloqueado, pois o IDS registrou somente alguns dos IP's falsos que enviamos, então o nosso IP passou despercebido. Podemos então, falsificar o IP, da seguinte forma" ```bash nmap -D 192.168.1.2,192.168.1.10,192.168.1.78 ``` Caso não queira ficar definindo o IP manualmente, use o modo random: ```bash nmap -D RND: ``` ### Idle Scan Para saber o IP da máquina zumbi, veja no metasploit como fazer isso ```bash nmap -PN -sI ``` ### ### Determinando Protocolos com Portas Os comandos abaixo especifica uma determinada porta para trabalhar com determinado protocolo, porém todas as outras portas serão scaneadas. Utilize o `-p` caso queira filtrar as portas: ```bash # Scan utilizando TCP/SYN na porta 80 nmap -PS80 # Scan utilizando TCP/ACK na porta 80 nmap -PA80 # Scan utilizando UDP na porta 80 nmap -PU80 # Scan utilizando SCTP na porta 80 nmap -PY80 # Scan utilizando ICMP Echo na porta 80 nmap -PE80 # Scan utilizando ICMP Timestamp na porta 80 nmap -PP80 # Scan utilizando IP/Ping na porta 80 nmap -PO80 # Scan utilizando ARP/Ping na porta 80 nmap -PR80 ``` ### SYN Stealth Scan Não completa as 3 etapas do Three-way Wayhandshake `SYN - SYN/ACK - ACK`. Só vai até o segundo passo (SYN/ACK).\ Isso dificulta os firewalls a localizar o scan, pois ele faz o scan com menos ruído. ```bash nmap -sS ``` ### Varredura sem Portas Sem varredura de porta. Portas fechadas enviam um pacote `RST` como resposta a pacotes `FIN`, enquanto portas abertas ignoram esses pacotes. Nenhuma flag é ligada no pacote `FIN`.\ Este substitui a antiga opção `-sP`. **OBS.:** Esse método não funciona com a plataforma Windows, uma vez que a Microsoft não seguiu RFC 973 ```bash nmap -sn ``` ### Varredura sem Portas (Somente IP's) Comando semelhante ao de cima, porém esse filtra para nos retornar somente os IP's ```bash sudo nmap -sn 192.168.0.0/24 | grep for | cut -d " " -f5,6 ``` ### Mapeando Regras de Firewall O objetivo desta varredura é mapear as regras de um firewall para determinar se o mesmo faz tratamento completo de conexão ou não. Esse scan inicia uma comunicação com o alvo usando uma flag de confirmação `ACK` ligada (último passo do Handshake de 3 vias) sem nem mesmo ter enviado alguma solicitação. Uma resposta reset (RST) indica que a porta consultada não está sendo filtrada. Os únicos resultados neste tipo de varredura são: * `Filtered`: A porta está protegida por firewall * `Unfiltered`: A porta não está protegida por firewall ```bash nmap -sA ``` ### TCP Connect() Scan É a técnica mais básica de TCP scanning. É utilizada a chamada de sistema (system call) `connect()` que envia um sinal as portas ativas. Caso a porta esteja aberta recebe como resposta `connect()`. É um dos scan mais rápido e consegue retornar mais informações que o `-sS`, pois completa o Handshake de 3 vias, porém é fácil de ser detectado, devido ao seu alto ruído ```bash nmap -sT ``` ### UDP Scan Este método é utilizado para determinar qual porta UDP está aberta em um host. A técnica consiste em enviar um pacote UDP de 0 byte para cada porta do host. Se for recebida uma mensagem `ICMP Port Unreachable`, então a porta está fechada, senão a porta pode estar aberta. Para variar um pouco, a Microsoft ignorou a sugestão da RFC e com isso a varredura de máquinas Windows é muito rápida. ```bash nmap -sU ``` É comum recerbemos `open|filtered` como resposta de uma porta UDP. Caso isso ocorra, podemos fazer o nmap executar alguns scripts NSE para tentar identificar o serviço (e sua respectiva versão) da determinada porta e trazer assim um resultado mais preciso. Esse processo também se aplica para portas TCP, pois é o mesmo que `-sV`. ```bash nmap -p -sUV ``` ### TCP e UDP ao mesmo tempo ```bash nmap -sS -sU -p T:22,80,111,U:161 -sV -A -sC ``` ### ### TCP NULL Envia uma flag Nula, se receber uma resposta `TCP RST`, a porta está fechada e, caso não tenha resposta, significa que a porta está aberta ```bash nmap -sN ``` ### Script Executa scripts básicos (semelhante ao `script=default`) que somente realizam scan e jamais atacam de fato, como Brute Force, DoS, etc ```bash nmap -sC ``` ### Scan FIN Scan utilizando o flag `FIN`, útil para burlar firewalls ```bash nmap -sF ``` ### Script Scan utilizando o flag `FIN`, útil para burlar firewalls ```bash nmap -sF ``` ### Xmas Scan Utiliza `Xmas Scan`, ou seja, todas as flags. Quase todos os servidores bloqueiam esse tipo de scan ```bash nmap -sX ``` ### Top Ports Pega as 10 primeiras portas principais ```bash nmap --top-ports 10 ``` ### Versionamento Retorna o versionamento das portas como versão do Apache, SSH, SMTP, etc ```bash nmap -sV ``` ### Intensidade Parâmetro adicionado do `-sV` para definir a intensidade do versionamento de porta. Essa intensidade varia de 0 a 9, sendo 0 o default e 9 o mais intensivo possível ```bash nmap -sV --version-intensity 9 ``` ### Alvos Aleatórios Realiza um scanner em 4 alvos aleatórios na rede ```bash nmap -iR 4 192.168.0.0/24 ``` ### Pegando o Sistema Operacional Ao realizar esse tipo de scan, podemos passar mais informações para o nmap, como portas que sabemos que estão abertas, opção `-sV` para versionar, etc, assim aumenta a probabilidade de conseguirmos descobrir o SO. #### Modo Simples ```bash nmap -O ``` #### Modo Agressivo ```bash nmap -O -osscan_guess ``` ### Fast Mode Filtra somente as portas principais ```bash nmap -F ``` ### Varredura sem usar Ping Útil para os burlar sistemas que bloqueam o ICMP ```bash nmap -P0 ``` O Nmap trabalha com o `hping3` (programa muito bom que foi descontinuado desde 2005) integrado. Para utilizá-lo, use o `nping` (também como `root`) ```bash sudo nping -c 2 --icmp --icmp-type time ``` ### Com/Sem Resolução de Nome ```bash # Não resolve o nome do alvo quando escaneia pelo IP nmap -n # Este sempre resolve o nome do alvo nmap -R ``` ### Agressive Scan Ativa o script enginer padrão com um scanner bem refinado, trazendo assim diversas informações, como se estivesse utilizando vários parâmetros como `-sC`, `-sV` e `--traceroute` de uma só vez ```bash nmap -A ``` ### Ping Null Ignora as opções de descoberta de host, pois não utiliza ping ```bash nmap -Pn ``` ### TCP Null Também mostra todas as máquinas que estão na rede, pois utiliza TCP NULL na flag. Desse modo faz com que não varra as portas e utilize somente a varredura ARP ```bash nmap -sn -PR 192.168.0.0/24 ``` ### Alvos a Partir de um Arquivo Lê um arquivo com os IP's a serem scaneados. Esse arquivo deve ter cada IP em uma linha ```bash nmap -iL ``` ### Excluindo um Alvo Caso esteja usando o `-iL` ou um `192.168.0.0/24` e deseja excluir determinado IP, utilize o `--exclude` ```bash nmap --exclude -iL # ou nmap 192.168.0.0/24 --exclude ``` ### Excluindo Alvos com Arquivo Varre todos os IP's, exceto os que estão contidos no arquivo ```bash nmap 192.168.0.0/24 --excludefile ``` ### Random Host com Pausas Não utilize esse scan em um host alvo, mas sim em toda a rede. O nmap vai fazer um scan em um host, vai pular para outro, depois outro, depois volta no primeiro host para continuar o scan, e assim por diante, para dificultar o que seja pego por um IDS ```bash nmap --randomize-hosts 192.168.0.0/24 ``` ### Bypass ICMP Máscara de endereço ICMP. Utilizado quando o host está configurado para ignorar mensagens ICMP ECHO, mas não pode ignorar outros tipos de mensagens ICMP ```bash nmap -PM ``` ### Fragment Packets Fragmenta os pacotes. Utilizado quando o alvo utiliza um dispositivo de filtagem de pacotes simples como firewall. Essa opção divide o cabeçalho TCP de 20 bytes em 3 pacotes, sendo 2 pacotes com 8 bytes e 1 pacote com 4 bytes. Isso deixa o scan com mais ruído, mas ao mesmo tempo fica mais difícil para o IDS detectar ```bash nmap -f ``` ### Cabeçalho Personalizado Envia um cabeçalho normal e insere bytes (nesse caso 80) de textos aleatórios adicionais no cabeçalho dos pacotes, para confundir o firewall que acha que são pacotes verdadeiros. Utilize em Pings e Port Scans. É um pouco mais lento, porém é mais discreto ```bash nmap --data-length 80 ``` ### Mensagens nos Pacotes Irá enviar a string "Hackeado!" nos pacotes. Os administradores de rede poderão ver essa mensagem no pacote/log. Serve só para irritar alguém ```bash nmap --data-string "Hackeado!" ``` ### Checksum Checksum é útil para validar se os pacotes TCP/IP chegam íntegros. Bad CheckSum utiliza Checksum mal configurado, alterando a sequência do Checksum, tirando assim a validação e fazendo com que o firewall se perca. Caso não retorne nada , é porque a rede está o checksum bem configurado ```bash nmap --badsum ``` ### Maximum Transmition Unique Semelhante a opção `-f`, porém temos a liberdade de escolher quantos bytes queremos dividir, lembrando que o MTU, deve ser sempre um valor divisível por 8. Por padrão, vem como MTU 24. Quanto menor o MTU, mais pacotes são fragmentados e enviados e, ao mesmo tempo mais difícil fica para o firewall detectar a varredura ```bash nmap -mtu 32 ``` ### Flag de Privilégio Adiciona a Flag de privilégio para acessar o host. Os firewalls checa essa flag para determinar você está na rede e pode ou não acesso o alvo. Esse parâmtro é muito útil, principalmente para realizar varreduras em IP's externos ```bash nmap --privileged ``` ### Enviando IP ao invés de ARP Por padrão o nmap utiliza o protocolo ARP pra fazer varredura. Utilize esse parâmetro para enviar IP no lugar de ARP ```bash nmap --send-ip ``` ### Mostrando os pacotes Mostra os pacotes que estão sendo enviados ```bash nmap --packet-trace ``` ### Salvando os Resultados É possível salvar os resultados do Nmap em alguns formatos ```bash # Output Normal, salva o resultado em um formato legível nmap -oN # Salva a saída em um arquivo separado nmap -o # Salva o resultado em um formato legível para outras ferramentas como o AMAP nmap -oM # Salva o resultado em um arquivo chamado outfile nmap -oN # Saída do terminal salvo em um arquivo GREPable (delimitado por tabulação), podendo assim ser lido por outros programas, como o GREP nmap -oG

# Salva o resultado em um arquivo XML nmap -oX

# Saída de arquivo semelhante ao comando -oG, porém escrito em "leetspeak", letras escritas com números utiliza por "Script Kiddies". Não utilizar isso em conteúdos profissionais nmap -oS

# Salva o resultado em todos os formatos de arquivo (XML, nmap e gnmap) nmap -oA

``` ### Velocidade da Varredura #### Rápido ```bash nmap -p- -T4 --min-parallelism=50 --min-rate=3000 ``` #### Lento Quanto mais devagar o Scan, mais difícil de ser detectado será e quanto mais rápido, o inverso. O Nmap também pode trazer falsos-positivos quando está realizando um Scan em uma velocidade muito rápida ```bash # Mais demorado (média de espera de 5 minutos para cada requisição), utilizado em redes onde o scan não pode ser detectado. O parâmetro "max_scan_delay" é ignorado. # Pode ser substituído por: --timing paranoid -T0 # Mais rápido que o T0, mantendo ainda sua discrição para não fazer ruídos na rede. Reduz o scan_delay par 15 segundos. O parâmetro "max_scan_delay" é ignorado # Pode ser substituído por: --timing sneaky -T1 # Mais rápido que o T0 e o T1. É o último scan utilizando a técnica "scanning serial". A partir deste, pode usar o "max_scan_delay" # Pode ser substituído por: --timing polite -T2 # É o scan default do nmap, caso não seja definido um. É o primeiro a usar a técnica de processamento paralelo, enviando vários probes simultaneamente e aumentando a velocidade # Pode ser substituído por: --timing normal -T3 # Velocidade mais ráido que o T3 # Pode ser substituído por: --timing agressive -T4 # É o scan mais rápido de todos, porém pode causar certos erros devido a sua alta velocidade # Pode ser substituído por: --timing isane -T5 ``` ### Traceroute Realiza um traceroute junto com o port scanner ```bash nmap --traceroute ``` ### Modo Debug Este é mais voltado para os desenvolvedores, muitas coisas não são legíveis até mesmo para programadores e administradores de redes ```bash nmap -d ``` ### Verbose O Verbose Mode pode ser acessado em dois níveis ```bash # Modo verbose nmap -v # Modo verbose mais detalhado nmap -vv ``` ### Entendendo o Porque do Resultado Explica o porque que o Nmap definiu determinada porta como `aberta`, `fechada` ou `filtrada` ```bash nmap --reason ```