Validação de Configuração de Rede

O que Validação de Configuração de Rede faz?

Use esta skill para revisar a configuração de rede antes de uma janela de mudança ou antes que uma execução de automação toque em dispositivos de produção.

Quando Usar

• Revisar trechos de configuração no estilo Cisco IOS ou IOS-XE antes da implantação.
• Auditar configuração gerada por scripts ou modelos.
• Procurar por comandos perigosos, endereços IP duplicados ou sobreposição de sub-redes.
• Verificar se ACLs, route-maps, prefix-lists ou políticas de linha são referenciadas, mas não definidas.
• Construir scripts leves de pré-voo para automação de rede.

Como Funciona

Trate a validação de configuração como evidência em camadas, não como um parser completo. Verificações com expressões regulares são úteis para avisos de pré-voo, mas a aprovação final ainda precisa de um engenheiro de rede para revisar intenção, sintaxe da plataforma e etapas de rollback.

Valide nesta ordem:

1. Comandos destrutivos.
2. Exposição de credenciais e plano de gerenciamento.
3. Endereços duplicados e sub-redes sobrepostas.
4. Referências obsoletas a ACLs, route-maps, prefix-lists e interfaces.
5. Higiene operacional como NTP, timestamps, logging remoto e banners.

Detecção de Comandos Perigosos

import re

PATTERNS_PERIGOSOS: list[tuple[re.Pattern[str], str]] = [
    (re.compile(r"\breload\b", re.I), "reload causa parada não programada"),
    (re.compile(r"\berase\s+(startup|nvram|flash)", re.I), "apaga armazenamento persistente"),
    (re.compile(r"\bformat\b", re.I), "formata o sistema de arquivos do dispositivo"),
    (re.compile(r"\bno\s+router\s+(bgp|ospf|eigrp)\b", re.I), "remove um processo de roteamento"),
    (re.compile(r"\bno\s+interface\s+\S+", re.I), "remove configuração de interface"),
    (re.compile(r"\baaa\s+new-model\b", re.I), "altera comportamento de autenticação"),
    (re.compile(r"\bcrypto\s+key\s+(zeroize|generate)\b", re.I), "altera chaves SSH do dispositivo"),
]

def encontrar_comandos_perigosos(linhas: list[str]) -> list[dict[str, str | int]]:
    resultados = []
    for numero_linha, linha in enumerate(linhas, start=1):
        linha_limpa = linha.strip()
        for padrao, motivo in PATTERNS_PERIGOSOS:
            if padrao.search(linha_limpa):
                resultados.append({
                    "linha": numero_linha,
                    "comando": linha_limpa,
                    "motivo": motivo,
                })
    return resultados

IPs Duplicados e Sobreposição de Sub-Redes

import ipaddress
import re
from collections import Counter

REGEX_END_IP = re.compile(
    r"^\s*ip address\s+"
    r"(?P<ip>\d{1,3}(?:\.\d{1,3}){3})\s+"
    r"(?P<mascara>\d{1,3}(?:\.\d{1,3}){3})\b",
    re.I | re.M,
)

def extrair_interfaces(config: str) -> list[dict[str, str]]:
    resultados = []
    atual = None
    for linha in config.splitlines():
        if linha.startswith("interface "):
            atual = linha.split(maxsplit=1)[1]
            continue
        match = REGEX_END_IP.match(linha)
        if atual and match:
            ip = match.group("ip")
            mascara = match.group("mascara")
            rede = ipaddress.ip_interface(f"{ip}/{mascara}").network
            resultados.append({"interface": atual, "ip": ip, "rede": str(rede)})
    return resultados

def encontrar_ips_duplicados(config: str) -> list[str]:
    ips = [entrada["ip"] for entrada in extrair_interfaces(config)]
    contagens = Counter(ips)
    return sorted(ip for ip, contagem in contagens.items() if contagem > 1)

def encontrar_subredes_sobrepostas(config: str) -> list[tuple[str, str]]:
    redes = [ipaddress.ip_network(entrada["rede"]) for entrada in extrair_interfaces(config)]
    sobrepostas = []
    for indice, esquerda in enumerate(redes):
        for direita in redes[indice + 1:]:
            if esquerda.overlaps(direita):
                sobrepostas.append((str(esquerda), str(direita)))
    return sobrepostas

