Nerva
_{Nerva: CLI rápida de fingerprinting de serviços}

Recursos • Instalação • Início Rápido • Uso • Protocolos • Biblioteca • Casos de Uso • Solução de Problemas

Fingerprinting de serviços de alto desempenho escrito em Go. Identifique mais de 170 protocolos de rede nos transportes TCP, UDP e SCTP com extração avançada de metadados.

O Nerva detecta e identifica rapidamente serviços em execução em portas de rede abertas. Use-o em conjunto com scanners de portas como o Naabu para fazer fingerprinting dos serviços descobertos, ou integre-o aos seus pipelines de segurança para reconhecimento automatizado.

Recursos

• Mais de 170 Plugins de Protocolo — Bancos de dados, acesso remoto, serviços web, mensageria, protocolos industriais e de telecomunicações
• 76 Fingerprinters HTTP — Detecte tecnologias web, incluindo firewalls, bancos de dados, servidores de IA/LLM e muito mais
• Detecção de Configurações de Segurança Incorretas — Identifique problemas de segurança comuns, como APIs não autenticadas e protocolos em texto claro (--misconfigs)
• Suporte a Múltiplos Transportes — TCP (padrão), UDP (--udp) e SCTP (--sctp, somente Linux)
• Suporte a Proxy — Encaminhe o tráfego de varredura de forma transparente por proxies SOCKS5 ou HTTP com resolução DNS configurável
• Metadados Ricos — Extraia versões, configurações e detalhes relevantes para segurança de cada serviço
• Modo Rápido — Escaneie apenas as portas padrão para reconhecimento rápido (--fast)
• Saída Flexível — Formatos JSON, CSV ou legível por humanos
• Compatível com Pipelines — Receba dados via pipe do Naabu, Nmap ou qualquer ferramenta que produza host:port
• Biblioteca Go — Importe diretamente em suas aplicações Go

Instalação

Releases

Baixe um binário pré-compilado na página de Releases.

Do GitHub```sh

go install github.com/praetorian-inc/nerva/cmd/nerva@latest

### Do Código-Fonte```sh
git clone https://github.com/praetorian-inc/nerva.git
cd nerva
go build ./cmd/nerva
./nerva -h

Docker```sh

git clone https://github.com/praetorian-inc/nerva.git cd nerva docker build -t nerva . docker run --rm nerva -h docker run --rm nerva -t example.com:80 --json

## Início Rápido

Fingerprint de um único alvo:```sh
nerva -t example.com:22
# ssh://example.com:22

Obtenha metadados JSON detalhados:```sh nerva -t example.com:22 --json

{"host":"example.com","ip":"93.184.216.34","port":22,"protocol":"ssh","transport":"tcp","metadata":{...}}

Pipe de um scanner de portas:```sh
naabu -host example.com -silent | nerva
# http://example.com:80
# ssh://example.com:22
# https://example.com:443

A referência completa — cada subcomando, alias e flag, incluindo os que estão ocultos de --help — é gerada em docs/CLI.md.

Uso```

nerva [flags]

TARGET SPECIFICATION: Requires host:port or ip:port format. Assumes ports are open.

EXAMPLES: nerva -t example.com:80 nerva -t example.com:80,example.com:443 nerva -l targets.txt nerva --json -t example.com:80 cat targets.txt | nerva

### Exemplos

**Múltiplos alvos:**```sh
nerva -t example.com:22,example.com:80,example.com:443

Do arquivo:```sh nerva -l targets.txt --json -o results.json

**Varredura UDP** (pode exigir root):```sh
sudo nerva -t example.com:53 -U
# dns://example.com:53

Varredura SCTP (apenas Linux):```sh nerva -t telecom-server:3868 -S

diameter://telecom-server:3868

**Modo rápido** (apenas portas padrão):```sh
nerva -l large-target-list.txt --fast --json

Roteamento de proxy com resolução DNS remota:```sh nerva -t target.internal:80 --proxy socks5://127.0.0.1:1080 --dns-order p

### Detecção de Configurações de Segurança Incorretas

O Nerva pode identificar configurações de segurança incorretas comuns quando ativado com `--misconfigs`:```sh
nerva -t example.com:2375 --misconfigs --json

