Validação de Configuração de Rede

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

Quando Usar

• Revisando trechos de configuração no estilo Cisco IOS ou IOS-XE antes da implantação.
• Auditando configurações geradas por scripts ou modelos.
• Procurando por comandos perigosos, endereços IP duplicados ou sobreposições de sub-redes.
• Verificando se ACLs, route-maps, prefix-lists ou políticas de linha são referenciados, mas não definidos.
• Construindo 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 analisador completo. Verificações de Regex são úteis para avisos de pré-voo, mas a aprovação final ainda requer que um engenheiro de rede revise a intenção, a sintaxe da plataforma e as etapas de reversão.

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, registro remoto e banners.

Detecção de Comandos Perigosos

import re

DANGEROUS_PATTERNS: list[tuple[re.Pattern[str], str]] = [
    (re.compile(r"\breload\b", re.I), "reload causes downtime"),
    (re.compile(r"\berase\s+(startup|nvram|flash)", re.I), "erases persistent storage"),
    (re.compile(r"\bformat\b", re.I), "formats a device filesystem"),
    (re.compile(r"\bno\s+router\s+(bgp|ospf|eigrp)\b", re.I), "removes a routing process"),
    (re.compile(r"\bno\s+interface\s+\S+", re.I), "removes interface configuration"),
    (re.compile(r"\baaa\s+new-model\b", re.I), "changes authentication behavior"),
    (re.compile(r"\bcrypto\s+key\s+(zeroize|generate)\b", re.I), "changes device SSH keys"),
]

def find_dangerous_commands(lines: list[str]) -> list[dict[str, str | int]]:
    findings = []
    for line_number, line in enumerate(lines, start=1):
        stripped = line.strip()
        for pattern, reason in DANGEROUS_PATTERNS:
            if pattern.search(stripped):
                findings.append({
                    "line": line_number,
                    "command": stripped,
                    "reason": reason,
                })
    return findings

IPs Duplicados e Sobreposições de Sub-redes

import ipaddress
import re
from collections import Counter

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

def extract_interfaces(config: str) -> list[dict[str, str]]:
    results = []
    current = None
    for line in config.splitlines():
        if line.startswith("interface "):
            current = line.split(maxsplit=1)[1]
            continue
        match = IP_ADDRESS_RE.match(line)
        if current and match:
            ip = match.group("ip")
            mask = match.group("mask")
            network = ipaddress.ip_interface(f"{ip}/{mask}").network
            results.append({"interface": current, "ip": ip, "network": str(network)})
    return results

def find_duplicate_ips(config: str) -> list[str]:
    ips = [entry["ip"] for entry in extract_interfaces(config)]
    counts = Counter(ips)
    return sorted(ip for ip, count in counts.items() if count > 1)

def find_subnet_overlaps(config: str) -> list[tuple[str, str]]:
    networks = [ipaddress.ip_network(entry["network"]) for entry in extract_interfaces(config)]
    overlaps = []
    for index, left in enumerate(networks):
        for right in networks[index + 1:]:
            if left.overlaps(right):
                overlaps.append((str(left), str(right)))
    return overlaps

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 iter_blocks(config: str, starts_with: str) -> list[str]:
    blocks = []
    current: list[str] = []
    for line in config.splitlines():
        if line.startswith(starts_with):
            if current:
                blocks.append("\n".join(current))
            current = [line]
            continue
        if current:
            if line and not line.startswith(" "):
                blocks.append("\n".join(current))
                current = []
            else:
                current.append(line)
    if current:
        blocks.append("\n".join(current))
    return blocks

def check_vty_blocks(config: str) -> list[str]:
    issues = []

…