Resumo do Nmap (ESP)

Reading time: 19 minutes

nmap -sV -sC -O -n -oA nmapscan 192.168.0.1/24

Parameters

IPs to scan

• <ip>,<net/mask>: Indica os ips diretamente
• -iL <ips_file>: list_IPs
• -iR <number>: Número de Ips aleatórios, você pode excluir Ips possíveis com --exclude <Ips> ou --excludefile <file>.

Equipment discovery

Por padrão Nmap lança uma fase de discovery consistindo de: -PA80 -PS443 -PE -PP

• -sL: Não é invasivo, lista os alvos fazendo requisições DNS para resolver nomes. É útil para saber se por exemplo www.prueba.es/24 todos os Ips são nossos alvos.
• -Pn: No ping. Útil se você sabe que todos estão ativos (caso contrário, pode perder muito tempo, mas essa opção também produz falsos negativos dizendo que não estão ativos), previne a fase de discovery.
• -sn : No port scan. Após completar a fase de reconnaissance, não escaneia portas. É relativamente stealthy, e permite um scan de rede pequeno. Com privilégios envia um ACK (-PA) para 80, um SYN(-PS) para 443 e um echo request e um Timestamp request, sem privilégios sempre completa conexões. Se o alvo é a rede, usa apenas ARP(-PR). Se usado com outra opção, apenas os pacotes da outra opção são descartados.
• -PR: Ping ARP. É usado por padrão ao analisar máquinas na nossa rede, é mais rápido que usar pings. Se não quiser usar pacotes ARP use --send-ip.
• -PS <ports>: Envia pacotes SYN aos quais, se responder SYN/ACK está open (responde com RST para não finalizar a conexão), se responder RST está closed e se não responder está unreachable. Caso não possua privilégios, uma conexão completa é automaticamente usada. Se não forem fornecidos ports, usa 80.
• -PA <ports>: Igual ao anterior mas com ACK, combinar ambos dá melhores resultados.
• -PU <ports>: O objetivo é o contrário, são enviados a portas que se espera estejam closed. Alguns firewalls só verificam conexões TCP. Se estiver closed responde com port unreachable, se responder com outro icmp ou não responder fica como destination unreachable.
• -PE, -PP, -PM : ICMP PINGS: echo reply, timestamp e addresmask. São lançados para descobrir se o alvo está ativo.
• -PY<ports>: Envia probes SCTP INIT para 80 por padrão, pode responder INIT-ACK(open) ou ABORT(closed) ou nada ou ICMP unreachable(inactive).
• -PO <protocols>: Indica um protocolo nos headers, por padrão 1(ICMP), 2(IGMP) e 4(Encap IP). Para ICMP, IGMP, TCP (6) e UDP (17) os headers de protocolo são enviados, para o resto só o header IP é enviado. O propósito é que, devido à malformação dos headers, seja respondido Protocol unreachable ou respostas do mesmo protocolo para saber se está up.
• -n: No DNS
• -R: DNS always

Port scanning techniques