Configurações incorretas detetadas:

Exemplo de saída com configurações incorretas:```json { "host": "example.com", "port": 2375, "protocol": "docker", "anonymous_access": true, "security_findings": [ { "id": "docker-unauth-api", "severity": "critical", "description": "Docker API accessible without authentication", "evidence": "Successfully queried /version endpoint without credentials" } ] }

### Suporte a Proxy

O Nerva oferece suporte ao roteamento de tráfego de varredura através de proxies SOCKS5 e HTTP com resolução DNS configurável.

**Esquemas de proxy suportados:**

- `socks5://` - Proxy SOCKS5 com resolução DNS local
- `socks5h://` - Proxy SOCKS5 com resolução DNS do lado do proxy (sempre)
- `http://` - Proxy HTTP CONNECT
- `https://` - Proxy HTTPS CONNECT

**Autenticação de proxy:**```sh
# Inline authentication (URL format)
nerva -t example.com:80 --proxy socks5://username:[email protected]:1080

# Separate authentication flag
nerva -t example.com:80 --proxy socks5://127.0.0.1:1080 --proxy-auth username:password

Estratégias de resolução DNS (--dns-order):

Nota: O esquema socks5h:// força automaticamente o DNS do lado do proxy (equivalente a --dns-order p)

Exemplo de varredura Tor:```sh

Scan .onion services through Tor (SOCKS5 proxy on port 9050)

nerva -t http://example.onion:80 --proxy socks5h://127.0.0.1:9050

**UDP através de proxy:**```sh
# UDP scanning through SOCKS5 proxy (limited support)
nerva -t target.com:161 --proxy socks5://127.0.0.1:1080 --udp

⚠️ Limitações do UDP: O UDP através do SOCKS5 tem suporte limitado. Nem todos os servidores SOCKS5 suportam associação UDP. Pode ocorrer fallback para UDP local.

Varredura paralela com limitação de taxa:```sh nerva -l large-target-list.txt -W 100 -H 5 -R 50 -v

**Encerramento gracioso** (Ctrl+C retorna resultados parciais):```sh
nerva -l huge-target-list.txt -W 50 -v
# Press Ctrl+C to stop — collected results are still printed

Protocolos Suportados

Mais de 170 plugins de detecção de serviços em TCP, UDP e SCTP:

Módulos de Fingerprint HTTP (66)

Detecção de tecnologia para serviços web, organizada por categoria:

Firewalls e Segurança de Rede (12)

IA/LLM e Machine Learning (6)

Bancos de Dados e Armazenamento de Dados (12)

DevOps e Infraestrutura (14)

Servidores Web e Frameworks (10)

Corporativo e Empresarial (8)

Casa e IoT (2)

Outros (2)

Bancos de Dados (20)

Acesso Remoto (6)

Web e API (2)

Mensageria e Filas (10)

Serviços de Arquivos e Diretórios (7)

Serviços de Rede (11)

Sistemas de Controle Industrial (18)

Telecom e VoIP (17)

VPN e Segurança (11)

Acesso Remoto e Gerenciamento (10)

Ferramentas de Desenvolvimento (8)

Uso da Biblioteca

Importe o Nerva em suas aplicações Go:```go package main

import ( "context" "fmt" "log" "net/netip" "time"

"github.com/praetorian-inc/nerva/pkg/plugins"
"github.com/praetorian-inc/nerva/pkg/scan"

)

func main() { // Configure scan config := scan.Config{ DefaultTimeout: 2 * time.Second, FastMode: false, UDP: false, Proxy: "socks5://127.0.0.1:1080", // optional ProxyAuth: "username:password", // optional DNSOrder: "p", // resolver strategy }

// Create target
ip, _ := netip.ParseAddr("93.184.216.34")
target := plugins.Target{
    Address: netip.AddrPortFrom(ip, 22),
    Host:    "example.com",
}

// Run scan
results, err := scan.ScanTargets(context.Background(), []plugins.Target{target}, config)
if err != nil {
    log.Fatal(err)
}

// Process results
for _, result := range results {
    fmt.Printf("%s:%d - %s (%s)\n",
        result.Host, result.Port,
        result.Protocol, result.Transport)
}

}