Verificações do Plano de Gerenciamento

Analise blocos VTY por seção para que as verificações de access-class não se espalhem por linhas não relacionadas.

import re

def iterar_blocos(config: str, comeca_com: str) -> list[str]:
    blocos = []
    atual: list[str] = []
    for linha in config.splitlines():
        if linha.startswith(comeca_com):
            if atual:
                blocos.append("\n".join(atual))
            atual = [linha]
            continue
        if atual:
            if linha and not linha.startswith(" "):
                blocos.append("\n".join(atual))
                atual = []
            else:
                atual.append(linha)
    if atual:
        blocos.append("\n".join(atual))
    return blocos

def verificar_blocos_vty(config: str) -> list[str]:
    problemas = []
    for bloco in iterar_blocos(config, "line vty"):
        if re.search(r"transport\s+input\s+.*telnet", bloco, re.I):
            problemas.append("VTY permite Telnet; exija apenas SSH.")
        if not re.search(r"\baccess-class\s+\S+\s+in\b", bloco, re.I):
            problemas.append("Bloco VTY não possui restrição de classe de acesso de entrada (access-class).")
        if not re.search(r"\bexec-timeout\s+\d+\s+\d+\b", bloco, re.I):
            problemas.append("Bloco VTY não possui exec-timeout explícito.")
    return problemas

Verificações de Higiene de Segurança

PADROES_SEGURANCA = [
    (re.compile(r"\bsnmp-server community\s+(public|private)\b", re.I),
     "comunidade SNMP padrão configurada"),
    (re.compile(r"\bsnmp-server community\s+\S+", re.I),
     "string de comunidade SNMPv2 configurada; prefira SNMPv3 authPriv"),
    (re.compile(r"\bip ssh version 1\b", re.I),
     "SSH versão 1 habilitado"),
    (re.compile(r"\benable password\b", re.I),
     "senha enable está presente; use enable secret"),
    (re.compile(r"\busername\s+\S+\s+password\b", re.I),
     "username local usa password em vez de secret"),
]

PADROES_MELHORES_PRATICAS = [
    (re.compile(r"\bntp server\b", re.I), "servidor NTP"),
    (re.compile(r"\bservice timestamps\b", re.I), "timestamps de log"),
    (re.compile(r"\blogging\s+\S+", re.I), "destino ou buffer de logging"),
    (re.compile(r"\bsnmp-server group\s+\S+\s+v3\s+priv\b", re.I), "grupo SNMPv3 authPriv"),
    (re.compile(r"\bbanner\s+(login|motd)\b", re.I), "banner de login"),
]

def verificar_seguranca(config: str) -> list[str]:
    return [mensagem for padrao, mensagem in PADROES_SEGURANCA if padrao.search(config)]

def verificar_higiene_ausente(config: str) -> list[str]:
    return [
        f"Ausente: {descricao}"
        for padrao, descricao in PADROES_MELHORES_PRATICAS
        if not padrao.search(config)
    ]

Exemplos

Pré-Voo de Janela de Mudança

1. Execute verificações de comandos perigosos no trecho exato a ser colado.
2. Execute verificações de IP duplicado e sobreposição de sub-rede na configuração candidata completa.
3. Confirme que toda ACL, route-map e prefix-list referenciada existe.
4. Confirme comandos de rollback e acesso fora de banda antes de qualquer alteração no plano de gerenciamento.

Pré-Voo de Automação

Use a validação como uma porta de bloqueio antes que Netmiko, NAPALM, Ansible ou automação via API de fornecedor aplique uma configuração gerada. Falhe fechado em comandos perigosos e credenciais. Avise sobre lacunas de melhores práticas que estão fora do escopo da mudança.

Antipadrões

• Tratar validação com expressão regular como um parser de dispositivo.
• Aplicar configuração gerada sem uma diferença (diff) simulada.
• Recomendar strings de comunidade SNMPv2 como requisito de monitoramento.
• Verificar blocos VTY com expressão regular que pode, acidentalmente, abranger seções não relacionadas.
• Testar comportamento de firewall desabilitando ACLs em vez de ler contadores/logs.

Veja Também

• Agente: network-config-reviewer
• Agente: network-troubleshooter
• Skill: network-interface-health