Resumo do Nmap (ESP)

Tip

Aprenda e pratique AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)
Aprenda e pratique Az Hacking: HackTricks Training Azure Red Team Expert (AzRTE) Navegue pelo catálogo completo do HackTricks Training para as trilhas de assessment (ARTA/GRTA/AzRTA) e Linux Hacking Expert (LHE).

Support HackTricks

• Confira os planos de assinatura!
• Junte-se ao 💬 grupo do Discord, ao grupo do telegram, siga @hacktricks_live no X/Twitter, ou confira a página do LinkedIn e o canal do YouTube.
• Compartilhe hacking tricks enviando PRs para os repositórios github HackTricks e HackTricks Cloud.

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

Parâmetros

IPs a escanear

• <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>.

Descoberta de equipamentos

Por padrão o Nmap lança uma fase de descoberta consistindo em: -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: Sem ping. Útil se você sabe que todos estão ativos (caso contrário, pode-se perder muito tempo, mas esta opção também produz falsos negativos dizendo que não estão ativos), impede a fase de descoberta.
• -sn : Sem varredura de portas. Após completar a fase de reconhecimento, não escaneia portas. É relativamente furtivo e permite uma varredura pequena da rede. 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 ele completa sempre as conexões. Se o alvo for 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 computadores 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 responderem SYN/ACK estão abertos (responderão com RST para não finalizar a conexão), se responderem RST estão fechados e se não responderem estão inacessíveis. Caso não tenha privilégios, uma conexão total é usada automaticamente. Se não forem dadas portas, usa 80.
• -PA <ports>: Como o anterior mas com ACK; combinar ambos dá melhores resultados.
• -PU <ports>: O objetivo é o oposto, são enviados para portas que se espera estarem fechadas. Alguns firewalls só verificam conexões TCP. Se estiver fechada responde com port unreachable, se responder com outro icmp ou não responder fica como destination unreachable.
• -PE, -PP, -PM : PINGS ICMP: 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 os demais apenas o header IP é enviado. O propósito é que, devido à malformação dos headers, seja respondido Protocol unreachable ou respostas do próprio protocolo para saber se está up.
• -n: Sem DNS
• -R: DNS sempre
• --system-dns: Força o resolvedor do SO em vez do parallel stub resolver do Nmap. Útil quando /etc/hosts, split-DNS, ou plugins de resolvedor retornam dados que as queries diretas do Nmap não retornam. É mais lento, e desde o Nmap 7.96 as forward lookups já são paralelizadas, geralmente só é necessário por compatibilidade de resolvedor.
• --dns-servers <server[,server],...>: Força servidores DNS específicos para reverse lookups. Útil em avaliações internas para consultar resolvers autoritativos ou internos diretamente, ou para desviar o tráfego de -sL/reverse-DNS dos resolvers padrão do testador.

Técnicas de varredura de portas

• -sS: Não completa a conexão então não deixa rastro, muito bom se puder ser usado. (privilegios) É 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). Em caso de open/filtered, -sV envia diversos requests para detectar qualquer das versões que nmap suporta e pode detectar o estado real. Aumenta muito o tempo.
• -sY: Protocolo SCTP 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 todas as solicitações que não tenham SYN, RST ou ACK: 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 retornará todos como closed.
• -sA, sW: ACK e Window, é usado para detectar firewalls, para saber se as portas estão filtradas ou não. O -sW distingue entre open/closed já que as abertas respondem com um window value diferente: open (RST com window diferente de 0), closed (RST window = 0), filtered (ICMP unreachable ou nada). Nem todos os computadores funcionam assim, então se tudo aparecer closed, não está funcionando; se alguns aparecerem open, está funcionando bem; e se muitos aparecerem open e poucos closed, está funcionando invertido.
• -sI: Idle scan. Para casos em que há um firewall ativo mas sabemos que ele não filtra para certo IP (ou quando simplesmente queremos anonimato) podemos usar o zombie scanner (funciona para todas as portas). Para procurar possíveis zombies 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: Scanner SCTP “Weird”, ao enviar probes com cookie echo fragments estes deveriam ser descartados se abertos ou respondidos com ABORT se fechados. Pode passar por firewalls que init não passa; o ruim é que não distingue entre filtered e open.
• -sO: Varredura por protocolo IP. Envia headers ruins e vazios em que às vezes nem se consegue distinguir o protocolo. 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, isto é feito conectando-se ao ftp de outra máquina e pedindo que ela envie arquivos para as portas que você quer escanear a partir dessa outra máquina; de acordo com as respostas saberemos se estão abertas ou não. [<user>:<password>@]<server>[:<port>] Quase todos os servidores ftp hoje não permitem mais isto, portanto tem pouco uso prático.

Análise Focada

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

-sV Scanning de versão, a intensidade pode ser regulada de 0 a 9, o padrão é 7.

–version-intensity Regulamos a intensidade, quanto menor for, apenas lançará as probes mais prováveis, mas não todas. Com isso, podemos encurtar consideravelmente o tempo de varredura UDP

–version-light Alias de --version-intensity 2. Muito útil para uma primeira passada contra ranges grandes ou serviços UDP lentos.

