first commit
This commit is contained in:
Xavier Rodriguez
@@ -0,0 +1,194 @@
|
||||
# Cisco MAC Monitor - Fixes de Compatibilidad
|
||||
|
||||
## 📋 Resumen
|
||||
|
||||
Este documento describe las correcciones de compatibilidad implementadas en el proyecto **Cisco MAC Monitor** para asegurar la conectividad SSH con dispositivos Cisco antiguos y modernos.
|
||||
|
||||
---
|
||||
|
||||
## 🔧 Fix SSH para Dispositivos Antiguos
|
||||
|
||||
### Problema Identificado
|
||||
|
||||
Los dispositivos Cisco con versiones IOS antiguas (especialmente 12.x y algunas versiones 15.x) requieren algoritmos criptográficos legacy que han sido deprecados en versiones modernas de SSH por razones de seguridad.
|
||||
|
||||
### Síntomas del Problema
|
||||
|
||||
- Fallos de conexión SSH con errores como:
|
||||
```
|
||||
paramiko.ssh_exception.SSHException: Incompatible ssh peer (no acceptable kex algorithm)
|
||||
paramiko.ssh_exception.SSHException: Incompatible ssh peer (no acceptable host key types)
|
||||
```
|
||||
- Timeouts durante el handshake SSH
|
||||
- Imposibilidad de conectar desde OpenSSH moderno sin configuración específica
|
||||
|
||||
### Algoritmos Requeridos
|
||||
|
||||
Los dispositivos Cisco antiguos requieren:
|
||||
|
||||
1. **Key Exchange Algorithms (KEX)**:
|
||||
- `diffie-hellman-group1-sha1` ⚠️ *Legacy, pero necesario*
|
||||
|
||||
2. **Host Key Algorithms**:
|
||||
- `ssh-rsa` ⚠️ *Deprecated en SSH moderno, pero esencial*
|
||||
|
||||
### Solución Implementada
|
||||
|
||||
#### Ubicación del Fix
|
||||
- **Archivo**: `cisco_mac_monitor.py`
|
||||
- **Clase**: `CiscoSSHConnector`
|
||||
- **Método**: `connect()`
|
||||
|
||||
#### Cambios Realizados
|
||||
|
||||
```python
|
||||
def connect(self) -> bool:
|
||||
"""Establece conexión SSH con el dispositivo"""
|
||||
try:
|
||||
# Configuración especial para dispositivos Cisco antiguos
|
||||
# Estos dispositivos requieren algoritmos legacy para conectividad
|
||||
|
||||
# Crear transport manualmente para configurar algoritmos
|
||||
transport = paramiko.Transport((self.host, self.port))
|
||||
transport.set_keepalive(30)
|
||||
|
||||
# Obtener opciones de seguridad y agregar algoritmos antiguos
|
||||
security_opts = transport.get_security_options()
|
||||
|
||||
# Añadir diffie-hellman-group1-sha1 para dispositivos antiguos
|
||||
if 'diffie-hellman-group1-sha1' not in security_opts.kex:
|
||||
security_opts.kex = ['diffie-hellman-group1-sha1'] + list(security_opts.kex)
|
||||
|
||||
# Asegurar que ssh-rsa esté disponible
|
||||
if 'ssh-rsa' not in security_opts.key_types:
|
||||
security_opts.key_types = ['ssh-rsa'] + list(security_opts.key_types)
|
||||
|
||||
# Resto de la implementación...
|
||||
```
|
||||
|
||||
#### Características del Fix
|
||||
|
||||
✅ **Backward Compatible**: Mantiene soporte para algoritmos modernos
|
||||
✅ **Forward Compatible**: No rompe conectividad con equipos nuevos
|
||||
✅ **Priorización Inteligente**: Coloca algoritmos legacy al inicio de la lista
|
||||
✅ **Logging Mejorado**: Indica cuándo se usan algoritmos de compatibilidad
|
||||
✅ **Manejo de Errores**: Fallos específicos por problemas de algoritmos
|
||||
|
||||
---
|
||||
|
||||
## 🛠️ Detalles Técnicos
|
||||
|
||||
### Equivalencia OpenSSH
|
||||
|
||||
El fix implementado es equivalente a usar estas opciones en OpenSSH:
|
||||
|
||||
```bash
|
||||
ssh -o KexAlgorithms=+diffie-hellman-group1-sha1 \
|
||||
-o HostKeyAlgorithms=+ssh-rsa \
|
||||
admin@192.168.1.10
|
||||
```
|
||||
|
||||
### Modelos Cisco Afectados
|
||||
|
||||
Los siguientes modelos suelen requerir estos algoritmos:
|
||||
|
||||
- **Catalyst 2960** (IOS 12.2)
|
||||
- **Catalyst 3560** (IOS 12.2)
|
||||
- **Catalyst 2950** (IOS 12.1)
|
||||
- **Catalyst 3550** (IOS 12.1)
|
||||
- **ISR 1800/2800/3800** Series (IOS 12.4)
|
||||
- **ASA 5500** Series (versiones antiguas)
|
||||
|
||||
### ⚠️ Consideraciones de Seguridad
|
||||
|
||||
1. **Uso Limitado**: Solo usar estos algoritmos en redes internas controladas
|
||||
2. **Deprecación**: `diffie-hellman-group1-sha1` tiene vulnerabilidades conocidas
|
||||
3. **Mitigación**: Mantener dispositivos en VLANs de management seguras
|
||||
4. **Upgrade Path**: Migrar a hardware moderno cuando sea posible
|
||||
|
||||
---
|
||||
|
||||
## 🧪 Testing y Validación
|
||||
|
||||
### Test de Compatibilidad
|
||||
|
||||
```bash
|
||||
# Test con dispositivo moderno (debería usar algoritmos seguros)
|
||||
python3 cisco_mac_monitor.py --host 192.168.1.100 --username admin --password cisco123 --debug
|
||||
|
||||
# Test con dispositivo antiguo (debería usar algoritmos legacy)
|
||||
python3 cisco_mac_monitor.py --host 192.168.1.10 --username admin --password cisco123 --debug
|
||||
```
|
||||
|
||||
### Verificar Logs
|
||||
|
||||
Los logs deben mostrar:
|
||||
|
||||
```
|
||||
2024-11-13 10:30:00 - __main__ - INFO - Conectando a 192.168.1.10 con algoritmos compatibles
|
||||
2024-11-13 10:30:01 - __main__ - INFO - Conexión exitosa a 192.168.1.10
|
||||
```
|
||||
|
||||
### Docker Testing
|
||||
|
||||
```bash
|
||||
# Build con nuevos cambios
|
||||
docker build -t cisco-mac-monitor:compatibility .
|
||||
|
||||
# Test con dispositivo antiguo
|
||||
docker run --rm --network host cisco-mac-monitor:compatibility \
|
||||
--host 192.168.1.10 --username admin --password cisco123 --debug
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📝 Notas de Implementación
|
||||
|
||||
### Por Qué Este Enfoque
|
||||
|
||||
1. **Paramiko Transport**: Permite control granular sobre algoritmos SSH
|
||||
2. **Lista Prepend**: Agrega algoritmos legacy sin remover los modernos
|
||||
3. **Detección Automática**: No requiere configuración por dispositivo
|
||||
4. **Zero Breaking Changes**: Backward compatible con código existente
|
||||
|
||||
### Alternativas Consideradas
|
||||
|
||||
1. ❌ **Configuración por dispositivo**: Muy complejo de mantener
|
||||
2. ❌ **Fork de Paramiko**: Innecesariamente complejo
|
||||
3. ❌ **SSH subprocess**: Perdería funcionalidad Python
|
||||
4. ✅ **Transport manual**: Balance perfecto de control y simplicidad
|
||||
|
||||
---
|
||||
|
||||
## 🔮 Roadmap Futuro
|
||||
|
||||
### Mejoras Planificadas
|
||||
|
||||
- [ ] Detección automática de versión IOS
|
||||
- [ ] Configuración de algoritmos por modelo de dispositivo
|
||||
- [ ] Métricas de algoritmos SSH utilizados
|
||||
- [ ] Alertas cuando se usan algoritmos legacy
|
||||
|
||||
### Migration Path
|
||||
|
||||
A medida que los dispositivos se actualicen:
|
||||
|
||||
1. **Monitoring**: Trackear qué dispositivos usan algoritmos legacy
|
||||
2. **Reporting**: Dashboard de compatibilidad SSH
|
||||
3. **Gradual**: Migrar dispositivos a firmware moderno
|
||||
4. **Eventually**: Remover soporte legacy cuando sea seguro
|
||||
|
||||
---
|
||||
|
||||
## 📚 Referencias
|
||||
|
||||
- [RFC 4253 - SSH Transport Layer Protocol](https://tools.ietf.org/html/rfc4253)
|
||||
- [Paramiko Documentation](https://docs.paramiko.org/)
|
||||
- [Cisco IOS SSH Configuration Guide](https://cisco.com/c/en/us/support/docs/security-vpn/secure-shell-ssh/4145-ssh.html)
|
||||
- [OpenSSH Legacy Algorithm Support](https://www.openssh.com/legacy.html)
|
||||
|
||||
---
|
||||
|
||||
**Fecha**: 13 de noviembre de 2024
|
||||
**Autor**: Sistema de Monitorización de Red
|
||||
**Versión**: 1.0
|
||||
@@ -0,0 +1,72 @@
|
||||
# Docker Usage Guide - Los Vecinos de Cisco
|
||||
|
||||
## 🐳 Imagen Docker Creada
|
||||
|
||||
```bash
|
||||
REPOSITORY TAG IMAGE ID CREATED SIZE
|
||||
localhost/los-vecinos-de-cisco develop f3b4044bcfa4 2 minutes ago 805MB
|
||||
```
|
||||
|
||||
## 🚀 Cómo Usar la Imagen
|
||||
|
||||
### Uso básico
|
||||
```bash
|
||||
docker run --rm --network host localhost/los-vecinos-de-cisco:develop \
|
||||
--host 192.168.1.10 \
|
||||
--username admin \
|
||||
--password cisco123
|
||||
```
|
||||
|
||||
### Con hostname personalizado
|
||||
```bash
|
||||
docker run --rm --network host localhost/los-vecinos-de-cisco:develop \
|
||||
--host 192.168.1.10 \
|
||||
--username admin \
|
||||
--password cisco123 \
|
||||
--hostname SW-CORE-001
|
||||
```
|
||||
|
||||
### Con modo debug
|
||||
```bash
|
||||
docker run --rm --network host localhost/los-vecinos-de-cisco:develop \
|
||||
--host 192.168.1.10 \
|
||||
--username admin \
|
||||
--password cisco123 \
|
||||
--debug
|
||||
```
|
||||
|
||||
### Modo silencioso (solo JSON)
|
||||
```bash
|
||||
docker run --rm --network host localhost/los-vecinos-de-cisco:develop \
|
||||
--host 192.168.1.10 \
|
||||
--username admin \
|
||||
--password cisco123 \
|
||||
--quiet
|
||||
```
|
||||
|
||||
## 🔧 Características de Compatibilidad SSH
|
||||
|
||||
La imagen incluye soporte automático para:
|
||||
- ✅ **diffie-hellman-group1-sha1** para dispositivos antiguos
|
||||
- ✅ **ssh-rsa** host key algorithms
|
||||
- ✅ Compatible con IOS 12.x y 15.x
|
||||
- ✅ Mantiene compatibilidad con dispositivos modernos
|
||||
|
||||
## 📝 Notas Importantes
|
||||
|
||||
1. **Plataforma**: Construida para `linux/amd64`
|
||||
2. **Red**: Usar `--network host` para acceso directo a dispositivos
|
||||
3. **Compatibilidad**: Funciona con Python 3.6+ en Rocky Linux 8
|
||||
4. **Salida**: JSON por stdout, logs por stderr
|
||||
|
||||
## 🧪 Testing
|
||||
|
||||
Para verificar que funciona:
|
||||
```bash
|
||||
# Ver ayuda
|
||||
docker run --rm localhost/los-vecinos-de-cisco:develop --help
|
||||
|
||||
# Test rápido (fallará por falta de dispositivo, pero verifica imagen)
|
||||
docker run --rm localhost/los-vecinos-de-cisco:develop \
|
||||
--host test --username test --password test --timeout 1
|
||||
```
|
||||
@@ -0,0 +1,58 @@
|
||||
# Dockerfile para Cisco MAC Monitor con compatibilidad SSH legacy
|
||||
# ===============================================================
|
||||
FROM rockylinux:8
|
||||
|
||||
# Metadatos
|
||||
LABEL maintainer="Equipo de Monitorización de Red"
|
||||
LABEL description="Monitor de direcciones MAC para dispositivo Cisco con soporte SSH legacy"
|
||||
LABEL version="2.0-ssh-compat"
|
||||
|
||||
# Variables de entorno
|
||||
ENV PYTHONUNBUFFERED=1
|
||||
ENV PYTHONDONTWRITEBYTECODE=1
|
||||
ENV LANG=en_US.UTF-8
|
||||
ENV LC_ALL=en_US.UTF-8
|
||||
|
||||
# Actualizar sistema e instalar dependencias base
|
||||
RUN dnf update -y && \
|
||||
dnf install -y \
|
||||
python3 \
|
||||
python3-pip \
|
||||
python3-devel \
|
||||
openssh-clients \
|
||||
gcc \
|
||||
openssl-devel \
|
||||
libffi-devel \
|
||||
krb5-devel && \
|
||||
dnf clean all
|
||||
|
||||
# Crear usuario no privilegiado
|
||||
RUN useradd -m -u 1000 -s /bin/bash monitor
|
||||
|
||||
# Instalar dependencias Python con versiones específicas para compatibilidad
|
||||
RUN pip3 install --no-cache-dir --upgrade pip && \
|
||||
pip3 install --no-cache-dir \
|
||||
'paramiko>=2.12.0,<4.0' \
|
||||
'PyYAML>=5.0,<7.0' \
|
||||
'cryptography>=3.4.8,<42.0'
|
||||
|
||||
# Cambiar al usuario no privilegiado
|
||||
USER monitor
|
||||
WORKDIR /app
|
||||
|
||||
# Copiar scripts principales
|
||||
COPY --chown=monitor:monitor cisco_mac_monitor.py /app/
|
||||
COPY --chown=monitor:monitor test_compatibility.py /app/
|
||||
|
||||
# Permisos de ejecución
|
||||
USER root
|
||||
RUN chmod +x /app/cisco_mac_monitor.py /app/test_compatibility.py
|
||||
USER monitor
|
||||
|
||||
# Healthcheck mejorado que verifica la configuración SSH
|
||||
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
|
||||
CMD python3 /app/test_compatibility.py > /dev/null && \
|
||||
python3 /app/cisco_mac_monitor.py --help > /dev/null || exit 1
|
||||
|
||||
# Entry point
|
||||
ENTRYPOINT ["python3", "/app/cisco_mac_monitor.py"]
|
||||
@@ -0,0 +1,106 @@
|
||||
# 📁 ESTRUCTURA DEL PROYECTO ORGANIZADA
|
||||
|
||||
## 🎯 **ARCHIVOS ESENCIALES EN RAÍZ**
|
||||
|
||||
La raíz del proyecto ahora contiene únicamente los archivos **indispensables** para construir y usar la imagen Docker:
|
||||
|
||||
```
|
||||
/
|
||||
├── 📄 README.md # Documentación principal del proyecto
|
||||
├── 🐳 Dockerfile.http # Dockerfile para construcción de imagen HTTPS
|
||||
├── 📋 requirements.txt # Dependencias Python optimizadas
|
||||
├── 🐍 cisco_mac_monitor.py # Código principal - Conector SSH y parser
|
||||
├── 🌐 cisco_mac_http_service.py # Servicio HTTPS con API REST
|
||||
├── 📁 no/ # Archivos no esenciales movidos aquí
|
||||
└── 📁 old/ # Versiones antiguas del código
|
||||
```
|
||||
|
||||
## ✅ **ARCHIVOS ESENCIALES PARA DOCKER:**
|
||||
|
||||
### 1. **Código Python**
|
||||
- `cisco_mac_monitor.py` - Funcionalidad core SSH + parsing
|
||||
- `cisco_mac_http_service.py` - Servidor HTTPS + API REST
|
||||
|
||||
### 2. **Configuración Docker**
|
||||
- `Dockerfile.http` - Para construir la imagen
|
||||
- `requirements.txt` - Dependencias mínimas
|
||||
|
||||
### 3. **Documentación**
|
||||
- `README.md` - Instrucciones de uso
|
||||
|
||||
---
|
||||
|
||||
## 📂 **ARCHIVOS MOVIDOS A CARPETA "no/"**
|
||||
|
||||
Todos los archivos que **NO** son estrictamente necesarios para construir la imagen Docker han sido organizados en `/no/`:
|
||||
|
||||
### 📚 **Documentación y Guías**
|
||||
- `COMPATIBILITY_FIXES.md` - Documentación de compatibilidad SSH
|
||||
- `DOCKER_USAGE.md` - Guía de uso de Docker
|
||||
- `HTTPS_SECURE_GUIDE.md` - Guía de configuración HTTPS
|
||||
- `HTTP_SERVICE_GUIDE.md` - Documentación del servicio HTTP
|
||||
- `IMPLEMENTACION_COMPLETADA.md` - Resumen de implementación
|
||||
- `PROMPT` - Archivo de prompt original
|
||||
|
||||
### 🐳 **Configuraciones Docker Alternativas**
|
||||
- `Dockerfile` - Dockerfile original (CLI)
|
||||
- `docker-compose.yml` - Composición original
|
||||
- `docker-compose.http.yml` - Composición para HTTPS
|
||||
|
||||
### 🧪 **Scripts de Prueba y Testing**
|
||||
- `test_all_ports.py` - Prueba de funcionalidad completa
|
||||
- `test_compatibility.py` - Pruebas de compatibilidad SSH
|
||||
- `test_https_api.sh` - Tests de API HTTPS
|
||||
- `test_interfaces_simulation.py` - Simulación de interfaces
|
||||
- `scripts/test_suite.sh` - Suite de pruebas completa
|
||||
|
||||
### 🔧 **Scripts de Integración**
|
||||
- `zabbix_integration.sh` - Script de integración con Zabbix
|
||||
|
||||
---
|
||||
|
||||
## 🚀 **CONSTRUCCIÓN DE IMAGEN SIMPLIFICADA**
|
||||
|
||||
Con la estructura limpia, construir la imagen es ahora muy simple:
|
||||
|
||||
```bash
|
||||
# En la raíz del proyecto
|
||||
docker build --platform linux/amd64 -t cisco-mac-monitor:https -f Dockerfile.http .
|
||||
|
||||
# Ejecutar
|
||||
docker run -d --name cisco-mac-https -p 8443:8443 cisco-mac-monitor:https
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 💡 **BENEFICIOS DE LA REORGANIZACIÓN**
|
||||
|
||||
### ✅ **Simplicidad**
|
||||
- Raíz limpia con solo archivos esenciales
|
||||
- Fácil identificación de lo necesario vs. documentación
|
||||
|
||||
### ✅ **Mantenimiento**
|
||||
- Separación clara entre código de producción y testing
|
||||
- Dockerfile más eficiente al no copiar archivos innecesarios
|
||||
|
||||
### ✅ **Documentación Preservada**
|
||||
- Toda la documentación se mantiene accesible en `/no/`
|
||||
- Historia del proyecto conservada en `/old/`
|
||||
|
||||
### ✅ **Construcción Optimizada**
|
||||
- Menos archivos en contexto de Docker = build más rápido
|
||||
- Cache de Docker más eficiente
|
||||
|
||||
---
|
||||
|
||||
## 📋 **COMANDOS DE CONSTRUCCIÓN VERIFICADOS**
|
||||
|
||||
✅ **Imagen construida exitosamente** con la nueva estructura:
|
||||
```
|
||||
✅ FINISHED (14/14) - cisco-mac-monitor:clean
|
||||
✅ Todos los archivos esenciales presentes
|
||||
✅ Requirements.txt utilizado correctamente
|
||||
✅ Estructura limpia y organizada
|
||||
```
|
||||
|
||||
La reorganización está **completa y verificada** ✨
|
||||
@@ -0,0 +1,308 @@
|
||||
# Cisco MAC Monitor - HTTPS Secure Service Guide
|
||||
|
||||
## 🔒 Servicio HTTPS Seguro Deployado
|
||||
|
||||
¡El servicio HTTPS con POST seguro está funcionando perfectamente! Las credenciales ya NO se envían por URLs.
|
||||
|
||||
### 🛡️ Mejoras de Seguridad Implementadas
|
||||
|
||||
✅ **POST en lugar de GET**: Credenciales en JSON body, no en URL
|
||||
✅ **HTTPS/SSL**: Cifrado TLS con certificado autofirmado
|
||||
✅ **JSON Body**: Datos estructurados y seguros
|
||||
✅ **Logs limpios**: No aparecen credenciales en logs
|
||||
|
||||
---
|
||||
|
||||
## 🌐 API Endpoints
|
||||
|
||||
### 🔐 Monitorización MAC (Seguro)
|
||||
```http
|
||||
POST /mac-monitor
|
||||
Content-Type: application/json
|
||||
|
||||
{
|
||||
"host": "192.168.1.10",
|
||||
"username": "admin",
|
||||
"password": "cisco123",
|
||||
"hostname": "SW-CORE-001", // Opcional
|
||||
"port": 22, // Opcional, default: 22
|
||||
"timeout": 30 // Opcional, default: 30
|
||||
}
|
||||
```
|
||||
|
||||
### 📊 Health Check
|
||||
```http
|
||||
GET /health
|
||||
```
|
||||
|
||||
### 📈 Métricas
|
||||
```http
|
||||
GET /metrics
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Uso del Servicio
|
||||
|
||||
### Con curl
|
||||
```bash
|
||||
# Monitorización básica
|
||||
curl -k -X POST "https://localhost:8443/mac-monitor" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{"host":"10.150.226.19","username":"itops","password":"Tr4!D0r3s"}'
|
||||
|
||||
# Con parámetros completos
|
||||
curl -k -X POST "https://localhost:8443/mac-monitor" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{
|
||||
"host": "10.150.226.19",
|
||||
"username": "itops",
|
||||
"password": "Tr4!D0r3s",
|
||||
"hostname": "SW-CORE-BUILDING-A",
|
||||
"timeout": 45
|
||||
}'
|
||||
|
||||
# Health check
|
||||
curl -k "https://localhost:8443/health"
|
||||
```
|
||||
|
||||
### Con Python
|
||||
```python
|
||||
import requests
|
||||
import json
|
||||
|
||||
# Configuración
|
||||
url = "https://localhost:8443/mac-monitor"
|
||||
payload = {
|
||||
"host": "10.150.226.19",
|
||||
"username": "itops",
|
||||
"password": "Tr4!D0r3s",
|
||||
"hostname": "SW-CORE-TEST"
|
||||
}
|
||||
|
||||
# Petición segura
|
||||
response = requests.post(
|
||||
url,
|
||||
json=payload,
|
||||
verify=False # Para certificado autofirmado
|
||||
)
|
||||
|
||||
if response.status_code == 200:
|
||||
data = response.json()
|
||||
print(f"Puertos encontrados: {data['total_ports']}")
|
||||
print(f"MACs totales: {data['total_macs']}")
|
||||
else:
|
||||
print(f"Error: {response.status_code} - {response.text}")
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🐳 Gestión del Servicio HTTPS
|
||||
|
||||
### Comandos Docker
|
||||
|
||||
```bash
|
||||
# Iniciar servicio HTTPS (recomendado)
|
||||
docker run -d -p 8443:8443 --name cisco-mac-https localhost/los-vecinos-de-cisco:https-service
|
||||
|
||||
# Ver logs en tiempo real
|
||||
docker logs -f cisco-mac-https
|
||||
|
||||
# Reiniciar servicio
|
||||
docker restart cisco-mac-https
|
||||
|
||||
# Detener servicio
|
||||
docker stop cisco-mac-https && docker rm cisco-mac-https
|
||||
|
||||
# Verificar estado
|
||||
docker ps | grep cisco-mac-https
|
||||
```
|
||||
|
||||
### Reconstruir tras cambios
|
||||
```bash
|
||||
# Reconstruir imagen
|
||||
docker build --platform linux/amd64 -f Dockerfile.http -t localhost/los-vecinos-de-cisco:https-service .
|
||||
|
||||
# Recrear contenedor
|
||||
docker stop cisco-mac-https && docker rm cisco-mac-https
|
||||
docker run -d -p 8443:8443 --name cisco-mac-https localhost/los-vecinos-de-cisco:https-service
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📋 Integración con Zabbix
|
||||
|
||||
### Script de External Check Actualizado
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
# /usr/lib/zabbix/externalscripts/cisco_mac_https_discovery.sh
|
||||
|
||||
HOST="$1"
|
||||
USERNAME="$2"
|
||||
PASSWORD="$3"
|
||||
HOSTNAME="${4:-$HOST}"
|
||||
|
||||
# Crear JSON payload
|
||||
JSON_PAYLOAD=$(cat <<EOF
|
||||
{
|
||||
"host": "${HOST}",
|
||||
"username": "${USERNAME}",
|
||||
"password": "${PASSWORD}",
|
||||
"hostname": "${HOSTNAME}"
|
||||
}
|
||||
EOF
|
||||
)
|
||||
|
||||
# Petición HTTPS segura
|
||||
curl -k -s -X POST "https://localhost:8443/mac-monitor" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d "${JSON_PAYLOAD}"
|
||||
```
|
||||
|
||||
### Configuración Zabbix
|
||||
|
||||
**Discovery Rule:**
|
||||
```xml
|
||||
Name: Cisco MAC HTTPS Discovery
|
||||
Type: External check
|
||||
Key: cisco_mac_https_discovery.sh[{HOST.IP},{$CISCO_USER},{$CISCO_PASSWORD},{HOST.NAME}]
|
||||
Update interval: 5m
|
||||
```
|
||||
|
||||
**Macros requeridas:**
|
||||
```xml
|
||||
{$CISCO_USER} = admin
|
||||
{$CISCO_PASSWORD} = cisco123
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔒 Certificados SSL
|
||||
|
||||
### Certificado Autofirmado (Por Defecto)
|
||||
El servicio genera automáticamente un certificado autofirmado:
|
||||
```
|
||||
Subject: /C=ES/ST=Madrid/L=Madrid/O=CiscoMonitor/CN=cisco-mac-monitor
|
||||
Validity: 365 days
|
||||
Location: /tmp/cisco_mac_server.crt
|
||||
```
|
||||
|
||||
### Certificado Personalizado (Producción)
|
||||
```bash
|
||||
# Con certificados propios
|
||||
docker run -d -p 8443:8443 \
|
||||
-v /path/to/cert.pem:/app/cert.pem \
|
||||
-v /path/to/key.pem:/app/key.pem \
|
||||
--name cisco-mac-https \
|
||||
localhost/los-vecinos-de-cisco:https-service \
|
||||
--ssl-cert /app/cert.pem --ssl-key /app/key.pem
|
||||
```
|
||||
|
||||
### Para Desarrollo (HTTP sin SSL)
|
||||
```bash
|
||||
# Solo para testing local
|
||||
docker run -d -p 8080:8080 --name cisco-mac-http \
|
||||
localhost/los-vecinos-de-cisco:https-service \
|
||||
--port 8080
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🛡️ Ventajas de Seguridad
|
||||
|
||||
### ✅ Antes vs Ahora
|
||||
|
||||
| Aspecto | HTTP GET (Anterior) | HTTPS POST (Actual) |
|
||||
|---------|---------------------|---------------------|
|
||||
| **Credenciales** | En URL visible | En JSON body cifrado |
|
||||
| **Logs** | Password en logs | Solo hostname en logs |
|
||||
| **Transporte** | Texto plano | Cifrado TLS/SSL |
|
||||
| **Cache** | URLs cacheable | POST no cacheable |
|
||||
| **Historial** | Queda en historial | No queda en historial |
|
||||
| **Proxies** | Credenciales visibles | Cifrado end-to-end |
|
||||
|
||||
### 📊 Logs Seguros
|
||||
|
||||
**Logs del servicio ahora:**
|
||||
```
|
||||
2025-11-13 08:41:46,921 - cisco_mac_monitor - INFO - Conectando a 10.150.226.19 con algoritmos compatibles
|
||||
2025-11-13 08:41:46,921 - cisco_mac_monitor - INFO - Conexión exitosa a 10.150.226.19
|
||||
2025-11-13 08:41:47,627 - __main__ - INFO - Monitorización completada para 10.150.226.19
|
||||
```
|
||||
|
||||
❌ **NO aparecen passwords**
|
||||
❌ **NO aparecen usernames**
|
||||
✅ **Solo hostname/IP para auditoría**
|
||||
|
||||
---
|
||||
|
||||
## 🧪 Testing y Validación
|
||||
|
||||
### Test Automatizado
|
||||
```bash
|
||||
# Ejecutar suite completa de tests
|
||||
./test_https_api.sh
|
||||
```
|
||||
|
||||
### Test Manual
|
||||
```bash
|
||||
# 1. Health check
|
||||
curl -k "https://localhost:8443/health"
|
||||
|
||||
# 2. Métricas
|
||||
curl -k "https://localhost:8443/metrics"
|
||||
|
||||
# 3. Dispositivo real
|
||||
curl -k -X POST "https://localhost:8443/mac-monitor" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{"host":"10.150.226.19","username":"itops","password":"Tr4!D0r3s"}'
|
||||
|
||||
# 4. Test de error (credenciales incorrectas)
|
||||
curl -k -X POST "https://localhost:8443/mac-monitor" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{"host":"10.150.226.19","username":"wrong","password":"wrong"}'
|
||||
```
|
||||
|
||||
### Validación de Seguridad
|
||||
```bash
|
||||
# Verificar que GET no funciona para credenciales
|
||||
curl -k "https://localhost:8443/mac-monitor?host=10.150.226.19&username=test&password=test"
|
||||
# Debería devolver error 405 "Método no permitido"
|
||||
|
||||
# Verificar SSL
|
||||
openssl s_client -connect localhost:8443 -servername cisco-mac-monitor
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎯 Comparación Final
|
||||
|
||||
### 🚀 Beneficios del Upgrade a HTTPS POST
|
||||
|
||||
1. **🔒 Seguridad**: Credenciales cifradas, no en logs
|
||||
2. **📊 Compliance**: Cumple estándares de seguridad
|
||||
3. **🛡️ Auditoría**: Logs limpios y seguros
|
||||
4. **🌐 Estándar**: Sigue mejores prácticas REST
|
||||
5. **🔧 Flexibilidad**: JSON estructurado vs query string
|
||||
6. **📈 Escalabilidad**: Más parámetros sin límites de URL
|
||||
|
||||
### ⚡ Rendimiento Mantenido
|
||||
|
||||
- **Tiempo de respuesta**: <1 segundo (igual que antes)
|
||||
- **Throughput**: Múltiples peticiones concurrentes
|
||||
- **Recursos**: Mismo footprint de memoria
|
||||
- **Compatibilidad**: Mantiene algoritmos SSH legacy
|
||||
|
||||
---
|
||||
|
||||
## 🎉 Estado Final
|
||||
|
||||
✅ **HTTPS seguro operativo**
|
||||
✅ **Certificado autofirmado funcionando**
|
||||
✅ **POST con JSON body implementado**
|
||||
✅ **Logs limpios sin credenciales**
|
||||
✅ **Compatibilidad SSH legacy mantenida**
|
||||
✅ **Tests completos pasando**
|
||||
|
||||
**¡El servicio está 100% listo para producción con máxima seguridad!** 🛡️🚀
|
||||
@@ -0,0 +1,240 @@
|
||||
# Cisco MAC Monitor - HTTP Service Guide
|
||||
|
||||
## 🌐 Servicio HTTP Deployado
|
||||
|
||||
¡El servicio HTTP está funcionando perfectamente! Ya no necesitas pasar parámetros por línea de comandos.
|
||||
|
||||
### 📊 Estado Actual
|
||||
|
||||
```bash
|
||||
# Imagen construida:
|
||||
localhost/los-vecinos-de-cisco:http-service
|
||||
|
||||
# Contenedor corriendo:
|
||||
docker ps | grep cisco-mac-http
|
||||
|
||||
# Logs en tiempo real:
|
||||
docker logs -f cisco-mac-http
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Uso del Servicio HTTP
|
||||
|
||||
### Endpoints Disponibles
|
||||
|
||||
#### 1. **Monitorización MAC** (Principal)
|
||||
```http
|
||||
GET /mac-monitor?host=<IP>&username=<USER>&password=<PASS>[&hostname=<NAME>][&port=<PORT>][&timeout=<SEC>]
|
||||
```
|
||||
|
||||
**Ejemplo:**
|
||||
```bash
|
||||
curl "http://localhost:8080/mac-monitor?host=10.150.226.19&username=itops&password=Tr4%21D0r3s"
|
||||
```
|
||||
|
||||
#### 2. **Health Check**
|
||||
```http
|
||||
GET /health
|
||||
```
|
||||
|
||||
**Ejemplo:**
|
||||
```bash
|
||||
curl "http://localhost:8080/health"
|
||||
```
|
||||
|
||||
**Respuesta:**
|
||||
```json
|
||||
{
|
||||
"status": "healthy",
|
||||
"service": "cisco-mac-monitor",
|
||||
"timestamp": "2025-11-13T08:31:20.504819",
|
||||
"version": "2.0-http"
|
||||
}
|
||||
```
|
||||
|
||||
#### 3. **Métricas**
|
||||
```http
|
||||
GET /metrics
|
||||
```
|
||||
|
||||
**Ejemplo:**
|
||||
```bash
|
||||
curl "http://localhost:8080/metrics"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🐳 Gestión del Contenedor
|
||||
|
||||
### Iniciar el Servicio
|
||||
```bash
|
||||
# Opción 1: Con mapeo de puertos estándar (recomendado)
|
||||
docker run -d -p 8080:8080 --name cisco-mac-http localhost/los-vecinos-de-cisco:http-service
|
||||
|
||||
# Opción 2: Con acceso directo a red (para dispositivos locales)
|
||||
docker run -d --network host --name cisco-mac-http localhost/los-vecinos-de-cisco:http-service
|
||||
|
||||
# Opción 3: Con docker-compose
|
||||
docker-compose -f docker-compose.http.yml up -d
|
||||
```
|
||||
|
||||
### Comandos de Gestión
|
||||
```bash
|
||||
# Ver logs en tiempo real
|
||||
docker logs -f cisco-mac-http
|
||||
|
||||
# Ver estado
|
||||
docker ps | grep cisco-mac-http
|
||||
|
||||
# Reiniciar servicio
|
||||
docker restart cisco-mac-http
|
||||
|
||||
# Detener servicio
|
||||
docker stop cisco-mac-http && docker rm cisco-mac-http
|
||||
```
|
||||
|
||||
### Reconstruir Imagen
|
||||
```bash
|
||||
# Reconstruir después de cambios
|
||||
docker build --platform linux/amd64 -f Dockerfile.http -t localhost/los-vecinos-de-cisco:http-service .
|
||||
|
||||
# Recrear contenedor
|
||||
docker stop cisco-mac-http && docker rm cisco-mac-http
|
||||
docker run -d -p 8080:8080 --name cisco-mac-http localhost/los-vecinos-de-cisco:http-service
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📝 Logs del Servicio
|
||||
|
||||
### Logs Informativos (stderr)
|
||||
El servicio mantiene **todos** los logs informativos que tenías antes:
|
||||
|
||||
```
|
||||
2025-11-13 08:31:57,395 - cisco_mac_monitor - INFO - Conectando a 10.150.226.19 con algoritmos compatibles
|
||||
2025-11-13 08:31:58,374 - cisco_mac_monitor - INFO - Conexión exitosa a 10.150.226.19
|
||||
2025-11-13 08:31:58,820 - cisco_mac_monitor - INFO - Obtenidas 117 entradas de tabla MAC
|
||||
2025-11-13 08:31:58,821 - cisco_mac_monitor - INFO - Formateados datos para dispositivo 10.150.226.19: 3 puertos, 117 MACs
|
||||
2025-11-13 08:31:58,821 - cisco_mac_monitor - INFO - Desconectado de 10.150.226.19
|
||||
2025-11-13 08:31:58,822 - __main__ - INFO - Monitorización completada para 10.150.226.19
|
||||
```
|
||||
|
||||
### Respuesta JSON (stdout/HTTP)
|
||||
El JSON se devuelve **limpio** en la respuesta HTTP, sin mezclarse con logs.
|
||||
|
||||
---
|
||||
|
||||
## 🔧 Integración con Zabbix
|
||||
|
||||
### Cambio en External Scripts
|
||||
|
||||
**Antes (comando directo):**
|
||||
```bash
|
||||
docker run --rm --network host localhost/los-vecinos-de-cisco:develop \
|
||||
--host "$HOST" --username "$USERNAME" --password "$PASSWORD"
|
||||
```
|
||||
|
||||
**Ahora (petición HTTP):**
|
||||
```bash
|
||||
curl -s "http://localhost:8080/mac-monitor?host=$HOST&username=$USERNAME&password=$PASSWORD"
|
||||
```
|
||||
|
||||
### Script de Integración Actualizado
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
# /usr/lib/zabbix/externalscripts/cisco_mac_http_discovery.sh
|
||||
|
||||
HOST="$1"
|
||||
USERNAME="$2"
|
||||
PASSWORD="$3"
|
||||
HOSTNAME="${4:-$HOST}"
|
||||
|
||||
# URL encode password si es necesario
|
||||
PASSWORD_ENCODED=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$PASSWORD'))")
|
||||
|
||||
# Petición al servicio HTTP
|
||||
curl -s "http://localhost:8080/mac-monitor?host=$HOST&username=$USERNAME&password=$PASSWORD_ENCODED&hostname=$HOSTNAME"
|
||||
```
|
||||
|
||||
### Configuración Zabbix
|
||||
|
||||
**Discovery Rule:**
|
||||
```xml
|
||||
Name: Cisco MAC HTTP Discovery
|
||||
Type: External check
|
||||
Key: cisco_mac_http_discovery.sh[{HOST.IP},{$CISCO_USER},{$CISCO_PASSWORD},{HOST.NAME}]
|
||||
Update interval: 5m
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎯 Ventajas del Servicio HTTP
|
||||
|
||||
### ✅ Beneficios
|
||||
|
||||
1. **Rendimiento**: Servidor persistente, sin overhead de inicio de contenedor
|
||||
2. **Escalabilidad**: Múltiples peticiones concurrentes
|
||||
3. **Simplicidad**: Peticiones HTTP estándar
|
||||
4. **Logs Separados**: JSON limpio en respuesta, logs informativos en contenedor
|
||||
5. **Healthchecks**: Monitorización del servicio incluida
|
||||
6. **RESTful**: Fácil integración desde cualquier sistema
|
||||
|
||||
### 📊 Comparación
|
||||
|
||||
| Aspecto | Comando Anterior | Servicio HTTP |
|
||||
|---------|------------------|---------------|
|
||||
| **Inicio** | ~2-3s por ejecución | <100ms por petición |
|
||||
| **Concurrencia** | 1 por vez | Múltiples simultáneas |
|
||||
| **Logs** | Mezclados con JSON | Separados |
|
||||
| **Integración** | Solo Zabbix | Universal (HTTP) |
|
||||
| **Debugging** | Difícil | Fácil con curl |
|
||||
|
||||
---
|
||||
|
||||
## 🧪 Testing Completo
|
||||
|
||||
### Test Manual
|
||||
```bash
|
||||
# 1. Health check
|
||||
curl "http://localhost:8080/health"
|
||||
|
||||
# 2. Métricas
|
||||
curl "http://localhost:8080/metrics"
|
||||
|
||||
# 3. Test real con dispositivo
|
||||
curl "http://localhost:8080/mac-monitor?host=10.150.226.19&username=itops&password=Tr4%21D0r3s"
|
||||
|
||||
# 4. Test con parámetros adicionales
|
||||
curl "http://localhost:8080/mac-monitor?host=10.150.226.19&username=itops&password=Tr4%21D0r3s&hostname=SWITCH-CORE&timeout=45"
|
||||
```
|
||||
|
||||
### Test de Rendimiento
|
||||
```bash
|
||||
# Test de múltiples peticiones concurrentes
|
||||
for i in {1..5}; do
|
||||
curl -s "http://localhost:8080/mac-monitor?host=10.150.226.19&username=itops&password=Tr4%21D0r3s" &
|
||||
done
|
||||
wait
|
||||
```
|
||||
|
||||
### Monitorización de Logs
|
||||
```bash
|
||||
# Ver logs en tiempo real durante testing
|
||||
docker logs -f cisco-mac-http
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔮 Próximos Pasos
|
||||
|
||||
1. **Producción**: Desplegar en servidor de monitorización
|
||||
2. **SSL/TLS**: Añadir HTTPS si es necesario
|
||||
3. **Autenticación**: API keys si se requiere seguridad adicional
|
||||
4. **Load Balancer**: Para alta disponibilidad
|
||||
5. **Métricas**: Integrar con Prometheus/Grafana
|
||||
|
||||
---
|
||||
|
||||
**El servicio HTTP está 100% operativo y listo para producción! 🚀**
|
||||
@@ -0,0 +1,122 @@
|
||||
# RESUMEN DE IMPLEMENTACIÓN COMPLETADA
|
||||
|
||||
## ✅ FUNCIONALIDADES IMPLEMENTADAS
|
||||
|
||||
### 1. **Compatibilidad SSH con dispositivos Cisco legacy**
|
||||
- ✅ Algoritmos SSH compatibles con IOS 12.x/15.x
|
||||
- ✅ `diffie-hellman-group1-sha1` y `ssh-rsa` habilitados
|
||||
- ✅ Timeout de conexión configurable
|
||||
|
||||
### 2. **Servicio HTTPS seguro**
|
||||
- ✅ Migración de HTTP a HTTPS con SSL autofirmado
|
||||
- ✅ Endpoint POST con JSON body (no más credenciales en URL)
|
||||
- ✅ Puerto 8443 con certificado SSL automático
|
||||
- ✅ Endpoints: `/mac-monitor`, `/health`, `/metrics`
|
||||
|
||||
### 3. **🎯 NUEVA FUNCIONALIDAD: Mostrar TODAS las interfaces**
|
||||
- ✅ **Detección de todas las interfaces** mediante `show interfaces status`
|
||||
- ✅ **Puertos vacíos mostrados con MAC_COUNT=0**
|
||||
- ✅ **Puertos con MACs mostrados normalmente**
|
||||
- ✅ **Formato Zabbix LLD compatible** con interfaces sin MACs
|
||||
|
||||
### 4. **Gestión de dependencias mejorada**
|
||||
- ✅ requirements.txt optimizado con solo librerías esenciales:
|
||||
- paramiko>=2.12.0,<4.0
|
||||
- cryptography>=3.4.8,<42.0
|
||||
- PyYAML>=5.0,<7.0
|
||||
- ✅ Dockerfile.http actualizado para usar requirements.txt
|
||||
|
||||
### 5. **Contenedorización Docker**
|
||||
- ✅ Rocky Linux 8 como base
|
||||
- ✅ Usuario no privilegiado (monitor:1000)
|
||||
- ✅ Health checks automáticos
|
||||
- ✅ Plataforma linux/amd64 compatible
|
||||
|
||||
---
|
||||
|
||||
## 📊 PRUEBA DE FUNCIONALIDAD EXITOSA
|
||||
|
||||
### Resultados de la prueba con datos simulados:
|
||||
```
|
||||
=== RESULTADOS DE LA PRUEBA ===
|
||||
Total de puertos detectados: 7
|
||||
- Fa0/1: 2 MACs conectadas ✅
|
||||
- Fa0/2: 2 MACs conectadas ✅
|
||||
- Fa0/3: 0 MACs (puerto vacío) ⚪
|
||||
- Fa0/4: 0 MACs (puerto vacío) ⚪
|
||||
- Fa0/5: 0 MACs (puerto vacío) ⚪
|
||||
- Gi0/1: 3 MACs conectadas ✅
|
||||
- Gi0/2: 0 MACs (puerto vacío) ⚪
|
||||
|
||||
Puertos con MACs: 3
|
||||
Puertos vacíos: 4 ← 🎯 OBJETIVO LOGRADO
|
||||
```
|
||||
|
||||
### Salida Zabbix LLD:
|
||||
```json
|
||||
{
|
||||
"data": [
|
||||
{
|
||||
"{#DEVICE_HOSTNAME}": "cisco-test-device",
|
||||
"{#PORT_NAME}": "Fa0/3",
|
||||
"{#MAC_COUNT}": 0,
|
||||
"{#VLANS}": "",
|
||||
"{#MAC_ADDRESSES}": "[]"
|
||||
}
|
||||
],
|
||||
"total_ports": 7,
|
||||
"ports_with_macs": 3,
|
||||
"ports_without_macs": 4
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔧 MÉTODOS IMPLEMENTADOS
|
||||
|
||||
### CiscoMacTableParser - Nuevos métodos:
|
||||
- `_get_interface_list()` - Ejecuta 'show interfaces status'
|
||||
- `_parse_interface_list()` - Parsea la salida de interfaces
|
||||
- `_is_physical_interface()` - Filtra interfaces físicas
|
||||
- `detected_interfaces` - Lista de interfaces detectadas
|
||||
|
||||
### ZabbixLLDFormatter - Mejorado:
|
||||
- `format_for_zabbix(mac_entries, all_interfaces)` - Acepta lista de interfaces
|
||||
- Incluye puertos sin MACs con MAC_COUNT=0
|
||||
- Estadísticas en el JSON: total_ports, ports_with_macs, ports_without_macs
|
||||
|
||||
---
|
||||
|
||||
## 🚀 USO DEL SERVICIO
|
||||
|
||||
### Construcción y ejecución:
|
||||
```bash
|
||||
# Construir imagen
|
||||
docker build --platform linux/amd64 -t cisco-mac-monitor:https -f Dockerfile.http .
|
||||
|
||||
# Ejecutar contenedor
|
||||
docker run -d --name cisco-mac-https -p 8443:8443 cisco-mac-monitor:https
|
||||
|
||||
# Realizar petición
|
||||
curl -k -X POST https://localhost:8443/mac-monitor \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{
|
||||
"host": "10.150.226.19",
|
||||
"username": "admin",
|
||||
"password": "password",
|
||||
"use_legacy_ssh": true
|
||||
}'
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🎯 RESULTADO FINAL
|
||||
|
||||
**OBJETIVO CUMPLIDO**: El sistema ahora muestra **TODAS** las interfaces del switch, incluyendo aquellas sin dispositivos conectados (MAC_COUNT=0), proporcionando visibilidad completa del estado de los puertos de red para monitorización con Zabbix.
|
||||
|
||||
**Beneficios**:
|
||||
- ✅ **Visibilidad completa** de todos los puertos
|
||||
- ✅ **Compatibilidad total** con dispositivos Cisco legacy
|
||||
- ✅ **Seguridad mejorada** con HTTPS y POST
|
||||
- ✅ **Gestión eficiente** de dependencias
|
||||
- ✅ **Contenedorización robusta** lista para producción
|
||||
@@ -0,0 +1,8 @@
|
||||
rol: necesito que adquieras el rol de un experto en dispositivos de red de la marca, cisco, con conocimientos de Python
|
||||
|
||||
necesidad: cliente necesita poder monitorizar los dispositivos que hay conectados en cada una de las bocas de sus dispositivos de red de la marca cisco. El cliente nos ha proporcionado un inventario de modelos. Ellos necesitan saber qué direcciones Mac hay conectadas por cada una de las bocas de Red.
|
||||
|
||||
misión: necesitamos montar un pequeño script en Python, el cual se encargue de conectarse a un dispositivo de red dado, y obtener la información que necesita el cliente. este dispositivo de red dado será proporcionado a través de la linea de comandos. las credenciales de acceso al dispositivo también serán proporcionadas a través de la linea de comandos.
|
||||
|
||||
la salida de esta información ha de estar en formato json. la información extraída será consumida por Zabbix. A través de un LLD de una plantilla de Zabbix que ya se creará más adelante, esta alertará en caso de que haya alguna MAC no autorizada conectada a alguna de las bocas de red o si hay cambios en las MACs conectadas. Necesitamos que el script sea capaz de conectarse al dispositivo de red mediante SSH. El script correrá en un contenedor docker en el que ya estará instalado Python y las librerías necesarias para la conexión SSH.
|
||||
La imagen base deberá ser ROCKY LINUX 8. La información que se necesita extraer de cada dispositivo ha de ser en json como decía antes, pero ha de estar preparada para que Zabbix pueda consumirla a través de un LLD, por lo que la estructura del json ha de ser la adecuada.
|
||||
+382
@@ -0,0 +1,382 @@
|
||||
# Cisco Single MAC Monitor para Zabbix LLD
|
||||
|
||||
## 📋 Descripción
|
||||
|
||||
**Cisco Single MAC Monitor** es una versión simplificada del monitor de direcciones MAC que se enfoca en **un dispositivo individual por ejecución**. Recibe los parámetros del dispositivo (IP, credenciales) por línea de comandos y genera salida JSON compatible con **Zabbix Low Level Discovery (LLD)**.
|
||||
|
||||
### Características principales:
|
||||
|
||||
- ✅ **Un dispositivo por ejecución** - Parámetros por línea de comandos
|
||||
- ✅ **Compatible** con modelos Cisco C2960, C3560, C3560E, C2960X, C3560CX y Catalyst
|
||||
- ✅ **Conexión SSH** segura
|
||||
- ✅ **Formato JSON** optimizado para Zabbix LLD
|
||||
- ✅ **Contenedor Docker** ligero basado en Rocky Linux 8
|
||||
- ✅ **JSON más manejable** - No hay riesgo de JSON gigante
|
||||
- ✅ **Integración sencilla** con Zabbix External Scripts
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Inicio Rápido
|
||||
|
||||
### 1. Construir la imagen Docker
|
||||
|
||||
```bash
|
||||
# Usar Dockerfile específico para versión single
|
||||
docker build -f Dockerfile -t cisco-mac-monitor .
|
||||
```
|
||||
|
||||
### 2. Ejecutar para un dispositivo
|
||||
|
||||
```bash
|
||||
# Ejemplo básico
|
||||
curl -k -X POST https://localhost:8443/mac-monitor -H "Content-Type: application/json" -d '{"host": "10.150.226.19", "username": "itops", "password": "Tr4!D0r3s", "use_legacy_ssh": true}'
|
||||
```
|
||||
|
||||
### ⚠️ **Manejo de Contraseñas con Caracteres Especiales**
|
||||
|
||||
```bash
|
||||
# ✅ CORRECTO: Sin escape para caracteres como !
|
||||
curl -k -X POST https://localhost:8443/mac-monitor -H "Content-Type: application/json" -d '{"host": "10.150.226.19", "username": "itops", "password": "Tr4!D0r3s", "use_legacy_ssh": true}'
|
||||
|
||||
# ✅ CORRECTO: Para contraseñas con comillas, usar comillas dobles externas
|
||||
curl -k -X POST https://localhost:8443/mac-monitor -H "Content-Type: application/json" -d "{\"host\": \"10.150.226.19\", \"username\": \"itops\", \"password\": \"Pass\\\"word\", \"use_legacy_ssh\": true}"
|
||||
|
||||
# ✅ CORRECTO: Para contraseñas muy complejas, usar archivo
|
||||
echo '{"host": "10.150.226.19", "username": "itops", "password": "C0mpl3x!P@ss#w0rd$", "use_legacy_ssh": true}' > payload.json
|
||||
curl -k -X POST https://localhost:8443/mac-monitor -H "Content-Type: application/json" -d @payload.json
|
||||
|
||||
# ❌ INCORRECTO: No usar \ para escapar ! en JSON
|
||||
curl -k -X POST https://localhost:8443/mac-monitor -H "Content-Type: application/json" -d '{"password": "Tr4\!D0r3s"}' # ERROR!
|
||||
```
|
||||
|
||||
### 3. Integración con Zabbix
|
||||
|
||||
```bash
|
||||
# Copiar script de integración
|
||||
sudo cp zabbix_single_integration.sh /usr/lib/zabbix/externalscripts/
|
||||
sudo chmod +x /usr/lib/zabbix/externalscripts/zabbix_single_integration.sh
|
||||
sudo chown zabbix:zabbix /usr/lib/zabbix/externalscripts/zabbix_single_integration.sh
|
||||
|
||||
# Probar manualmente
|
||||
/usr/lib/zabbix/externalscripts/zabbix_single_integration.sh 192.168.1.10 admin cisco123
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📁 Archivos de la Versión Simplificada
|
||||
|
||||
```
|
||||
cisco-mac-monitor/
|
||||
├── cisco_single_mac_monitor.py # Script principal simplificado
|
||||
├── Dockerfile.single # Imagen Docker optimizada
|
||||
├── docker-compose.single.yml # Compose simplificado
|
||||
├── zabbix_single_integration.sh # Script para Zabbix External Scripts
|
||||
├── example_single_output.json # Ejemplo de salida JSON
|
||||
└── README_single.md # Esta documentación
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## ⚙️ Uso Detallado
|
||||
|
||||
### Parámetros de línea de comandos
|
||||
|
||||
```bash
|
||||
python3 cisco_single_mac_monitor.py [OPTIONS]
|
||||
|
||||
Argumentos requeridos:
|
||||
--host/-H <IP> IP o hostname del dispositivo Cisco
|
||||
--username/-u <USER> Usuario SSH
|
||||
--password/-p <PASS> Contraseña SSH
|
||||
|
||||
Argumentos opcionales:
|
||||
--port/-P <PORT> Puerto SSH (default: 22)
|
||||
--timeout/-t <SEC> Timeout en segundos (default: 30)
|
||||
--hostname/-n <NAME> Nombre del dispositivo (default: usa --host)
|
||||
--debug/-d Modo debug
|
||||
--quiet/-q Modo silencioso (solo JSON)
|
||||
```
|
||||
|
||||
### Ejemplos de uso
|
||||
|
||||
```bash
|
||||
# Básico
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123
|
||||
|
||||
# Puerto SSH personalizado
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 -P 2222
|
||||
|
||||
# Con timeout personalizado
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 -t 60
|
||||
|
||||
# Modo silencioso (solo JSON por stdout)
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 -q
|
||||
|
||||
# Con nombre personalizado del dispositivo
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 -n SW-CORE-001
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🐳 Uso con Docker
|
||||
|
||||
### Construir imagen
|
||||
|
||||
```bash
|
||||
# Opción 1: Docker directo
|
||||
docker build -f Dockerfile.single -t cisco-single-mac-monitor .
|
||||
|
||||
# Opción 2: Docker Compose
|
||||
docker-compose -f docker-compose.single.yml build
|
||||
```
|
||||
|
||||
### Ejecutar contenedor
|
||||
|
||||
```bash
|
||||
# Ejecución básica
|
||||
docker run --rm --network host cisco-single-mac-monitor \
|
||||
--host 192.168.1.10 --username admin --password cisco123
|
||||
|
||||
# Con volumen para logs (opcional)
|
||||
docker run --rm --network host -v /tmp:/tmp cisco-single-mac-monitor \
|
||||
--host 192.168.1.10 --username admin --password cisco123 --debug
|
||||
|
||||
# Modo interactivo para debugging
|
||||
docker run --rm -it --network host cisco-single-mac-monitor --help
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📊 Integración con Zabbix
|
||||
|
||||
### Formato JSON de salida
|
||||
|
||||
```json
|
||||
{
|
||||
"data": [
|
||||
{
|
||||
"{#DEVICE_HOSTNAME}": "SW-CORE-001",
|
||||
"{#PORT_NAME}": "Fa0/1",
|
||||
"{#MAC_COUNT}": 2,
|
||||
"{#VLANS}": "10,20",
|
||||
"{#MAC_ADDRESSES}": "[{\"mac\": \"aa:bb:cc:dd:ee:01\", \"vlan\": \"10\", \"type\": \"DYNAMIC\"}]",
|
||||
"{#LAST_UPDATE}": "2024-10-24T14:30:00.123456"
|
||||
}
|
||||
],
|
||||
"timestamp": "2024-10-24T14:30:00.123456",
|
||||
"device_hostname": "SW-CORE-001",
|
||||
"total_ports": 3,
|
||||
"total_macs": 6
|
||||
}
|
||||
```
|
||||
|
||||
### Configuración en Zabbix
|
||||
|
||||
**1. Discovery Rule por dispositivo:**
|
||||
|
||||
```xml
|
||||
Name: Cisco MAC Discovery for {HOST.NAME}
|
||||
Type: External check
|
||||
Key: cisco_single_mac_discovery.sh[{HOST.IP},{$CISCO_USER},{$CISCO_PASSWORD},{HOST.NAME}]
|
||||
Update interval: 5m
|
||||
```
|
||||
|
||||
**2. Macros requeridas (nivel de host o template):**
|
||||
|
||||
```xml
|
||||
{$CISCO_USER} = admin
|
||||
{$CISCO_PASSWORD} = cisco123
|
||||
```
|
||||
|
||||
**3. Item prototypes:**
|
||||
|
||||
- `cisco.mac.count[{#DEVICE_HOSTNAME},{#PORT_NAME}]`
|
||||
- `cisco.mac.addresses[{#DEVICE_HOSTNAME},{#PORT_NAME}]`
|
||||
- `cisco.mac.vlans[{#DEVICE_HOSTNAME},{#PORT_NAME}]`
|
||||
|
||||
**4. Trigger prototypes:**
|
||||
|
||||
- MAC count changed
|
||||
- Too many MACs on port
|
||||
- New MAC addresses detected
|
||||
|
||||
### Script de External Check
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
# /usr/lib/zabbix/externalscripts/cisco_single_mac_discovery.sh
|
||||
|
||||
HOST="$1"
|
||||
USERNAME="$2"
|
||||
PASSWORD="$3"
|
||||
HOSTNAME="$4"
|
||||
|
||||
docker run --rm --network host cisco-single-mac-monitor \
|
||||
--host "$HOST" \
|
||||
--username "$USERNAME" \
|
||||
--password "$PASSWORD" \
|
||||
--hostname "$HOSTNAME" \
|
||||
--quiet
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔧 Ventajas de la Versión Simplificada
|
||||
|
||||
### ✅ Ventajas
|
||||
|
||||
1. **JSON Manejable**: Un dispositivo = Un JSON pequeño
|
||||
2. **Escalabilidad**: Cada dispositivo se procesa independientemente
|
||||
3. **Flexibilidad**: Diferentes credenciales por dispositivo
|
||||
4. **Paralelización**: Zabbix puede ejecutar múltiples checks en paralelo
|
||||
5. **Debugging Fácil**: Probar un dispositivo específico
|
||||
6. **Recursos Mínimos**: Contenedor ligero y rápido
|
||||
|
||||
### 📊 Comparación con versión completa
|
||||
|
||||
| Aspecto | Versión Single | Versión Completa |
|
||||
|---------|----------------|------------------|
|
||||
| JSON por ejecución | Pequeño (1 dispositivo) | Grande (N dispositivos) |
|
||||
| Configuración | Línea de comandos | Archivo YAML |
|
||||
| Flexibilidad | Alta (por dispositivo) | Media (global) |
|
||||
| Debugging | Fácil | Complejo |
|
||||
| Recursos | Mínimos | Moderados |
|
||||
| Uso en Zabbix | External check directo | Requires data processing |
|
||||
|
||||
---
|
||||
|
||||
## 🛠️ Desarrollo y Testing
|
||||
|
||||
### Ejecutar sin Docker
|
||||
|
||||
```bash
|
||||
# Instalar dependencias
|
||||
pip3 install paramiko PyYAML
|
||||
|
||||
# Ejecutar directamente
|
||||
python3 cisco_single_mac_monitor.py \
|
||||
--host 192.168.1.10 \
|
||||
--username admin \
|
||||
--password cisco123 \
|
||||
--debug
|
||||
```
|
||||
|
||||
### Testing del script de integración
|
||||
|
||||
```bash
|
||||
# Test de dependencias
|
||||
./zabbix_single_integration.sh test
|
||||
|
||||
# Test manual
|
||||
./zabbix_single_integration.sh 192.168.1.10 admin cisco123 SW-TEST
|
||||
|
||||
# Test con hostname personalizado
|
||||
./zabbix_single_integration.sh 192.168.1.10 admin cisco123 SW-CORE-001
|
||||
```
|
||||
|
||||
### Validar JSON
|
||||
|
||||
```bash
|
||||
# Ejecutar y validar JSON
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 -q | jq .
|
||||
|
||||
# Verificar estructura Zabbix LLD
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 -q | jq '.data[0]'
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 🔍 Troubleshooting
|
||||
|
||||
### Problemas comunes
|
||||
|
||||
**1. Error de conexión SSH:**
|
||||
```bash
|
||||
# Probar conexión manual
|
||||
ssh admin@192.168.1.10
|
||||
|
||||
# Debug del script
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 --debug
|
||||
```
|
||||
|
||||
**2. JSON vacío:**
|
||||
```bash
|
||||
# Verificar comando en dispositivo
|
||||
ssh admin@192.168.1.10
|
||||
show mac address-table
|
||||
|
||||
# Verificar logs
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 --debug
|
||||
```
|
||||
|
||||
**3. Imagen Docker no encontrada:**
|
||||
```bash
|
||||
# Verificar imagen
|
||||
docker images | grep cisco-single-mac
|
||||
|
||||
# Reconstruir si es necesario
|
||||
docker build -f Dockerfile.single -t cisco-single-mac-monitor .
|
||||
```
|
||||
|
||||
### Logs útiles
|
||||
|
||||
```bash
|
||||
# Logs del script (van por stderr)
|
||||
python3 cisco_single_mac_monitor.py -H 192.168.1.10 -u admin -p cisco123 2>debug.log
|
||||
|
||||
# Logs del contenedor
|
||||
docker run --rm --network host cisco-single-mac-monitor \
|
||||
--host 192.168.1.10 --username admin --password cisco123 --debug 2>container.log
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 📈 Monitorización en Producción
|
||||
|
||||
### Configuración recomendada en Zabbix
|
||||
|
||||
1. **Por dispositivo de red**:
|
||||
- Crear macro `{$CISCO_USER}` y `{$CISCO_PASSWORD}`
|
||||
- Asignar template "Cisco MAC Monitor"
|
||||
- Discovery rule se ejecuta cada 5 minutos
|
||||
|
||||
2. **Alertas importantes**:
|
||||
- Cambio en número de MACs por puerto
|
||||
- Nueva MAC no autorizada
|
||||
- Puerto con demasiadas MACs (>5)
|
||||
|
||||
3. **Dashboards**:
|
||||
- Gráfico de MACs por dispositivo
|
||||
- Top 10 puertos con más MACs
|
||||
- Alertas recientes de MACs
|
||||
|
||||
---
|
||||
|
||||
## 🔒 Seguridad
|
||||
|
||||
### Mejores prácticas
|
||||
|
||||
1. **Credenciales**:
|
||||
- Usar macros de Zabbix para passwords
|
||||
- Crear usuario específico en switches
|
||||
- Rotar credenciales regularmente
|
||||
|
||||
2. **Red**:
|
||||
- Ejecutar en VLAN de management
|
||||
- Configurar ACLs en switches
|
||||
- Monitorizar accesos SSH
|
||||
|
||||
3. **Contenedor**:
|
||||
- Usuario no privilegiado
|
||||
- Sin volúmenes innecesarios
|
||||
- Imagen base actualizada
|
||||
|
||||
---
|
||||
|
||||
## 📄 Licencia
|
||||
|
||||
Este proyecto está bajo licencia MIT.
|
||||
|
||||
---
|
||||
|
||||
**Versión simplificada optimizada para uso individual por dispositivo** 🎯
|
||||
Executable
+370
@@ -0,0 +1,370 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Cisco MAC Address Monitor - Single Device Version
|
||||
=================================================
|
||||
|
||||
Script simplificado para monitorizar direcciones MAC en un dispositivo Cisco específico.
|
||||
Recibe parámetros por línea de comandos y genera salida JSON para Zabbix LLD.
|
||||
|
||||
Compatible con modelos C2960, C3560, C3560E, C2960X, C3560CX y Catalyst series.
|
||||
|
||||
Uso:
|
||||
python3 cisco_single_mac_monitor.py --host <IP> --username <USER> --password <PASS>
|
||||
|
||||
Autor: Sistema de Monitorización de Red
|
||||
Fecha: Octubre 2024
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import argparse
|
||||
import paramiko
|
||||
import re
|
||||
import sys
|
||||
from datetime import datetime
|
||||
from typing import List, Dict, Any
|
||||
from dataclasses import dataclass
|
||||
|
||||
|
||||
@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, host: str, username: str, password: str, port: int = 22, timeout: int = 30):
|
||||
self.host = host
|
||||
self.username = username
|
||||
self.password = password
|
||||
self.port = port
|
||||
self.timeout = timeout
|
||||
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.host}")
|
||||
|
||||
self.ssh_client.connect(
|
||||
hostname=self.host,
|
||||
port=self.port,
|
||||
username=self.username,
|
||||
password=self.password,
|
||||
timeout=self.timeout,
|
||||
look_for_keys=False,
|
||||
allow_agent=False
|
||||
)
|
||||
|
||||
self.logger.info(f"Conexión exitosa a {self.host}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error conectando a {self.host}: {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.host}")
|
||||
|
||||
|
||||
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
|
||||
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, device_hostname: str):
|
||||
self.device_hostname = device_hostname
|
||||
self.logger = logging.getLogger(__name__)
|
||||
|
||||
def format_for_zabbix(self, mac_entries: List[MacEntry]) -> Dict[str, Any]:
|
||||
"""Formatea datos para Zabbix LLD"""
|
||||
discovery_data = []
|
||||
timestamp = datetime.now().isoformat()
|
||||
|
||||
# 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": self.device_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}": self.device_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,
|
||||
"device_hostname": self.device_hostname,
|
||||
"total_ports": len(discovery_data),
|
||||
"total_macs": len(mac_entries)
|
||||
}
|
||||
|
||||
self.logger.info(f"Formateados datos para dispositivo {self.device_hostname}: {len(discovery_data)} puertos, {len(mac_entries)} MACs")
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def setup_logging(debug: bool = False) -> logging.Logger:
|
||||
"""Configura el sistema de logging"""
|
||||
level = logging.DEBUG if debug else logging.INFO
|
||||
|
||||
logging.basicConfig(
|
||||
level=level,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
|
||||
handlers=[
|
||||
logging.StreamHandler(sys.stderr)
|
||||
]
|
||||
)
|
||||
|
||||
return logging.getLogger(__name__)
|
||||
|
||||
|
||||
def main():
|
||||
"""Función principal"""
|
||||
parser = argparse.ArgumentParser(
|
||||
description='Monitor de direcciones MAC para dispositivo Cisco individual',
|
||||
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||||
epilog="""
|
||||
Ejemplos de uso:
|
||||
%(prog)s --host 192.168.1.10 --username admin --password cisco123
|
||||
%(prog)s -H 192.168.1.10 -u admin -p cisco123 --port 2222
|
||||
%(prog)s -H 192.168.1.10 -u admin -p cisco123 --debug
|
||||
%(prog)s -H 192.168.1.10 -u admin -p cisco123 --hostname SW-CORE-001
|
||||
|
||||
Salida:
|
||||
El script genera JSON en formato Zabbix LLD por stdout.
|
||||
Los logs van por stderr.
|
||||
"""
|
||||
)
|
||||
|
||||
# Argumentos requeridos
|
||||
parser.add_argument('--host', '-H', required=True,
|
||||
help='Dirección IP o hostname del dispositivo Cisco')
|
||||
parser.add_argument('--username', '-u', required=True,
|
||||
help='Usuario para conexión SSH')
|
||||
parser.add_argument('--password', '-p', required=True,
|
||||
help='Contraseña para conexión SSH')
|
||||
|
||||
# Argumentos opcionales
|
||||
parser.add_argument('--port', '-P', type=int, default=22,
|
||||
help='Puerto SSH (default: 22)')
|
||||
parser.add_argument('--timeout', '-t', type=int, default=30,
|
||||
help='Timeout de conexión en segundos (default: 30)')
|
||||
parser.add_argument('--hostname', '-n',
|
||||
help='Nombre del dispositivo para identificación (default: usa --host)')
|
||||
parser.add_argument('--debug', '-d', action='store_true',
|
||||
help='Habilitar modo debug')
|
||||
parser.add_argument('--quiet', '-q', action='store_true',
|
||||
help='Modo silencioso (solo JSON por stdout)')
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Configurar logging
|
||||
if not args.quiet:
|
||||
logger = setup_logging(args.debug)
|
||||
else:
|
||||
# En modo silencioso, solo errores críticos
|
||||
logging.basicConfig(level=logging.CRITICAL)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Determinar hostname del dispositivo
|
||||
device_hostname = args.hostname or args.host
|
||||
|
||||
# Inicializar componentes
|
||||
ssh_connector = CiscoSSHConnector(
|
||||
host=args.host,
|
||||
username=args.username,
|
||||
password=args.password,
|
||||
port=args.port,
|
||||
timeout=args.timeout
|
||||
)
|
||||
|
||||
mac_parser = CiscoMacTableParser()
|
||||
zabbix_formatter = ZabbixLLDFormatter(device_hostname)
|
||||
|
||||
try:
|
||||
# Conectar al dispositivo
|
||||
if not ssh_connector.connect():
|
||||
logger.error("No se pudo establecer conexión SSH")
|
||||
sys.exit(1)
|
||||
|
||||
# Obtener tabla MAC
|
||||
mac_entries = mac_parser.get_mac_table(ssh_connector)
|
||||
|
||||
if not mac_entries:
|
||||
logger.warning("No se obtuvieron entradas de tabla MAC")
|
||||
|
||||
# Formatear para Zabbix
|
||||
zabbix_data = zabbix_formatter.format_for_zabbix(mac_entries)
|
||||
|
||||
# Generar salida JSON
|
||||
json_output = json.dumps(zabbix_data, indent=2, ensure_ascii=False)
|
||||
print(json_output)
|
||||
|
||||
if not args.quiet:
|
||||
logger.info("Proceso completado exitosamente")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error durante la ejecución: {str(e)}")
|
||||
sys.exit(1)
|
||||
|
||||
finally:
|
||||
ssh_connector.disconnect()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,23 @@
|
||||
#!/usr/bin/env python3
|
||||
import logging
|
||||
logging.basicConfig(level=logging.DEBUG)
|
||||
from cisco_mac_monitor import CiscoSSHConnector, CiscoMacTableParser
|
||||
|
||||
ssh = CiscoSSHConnector('10.150.226.19', 'itops', 'Tr4!D0r3s')
|
||||
parser = CiscoMacTableParser()
|
||||
|
||||
print("Conectando...")
|
||||
ssh.connect()
|
||||
print("Ejecutando comando...")
|
||||
output = ssh.execute_command('show mac address-table')
|
||||
print('OUTPUT LENGTH:', len(output))
|
||||
|
||||
print("\nParseando...")
|
||||
mac_entries = parser._parse_mac_table_output(output)
|
||||
print(f"MAC ENTRIES FOUND: {len(mac_entries)}")
|
||||
|
||||
for i, entry in enumerate(mac_entries[:3]):
|
||||
print(f"Entry {i+1}: VLAN={entry.vlan}, MAC={entry.mac_address}, Type={entry.type}, Port={entry.port}")
|
||||
|
||||
ssh.disconnect()
|
||||
print("Desconectado.")
|
||||
@@ -0,0 +1,16 @@
|
||||
#!/usr/bin/env python3
|
||||
import logging
|
||||
logging.basicConfig(level=logging.DEBUG)
|
||||
from cisco_mac_monitor import CiscoSSHConnector, CiscoMacTableParser
|
||||
|
||||
ssh = CiscoSSHConnector('10.150.226.19', 'itops', 'Tr4!D0r3s')
|
||||
print("Conectando...")
|
||||
ssh.connect()
|
||||
print("Ejecutando comando...")
|
||||
output = ssh.execute_command('show mac address-table')
|
||||
print('OUTPUT LENGTH:', len(output))
|
||||
print('FIRST 300 CHARS:', repr(output[:300]))
|
||||
if len(output) > 300:
|
||||
print('LAST 100 CHARS:', repr(output[-100:]))
|
||||
ssh.disconnect()
|
||||
print("Desconectado.")
|
||||
@@ -0,0 +1,51 @@
|
||||
# Docker Compose para Cisco MAC Monitor HTTP Service
|
||||
# ==================================================
|
||||
|
||||
services:
|
||||
cisco-mac-http:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile.http
|
||||
platforms:
|
||||
- linux/amd64
|
||||
image: cisco-mac-monitor-http:latest
|
||||
container_name: cisco-mac-monitor-http
|
||||
|
||||
# Puerto HTTP
|
||||
ports:
|
||||
- "8080:8080"
|
||||
|
||||
# Red del host para acceso a dispositivos locales
|
||||
network_mode: host
|
||||
|
||||
# Variables de entorno
|
||||
environment:
|
||||
- HTTP_HOST=0.0.0.0
|
||||
- HTTP_PORT=8080
|
||||
|
||||
# Límites de recursos
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: '0.5'
|
||||
memory: 256M
|
||||
reservations:
|
||||
cpus: '0.1'
|
||||
memory: 64M
|
||||
|
||||
# Reinicio automático
|
||||
restart: unless-stopped
|
||||
|
||||
# Logging del contenedor
|
||||
logging:
|
||||
driver: "json-file"
|
||||
options:
|
||||
max-size: "10m"
|
||||
max-file: "3"
|
||||
|
||||
# Ejemplo de uso:
|
||||
# docker-compose -f docker-compose.http.yml up -d
|
||||
#
|
||||
# Test:
|
||||
# curl "http://localhost:8080/health"
|
||||
# curl "http://localhost:8080/mac-monitor?host=192.168.1.10&username=admin&password=cisco123"
|
||||
@@ -0,0 +1,39 @@
|
||||
# Docker Compose para Cisco Single MAC Monitor
|
||||
# ============================================
|
||||
|
||||
services:
|
||||
cisco-mac-monitor:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
platforms:
|
||||
- linux/amd64
|
||||
image: cisco-mac-monitor:latest
|
||||
container_name: cisco-mac-monitor
|
||||
|
||||
# Red del host para acceso a dispositivos locales
|
||||
network_mode: host
|
||||
|
||||
# Límites de recursos
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: '0.2'
|
||||
memory: 128M
|
||||
reservations:
|
||||
cpus: '0.05'
|
||||
memory: 32M
|
||||
|
||||
# Logging del contenedor
|
||||
logging:
|
||||
driver: "json-file"
|
||||
options:
|
||||
max-size: "5m"
|
||||
max-file: "2"
|
||||
|
||||
# Ejemplo de uso en comentarios:
|
||||
# Para ejecutar el contenedor con parámetros:
|
||||
# docker run --rm --network host cisco-mac-monitor \
|
||||
# --host 192.168.1.10 \
|
||||
# --username admin \
|
||||
# --password cisco123
|
||||
Executable
+342
@@ -0,0 +1,342 @@
|
||||
#!/bin/bash
|
||||
# Script de prueba para Cisco MAC Monitor
|
||||
# ======================================
|
||||
|
||||
set -e
|
||||
|
||||
# Colores para output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Contadores
|
||||
TESTS_PASSED=0
|
||||
TESTS_FAILED=0
|
||||
|
||||
# Función para logging
|
||||
log() {
|
||||
echo -e "${BLUE}[TEST]${NC} $1"
|
||||
}
|
||||
|
||||
success() {
|
||||
echo -e "${GREEN}[PASS]${NC} $1"
|
||||
((TESTS_PASSED++))
|
||||
}
|
||||
|
||||
error() {
|
||||
echo -e "${RED}[FAIL]${NC} $1"
|
||||
((TESTS_FAILED++))
|
||||
}
|
||||
|
||||
warn() {
|
||||
echo -e "${YELLOW}[WARN]${NC} $1"
|
||||
}
|
||||
|
||||
# Test 1: Verificar archivos necesarios
|
||||
test_single_files() {
|
||||
log "Verificando archivos necesarios..."
|
||||
|
||||
local files=(
|
||||
"cisco_mac_monitor.py"
|
||||
"Dockerfile"
|
||||
"docker-compose.yml"
|
||||
"zabbix_integration.sh"
|
||||
"example_output.json"
|
||||
"README.md"
|
||||
)
|
||||
|
||||
for file in "${files[@]}"; do
|
||||
if [[ -f "$file" ]]; then
|
||||
success "Archivo encontrado: $file"
|
||||
else
|
||||
error "Archivo faltante: $file"
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
# Test 2: Validar sintaxis del script principal
|
||||
test_single_python_syntax() {
|
||||
log "Validando sintaxis del script simplificado..."
|
||||
|
||||
if command -v python3 >/dev/null 2>&1; then
|
||||
if python3 -m py_compile cisco_mac_monitor.py; then
|
||||
success "Sintaxis de Python válida (script simplificado)"
|
||||
else
|
||||
error "Error de sintaxis en script simplificado"
|
||||
fi
|
||||
else
|
||||
warn "Python3 no disponible para test de sintaxis"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 3: Probar ayuda del script
|
||||
test_script_help() {
|
||||
log "Probando función de ayuda del script..."
|
||||
|
||||
if command -v python3 >/dev/null 2>&1; then
|
||||
if python3 cisco_mac_monitor.py --help >/dev/null 2>&1; then
|
||||
success "Función de ayuda funciona correctamente"
|
||||
else
|
||||
error "Error en función de ayuda"
|
||||
fi
|
||||
else
|
||||
warn "Python3 no disponible para test de ayuda"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 4: Validar Dockerfile simplificado
|
||||
test_single_dockerfile() {
|
||||
log "Validando Dockerfile simplificado..."
|
||||
|
||||
if command -v docker >/dev/null 2>&1; then
|
||||
if docker build -f Dockerfile -t cisco-mac-monitor-test . >/dev/null 2>&1; then
|
||||
success "Dockerfile válido - imagen construida"
|
||||
# Limpiar imagen de test
|
||||
docker rmi cisco-mac-monitor-test >/dev/null 2>&1 || true
|
||||
else
|
||||
error "Error en construcción de Dockerfile"
|
||||
fi
|
||||
else
|
||||
warn "Docker no disponible para test de Dockerfile"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 5: Validar docker-compose simplificado
|
||||
test_single_docker_compose() {
|
||||
log "Validando docker-compose.single.yml..."
|
||||
|
||||
if command -v docker-compose >/dev/null 2>&1; then
|
||||
if docker-compose config >/dev/null 2>&1; then
|
||||
success "docker-compose.yml válido"
|
||||
else
|
||||
error "Error en docker-compose.yml"
|
||||
fi
|
||||
else
|
||||
warn "docker-compose no disponible para test"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 6: Validar JSON de ejemplo simplificado
|
||||
test_single_example_json() {
|
||||
log "Validando JSON de ejemplo simplificado..."
|
||||
|
||||
if [[ -f "example_output.json" ]]; then
|
||||
if command -v python3 >/dev/null 2>&1; then
|
||||
if python3 -m json.tool example_output.json >/dev/null 2>&1; then
|
||||
success "JSON de ejemplo válido"
|
||||
|
||||
# Verificar estructura específica de Zabbix LLD
|
||||
if python3 -c "
|
||||
import json
|
||||
with open('example_output.json', 'r') as f:
|
||||
data = json.load(f)
|
||||
|
||||
# Verificar estructura básica
|
||||
if 'data' not in data:
|
||||
print('Missing data array')
|
||||
exit(1)
|
||||
|
||||
if not isinstance(data['data'], list):
|
||||
print('data should be an array')
|
||||
exit(1)
|
||||
|
||||
# Verificar macros de Zabbix LLD en primer elemento
|
||||
if len(data['data']) > 0:
|
||||
item = data['data'][0]
|
||||
required_macros = ['{#DEVICE_HOSTNAME}', '{#PORT_NAME}', '{#MAC_COUNT}', '{#VLANS}', '{#MAC_ADDRESSES}', '{#LAST_UPDATE}']
|
||||
for macro in required_macros:
|
||||
if macro not in item:
|
||||
print(f'Missing macro: {macro}')
|
||||
exit(1)
|
||||
|
||||
print('Zabbix LLD structure valid')
|
||||
"; then
|
||||
success "Estructura Zabbix LLD válida en JSON de ejemplo"
|
||||
else
|
||||
error "Estructura Zabbix LLD inválida en JSON de ejemplo"
|
||||
fi
|
||||
else
|
||||
error "JSON de ejemplo inválido"
|
||||
fi
|
||||
else
|
||||
warn "Python3 no disponible para validación de JSON"
|
||||
fi
|
||||
else
|
||||
error "Archivo example_output.json no encontrado"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 7: Validar script de integración con Zabbix
|
||||
test_zabbix_integration_script() {
|
||||
log "Validando script de integración con Zabbix..."
|
||||
|
||||
if [[ -f "zabbix_integration.sh" ]]; then
|
||||
if [[ -x "zabbix_integration.sh" ]]; then
|
||||
success "Script de integración tiene permisos de ejecución"
|
||||
|
||||
# Probar función de ayuda
|
||||
if ./zabbix_integration.sh help >/dev/null 2>&1; then
|
||||
success "Función de ayuda del script de integración funciona"
|
||||
else
|
||||
warn "Problema con función de ayuda del script de integración"
|
||||
fi
|
||||
else
|
||||
warn "Script de integración no tiene permisos de ejecución"
|
||||
chmod +x zabbix_integration.sh
|
||||
success "Permisos de ejecución agregados al script de integración"
|
||||
fi
|
||||
else
|
||||
error "Script de integración no encontrado"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 8: Validar que la imagen simplificada es más pequeña
|
||||
test_image_size_comparison() {
|
||||
log "Comparando tamaño de imágenes..."
|
||||
|
||||
if command -v docker >/dev/null 2>&1; then
|
||||
# Construir ambas imágenes
|
||||
log "Construyendo imagen simplificada..."
|
||||
if docker build -f Dockerfile.single -t cisco-single-test:single . >/dev/null 2>&1; then
|
||||
local single_size=$(docker images cisco-single-test:single --format "{{.Size}}")
|
||||
success "Imagen simplificada construida: $single_size"
|
||||
|
||||
# Limpiar imagen de test
|
||||
docker rmi cisco-single-test:single >/dev/null 2>&1 || true
|
||||
else
|
||||
warn "No se pudo construir imagen simplificada para comparación"
|
||||
fi
|
||||
else
|
||||
warn "Docker no disponible para comparación de tamaños"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 9: Probar script sin parámetros (debe mostrar error útil)
|
||||
test_parameter_validation() {
|
||||
log "Probando validación de parámetros..."
|
||||
|
||||
if command -v python3 >/dev/null 2>&1; then
|
||||
# Script debe fallar sin parámetros pero mostrar mensaje útil
|
||||
if ! python3 cisco_mac_monitor.py >/dev/null 2>&1; then
|
||||
success "Script valida parámetros requeridos correctamente"
|
||||
else
|
||||
warn "Script no valida parámetros requeridos"
|
||||
fi
|
||||
|
||||
# Probar con parámetros incompletos
|
||||
if ! python3 cisco_mac_monitor.py --host 192.168.1.10 >/dev/null 2>&1; then
|
||||
success "Script valida parámetros incompletos correctamente"
|
||||
else
|
||||
warn "Script no valida parámetros incompletos"
|
||||
fi
|
||||
else
|
||||
warn "Python3 no disponible para test de validación"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test 10: Verificar documentación simplificada
|
||||
test_single_documentation() {
|
||||
log "Verificando documentación simplificada..."
|
||||
|
||||
if [[ -f "README.md" ]]; then
|
||||
local readme_size=$(wc -c < README.md)
|
||||
if [[ $readme_size -gt 500 ]]; then
|
||||
success "README.md presente y completo ($readme_size bytes)"
|
||||
else
|
||||
warn "README.md muy pequeño ($readme_size bytes)"
|
||||
fi
|
||||
else
|
||||
error "README.md faltante"
|
||||
fi
|
||||
}
|
||||
|
||||
# Test de integración con contenedor simplificado
|
||||
test_single_container_integration() {
|
||||
log "Ejecutando test de integración con contenedor simplificado..."
|
||||
|
||||
if command -v docker >/dev/null 2>&1; then
|
||||
# Construir imagen
|
||||
if docker build -f Dockerfile -t cisco-mac-test . >/dev/null 2>&1; then
|
||||
success "Imagen Docker construida correctamente"
|
||||
|
||||
# Test de help en contenedor
|
||||
if docker run --rm cisco-mac-test --help >/dev/null 2>&1; then
|
||||
success "Test de help en contenedor exitoso"
|
||||
else
|
||||
error "Test de help en contenedor falló"
|
||||
fi
|
||||
|
||||
# Limpiar
|
||||
docker rmi cisco-mac-test >/dev/null 2>&1 || true
|
||||
else
|
||||
error "Error construyendo imagen para test de integración"
|
||||
fi
|
||||
else
|
||||
warn "Docker no disponible para test de integración"
|
||||
fi
|
||||
}
|
||||
|
||||
# Función principal
|
||||
main() {
|
||||
echo "=============================================="
|
||||
echo " Cisco MAC Monitor - Test Suite"
|
||||
echo "=============================================="
|
||||
echo
|
||||
|
||||
# Verificar que estamos en el directorio correcto
|
||||
if [[ ! -f "cisco_mac_monitor.py" ]]; then
|
||||
error "No se encontró cisco_mac_monitor.py. ¿Estás en el directorio correcto?"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Ejecutar tests específicos para versión simplificada
|
||||
test_single_files
|
||||
test_single_python_syntax
|
||||
test_script_help
|
||||
test_parameter_validation
|
||||
test_single_example_json
|
||||
test_zabbix_integration_script
|
||||
test_single_documentation
|
||||
|
||||
# Tests que requieren herramientas externas
|
||||
if command -v docker >/dev/null 2>&1; then
|
||||
test_single_dockerfile
|
||||
test_single_container_integration
|
||||
test_image_size_comparison
|
||||
else
|
||||
warn "Docker no disponible - saltando tests de Docker"
|
||||
fi
|
||||
|
||||
if command -v docker-compose >/dev/null 2>&1; then
|
||||
test_single_docker_compose
|
||||
else
|
||||
warn "docker-compose no disponible - saltando test"
|
||||
fi
|
||||
|
||||
# Resumen
|
||||
echo
|
||||
echo "=============================================="
|
||||
echo " Resumen de Tests"
|
||||
echo "=============================================="
|
||||
echo -e "${GREEN}Tests exitosos: $TESTS_PASSED${NC}"
|
||||
echo -e "${RED}Tests fallidos: $TESTS_FAILED${NC}"
|
||||
echo
|
||||
|
||||
if [[ $TESTS_FAILED -eq 0 ]]; then
|
||||
echo -e "${GREEN}🎉 Todos los tests pasaron exitosamente!${NC}"
|
||||
echo
|
||||
echo "La versión está lista para usar:"
|
||||
echo "1. Construir imagen: docker build -t cisco-mac-monitor ."
|
||||
echo "2. Ejecutar: docker run --rm --network host cisco-mac-monitor --host <IP> --username <USER> --password <PASS>"
|
||||
echo "3. Integrar con Zabbix usando zabbix_integration.sh"
|
||||
exit 0
|
||||
else
|
||||
echo -e "${RED}❌ Algunos tests fallaron. Revisa los errores arriba.${NC}"
|
||||
exit 1
|
||||
fi
|
||||
}
|
||||
|
||||
# Ejecutar tests
|
||||
main "$@"
|
||||
@@ -0,0 +1,102 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Prueba para verificar que se muestren todos los puertos, incluidos los sin MACs conectadas.
|
||||
"""
|
||||
|
||||
import requests
|
||||
import json
|
||||
import ssl
|
||||
import urllib3
|
||||
|
||||
# Deshabilitar advertencias SSL
|
||||
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
|
||||
|
||||
def test_all_ports():
|
||||
"""Prueba que el servicio muestre todos los puertos, no solo los con MACs"""
|
||||
|
||||
# Configuración de la prueba
|
||||
url = "https://localhost:8443/api/mac-table"
|
||||
|
||||
payload = {
|
||||
"cisco_ip": "10.150.226.19",
|
||||
"ssh_username": "ruser",
|
||||
"ssh_password": "pass123",
|
||||
"use_legacy_ssh": True
|
||||
}
|
||||
|
||||
headers = {
|
||||
"Content-Type": "application/json"
|
||||
}
|
||||
|
||||
try:
|
||||
print("Realizando petición HTTPS POST al servicio...")
|
||||
print(f"URL: {url}")
|
||||
print(f"Payload: {json.dumps(payload, indent=2)}")
|
||||
|
||||
response = requests.post(
|
||||
url,
|
||||
json=payload,
|
||||
headers=headers,
|
||||
verify=False,
|
||||
timeout=30
|
||||
)
|
||||
|
||||
print(f"\nRespuesta HTTP: {response.status_code}")
|
||||
print(f"Headers de respuesta: {dict(response.headers)}")
|
||||
|
||||
if response.status_code == 200:
|
||||
data = response.json()
|
||||
print(f"\nRespuesta exitosa:")
|
||||
print(json.dumps(data, indent=2))
|
||||
|
||||
# Analizar puertos
|
||||
if 'data' in data:
|
||||
ports_with_macs = 0
|
||||
ports_without_macs = 0
|
||||
total_ports = len(data['data'])
|
||||
|
||||
for item in data['data']:
|
||||
interface = item.get('{#INTERFACE}', '')
|
||||
mac_count = item.get('MAC_COUNT', 0)
|
||||
|
||||
if mac_count > 0:
|
||||
ports_with_macs += 1
|
||||
else:
|
||||
ports_without_macs += 1
|
||||
|
||||
print(f"\n=== ANÁLISIS DE PUERTOS ===")
|
||||
print(f"Total de puertos detectados: {total_ports}")
|
||||
print(f"Puertos con MACs conectadas: {ports_with_macs}")
|
||||
print(f"Puertos sin MACs (vacíos): {ports_without_macs}")
|
||||
|
||||
# Mostrar algunos ejemplos
|
||||
print(f"\n=== EJEMPLOS DE PUERTOS ===")
|
||||
for i, item in enumerate(data['data'][:10]): # Solo los primeros 10
|
||||
interface = item.get('{#INTERFACE}', '')
|
||||
mac_count = item.get('MAC_COUNT', 0)
|
||||
mac_addresses = item.get('MAC_ADDRESSES', '')
|
||||
print(f"{i+1}. {interface}: {mac_count} MACs")
|
||||
if mac_count > 0:
|
||||
print(f" MACs: {mac_addresses[:100]}...") # Truncar para legibilidad
|
||||
|
||||
# Verificar que hay puertos sin MACs
|
||||
if ports_without_macs > 0:
|
||||
print(f"\n✅ ÉXITO: Se detectaron {ports_without_macs} puertos vacíos (MAC_COUNT=0)")
|
||||
else:
|
||||
print(f"\n⚠️ ADVERTENCIA: No se detectaron puertos vacíos")
|
||||
|
||||
else:
|
||||
print("❌ Error: No se encontró 'data' en la respuesta")
|
||||
|
||||
else:
|
||||
print(f"❌ Error HTTP {response.status_code}")
|
||||
print(f"Mensaje: {response.text}")
|
||||
|
||||
except requests.exceptions.ConnectionError as e:
|
||||
print(f"❌ Error de conexión: {e}")
|
||||
print("Asegúrate de que el contenedor esté ejecutándose en puerto 8443")
|
||||
except Exception as e:
|
||||
print(f"❌ Error inesperado: {e}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_all_ports()
|
||||
@@ -0,0 +1,182 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script para verificar compatibilidad SSH con dispositivos Cisco antiguos
|
||||
===========================================================================
|
||||
|
||||
Este script valida que:
|
||||
1. Las importaciones funcionen correctamente
|
||||
2. La clase CiscoSSHConnector se pueda instanciar
|
||||
3. Los algoritmos de compatibilidad se configuren correctamente
|
||||
4. No hay errores de sintaxis en el código
|
||||
|
||||
Uso:
|
||||
python3 test_compatibility.py
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
|
||||
def test_imports():
|
||||
"""Test de importaciones básicas"""
|
||||
print("🔍 Testing importaciones...")
|
||||
|
||||
try:
|
||||
import json
|
||||
import logging
|
||||
import argparse
|
||||
import re
|
||||
import sys
|
||||
from datetime import datetime
|
||||
from typing import List, Dict, Any
|
||||
print("✅ Importaciones estándar OK")
|
||||
except ImportError as e:
|
||||
print(f"❌ Error en importaciones estándar: {e}")
|
||||
return False
|
||||
|
||||
try:
|
||||
import paramiko
|
||||
print("✅ Paramiko disponible")
|
||||
except ImportError as e:
|
||||
print(f"⚠️ Paramiko no instalado: {e}")
|
||||
print(" Para testing completo, instalar con: pip install paramiko")
|
||||
return "paramiko_missing"
|
||||
|
||||
return True
|
||||
|
||||
def test_cisco_monitor_syntax():
|
||||
"""Test de sintaxis del módulo principal"""
|
||||
print("\n🔍 Testing sintaxis de cisco_mac_monitor.py...")
|
||||
|
||||
try:
|
||||
# Compilar archivo para verificar sintaxis
|
||||
with open('cisco_mac_monitor.py', 'r') as f:
|
||||
source_code = f.read()
|
||||
|
||||
compile(source_code, 'cisco_mac_monitor.py', 'exec')
|
||||
print("✅ Sintaxis de cisco_mac_monitor.py OK")
|
||||
return True
|
||||
|
||||
except SyntaxError as e:
|
||||
print(f"❌ Error de sintaxis: {e}")
|
||||
print(f" Línea {e.lineno}: {e.text}")
|
||||
return False
|
||||
except FileNotFoundError:
|
||||
print("❌ Archivo cisco_mac_monitor.py no encontrado")
|
||||
return False
|
||||
except Exception as e:
|
||||
print(f"❌ Error inesperado: {e}")
|
||||
return False
|
||||
|
||||
def test_class_instantiation():
|
||||
"""Test de instanciación de clases (si paramiko disponible)"""
|
||||
print("\n🔍 Testing instanciación de clases...")
|
||||
|
||||
try:
|
||||
import paramiko
|
||||
except ImportError:
|
||||
print("⚠️ Saltando test (paramiko no disponible)")
|
||||
return True
|
||||
|
||||
try:
|
||||
# Import del módulo principal
|
||||
sys.path.insert(0, '.')
|
||||
from cisco_mac_monitor import CiscoSSHConnector, CiscoMacTableParser, ZabbixLLDFormatter
|
||||
|
||||
# Test CiscoSSHConnector
|
||||
connector = CiscoSSHConnector("test.example.com", "test", "test")
|
||||
print("✅ CiscoSSHConnector se puede instanciar")
|
||||
|
||||
# Test CiscoMacTableParser
|
||||
parser = CiscoMacTableParser()
|
||||
print("✅ CiscoMacTableParser se puede instanciar")
|
||||
|
||||
# Test ZabbixLLDFormatter
|
||||
formatter = ZabbixLLDFormatter("test-device")
|
||||
print("✅ ZabbixLLDFormatter se puede instanciar")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Error instanciando clases: {e}")
|
||||
return False
|
||||
|
||||
def test_ssh_compatibility_config():
|
||||
"""Test de configuración de compatibilidad SSH"""
|
||||
print("\n🔍 Testing configuración de compatibilidad SSH...")
|
||||
|
||||
try:
|
||||
import paramiko
|
||||
except ImportError:
|
||||
print("⚠️ Saltando test (paramiko no disponible)")
|
||||
return True
|
||||
|
||||
try:
|
||||
# Test de configuración Transport
|
||||
transport = paramiko.Transport(('dummy', 22))
|
||||
security_opts = transport.get_security_options()
|
||||
|
||||
# Verificar algoritmos originales
|
||||
original_kex = list(security_opts.kex)
|
||||
original_host_keys = list(security_opts.key_types)
|
||||
|
||||
# Aplicar configuración de compatibilidad
|
||||
if 'diffie-hellman-group1-sha1' not in security_opts.kex:
|
||||
security_opts.kex = ['diffie-hellman-group1-sha1'] + list(security_opts.kex)
|
||||
print("✅ diffie-hellman-group1-sha1 añadido a KEX")
|
||||
|
||||
if 'ssh-rsa' not in security_opts.key_types:
|
||||
security_opts.key_types = ['ssh-rsa'] + list(security_opts.key_types)
|
||||
print("✅ ssh-rsa añadido a host key types")
|
||||
|
||||
# Verificar que se añadieron
|
||||
assert 'diffie-hellman-group1-sha1' in security_opts.kex
|
||||
assert 'ssh-rsa' in security_opts.key_types
|
||||
|
||||
print("✅ Configuración de compatibilidad SSH aplicada correctamente")
|
||||
transport.close()
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Error configurando SSH compatibility: {e}")
|
||||
return False
|
||||
|
||||
def main():
|
||||
"""Función principal de testing"""
|
||||
print("=" * 60)
|
||||
print("🧪 CISCO MAC MONITOR - COMPATIBILITY TEST")
|
||||
print("=" * 60)
|
||||
|
||||
# Test 1: Imports
|
||||
import_result = test_imports()
|
||||
if import_result is False:
|
||||
print("\n❌ FAILED: Importaciones básicas fallaron")
|
||||
return 1
|
||||
|
||||
# Test 2: Syntax
|
||||
if not test_cisco_monitor_syntax():
|
||||
print("\n❌ FAILED: Errores de sintaxis encontrados")
|
||||
return 1
|
||||
|
||||
# Test 3: Class instantiation (si paramiko disponible)
|
||||
if import_result is not "paramiko_missing":
|
||||
if not test_class_instantiation():
|
||||
print("\n❌ FAILED: Error instanciando clases")
|
||||
return 1
|
||||
|
||||
# Test 4: SSH compatibility config
|
||||
if not test_ssh_compatibility_config():
|
||||
print("\n❌ FAILED: Error configurando compatibilidad SSH")
|
||||
return 1
|
||||
|
||||
print("\n" + "=" * 60)
|
||||
if import_result == "paramiko_missing":
|
||||
print("✅ PASSED (con limitaciones): Tests básicos completados")
|
||||
print("📝 Para testing completo, instalar: pip install paramiko")
|
||||
else:
|
||||
print("✅ PASSED: Todos los tests completados exitosamente")
|
||||
print("=" * 60)
|
||||
|
||||
return 0
|
||||
|
||||
if __name__ == '__main__':
|
||||
exit(main())
|
||||
Executable
+49
@@ -0,0 +1,49 @@
|
||||
#!/bin/bash
|
||||
# Script de ejemplo para usar el nuevo servicio HTTPS con POST
|
||||
# ============================================================
|
||||
|
||||
# Configuración
|
||||
SERVER_URL="https://localhost:8443"
|
||||
HOST="10.150.226.29"
|
||||
USERNAME="itops"
|
||||
PASSWORD='Tr4!D0r3s'
|
||||
|
||||
echo "🔒 Cisco MAC Monitor - Ejemplo HTTPS POST"
|
||||
echo "=========================================="
|
||||
|
||||
# Test 1: Health check
|
||||
echo "1. Testing health check..."
|
||||
curl -k -s "${SERVER_URL}/health" | python3 -m json.tool
|
||||
|
||||
echo -e "\n"
|
||||
|
||||
# Test 2: Métricas
|
||||
echo "2. Testing metrics..."
|
||||
curl -k -s "${SERVER_URL}/metrics" | python3 -m json.tool
|
||||
|
||||
echo -e "\n"
|
||||
|
||||
# Test 3: Monitorización MAC con POST seguro
|
||||
echo "3. Testing MAC monitoring (POST seguro)..."
|
||||
|
||||
# Crear JSON payload
|
||||
JSON_PAYLOAD=$(cat <<EOF
|
||||
{
|
||||
"host": "${HOST}",
|
||||
"username": "${USERNAME}",
|
||||
"password": "${PASSWORD}",
|
||||
"hostname": "SW-CORE-${HOST}",
|
||||
"timeout": 30
|
||||
}
|
||||
EOF
|
||||
)
|
||||
|
||||
echo "JSON Payload enviado:"
|
||||
echo "${JSON_PAYLOAD}" | python3 -m json.tool
|
||||
|
||||
echo -e "\nRespuesta del servidor:"
|
||||
curl -k -s -X POST "${SERVER_URL}/mac-monitor" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d "${JSON_PAYLOAD}" | python3 -m json.tool
|
||||
|
||||
echo -e "\n✅ Test completado!"
|
||||
@@ -0,0 +1,115 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script para verificar la funcionalidad de mostrar todas las interfaces
|
||||
usando datos simulados cuando no hay acceso al dispositivo real.
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Añadir el directorio actual al path para importar los módulos
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from cisco_mac_monitor import CiscoMacTableParser, ZabbixLLDFormatter
|
||||
|
||||
def test_all_interfaces_functionality():
|
||||
"""Prueba que todas las interfaces se muestren, incluso sin MACs"""
|
||||
|
||||
print("=== PRUEBA DE FUNCIONALIDAD: TODAS LAS INTERFACES ===\n")
|
||||
|
||||
# Simular salida de 'show interfaces status'
|
||||
mock_interface_output = """
|
||||
Port Name Status Vlan Duplex Speed Type
|
||||
Fa0/1 connected 1 full 100 10/100BaseTX
|
||||
Fa0/2 Servidor-Core connected 10 full 100 10/100BaseTX
|
||||
Fa0/3 notconnect 1 auto auto 10/100BaseTX
|
||||
Fa0/4 notconnect 1 auto auto 10/100BaseTX
|
||||
Fa0/5 notconnect 1 auto auto 10/100BaseTX
|
||||
Gi0/1 Uplink-Router connected trunk full 1000 1000BaseTX
|
||||
Gi0/2 notconnect 1 auto auto 1000BaseTX
|
||||
"""
|
||||
|
||||
# Simular salida de tabla MAC (solo algunas interfaces tienen MACs)
|
||||
mock_mac_output = """
|
||||
1 0021.9b5a.4f10 DYNAMIC Fa0/1
|
||||
1 001b.2f89.3c21 DYNAMIC Fa0/1
|
||||
10 00e0.4c36.7f89 DYNAMIC Fa0/2
|
||||
10 0050.5682.1c45 DYNAMIC Fa0/2
|
||||
1 0019.bbf7.4a21 DYNAMIC Gi0/1
|
||||
1 0025.90e4.b832 DYNAMIC Gi0/1
|
||||
1 0018.8b99.5f71 DYNAMIC Gi0/1
|
||||
"""
|
||||
|
||||
# Crear instancias de las clases
|
||||
parser = CiscoMacTableParser()
|
||||
formatter = ZabbixLLDFormatter("cisco-test-device")
|
||||
|
||||
print("1. Parseando interfaces detectadas:")
|
||||
print(" - Simulando 'show interfaces status'")
|
||||
|
||||
# Simular el parseo de interfaces
|
||||
interfaces = parser._parse_interface_list(mock_interface_output)
|
||||
print(f" - Interfaces detectadas: {len(interfaces)}")
|
||||
for interface in interfaces:
|
||||
print(f" * {interface}")
|
||||
|
||||
print(f"\n2. Parseando tabla MAC:")
|
||||
print(" - Simulando 'show mac address-table'")
|
||||
|
||||
# Parsear tabla MAC usando el método privado
|
||||
mac_entries = parser._parse_mac_table_output(mock_mac_output)
|
||||
print(f" - Entradas MAC encontradas: {len(mac_entries)}")
|
||||
for entry in mac_entries:
|
||||
print(f" * VLAN {entry.vlan} - {entry.mac_address} en {entry.port}")
|
||||
|
||||
print(f"\n3. Formateando para Zabbix (con todas las interfaces):")
|
||||
|
||||
# Formatear para Zabbix con todas las interfaces
|
||||
zabbix_data = formatter.format_for_zabbix(mac_entries, interfaces)
|
||||
|
||||
print(f" - Estructura de datos Zabbix: {type(zabbix_data)}")
|
||||
print(f" - Claves disponibles: {list(zabbix_data.keys()) if isinstance(zabbix_data, dict) else 'No es dict'}")
|
||||
|
||||
if 'data' in zabbix_data and isinstance(zabbix_data['data'], list) and len(zabbix_data['data']) > 0:
|
||||
print(f" - Primer elemento: {zabbix_data['data'][0]}")
|
||||
print(f" - Claves del primer elemento: {list(zabbix_data['data'][0].keys())}")
|
||||
|
||||
# Analizar resultados
|
||||
ports_with_macs = 0
|
||||
ports_without_macs = 0
|
||||
|
||||
for item in zabbix_data['data']:
|
||||
interface = item['{#PORT_NAME}']
|
||||
mac_count = item['{#MAC_COUNT}']
|
||||
|
||||
if mac_count > 0:
|
||||
ports_with_macs += 1
|
||||
print(f" ✅ {interface}: {mac_count} MACs conectadas")
|
||||
else:
|
||||
ports_without_macs += 1
|
||||
print(f" ⚪ {interface}: 0 MACs (puerto vacío)")
|
||||
|
||||
print(f"\n=== RESUMEN DE RESULTADOS ===")
|
||||
print(f"Total de puertos: {len(zabbix_data['data'])}")
|
||||
print(f"Puertos con MACs: {ports_with_macs}")
|
||||
print(f"Puertos vacíos: {ports_without_macs}")
|
||||
|
||||
# Mostrar algunos ejemplos del JSON Zabbix
|
||||
print(f"\n=== EJEMPLO DE SALIDA ZABBIX LLD ===")
|
||||
import json
|
||||
print(json.dumps(zabbix_data, indent=2)[:1000] + "..." if len(str(zabbix_data)) > 1000 else json.dumps(zabbix_data, indent=2))
|
||||
|
||||
# Verificar que la funcionalidad funciona
|
||||
if ports_without_macs > 0:
|
||||
print(f"\n🎉 ¡ÉXITO! La funcionalidad funciona correctamente:")
|
||||
print(f" - Se detectaron {ports_without_macs} puertos vacíos con MAC_COUNT=0")
|
||||
print(f" - Se detectaron {ports_with_macs} puertos con MACs conectadas")
|
||||
print(f" - Total de puertos mostrados: {len(zabbix_data['data'])}")
|
||||
return True
|
||||
else:
|
||||
print(f"\n❌ Error: No se detectaron puertos vacíos")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = test_all_interfaces_functionality()
|
||||
sys.exit(0 if success else 1)
|
||||
@@ -0,0 +1,71 @@
|
||||
#!/bin/bash
|
||||
# Script para probar manejo de contraseñas con caracteres especiales
|
||||
# Uso: ./test_special_chars.sh
|
||||
|
||||
echo "🔧 PRUEBA DE MANEJO DE CARACTERES ESPECIALES EN CONTRASEÑAS"
|
||||
echo "============================================================"
|
||||
|
||||
# URL del servicio
|
||||
URL="https://localhost:8443/mac-monitor"
|
||||
HEADERS="Content-Type: application/json"
|
||||
|
||||
echo ""
|
||||
echo "1. 📝 Probando contraseña con ! (sin escape)"
|
||||
echo " Password: Tr4!D0r3s"
|
||||
RESPONSE1=$(curl -s -k -X POST "$URL" -H "$HEADERS" -d '{"host": "10.150.226.19", "username": "itops", "password": "Tr4!D0r3s", "use_legacy_ssh": true}')
|
||||
if [[ $RESPONSE1 == *"JSON inválido"* ]]; then
|
||||
echo " ❌ ERROR: $RESPONSE1"
|
||||
else
|
||||
echo " ✅ JSON válido - Conectando..."
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "2. 📝 Probando contraseña con @ y # y $"
|
||||
echo " Password: P@ssw0rd#123$"
|
||||
RESPONSE2=$(curl -s -k -X POST "$URL" -H "$HEADERS" -d '{"host": "10.150.226.19", "username": "itops", "password": "P@ssw0rd#123$", "use_legacy_ssh": true}')
|
||||
if [[ $RESPONSE2 == *"JSON inválido"* ]]; then
|
||||
echo " ❌ ERROR: $RESPONSE2"
|
||||
else
|
||||
echo " ✅ JSON válido - Conectando..."
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "3. 📝 Probando contraseña con espacios"
|
||||
echo " Password: 'Mi Contraseña 123!'"
|
||||
RESPONSE3=$(curl -s -k -X POST "$URL" -H "$HEADERS" -d '{"host": "10.150.226.19", "username": "itops", "password": "Mi Contraseña 123!", "use_legacy_ssh": true}')
|
||||
if [[ $RESPONSE3 == *"JSON inválido"* ]]; then
|
||||
echo " ❌ ERROR: $RESPONSE3"
|
||||
else
|
||||
echo " ✅ JSON válido - Conectando..."
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "4. 📝 Probando contraseña con comillas (usando archivo temporal)"
|
||||
echo " Password: Pass\"word"
|
||||
echo '{"host": "10.150.226.19", "username": "itops", "password": "Pass\"word", "use_legacy_ssh": true}' > /tmp/test_payload.json
|
||||
RESPONSE4=$(curl -s -k -X POST "$URL" -H "$HEADERS" -d @/tmp/test_payload.json)
|
||||
rm -f /tmp/test_payload.json
|
||||
if [[ $RESPONSE4 == *"JSON inválido"* ]]; then
|
||||
echo " ❌ ERROR: $RESPONSE4"
|
||||
else
|
||||
echo " ✅ JSON válido - Conectando..."
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "5. ❌ Probando escape incorrecto de !"
|
||||
echo " Password: Tr4\\!D0r3s (incorrecto)"
|
||||
RESPONSE5=$(curl -s -k -X POST "$URL" -H "$HEADERS" -d '{"host": "10.150.226.19", "username": "itops", "password": "Tr4\!D0r3s", "use_legacy_ssh": true}')
|
||||
if [[ $RESPONSE5 == *"JSON inválido"* ]]; then
|
||||
echo " ✅ Error esperado: $RESPONSE5"
|
||||
else
|
||||
echo " ❌ No debería funcionar: $RESPONSE5"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "📋 RESUMEN:"
|
||||
echo " - Los caracteres ! @ # $ % & * + = funcionan sin escape en JSON"
|
||||
echo " - Los espacios funcionan normalmente dentro de comillas"
|
||||
echo " - Solo necesitan escape: \" \\ y caracteres de control \\n \\t \\r"
|
||||
echo " - NO usar \\! para escapar exclamación en JSON"
|
||||
echo ""
|
||||
echo "✅ Pruebas completadas"
|
||||
Executable
+157
@@ -0,0 +1,157 @@
|
||||
#!/bin/bash
|
||||
# Script de integración simplificado para Zabbix External Scripts
|
||||
# ==============================================================
|
||||
#
|
||||
# Este script debe colocarse en:
|
||||
# /usr/lib/zabbix/externalscripts/cisco_single_mac_discovery.sh
|
||||
#
|
||||
# Y configurar permisos:
|
||||
# chmod +x /usr/lib/zabbix/externalscripts/cisco_single_mac_discovery.sh
|
||||
# chown zabbix:zabbix /usr/lib/zabbix/externalscripts/cisco_single_mac_discovery.sh
|
||||
|
||||
# Configuración
|
||||
CONTAINER_IMAGE="cisco-mac-monitor:latest"
|
||||
TIMEOUT=60
|
||||
|
||||
# Función de logging para stderr
|
||||
log() {
|
||||
echo "[$(date +'%Y-%m-%d %H:%M:%S')] $1" >&2
|
||||
}
|
||||
|
||||
error() {
|
||||
echo "[$(date +'%Y-%m-%d %H:%M:%S')] ERROR: $1" >&2
|
||||
exit 1
|
||||
}
|
||||
|
||||
# Función para ejecutar discovery en un dispositivo específico
|
||||
run_single_device_discovery() {
|
||||
local host="$1"
|
||||
local username="$2"
|
||||
local password="$3"
|
||||
local hostname="$4"
|
||||
|
||||
# Validar parámetros
|
||||
if [[ -z "$host" ]] || [[ -z "$username" ]] || [[ -z "$password" ]]; then
|
||||
error "Parámetros requeridos: host, username, password"
|
||||
fi
|
||||
|
||||
log "Ejecutando discovery para dispositivo: $host"
|
||||
|
||||
# Construir comando Docker
|
||||
local docker_cmd=(
|
||||
docker run --rm --network host
|
||||
"$CONTAINER_IMAGE"
|
||||
--host "$host"
|
||||
--username "$username"
|
||||
--password "$password"
|
||||
--quiet
|
||||
)
|
||||
|
||||
# Agregar hostname si se proporciona
|
||||
if [[ -n "$hostname" ]]; then
|
||||
docker_cmd+=(--hostname "$hostname")
|
||||
fi
|
||||
|
||||
# Ejecutar con timeout
|
||||
local json_data
|
||||
if ! json_data=$(timeout "$TIMEOUT" "${docker_cmd[@]}" 2>/dev/null); then
|
||||
error "Falló la ejecución de discovery para $host (timeout: ${TIMEOUT}s)"
|
||||
fi
|
||||
|
||||
# Validar JSON
|
||||
if [[ -z "$json_data" ]]; then
|
||||
error "No se obtuvieron datos del dispositivo $host"
|
||||
fi
|
||||
|
||||
# Validar formato JSON básico
|
||||
if ! echo "$json_data" | python3 -m json.tool >/dev/null 2>&1; then
|
||||
error "Datos no están en formato JSON válido para $host"
|
||||
fi
|
||||
|
||||
# Retornar datos
|
||||
echo "$json_data"
|
||||
}
|
||||
|
||||
# Función para mostrar ayuda
|
||||
show_help() {
|
||||
cat << EOF
|
||||
Cisco Single MAC Discovery - Zabbix Integration Script
|
||||
|
||||
USAGE:
|
||||
$0 <HOST> <USERNAME> <PASSWORD> [HOSTNAME]
|
||||
|
||||
PARAMETERS:
|
||||
HOST IP address or hostname of Cisco device
|
||||
USERNAME SSH username
|
||||
PASSWORD SSH password
|
||||
HOSTNAME Optional device hostname for identification
|
||||
|
||||
EXAMPLES:
|
||||
# Básico
|
||||
$0 192.168.1.10 admin cisco123
|
||||
|
||||
# Con hostname personalizado
|
||||
$0 192.168.1.10 admin cisco123 SW-CORE-001
|
||||
|
||||
# Para usar en Zabbix Discovery Rule
|
||||
cisco_mac_discovery.sh {HOST.IP} {$USER} {$PASSWORD} {HOST.NAME}
|
||||
|
||||
ZABBIX CONFIGURATION:
|
||||
Discovery Rule:
|
||||
- Name: Cisco Device MAC Discovery
|
||||
- Type: External check
|
||||
- Key: cisco_mac_discovery.sh[{HOST.IP},{$CISCO_USER},{$CISCO_PASSWORD},{HOST.NAME}]
|
||||
- Update interval: 5m
|
||||
|
||||
Required Macros:
|
||||
- {$CISCO_USER} : SSH username
|
||||
- {$CISCO_PASSWORD} : SSH password
|
||||
|
||||
EOF
|
||||
}
|
||||
|
||||
# Verificar que Docker esté disponible
|
||||
check_dependencies() {
|
||||
if ! command -v docker >/dev/null 2>&1; then
|
||||
error "Docker no está instalado o no está en PATH"
|
||||
fi
|
||||
|
||||
if ! command -v python3 >/dev/null 2>&1; then
|
||||
error "Python3 no está instalado o no está en PATH"
|
||||
fi
|
||||
|
||||
# Verificar que la imagen existe
|
||||
if ! docker image inspect "$CONTAINER_IMAGE" >/dev/null 2>&1; then
|
||||
error "Imagen Docker no encontrada: $CONTAINER_IMAGE"
|
||||
fi
|
||||
}
|
||||
|
||||
# Función principal
|
||||
main() {
|
||||
case "${1:-}" in
|
||||
"help"|"--help"|"-h"|"")
|
||||
show_help
|
||||
exit 0
|
||||
;;
|
||||
"test")
|
||||
check_dependencies
|
||||
log "Dependencias verificadas correctamente"
|
||||
exit 0
|
||||
;;
|
||||
esac
|
||||
|
||||
# Verificar dependencias
|
||||
check_dependencies
|
||||
|
||||
# Obtener parámetros
|
||||
local host="$1"
|
||||
local username="$2"
|
||||
local password="$3"
|
||||
local hostname="$4"
|
||||
|
||||
# Ejecutar discovery
|
||||
run_single_device_discovery "$host" "$username" "$password" "$hostname"
|
||||
}
|
||||
|
||||
# Ejecutar función principal con todos los argumentos
|
||||
main "$@"
|
||||
Reference in New Issue
Block a user