• -sS: Não completa a conexão então não deixa rastro, muito bom se puder ser usado.(privileges) É o usado por padrão.
• -sT: Completa a conexão, portanto deixa rastro, mas pode ser usado com certeza. Por padrão sem privilégios.
• -sU: Mais lento, para UDP. Principalmente: DNS(53), SNMP(161,162), DHCP(67 e 68), (-sU53,161,162,67,68): open(reply), closed(port unreachable), filtered (outro ICMP), open/filtered (nada). No caso de open/filtered, -sV envia numerosas requisições para detectar alguma das versões que nmap suporta e pode detectar o estado real. Aumenta muito o tempo.
• -sY: SCTP protocol falha em estabelecer a conexão, então não há logs, funciona como -PY
• -sN,-sX,-sF: Null, Fin, Xmas, podem penetrar alguns firewalls e extrair informação. Baseiam-se no fato de que máquinas compatíveis com o padrão devem responder com RST a todas requisições que não têm SYN, RST ou ACK setados: open/filtered(nada), closed(RST), filtered (ICMP unreachable). Não confiável em WIndows, CIsco, BSDI e OS/400. Em unix sim.
• -sM: Maimon scan: Envia flags FIN e ACK, usado para BSD, atualmente irá retornar tudo como closed.
• -sA, sW: ACK e Window, é usado para detectar firewalls, para saber se as portas estão filtered ou não. O -sW distingue entre open/closed pois as open respondem com um valor de window diferente: open (RST com window diferente de 0), closed (RST window = 0), filtered (ICMP unreachable ou nada). Nem todas as máquinas funcionam assim, então se tudo aparecer closed, não está funcionando; se aparecerem algumas open, está funcionando bem; e se aparecerem muitas open e poucas closed, funciona ao contrário.
• -sI: Idle scan. Para casos em que há um firewall ativo mas sabemos que ele não filtra para certo Ip (ou quando queremos anonimato) podemos usar o zombie scanner (funciona para todas as portas), para procurar zombies possíveis podemos usar o scrpit ipidseq ou o exploit auxiliary/scanner/ip/ipidseq. Este scanner baseia-se no número IPID dos pacotes IP.
• --badsum: Envia o checksum errado, os computadores descartariam os pacotes, mas os firewalls poderiam responder algo, é usado para detectar firewalls.
• -sZ: "Weird" SCTP scanner, ao enviar probes com cookie echo fragments estes deveriam ser descartados se open ou responder com ABORT se closed. Pode passar por firewalls que init não passa, o ruim é que não distingue entre filtered e open.
• -sO: Protocol Ip scan. Envia headers inválidos e vazios nos quais às vezes nem mesmo o protocolo pode ser distinguido. Se chegar ICMP unreachable protocol está closed, se chegar unreachable port está open, se chegar outro erro, filtered, se nada chegar, open|filtered.
• -b <server>: FTPhost--> Usado para escanear um host a partir de outro, isso é feito conectando ao ftp de outra máquina e pedindo que ela envie arquivos para as portas que você quer escanear nessa outra máquina; conforme as respostas saberemos se estão open ou não. [<user>:<password>@]<server>[:<port>] Quase todos os ftp servers já não permitem mais isso e portanto tem pouco uso prático.

Focus Analysis

-p: Usado para especificar portas a escanear. Para selecionar todas as 65.335 portas: -p- ou -p all. Nmap tem uma classificação interna baseada em popularidade. Por padrão usa as top 1000 ports. Com -F (fast scan) analisa as top 100. Com --top-ports analisa esse número de top ports (de 1 a 65,335). Verifica portas em ordem aleatória; para prevenir isso, use -r. Podemos também selecionar portas específicas: 20-30,80,443,1024- (este último significa buscar a partir de 1024). Também podemos agrupar portas por protocolos: U:53,T:21-25,80,139,S:9. Podemos também escolher um intervalo dentro das portas populares do Nmap: -p [-1024] analisa até a porta 1024 das inclusas em nmap-services. --port-ratio Analisa as portas mais comuns dentro de uma razão entre 0 e 1

-sV Version scanning, a intensidade pode ser regulada de 0 a 9, default é 7.

--version-intensity Regulamos a intensidade, quanto menor for, só lançará os probes mais prováveis, mas não todos. Com isso podemos reduzir consideravelmente o tempo de scan UDP

-O Detecção de OS

--osscan-limit Para um scanner de host adequado, é necessário pelo menos uma porta open e uma closed. Se essa condição não for atendida e tivermos isto configurado, não tentará a predição do OS (economiza tempo)

--osscan-guess Quando a detecção de OS não é perfeita, faz com que tente mais

Scripts

--script |||[,...]

Para usar os scripts default, use -sC ou --script=default

Tipos disponíveis: auth, broadcast, default, discovery, dos, exploit, external, fuzzer, intrusive, malware, safe, version, and vuln

• Auth: executa todos os scripts de authentication disponíveis
• Default: executa os scripts básicos default da ferramenta
• Discovery: recupera informação do target ou victim
• External: script para usar recursos externos
• Intrusive: usa scripts considerados intrusive ao victim ou target
• Malware: verifica conexões abertas por código malicioso ou backdoors
• Safe: executa scripts não-intrusivos
• Vuln: descobre as vulnerabilidades mais conhecidas
• All: executa absolutamente todos os NSE extension scripts disponíveis