Consulte [examples/service-fingerprinting-example.go](https://github.com/praetorian-inc/nerva/blob/main/examples/service-fingerprinting-example.go) para um exemplo completo e funcional.

## Casos de Uso

### Testes de Penetração

Identifique rapidamente os serviços descobertos durante o reconhecimento para identificar potenciais vetores de ataque.

### Pipelines de Descoberta de Ativos

Combine com Naabu ou Masscan para inventário de ativos em larga escala:```sh
naabu -host 10.0.0.0/24 -silent | nerva --json | jq '.protocol'

Verificação de Segurança em CI/CD

Integre em pipelines de implantação para verificar se apenas os serviços esperados estão expostos.

Reconhecimento em Bug Bounty

Enumere rapidamente serviços em alvos do escopo para encontrar endpoints interessantes.

Análise de Redes de Telecomunicações

Identifique nós Diameter em redes LTE/5G usando transporte SCTP (Linux):```sh nerva -t mme.telecom.local:3868 -S --json

## Arquitetura```mermaid
graph LR
    A[host:port input] --> B[Target Parser]
    B --> C[Scan Engine]
    C --> D{Transport}
    D -->|TCP| E[TCP Plugins]
    D -->|UDP| F[UDP Plugins]
    D -->|SCTP| G[SCTP Plugins]
    E --> H[Service Detection]
    F --> H
    G --> H
    H --> I[Metadata Extraction]
    I --> J[JSON/CSV/Text Output]

Por que Nerva?

vs Nmap

• Padrões mais inteligentes: Nerva verifica o protocolo mais provável primeiro com base no número da porta
• Saída estruturada: Suporte nativo a JSON/CSV para facilitar a análise e integração em pipelines
• Focado: Apenas fingerprinting de serviços — combine com scanners de portas dedicados para descoberta

vs zgrab2

• Detecção automática: Não é necessário especificar o protocolo antecipadamente
• Uso mais simples: nerva -t host:port vs echo host | zgrab2 http -p port

Solução de problemas

Sem saída

Causa: A porta está fechada ou nenhum serviço suportado foi detectado.

Solução: Verifique se a porta está aberta:```sh nc -zv example.com 80

### Erros de timeout

**Causa**: O timeout padrão de 2 segundos é muito curto para serviços lentos.

**Solução**: Aumente o timeout:```sh
nerva -t example.com:80 -w 5000  # 5 seconds

Serviços UDP não detectados

Causa: varredura UDP desabilitada por padrão.

Solução: Habilite com a flag -U (pode exigir root):```sh sudo nerva -t example.com:53 -U

### SCTP não está funcionando

**Causa**: SCTP só é suportado no Linux.

**Solução**: Execute em um sistema Linux ou contêiner:```sh
docker run --rm nerva -t telecom:3868 -S

Terminologia

• Serviço: Um serviço de rede em execução numa porta (SSH, HTTP, PostgreSQL, etc.)
• Fingerprinting: Deteção e identificação do tipo de serviço, versão e configuração
• Plugin: Um módulo de deteção específico de protocolo
• Modo Rápido: Digitalizar apenas a porta predefinida para cada protocolo (otimização 80/20)
• Transporte: Protocolo da camada de rede (TCP, UDP ou SCTP)

Suporte

Se considera o Nerva útil, por favor considere dar-lhe uma estrela:

Contribuir

Acolhemos contribuições! Consulte CONTRIBUTING.md para orientações.

Licença

Apache 2.0 — consulte LICENSE para detalhes.

Agradecimentos

O Nerva é um fork mantido de fingerprintx, originalmente desenvolvido pela turma de estagiários da Praetorian de 2022:

• Soham Roy
• Jue Huang
• Henry Jung
• Tristan Wiesepape
• Joseph Henry
• Noah Tutt
• Nathan Sportsman