–version-all Alias de --version-intensity 9. Força todas as probes e é útil quando um serviço responde apenas a probes raras.

–allports Força a detecção de versão em portas excluídas por nmap-service-probes (notavelmente TCP/9100). Cuidado: em algumas impressoras ou listeners raw socket isso pode fazê-los imprimir os dados do probe.

-O Detecção de SO

–osscan-limit Para uma varredura adequada do host, é necessário pelo menos uma porta aberta e uma porta fechada. Se essa condição não for atendida e tivermos definido isto, não tentará previsão de SO (economiza tempo)

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

Scripts

–script |||[,…]

Para usar scripts padrão, use -sC ou –script=default

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

• Auth: executa todos os scripts de autenticação disponíveis
• Default: executa scripts básicos padrão da ferramenta
• Discovery: recupera informação do alvo ou vítima
• External: script para usar recursos externos
• Intrusive: usa scripts considerados intrusivos ao alvo ou vítima
• 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 scripts de extensão NSE disponíveis

Para procurar scripts:

nmap –script-help=“http-*” -> Aqueles que começam com http-

nmap –script-help=“not intrusive” -> Todos exceto esses

nmap –script-help=“default or safe” -> Aqueles em um ou outro

nmap –script-help=“default and safe” –> Aqueles em ambos

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 serão executados, então opções do scanner também podem ser adicionadas. Podemos adicionar “safe=1” para executar apenas os seguros.

Controle de Tempo

Nmap pode modificar tempo em segundos, minutos, ms: –host-timeout argumentos 900000ms, 900, 900s, e 15m fazem a mesma coisa.

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

Isto pode ser alterado com –min-hostgroup ; –max-hostgroup (Ajusta tamanhos de grupo de varredura paralela)