Para buscar scripts:

nmap --script-help="http-*" -> Those starting with http-

nmap --script-help="not intrusive" -> All except those

nmap --script-help="default or safe" -> Those in either or both

nmap --script-help="default and safe" --> Those in both

nmap --script-help="(default or safe or intrusive) and not http-*"

--script-args =,={=},={,}

--script-args-file

--script-help ||||all[,...]

--script-trace ---> Fornece info sobre como o script está progredindo

--script-updatedb

Para usar um script, basta digitar: nmap --script Script_Name target --> Ao usar o script, tanto o script quanto o scanner irão executar, então opções do scanner também podem ser adicionadas. Podemos adicionar "safe=1" para executar apenas os safe ones.

Time Control

Nmap pode modificar tempo em seconds, minutes, ms: --host-timeout argumentos 900000ms, 900, 900s, e 15m todos fazem o mesmo.

Nmap divide o número total de hosts a escanear em grupos e analisa esses grupos em blocos, então não passa ao próximo bloco até que todos tenham sido analisados (e o usuário não recebe atualizações até o bloco ser analisado). Desta forma, é mais ótimo para Nmap usar grupos grandes. Por padrão em class C, usa 256.

Isto pode ser alterado com --min-hostgroup ; --max-hostgroup (Ajusta tamanhos de grupo de scan paralelos)

Você pode controlar o número de scanners paralelos mas é melhor não fazê-lo (Nmap já incorpora controle automático baseado no estado da rede): --min-parallelism ; --max-parallelism

Podemos modificar o timeout RTT, mas geralmente não é necessário: --min-rtt-timeout , --max-rtt-timeout , --initial-rtt-timeout

Podemos modificar o número de tentativas: --max-retries

Podemos modificar o tempo de scan de um host: --host-timeout

Podemos modificar o tempo entre cada teste para desacelerar: --scan-delay ; --max-scan-delay

Podemos modificar o número de pacotes por segundo: --min-rate ; --max-rate

Muitas portas levam muito tempo para responder quando filtered ou closed. Se estamos interessados apenas nas open, podemos ir mais rápido com: --defeat-rst-ratelimit

Para definir quão agressivo queremos que o Nmap seja: -T paranoid|sneaky|polite|normal|aggressive|insane

-T (0-1)

-T0 --> Apenas escaneia 1 porta por vez e espera 5min até a próxima

-T1 and T2 --> Muito similares mas esperam apenas 15 e 0.4sec respectivamente entre cada teste

-T3 --> Operação default, inclui scanning paralelo

-T4 --> --max-rtt-timeout 1250ms --min-rtt-timeout 100ms --initial-rtt-timeout 500ms --max-retries 6 --max-scan-delay 10ms

-T5 --> --max-rtt-timeout 300ms --min-rtt-timeout 50ms --initial-rtt-timeout 250ms --max-retries 2 --host-timeout 15m --max-scan-delay 5ms

Firewall/IDS

Eles não permitem acesso a portas e analisam pacotes.

-f Para fragmentar pacotes, por padrão fragmenta em 8bytes após o header, para especificar esse tamanho usamos ..mtu (com isso, não use -f), o offset deve ser múltiplo de 8. Version scanners e scripts não suportam fragmentation

-D decoy1,decoy2,ME Nmap envia scanners mas com outros IP addresses como origem, assim escondem você. Se colocar ME na lista, Nmap irá te posicionar lá, é melhor colocar 5 ou 6 antes de você para mascarar completamente. IPs aleatórios podem ser gerados com RND: Para gerar de IPs aleatórios. Eles não funcionam com TCP version detectors sem conexão. Se você está dentro de uma rede, interessa usar IPs ativos, caso contrário será muito fácil descobrir que é o único ativo.

Para usar IPs aleatórios: nmap -D RND:10 Target_IP

