423 lines
15 KiB
Python
Executable File
423 lines
15 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Cisco MAC Address Monitor for Zabbix LLD
|
|
========================================
|
|
|
|
Script para monitorizar direcciones MAC conectadas a puertos de switches Cisco.
|
|
Compatible con modelos C2960, C3560, C3560E, C2960X, C3560CX y Catalyst series.
|
|
Genera salida JSON compatible con Zabbix Low Level Discovery.
|
|
|
|
Autor: Sistema de Monitorización de Red
|
|
Fecha: Octubre 2024
|
|
"""
|
|
|
|
import json
|
|
import logging
|
|
import time
|
|
import yaml
|
|
import paramiko
|
|
import re
|
|
import sys
|
|
from datetime import datetime
|
|
from typing import Dict, List, Any, Optional
|
|
from dataclasses import dataclass
|
|
|
|
|
|
@dataclass
|
|
class DeviceConfig:
|
|
"""Configuración de dispositivo de red"""
|
|
hostname: str
|
|
ip: str
|
|
username: str
|
|
password: str
|
|
port: int = 22
|
|
device_type: str = "cisco_ios"
|
|
timeout: int = 30
|
|
|
|
|
|
@dataclass
|
|
class MacEntry:
|
|
"""Entrada de tabla MAC"""
|
|
vlan: str
|
|
mac_address: str
|
|
type: str
|
|
port: str
|
|
|
|
|
|
class CiscoSSHConnector:
|
|
"""Conector SSH para dispositivos Cisco"""
|
|
|
|
def __init__(self, device_config: DeviceConfig):
|
|
self.device_config = device_config
|
|
self.ssh_client = None
|
|
self.logger = logging.getLogger(__name__)
|
|
|
|
def connect(self) -> bool:
|
|
"""Establece conexión SSH con el dispositivo"""
|
|
try:
|
|
self.ssh_client = paramiko.SSHClient()
|
|
self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
|
|
|
|
self.logger.info(f"Conectando a {self.device_config.hostname} ({self.device_config.ip})")
|
|
|
|
self.ssh_client.connect(
|
|
hostname=self.device_config.ip,
|
|
port=self.device_config.port,
|
|
username=self.device_config.username,
|
|
password=self.device_config.password,
|
|
timeout=self.device_config.timeout,
|
|
look_for_keys=False,
|
|
allow_agent=False
|
|
)
|
|
|
|
self.logger.info(f"Conexión exitosa a {self.device_config.hostname}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error conectando a {self.device_config.hostname}: {str(e)}")
|
|
return False
|
|
|
|
def execute_command(self, command: str) -> str:
|
|
"""Ejecuta comando en el dispositivo"""
|
|
if not self.ssh_client:
|
|
raise Exception("No hay conexión SSH activa")
|
|
|
|
try:
|
|
self.logger.debug(f"Ejecutando comando: {command}")
|
|
stdin, stdout, stderr = self.ssh_client.exec_command(command)
|
|
|
|
output = stdout.read().decode('utf-8')
|
|
error = stderr.read().decode('utf-8')
|
|
|
|
if error:
|
|
self.logger.warning(f"Error en comando '{command}': {error}")
|
|
|
|
return output
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error ejecutando comando '{command}': {str(e)}")
|
|
raise
|
|
|
|
def disconnect(self):
|
|
"""Cierra la conexión SSH"""
|
|
if self.ssh_client:
|
|
self.ssh_client.close()
|
|
self.logger.info(f"Desconectado de {self.device_config.hostname}")
|
|
|
|
|
|
class CiscoMacTableParser:
|
|
"""Parser para tabla MAC de dispositivos Cisco"""
|
|
|
|
def __init__(self):
|
|
self.logger = logging.getLogger(__name__)
|
|
|
|
def get_mac_table(self, ssh_connector: CiscoSSHConnector) -> List[MacEntry]:
|
|
"""Obtiene la tabla MAC del dispositivo"""
|
|
try:
|
|
# Comando para obtener tabla MAC (compatible con IOS 12.x y 15.x)
|
|
command = "show mac address-table"
|
|
output = ssh_connector.execute_command(command)
|
|
|
|
mac_entries = self._parse_mac_table_output(output)
|
|
self.logger.info(f"Obtenidas {len(mac_entries)} entradas de tabla MAC")
|
|
|
|
return mac_entries
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error obteniendo tabla MAC: {str(e)}")
|
|
return []
|
|
|
|
def _parse_mac_table_output(self, output: str) -> List[MacEntry]:
|
|
"""Parsea la salida del comando show mac address-table"""
|
|
mac_entries = []
|
|
|
|
# Patrones para diferentes formatos de salida de IOS
|
|
# Formato típico: VLAN MAC Address Type Ports
|
|
patterns = [
|
|
# IOS 12.x y 15.x estándar
|
|
r'^\s*(\d+)\s+([0-9a-fA-F]{4}\.[0-9a-fA-F]{4}\.[0-9a-fA-F]{4})\s+(\w+)\s+(.+)$',
|
|
# Formato alternativo con guiones
|
|
r'^\s*(\d+)\s+([0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2}-[0-9a-fA-F]{2})\s+(\w+)\s+(.+)$',
|
|
# Formato con dos puntos
|
|
r'^\s*(\d+)\s+([0-9a-fA-F]{2}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2}:[0-9a-fA-F]{2})\s+(\w+)\s+(.+)$'
|
|
]
|
|
|
|
lines = output.split('\n')
|
|
|
|
for line in lines:
|
|
line = line.strip()
|
|
if not line or line.startswith('-') or 'VLAN' in line.upper() or 'MAC Address' in line:
|
|
continue
|
|
|
|
for pattern in patterns:
|
|
match = re.match(pattern, line)
|
|
if match:
|
|
vlan = match.group(1)
|
|
mac_address = self._normalize_mac_address(match.group(2))
|
|
mac_type = match.group(3)
|
|
port = match.group(4).strip()
|
|
|
|
# Filtrar MACs del CPU y otras no relevantes
|
|
if not self._is_valid_port(port):
|
|
continue
|
|
|
|
mac_entries.append(MacEntry(
|
|
vlan=vlan,
|
|
mac_address=mac_address,
|
|
type=mac_type,
|
|
port=port
|
|
))
|
|
break
|
|
|
|
return mac_entries
|
|
|
|
def _normalize_mac_address(self, mac: str) -> str:
|
|
"""Normaliza formato de dirección MAC"""
|
|
# Remover todos los separadores y convertir a minúsculas
|
|
clean_mac = re.sub(r'[.:-]', '', mac.lower())
|
|
|
|
# Formatear como XX:XX:XX:XX:XX:XX
|
|
if len(clean_mac) == 12:
|
|
return ':'.join([clean_mac[i:i+2] for i in range(0, 12, 2)])
|
|
|
|
return mac
|
|
|
|
def _is_valid_port(self, port: str) -> bool:
|
|
"""Verifica si el puerto es válido para monitorización"""
|
|
# Excluir puertos del CPU, uplinks management, etc.
|
|
exclude_patterns = [
|
|
r'cpu',
|
|
r'switch',
|
|
r'router',
|
|
r'null',
|
|
r'drop',
|
|
r'punt'
|
|
]
|
|
|
|
port_lower = port.lower()
|
|
for pattern in exclude_patterns:
|
|
if re.search(pattern, port_lower):
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
class ZabbixLLDFormatter:
|
|
"""Formateador de datos para Zabbix Low Level Discovery"""
|
|
|
|
def __init__(self):
|
|
self.logger = logging.getLogger(__name__)
|
|
|
|
def format_for_zabbix(self, device_data: Dict[str, List[MacEntry]]) -> Dict[str, Any]:
|
|
"""Formatea datos para Zabbix LLD"""
|
|
discovery_data = []
|
|
|
|
timestamp = datetime.now().isoformat()
|
|
|
|
for hostname, mac_entries in device_data.items():
|
|
# Agrupar MACs por puerto
|
|
ports_data = {}
|
|
|
|
for entry in mac_entries:
|
|
port = entry.port
|
|
if port not in ports_data:
|
|
ports_data[port] = {
|
|
"port_name": port,
|
|
"device_hostname": hostname,
|
|
"mac_addresses": [],
|
|
"mac_count": 0,
|
|
"vlans": set()
|
|
}
|
|
|
|
ports_data[port]["mac_addresses"].append({
|
|
"mac": entry.mac_address,
|
|
"vlan": entry.vlan,
|
|
"type": entry.type
|
|
})
|
|
ports_data[port]["vlans"].add(entry.vlan)
|
|
|
|
# Crear entradas para LLD
|
|
for port, data in ports_data.items():
|
|
data["mac_count"] = len(data["mac_addresses"])
|
|
data["vlans"] = list(data["vlans"])
|
|
|
|
discovery_item = {
|
|
"{#DEVICE_HOSTNAME}": hostname,
|
|
"{#PORT_NAME}": port,
|
|
"{#MAC_COUNT}": data["mac_count"],
|
|
"{#VLANS}": ",".join(data["vlans"]),
|
|
"{#MAC_ADDRESSES}": json.dumps(data["mac_addresses"]),
|
|
"{#LAST_UPDATE}": timestamp
|
|
}
|
|
|
|
discovery_data.append(discovery_item)
|
|
|
|
result = {
|
|
"data": discovery_data,
|
|
"timestamp": timestamp,
|
|
"total_devices": len(device_data),
|
|
"total_ports": len(discovery_data)
|
|
}
|
|
|
|
self.logger.info(f"Formateados datos para {len(device_data)} dispositivos, {len(discovery_data)} puertos")
|
|
|
|
return result
|
|
|
|
|
|
class CiscoMacMonitor:
|
|
"""Monitor principal para dispositivos Cisco"""
|
|
|
|
def __init__(self, config_file: str = "config.yaml"):
|
|
self.config_file = config_file
|
|
self.config = None
|
|
self.devices = []
|
|
self.logger = self._setup_logging()
|
|
|
|
self.mac_parser = CiscoMacTableParser()
|
|
self.zabbix_formatter = ZabbixLLDFormatter()
|
|
|
|
def _setup_logging(self) -> logging.Logger:
|
|
"""Configura el sistema de logging"""
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
|
handlers=[
|
|
logging.FileHandler('/tmp/cisco_mac_monitor.log'),
|
|
logging.StreamHandler(sys.stdout)
|
|
]
|
|
)
|
|
return logging.getLogger(__name__)
|
|
|
|
def load_config(self) -> bool:
|
|
"""Carga configuración desde archivo YAML"""
|
|
try:
|
|
with open(self.config_file, 'r', encoding='utf-8') as f:
|
|
self.config = yaml.safe_load(f)
|
|
|
|
# Validar configuración
|
|
if 'devices' not in self.config:
|
|
raise ValueError("No se encontró sección 'devices' en configuración")
|
|
|
|
if 'monitoring' not in self.config:
|
|
raise ValueError("No se encontró sección 'monitoring' en configuración")
|
|
|
|
# Crear objetos DeviceConfig
|
|
self.devices = []
|
|
for device_data in self.config['devices']:
|
|
device = DeviceConfig(**device_data)
|
|
self.devices.append(device)
|
|
|
|
self.logger.info(f"Configuración cargada: {len(self.devices)} dispositivos")
|
|
return True
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error cargando configuración: {str(e)}")
|
|
return False
|
|
|
|
def monitor_single_device(self, device: DeviceConfig) -> List[MacEntry]:
|
|
"""Monitoriza un dispositivo individual"""
|
|
ssh_connector = CiscoSSHConnector(device)
|
|
mac_entries = []
|
|
|
|
try:
|
|
if ssh_connector.connect():
|
|
mac_entries = self.mac_parser.get_mac_table(ssh_connector)
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Error monitorizando {device.hostname}: {str(e)}")
|
|
|
|
finally:
|
|
ssh_connector.disconnect()
|
|
|
|
return mac_entries
|
|
|
|
def monitor_all_devices(self) -> Dict[str, List[MacEntry]]:
|
|
"""Monitoriza todos los dispositivos configurados"""
|
|
all_data = {}
|
|
|
|
for device in self.devices:
|
|
self.logger.info(f"Monitorizando dispositivo: {device.hostname}")
|
|
mac_entries = self.monitor_single_device(device)
|
|
all_data[device.hostname] = mac_entries
|
|
|
|
return all_data
|
|
|
|
def run_monitoring_cycle(self) -> Dict[str, Any]:
|
|
"""Ejecuta un ciclo completo de monitorización"""
|
|
self.logger.info("Iniciando ciclo de monitorización")
|
|
|
|
# Monitorizar todos los dispositivos
|
|
device_data = self.monitor_all_devices()
|
|
|
|
# Formatear para Zabbix
|
|
zabbix_data = self.zabbix_formatter.format_for_zabbix(device_data)
|
|
|
|
self.logger.info("Ciclo de monitorización completado")
|
|
|
|
return zabbix_data
|
|
|
|
def run_continuous_monitoring(self):
|
|
"""Ejecuta monitorización continua según configuración"""
|
|
if not self.config:
|
|
self.logger.error("No hay configuración cargada")
|
|
return
|
|
|
|
interval = self.config['monitoring'].get('interval_minutes', 5)
|
|
output_file = self.config['monitoring'].get('output_file', '/tmp/cisco_mac_data.json')
|
|
|
|
self.logger.info(f"Iniciando monitorización continua cada {interval} minutos")
|
|
|
|
while True:
|
|
try:
|
|
# Ejecutar ciclo de monitorización
|
|
zabbix_data = self.run_monitoring_cycle()
|
|
|
|
# Guardar datos
|
|
with open(output_file, 'w', encoding='utf-8') as f:
|
|
json.dump(zabbix_data, f, indent=2, ensure_ascii=False)
|
|
|
|
self.logger.info(f"Datos guardados en: {output_file}")
|
|
|
|
# Esperar hasta el siguiente ciclo
|
|
time.sleep(interval * 60)
|
|
|
|
except KeyboardInterrupt:
|
|
self.logger.info("Monitorización detenida por usuario")
|
|
break
|
|
except Exception as e:
|
|
self.logger.error(f"Error en ciclo de monitorización: {str(e)}")
|
|
time.sleep(60) # Esperar 1 minuto antes de reintentar
|
|
|
|
|
|
def main():
|
|
"""Función principal"""
|
|
import argparse
|
|
|
|
parser = argparse.ArgumentParser(description='Monitor de direcciones MAC para dispositivos Cisco')
|
|
parser.add_argument('--config', '-c', default='config.yaml', help='Archivo de configuración')
|
|
parser.add_argument('--single-run', '-s', action='store_true', help='Ejecutar una sola vez')
|
|
parser.add_argument('--output', '-o', help='Archivo de salida para modo single-run')
|
|
|
|
args = parser.parse_args()
|
|
|
|
monitor = CiscoMacMonitor(args.config)
|
|
|
|
if not monitor.load_config():
|
|
sys.exit(1)
|
|
|
|
if args.single_run:
|
|
# Ejecución única
|
|
zabbix_data = monitor.run_monitoring_cycle()
|
|
|
|
output_file = args.output or '/tmp/cisco_mac_data.json'
|
|
with open(output_file, 'w', encoding='utf-8') as f:
|
|
json.dump(zabbix_data, f, indent=2, ensure_ascii=False)
|
|
|
|
print(f"Datos guardados en: {output_file}")
|
|
else:
|
|
# Monitorización continua
|
|
monitor.run_continuous_monitoring()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main() |