Você pode controlar o número de scanners paralelos, mas é melhor não o fazer (o 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 escaneamento 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 demoram muito para responder quando filtradas ou fechadas. Se estivermos interessados apenas nas abertas, 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 varre 1 porta por vez e espera 5min até a próxima

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

-T3 –> Operação padrão, inclui varredura paralela

-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 às 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 fragmentação

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

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

-S IP Para quando o Nmap não detecta seu IP você deve fornecê-lo. Também serve para fazê-los pensar que outro alvo está escaneando-os.

-e Para escolher a interface

Muitos administradores deixam portas de entrada abertas para que tudo funcione corretamente e isso é mais fácil para eles do que encontrar outra solução. Podem ser portas DNS ou FTP… para encontrar esta vulnerabilidade o Nmap incorpora: –source-port ;-g São equivalentes

–data Para enviar texto hexadecimal: –data 0xdeadbeef e –data \xCA\xFE\x09

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

–data-length O Nmap só envia headers; com isto conseguimos adicionar um número de bytes extras (que serão gerados aleatoriamente)

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 teria que ser modificado: –max-parallelism

-sP Para descobrir hosts na nossa rede via 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 dessas portas: nmap –source-port 53 IP

Saídas

-oN file Normal output

-oX file XML output

-oS file Script kiddies output

-oG file Greppable output. Ainda funciona, mas está depreciado; XML é o melhor formato para automação porque novas features do Nmap são adicionadas lá primeiro. Continue usando -oN se quiser --resume, e prefira -oX/-oA para parsing por máquina.

-oA file All exceto -oS

–webxml Altera a referência da stylesheet XML para https://nmap.org/svn/docs/nmap.xsl, tornando o XML mais fácil de abrir como HTML em outra máquina.

–stylesheet <path|url> Usa uma stylesheet XSL customizada. --webxml é apenas um atalho para a stylesheet oficial hospedada.

-v level verbosidade

-d level debug

–reason Motivo do host e estado

–stats-every time A cada esse tempo nos informa 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 Retoma um scan interrompido a partir de um arquivo de saída normal (-oN) ou grepable (-oG). Em fluxos de trabalho atuais é comum manter -oN para resumibilidade e -oX para parsing.

Exemplo para fluxos de parsing/conversão para HTML:

# Send only XML to stdout for tooling
nmap -sV -oX - 10.10.10.0/24

# Portable HTML-friendly XML
nmap -sV --webxml -oX scan.xml 10.10.10.10

Diversos

-6 Permite IPv6

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

Tempo de execução

Enquanto o Nmap estiver em execução podemos alterar opções:

v / V Aumenta / diminui o nível de verbosidade

d / D Aumenta / diminui o nível de depuração

p / P Ativa / desativa o rastreamento de pacotes

? Imprime uma tela de ajuda de interação em tempo de execução

Vulscan

Script do Nmap que verifica versões de serviços obtidas em uma base de dados offline (baixada de outras bastante importantes) e retorna possíveis vulnerabilidades

The DBs it uses are:

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

To download and install in the Nmap folder:

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 de DB e adicioná-los em /usr/share/nmap/scripts/vulscan/

Uso:

To use all: sudo nmap -sV –script=vulscan HOST_TO_SCAN

To use a specific DB: sudo nmap -sV –script=vulscan –script-args vulscandb=cve.csv HOST_TO_SCAN

If you have Internet access, Nmap’s official vulners NSE script is usually the quickest maintained alternative for version-based enrichment:

nmap -sV --script vulners --script-args mincvss=7.0 <IP>

This script pertence às categorias safe, external e vuln. Como depende da precisão do -sV, valide as detecções manualmente quando o banner do serviço for genérico ou proxied.

Observações Práticas Recentes (7.94+)

• Desde o Nmap 7.94, o UDP port scan (-sU) e a detecção de versão (-sV) usam a mesma fonte de payload nmap-service-probes. Uma resposta UDP da fase de scan pode alimentar imediatamente a correspondência de versão, então -sU -sV --version-light é agora um bom primeiro passe contra ranges grandes ou com perda.
• Desde o Nmap 7.94, o -sV também pode sondar serviços UDP escondidos atrás de DTLS, o que é útil para equipamentos modernos de gestão/ICS que encapsulam protocolos UDP em DTLS.
• O Nmap 7.95 adicionou um grande lote de novas fingerprints de serviço, incluindo grpc, mysqlx, remotemouse e tuya, além de nova cobertura NSE focada em ICS como hartip-info e iec61850-mms. Se você estiver escaneando ambientes OT ou embedded, atualizar o Nmap importa mais do que adicionar probes customizados cedo demais.
• Desde o Nmap 7.96, as consultas DNS forward também são paralelizadas. Grandes listas de hostnames são muito mais rápidas agora, então --system-dns geralmente deve ser reservado para problemas de compatibilidade em vez de performance.

Acelerar o service scan do Nmap x16

De acordo com para este post você pode acelerar a análise de serviços do nmap modificando todos os valores 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 padrão de 5000. Portanto, podemos ou adicionar valores a cada um dos probes, ou podemos compilar nmap nós mesmos e alterar o valor padrão em service_scan.h.

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

Construir um Nmap estático para ambientes restritos

Em ambientes Linux endurecidos ou minimalistas (containers, appliances), binários Nmap dinamicamente ligados frequentemente falham devido a loaders de runtime ou bibliotecas compartilhadas ausentes (e.g., /lib64/ld-linux-x86-64.so.2, libc.so). Construir seu próprio Nmap ligado estaticamente e empacotar os dados NSE permite a execução sem instalar pacotes do sistema.

Abordagem de alto nível

• Use um builder Ubuntu amd64 limpo via Docker.
• Compile OpenSSL e PCRE2 como bibliotecas estáticas.
• Compile o Nmap vinculando estaticamente e usando o libpcap/libdnet incluídos para evitar dependências dinâmicas.
• Empacote os scripts NSE e diretórios de dados com o binário.

Descobrir arquitetura alvo (exemplo)

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 shared libpcap target se presente.

Passo 5 — Agrupar binário e 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 ops

• Use file no artefato para confirmar que está linkado estaticamente.
• Mantenha os dados NSE com o binário para garantir paridade de scripts em hosts sem Nmap instalado.
• Mesmo com um binário estático, a execução pode ser bloqueada por AppArmor/seccomp/SELinux; DNS/egress ainda devem funcionar.
• Builds determinísticos reduzem o risco da cadeia de suprimentos em comparação com o download de binários “static” opacos.

One-liner (Dockerized)

</details>

## Referências

- [Compiling static Nmap binary for jobs in restricted environments](https://www.pentestpartners.com/security-blog/compiling-static-nmap-binary-for-jobs-in-restricted-environments/)
- [Static Nmap Binary Generator (helper tool)](https://github.com/0x5ubt13/static_nmap_binary_generator)
- [OpenSSL sources](https://www.openssl.org/source/)
- [PCRE2 releases](https://github.com/PCRE2Project/pcre2/releases)
- [Nmap source tarballs](https://nmap.org/dist/)
- [Nmap Change Log](https://nmap.org/changelog.html)
- [Nmap Output Formats](https://nmap.org/book/man-output.html)


> [!TIP]
> Aprenda e pratique AWS Hacking:<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://hacktricks-training.com/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> Aprenda e pratique GCP Hacking: <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://hacktricks-training.com/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> Aprenda e pratique Az Hacking: <img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training Azure Red Team Expert (AzRTE)**](https://hacktricks-training.com/courses/azrte)<img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
> Navegue pelo [**catálogo completo do HackTricks Training**](https://hacktricks-training.com/courses/) para as trilhas de assessment (**ARTA/GRTA/AzRTA**) e [**Linux Hacking Expert (LHE)**](https://hacktricks-training.com/courses/lhe/).
>
> <details>
>
> <summary>Support HackTricks</summary>
>
> - Confira os [**planos de assinatura**](https://github.com/sponsors/carlospolop)!
> - **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f), ao [**grupo do telegram**](https://t.me/peass), **siga** [**@hacktricks_live**](https://twitter.com/hacktricks_live) no **X/Twitter**, ou confira a [**página do LinkedIn**](https://www.linkedin.com/company/hacktricks/) e o [**canal do YouTube**](https://www.youtube.com/@hacktricks_LIVE).
> - **Compartilhe hacking tricks enviando PRs para os repositórios github** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
>
> </details>