-S IP Para quando Nmap não captura seu IP você tem que fornecê-lo com isto. Também serve para fazê-los pensar que outro target está escaneando eles.

-e Para escolher a interface

Muitos administradores deixam portas de entrada abertas para tudo funcionar corretamente e isso é mais fácil para eles do que achar outra solução. Estas podem ser portas DNS ou FTP... para encontrar essa vulnerabilidade Nmap incorpora: --source-port ;-g They are equivalent

--data Para enviar texto hexadecimal: --data 0xdeadbeef and --data \xCA\xFE\x09

--data-string Para enviar texto normal: --data-string "Scan conducted by Security Ops, extension 7192"

--data-length Nmap apenas envia headers, com isto conseguimos adicionar um número de bytes extras (que serão gerados randomicamente)

Para configurar completamente o pacote IP use --ip-options

Se desejar ver as opções nos pacotes enviados e recebidos, especifique --packet-trace. Para mais informação e exemplos de uso de IP options com Nmap, veja http://seclists.org/nmap-dev/2006/q3/52.

--ttl

--randomize-hosts Para tornar o ataque menos óbvio

--spoof-mac <MAC address, prefix, or vendor name> Para alterar o MAC exemplos: Apple, 0, 01:02:03:04:05:06, deadbeefcafe, 0020F2, and Cisco

--proxies Para usar proxies, às vezes um proxy não mantém tantas conexões abertas quanto o Nmap quer então o paralelismo precisará ser modificado: --max-parallelism

-sP Para descobrir hosts na nossa rede por ARP

Muitos administradores criam uma regra de firewall que permite que todos os pacotes vindos de uma porta particular passem (como 20,53 e 67), podemos dizer ao Nmap para enviar nossos pacotes a partir dessas portas: nmap --source-port 53 IP

Outputs

-oN file Normal output

-oX file XML output

-oS file Script kiddies output

-oG file Greppable output

-oA file All except -oS

-v level verbosity

-d level debugging

--reason Razão do host e estado

--stats-every time A cada esse tempo nos diz como está indo

--packet-trace Para ver quais pacotes saem, filtros podem ser especificados como: --version-trace ou --script-trace

--open mostra open, open|filtered e unfiltered

--resume file Outputs um resumo

Miscellaneous

-6 Permite IPv6

-A é o mesmo que -O -sV -sC --traceroute

Run time

Enquanto Nmap está rodando podemos mudar opções:

v / V Aumentar / diminuir o nível de verbosity

d / D Aumentar / diminuir o nível de debugging

p / P Ligar / desligar packet tracing

? Imprime uma tela de ajuda de interação em runtime

Vulscan

Nmap script que olha as versões dos serviços obtidas em uma DB offline (baixada de outras muito importantes) e retorna vulnerabilidades possíveis

As DBs que usa são:

1. Scipvuldb.csv | http://www.scip.ch/en/?vuldb
2. Cve.csv | http://cve.mitre.org
3. Osvdb.csv | http://www.osvdb.org
4. Securityfocus.csv | http://www.securityfocus.com/bid/
5. Securitytracker.csv | http://www.securitytracker.com
6. Xforce.csv | http://xforce.iss.net
7. Exploitdb.csv | http://www.exploit-db.com
8. Openvas.csv | http://www.openvas.org

Para baixar e instalar na pasta do Nmap:

wget http://www.computec.ch/projekte/vulscan/download/nmap_nse_vulscan-2.0.tar.gz && tar -czvf nmap_nse_vulscan-2.0.tar.gz vulscan/ && sudo cp -r vulscan/ /usr/share/nmap/scripts/

Você também precisará baixar os pacotes DB e adicioná-los em /usr/share/nmap/scripts/vulscan/

Uso:

Para usar todos: sudo nmap -sV --script=vulscan HOST_TO_SCAN

Para usar uma DB específica: sudo nmap -sV --script=vulscan --script-args vulscandb=cve.csv HOST_TO_SCAN

Speed Up Nmap Service scan x16

According to this post você pode acelerar a análise de service do nmap modificando todos os valores de totalwaitms em /usr/share/nmap/nmap-service-probes para 300 e tcpwrappedms para 200.

