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

Funcionalidades • 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 rica de metadados.

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

Funcionalidades

• 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 AI/LLM e mais
• Detecção de Configurações Incorretas de Segurança — Identifique problemas comuns de segurança como APIs não autenticadas e protocolos em texto claro (--misconfigs)
• Suporte a Múltiplos Transportes — TCP (padrão), UDP (--udp) e SCTP (--sctp, apenas Linux)
• Suporte a Proxy — Roteie o tráfego de varredura de forma transparente através de proxies SOCKS5 ou HTTP com resolução de DNS configurável
• Metadados Ricos — Extraia versões, configurações e detalhes relevantes de segurança de cada serviço
• Modo Rápido — Escaneie apenas portas padrão para reconhecimento rápido (--fast)
• Saída Flexível — Formatos JSON, CSV ou legíveis por humanos
• Amigável para Pipelines — Pipe a partir de Naabu, Nmap ou qualquer ferramenta que produza host:porta
• Biblioteca Go — Importe diretamente em suas aplicações Go

Instalação

Lançamentos

Baixe um binário pré-compilado da página de Lançamentos.

A partir do GitHub```sh

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

### A partir 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

Identifique 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

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

### Flags

| Flag | Short | Descrição | Padrão |
|------|-------|-----------|---------|
| `--targets` | `-t` | Alvo ou lista de alvos separados por vírgula | — |
| `--list` | `-l` | Ficheiro de entrada contendo alvos | — |
| `--output` | `-o` | Caminho do ficheiro de saída | stdout |
| `--json` | | Saída no formato JSON | false |
| `--csv` | | Saída no formato CSV | false |
| `--misconfigs` | | Ativar deteção de configurações incorretas de segurança | false |
| `--proxy` | | URL do proxy (ex.: socks5://127.0.0.1:1080) | — |
| `--proxy-auth` | | Autenticação do proxy SOCKS5 (ex.: username:password) | — |
| `--dns-order` | | Ordem de resolução DNS: `p`, `l`, `lp`, `pl` | `lp` |
| `--fast` | `-f` | Modo rápido (apenas portas padrão) | false |
| `--capabilities` | `-c` | Listar capacidades disponíveis e sair | false |
| `--udp` | `-U` | Executar plugins UDP | false |
| `--sctp` | `-S` | Executar plugins SCTP (apenas Linux) | false |
| `--timeout` | `-w` | Tempo limite em milissegundos | 2000 |
| `--verbose` | `-v` | Saída detalhada para stderr | false |
| `--workers` | `-W` | Trabalhadores de análise concorrentes | 50 |
| `--max-host-conn` | `-H` | Máximo de conexões concorrentes por IP de anfitrião (0=sem limite) | 0 |
| `--rate-limit` | `-R` | Máximo de análises por segundo globalmente (0=sem limite) | 0 |

### 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 (somente 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ção Incorreta de Segurança

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

Configurações incorretas detectadas:

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

Nerva suporta o roteamento do 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 de DNS (--dns-order):

Nota: O esquema socks5h:// força automaticamente a resolução de DNS pelo proxy (equivalente a --dns-order p)

Exemplo de varredura com 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 de UDP: O UDP através de 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

**Desligamento 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

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

Módulos de Impressão Digital HTTP (66)

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

Firewalls e Segurança de Rede (12)

AI/LLM e Aprendizado de Máquina (6)

Bancos de Dados e Armazenamento de Dados (12)

DevOps e Infraestrutura (14)

Servidores Web e Frameworks (10)

Empresarial e Negócios (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 Arquivo e Diretório (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 para Desenvolvedores (8)

Uso da Biblioteca

Importe o Nerva para 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)
}

}

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

## Casos de Uso

### Testes de Penetração

Identifique rapidamente os serviços descobertos durante o reconhecimento para identificar possíveis 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'

Varredura de Segurança CI/CD

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

Reconhecimento para Bug Bounty

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

Análise de Rede 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 fácil análise e integração em pipelines
• Focado: Apenas impressão digital de serviços — combine com scanners de porta 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: Porta está fechada ou nenhum serviço suportado 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: Ative 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 ou contêiner Linux:```sh
docker run --rm nerva -t telecom:3868 -S

Terminologia

• Serviço: Um serviço de rede executando em uma porta (SSH, HTTP, PostgreSQL, etc.)
• Fingerprinting: Detectando e identificando o tipo, versão e configuração do serviço
• Plugin: Um módulo de detecção específico de protocolo
• Modo Rápido: Escaneando apenas a porta padrão para cada protocolo (otimização 80/20)
• Transporte: Protocolo de camada de rede (TCP, UDP ou SCTP)

Suporte

Se você acha o Nerva útil, considere dar uma estrela:

Contribuindo

Aceitamos contribuições! Veja CONTRIBUTING.md para diretrizes.

Licença

Apache 2.0 — veja LICENSE para detalhes.

Agradecimentos

Nerva é um fork mantido do 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