A eficiência em atividades de reconhecimento de rede depende do equilíbrio entre velocidade e precisão. Enquanto o masscan é reconhecido por sua capacidade de escanear grandes volumes de portas em tempo recorde, o nmap oferece uma profundidade inigualável na identificação de serviços e versões. Este artigo descreve uma abordagem híbrida que automatiza o pipeline de descoberta, utilizando o masscan para identificar portas abertas e o nmap para realizar a análise detalhada dos serviços encontrados.

Pré-requisitos do Sistema

Para implementar esta solução, é necessário ter as ferramentas de linha de comando instaladas no ambiente Linux, além da biblioteca de integração para Python.

• Masscan: Responsável pela varredura inicial de alta velocidade.
• Nmap: Utilizado para o fingerprinting de serviços.
• Python-nmap: Wrapper para manipulação dos resultados do nmap via script.

pip3 install python-nmap

Arquitetura do Script de Automação

O fluxo de trabalho é dividido em quatro etapas principais: varredura bruta, processamento de dados, varredura refinada e persistência de resultados. Abaixo, apresentamos uma reestruturação da lógica principal do script.

import nmap
import json
import multiprocessing

# Configurações de execução
ARQUIVO_ALVOS = 'ips.txt'
PATH_MASSCAN = '/usr/bin/masscan'
TAXA_TRANSMISSAO = 1000000
SAIDA_MASSCAN = 'scan_result.json'
LIMITE_PROCESSOS = 500

def executar_descoberta_inicial():
    """Executa o masscan para identificar portas ativas."""
    # Comando simulado via subprocess para gerar o JSON de portas abertas
    pass

def processar_saida_masscan():
    """Converte o JSON do masscan em uma lista de tuplas (ip, porta)."""
    lista_alvos = []
    with open(SAIDA_MASSCAN, 'r') as f:
        dados = json.load(f)
        for entrada in dados:
            ip = entrada['ip']
            for p in entrada['ports']:
                lista_alvos.append((ip, p['port']))
    return lista_alvos

def analisar_servico_nmap(info_alvo):
    """Realiza o fingerprinting de um serviço específico."""
    ip, porta = info_alvo
    nm = nmap.PortScanner()
    try:
        resultado = nm.scan(ip, str(porta), arguments='-sS')
        servico = resultado['scan'][ip]['tcp'][int(porta)]['name']
        return f"{ip}:{porta}:{servico}"
    except Exception as e:
        return f"{ip}:{porta}:desconhecido"

def fluxo_principal():
    # 1. Varredura de alta velocidade
    executar_descoberta_inicial()
    
    # 2. Extração de alvos ativos
    alvos_encontrados = processar_saida_masscan()
    
    # 3. Análise paralela de serviços com Nmap
    pool = multiprocessing.Pool(processes=LIMITE_PROCESSOS)
    resultados_finais = pool.map(analisar_servico_nmap, alvos_encontrados)
    
    # 4. Escrita dos resultados em disco
    with open('servicos_detectados.txt', 'w') as f:
        for linha in resultados_finais:
            f.write(linha + '\n')

Parâmetros de Desempenho

A performance deste método é altamente dependente da largura de banda disponível e dos recursos de CPU. Em testes controlados, ao escanear aproximadamente 9.000 endereços IP, resultando em mais de 230.000 portas abertas, a combinação de uma taxa de 1.000.000 pps no masscan com 800 processos paralelos de nmap permitiu concluir a tarefa em cerca de 80 minutos.

É fundamental ajustar o parâmetro --rate do masscan para evitar saturação de banda ou bloqueios por sistemas de detecção de intrusão (IDS) na rede de destino.

Refinamento e Detecção de Versões

Se o objetivo for além da simples identificação do nome do serviço, é possível ajustar os argumentos do nmap para capturar versões específicas de softwares e sistemas operacionais. Note que isso aumentará significativamente o tempo total da varredura.

Para obter detalhes granulares, modifique a chamada do nmap no script:

# Versão otimizada para detecção de versão e produto
resultado = nm.scan(ip, str(porta), arguments='-sV')
detalhes = resultado['scan'][ip]['tcp'][int(porta)]
nome = detalhes.get('name')
produto = detalhes.get('product')
versao = detalhes.get('version')
msg = f"{ip}:{porta}:{nome}:{produto}:{versao}"

Considerações Técnicas Adicionais

• Gestão de Recursos: O uso de múltiplos processos (multiprocessing) é preferível em relação a threads para o nmap em Python, devido ao Global Interpreter Lock (GIL) e ao overehad de chamadas de sistema externas.
• Tratamento de Erros: Varreduras em larga escala frequentemente encontram timeouts ou recusas de conexão; implementar mecanismos de retry ou logs de erro é essencial para a integridade dos dados.
• Saída de Dados: Para integrações com outras ferramentas (como bancos de dados ou SIEMs), recomenda-se converter a saída final para o formato CSV ou JSON.