Além disso, probes que não têm um servicewaitms especificamente definido usam um valor default de 5000. Portanto, podemos ou adicionar valores a cada um dos probes, ou podemos compile nmap nós mesmos e alterar o valor default em service_scan.h.

Se você não quer mudar os valores de totalwaitms e tcpwrappedms no arquivo /usr/share/nmap/nmap-service-probes, você pode editar o parsing code tal que esses valores no arquivo nmap-service-probes sejam completamente ignorados.

Build a static Nmap for restricted environments

Em ambientes Linux hardenizados ou mínimos (containers, appliances), binários Nmap dinamicamente linkados frequentemente falham devido a loaders de runtime ou shared libraries ausentes (por exemplo, /lib64/ld-linux-x86-64.so.2, libc.so). Construir seu próprio Nmap estaticamente linkado e empacotar os dados NSE permite execução sem instalar pacotes do sistema.

High-level approach

• Use um clean amd64 Ubuntu builder via Docker.
• Build OpenSSL and PCRE2 como static libraries.
• Build Nmap linkando estaticamente e usando o libpcap/libdnet incluídos para evitar deps dinâmicos.
• Bundle NSE scripts e diretórios de data com o binário.

Discover target architecture (example)

uname -a
# If building from macOS/ARM/etc., pin the builder arch:
docker run --rm --platform=linux/amd64 -v "$(pwd)":/out -w /tmp ubuntu:22.04 bash -lc 'echo ok'

Passo 1 — Preparar toolchain

set -euo pipefail
export DEBIAN_FRONTEND=noninteractive
apt-get update && apt-get install -y --no-install-recommends \
build-essential ca-certificates curl bzip2 xz-utils pkg-config perl python3 file git \
automake autoconf libtool m4 zlib1g-dev

Passo 2 — Compilar OpenSSL estático (1.1.1w)

OSSL="1.1.1w"
curl -fsSLO "https://www.openssl.org/source/openssl-$OSSL.tar.gz"
tar xzf "openssl-$OSSL.tar.gz" && cd "openssl-$OSSL"
./Configure no-shared no-zlib linux-x86_64 -static --prefix=/opt/ossl
make -j"$(nproc)" && make install_sw
cd /tmp

Passo 3 — Compilar PCRE2 estático (10.43)

PCRE2=10.43
curl -fsSLO "https://github.com/PCRE2Project/pcre2/releases/download/pcre2-$PCRE2/pcre2-$PCRE2.tar.bz2"
tar xjf "pcre2-$PCRE2.tar.bz2" && cd "pcre2-$PCRE2"
./configure --disable-shared --enable-static --prefix=/opt/pcre2
make -j"$(nproc)" && make install
cd /tmp

Passo 4 — Compilar Nmap estático (7.98)

NMAP=7.98
curl -fsSLO "https://nmap.org/dist/nmap-$NMAP.tar.bz2"
tar xjf "nmap-$NMAP.tar.bz2" && cd "nmap-$NMAP"
export CPPFLAGS="-I/opt/ossl/include -I/opt/pcre2/include"
export LDFLAGS="-L/opt/ossl/lib -L/opt/pcre2/lib -static -static-libstdc++ -static-libgcc"
export LIBS="-lpcre2-8 -ldl -lpthread -lz"
./configure \
--with-openssl=/opt/ossl \
--with-libpcre=/opt/pcre2 \
--with-libpcap=included \
--with-libdnet=included \
--without-zenmap --without-ndiff --without-nmap-update
# Avoid building shared libpcap by accident
sed -i -e "s/^shared: /shared: #/" libpcap/Makefile || true
make -j1 V=1 nmap
strip nmap

Pontos-chave

• -static, -static-libstdc++, -static-libgcc forçam ligação estática.
• Usar --with-libpcap=included/--with-libdnet=included evita bibliotecas compartilhadas do sistema.
• Ajuste com sed neutraliza um alvo libpcap compartilhado, se presente.

Passo 5 — Empacotar o binário e os dados NSE

mkdir -p /out/nmap-bundle/nmap-data
cp nmap /out/nmap-bundle/nmap-linux-amd64-static
cp -r scripts nselib /out/nmap-bundle/nmap-data/
cp nse_main.lua nmap-services nmap-protocols nmap-service-probes \
nmap-mac-prefixes nmap-os-db nmap-payloads nmap-rpc \
/out/nmap-bundle/nmap-data/ 2>/dev/null || true

tar -C /out -czf /out/nmap-linux-amd64-static-bundle.tar.gz nmap-bundle

Notas de verificação e operações

• Use file no artefato para confirmar que ele está statically linked.
• Mantenha os dados NSE com o binary para garantir paridade de scripts em hosts sem Nmap instalado.
• Mesmo com um static binary, a execução pode ser bloqueada por AppArmor/seccomp/SELinux; DNS/egress ainda devem funcionar.
• Compilações determinísticas reduzem o risco da cadeia de suprimentos vs baixar binários opacos “static”.

Comando único (Dockerizado)

docker run --rm --platform=linux/amd64 -v "$(pwd)":/out -w /tmp ubuntu:22.04 bash -lc '
set -euo pipefail
export DEBIAN_FRONTEND=noninteractive
apt-get update && apt-get install -y --no-install-recommends \
build-essential ca-certificates curl bzip2 xz-utils pkg-config perl python3 file git \
automake autoconf libtool m4 zlib1g-dev

OSSL="1.1.1w"; curl -fsSLO "https://www.openssl.org/source/openssl-$OSSL.tar.gz" \
&& tar xzf "openssl-$OSSL.tar.gz" && cd "openssl-$OSSL" \
&& ./Configure no-shared no-zlib linux-x86_64 -static --prefix=/opt/ossl \
&& make -j"$(nproc)" && make install_sw && cd /tmp

PCRE2=10.43; curl -fsSLO "https://github.com/PCRE2Project/pcre2/releases/download/pcre2-$PCRE2/pcre2-$PCRE2.tar.bz2" \
&& tar xjf "pcre2-$PCRE2.tar.bz2" && cd "pcre2-$PCRE2" \
&& ./configure --disable-shared --enable-static --prefix=/opt/pcre2 \
&& make -j"$(nproc)" && make install && cd /tmp

NMAP=7.98; curl -fsSLO "https://nmap.org/dist/nmap-$NMAP.tar.bz2" \
&& tar xjf "nmap-$NMAP.tar.bz2" && cd "nmap-$NMAP" \
&& export CPPFLAGS="-I/opt/ossl/include -I/opt/pcre2/include" \
&& export LDFLAGS="-L/opt/ossl/lib -L/opt/pcre2/lib -static -static-libstdc++ -static-libgcc" \
&& export LIBS="-lpcre2-8 -ldl -lpthread -lz" \
&& ./configure --with-openssl=/opt/ossl --with-libpcre=/opt/pcre2 --with-libpcap=included --with-libdnet=included --without-zenmap --without-ndiff --without-nmap-update \
&& sed -i -e "s/^shared: /shared: #/" libpcap/Makefile || true \
&& make -j1 V=1 nmap && strip nmap

mkdir -p /out/nmap-bundle/nmap-data \
&& cp nmap /out/nmap-bundle/nmap-linux-amd64-static \
&& cp -r scripts nselib /out/nmap-bundle/nmap-data/ \
&& cp nse_main.lua nmap-services nmap-protocols nmap-service-probes nmap-mac-prefixes nmap-os-db nmap-payloads nmap-rpc /out/nmap-bundle/nmap-data/ 2>/dev/null || true \
&& tar -C /out -czf /out/nmap-linux-amd64-static-bundle.tar.gz nmap-bundle \
&& echo "===== OUTPUT ====="; ls -lah /out; echo "===== FILE TYPE ====="; file /out/nmap-bundle/nmap-linux-amd64-static || true
'

Referências

• Compiling static Nmap binary for jobs in restricted environments
• Static Nmap Binary Generator (helper tool)
• OpenSSL sources
• PCRE2 releases
• Nmap source tarballs