# === Configuración de entorno e importación de librerías ===

# Estilo personalizado para la visualización en Jupyter Notebook
from IPython.display import display, HTML, Markdown

# Configuración de localización para manejar fechas y formatos en español
import locale
locale.setlocale(locale.LC_ALL, '')  # Idioma local, puede ajustarse según sea necesario

# === Librerías para análisis y visualización de datos ===

# Manejo de fechas y tiempos
import datetime
from datetime import timedelta

# Regular expressions para manipulación de texto
import re

# Manejo de datos con pandas y numpy
import pandas as pd
import numpy as np

# Configuración de pandas para mostrar más datos en la consola
pd.set_option('display.max_columns', None)  # Mostrar todas las columnas
pd.set_option('display.max_rows', None)     # Mostrar todas las filas
pd.set_option('max_colwidth', None)         # No truncar el ancho de las columnas

# Visualización estática con Matplotlib
import matplotlib.pyplot as plt

# Mostrar gráficos directamente en el notebook
%matplotlib inline  

# Visualización interactiva con Plotly
import plotly
import plotly.graph_objs as go
import plotly.express as px
from plotly.subplots import make_subplots

# Configuración de Plotly para usar gráficos en Jupyter Notebook
from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
init_notebook_mode(connected=True)  # Conexión inicial para gráficas en el notebook

# === Librerías para conexiones y automatización de redes ===

# Conexión a dispositivos de red con Netmiko
from netmiko import ConnectHandler, NetmikoTimeoutException

# Manejo de dispositivos de red con NAPALM
import napalm

# === Manejo de advertencias para evitar ruido en la salida de las celdas de Notebook===
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
warnings.filterwarnings("ignore", category=FutureWarning)

# === Configuración inicial para conexión al dispositivo Fortinet ===

# Diccionario con la configuración del dispositivo Fortinet

forti = {
    'device_type': 'fortinet',
    'host': 'tu_ip_del_forti', #192.168.100.2 como ejemplo
    'username': 'usuario_admin_del_forti', #administrador
    'password': 'tu_password_del_forti',
    'port': 22,
    'global_delay_factor': 2
}

# === Obtener datos del dispositivo usando NAPALM ===

# Crear un objeto controlador NAPALM para dispositivos Fortinet
driver = napalm.get_network_driver(forti['device_type'])

# Inicializar la conexión al dispositivo usando las credenciales configuradas
device_napalm = driver(
    hostname=forti['host'],
    username=forti['username'],
    password=forti['password']
)

# Abrir la conexión con el dispositivo
device_napalm.open()

# Obtener la tabla ARP (Address Resolution Protocol) del dispositivo
arp_table_forti = device_napalm.get_arp_table()

# Cerrar la conexión al dispositivo después de obtener los datos
device_napalm.close()

# === Transformar los datos obtenidos ===

# Convertir la tabla ARP (lista de diccionarios) en un DataFrame de pandas
arp_table_forti = pd.DataFrame.from_dict(arp_table_forti, orient='columns')

# Normalizar las direcciones MAC a mayúsculas para mantener la consistencia
arp_table_forti['mac'] = arp_table_forti['mac'].apply(lambda x: x.upper())

# === Operaciones adicionales que no se pueden realizar con NAPALM (Usar Netmiko) ===

# Conectar al dispositivo usando Netmiko
net_connect = ConnectHandler(**forti)

# Activar privilegios de administrador en el dispositivo
net_connect.enable()

# Ejecutar el comando para listar usuarios autenticados en el firewall
output_auth_list = net_connect.send_command("diagnose firewall auth list")

# Cerrar la conexión con el dispositivo una vez finalizado el comando
net_connect.disconnect()

# === Procesar la salida del comando para extraer información ===

# Patrón de expresión regular para extraer información relevante de la salida del comando
pattern = r"""(?P<ip>\d+\.\d+\.\d+\.\d+), (?P<username>\S+)\n\ttype: (?P<type>\S+).*?\n\tserver: (?P<server>\S+)\n\tpackets: in (?P<packets_in>\d+) out (?P<packets_out>\d+), bytes: in (?P<bytes_in>\d+) out (?P<bytes_out>\d+)\n\tgroup_id: (?P<group_id>.+?)\n\tgroup_name: (?P<group_name>.+?)\n"""

# Utilizar re.finditer para buscar coincidencias según el patrón definido
matches = re.finditer(pattern, output_auth_list, re.DOTALL)

# Crear una lista de diccionarios con los datos extraídos de cada coincidencia
data_list = [match.groupdict() for match in matches]

# Convertir la lista de diccionarios en un DataFrame de pandas para análisis y manipulación
df_ips_users = pd.DataFrame(data_list)

# === Final: El DataFrame df_ips_users contiene información extraída del dispositivo ===

## Lo que no podemos hacer por Napalm, lo hacemos por NETMIKO

# Conexión al dispositivo
net_connect = ConnectHandler(**forti)
net_connect.enable()

# Ejecutar el comando
output_firewall_address = net_connect.send_command("show firewall address")

# Cerrar la conexión
net_connect.disconnect()
# Procesar la salida (ejemplo básico)
# Expresión regular para extraer los datos

import re

pattern = r"""
    edit\s+"(?P<name>[^"]+)"\s*                       # Captura el nombre después de 'edit'
    (?:set\s+uuid\s+(?P<uuid>[^\s]+)\s*)?              # Captura el UUID si está presente
    (?:set\s+comment\s+"(?P<comment>[^"]+)"\s*)?     # Captura el comentario si está presente
    (?:set\s+type\s+(?P<type>[^\s]+)\s*)?              # Captura el tipo si está presente
    (?:set\s+start-ip\s+(?P<start_ip>[^\s]+)\s*)?     # Captura la IP de inicio si está presente
    (?:set\s+end-ip\s+(?P<end_ip>[^\s]+)\s*)?         # Captura la IP de fin si está presente
    (?:set\s+fqdn\s+"(?P<fqdn>[^"]+)"\s*)?            # Captura el fqdn si está presente
    (?:set\s+subnet\s+(?P<subnet>(?:[\d\.]+(?:\s+[\d\.]+|\/\d+))?)\s*)?  # Captura IP/Máscara o CIDR
    (?:set\s+interface\s+"(?P<interface>[^"]+)"\s*)? # Captura la interfaz si está presente
    (?:set\s+macaddr\s+"(?P<macaddr>[^"]+)"\s*)?     # Captura la dirección MAC si está presente
"""
# Compilar el patrón para utilizarlo en la búsqueda
compiled_pattern = re.compile(pattern, re.VERBOSE)

# Buscar las coincidencias en el texto
matches = compiled_pattern.finditer(output_firewall_address)

# Convertir las coincidencias en una lista de diccionarios
data_list_firewall_address = [match.groupdict() for match in matches]

# Crear el DataFrame
df_firewall_address = pd.DataFrame(data_list_firewall_address)
df_firewall_address[['ip', 'mask']] = df_firewall_address['subnet'].str.split(' ', expand=True)

arp_table_forti['username_from_forti']=arp_table_forti['ip'].map(df_ips_users.set_index('ip').to_dict()['username'])
arp_table_forti['objectname_from_forti']=arp_table_forti['ip'].map(df_firewall_address.set_index('ip').to_dict()['name'])
arp_table_forti['comment_from_forti']=arp_table_forti['ip'].map(df_firewall_address.set_index('ip').to_dict()['comment'])

arp_table_forti.set_index(['interface','ip']).sort_index().sample(5)

arp_table_forti[arp_table_forti['ip'].str.contains('199', na=False)]

arp_table_forti.username_from_forti.nunique()

335

device = {
    'device_type': 'junos',
    'host': 'la_ip_de_tu_equipo_juniper', #192.168.4.2
    'username': 'username_de_tu_equio_juniper',
    'password': '***************',
    'secret':'**************',
    'port': 22,
    'global_delay_factor': 2
}

driver = napalm.get_network_driver(device['device_type'])

device_napalm = driver(hostname=device['host'],
                       username=device['username'],
                       password=device['password'],
                       optional_args = {'secret': 'RegistKm5'} )
## Conexión al equipo
device_napalm.open()

## Extracción de datos con napalm
is_alive = device_napalm.is_alive()
enviroment = device_napalm.get_environment()
configuracion=device_napalm.get_config()
facts = device_napalm.get_facts()
interfaces=device_napalm.get_interfaces()
interfaces_counter = device_napalm.get_interfaces_counters()
users=device_napalm.get_users()
optics=device_napalm.get_optics()
interfaces_ip = device_napalm.get_interfaces_ip()
lldp_neighbors = device_napalm.get_lldp_neighbors()
lldp_neighbors_detail=device_napalm.get_lldp_neighbors_detail()
vlans=device_napalm.get_vlans()
mac_address_table =device_napalm.get_mac_address_table()

## Cierre de conexión al equipo
device_napalm.close()

## Transformación de datos para visualización 
ip_admin = device['host']
uptime = facts['uptime']
hostname = facts['hostname']
vendor = facts['vendor']
model = facts['model']
serial = facts['serial_number']
os_version = facts['os_version']
fqdn = facts['fqdn']
uptime = timedelta(seconds=uptime)

## Transformación de datos de Enviroment
df_power = pd.DataFrame.from_dict(enviroment['power'], orient='index')
df_temperature = pd.DataFrame.from_dict(enviroment['temperature'], orient='index')
df_fans= pd.DataFrame.from_dict(enviroment['fans'], orient='index')
df_cpu = pd.DataFrame.from_dict(enviroment['cpu'], orient='index')
df_memory = pd.DataFrame.from_dict(enviroment['memory'], orient='index')

## Transformación de datos de Interfaces
df_interfaces = pd.DataFrame.from_dict(interfaces, orient='index')
df_interfaces_counter = pd.DataFrame.from_dict(interfaces_counter, orient='index')

## Transformación de Datos para tabla Mac completa, utilizando datos obtenidos de escaneo de puertos y datos obtenidos del gateway
df_mac_address_table = pd.DataFrame.from_dict(mac_address_table, orient='columns')
df_mac_address_table['ip_form_arp_table_forti']=df_mac_address_table['mac'].map(arp_table_forti.set_index('mac').to_dict()['ip'])
df_mac_address_table['username_from_forti']=df_mac_address_table['ip_form_arp_table_forti'].map(df_ips_users.set_index('ip').to_dict()['username'])
df_mac_address_table['vlan_name']=df_mac_address_table['vlan'].apply(lambda x: vlans[str(x)]['name'])
df_mac_address_table['name_from_forti']=df_mac_address_table['ip_form_arp_table_forti'].map(df_firewall_address.set_index('ip').to_dict()['name'])
df_mac_address_table['hostname']=hostname
df_mac_address_table['ip_admin']=ip_admin#df_mac_address_table['ports_from_nmap']=df_mac_address_table['ip_form_arp_table_forti'].map(df_puertos_so.set_index('ip')['puertos_tcp']).replace(np.nan,'')

## Datos para fecha
FECHA_HOY = datetime.datetime.now()
FECHA_UPTIME = (FECHA_HOY - uptime).strftime('%d/%m/%Y %H:%M:%S')

## Visualización de Datos
## Datos del Equipo
display(Markdown(f'## <center> {hostname} ({ip_admin}) - {vendor}-{model} os_version: {os_version} </center>'))
display(Markdown(f'### <center> serial: {serial} </center>'))
display(Markdown(f'## <center> Encendido desde {FECHA_UPTIME} </center>'))
display(Markdown(f'## <center> uptime: {uptime} </center>'))


display(Markdown('## <center> Enviroment </center>'))
display(df_power)
display(df_temperature)
display(df_fans)
display(df_cpu)
display(df_memory)

## Visualización de utilización de Puertos
df_graph = df_interfaces_counter[~df_interfaces_counter.index.str.contains(r'\.|fti0|me0|mtun|vme|vtep',regex=True)].copy()
fig = px.bar(df_graph, 
             x=df_graph.index,
             y=df_graph.columns,
             orientation='v',
             color_discrete_sequence =px.colors.qualitative.D3_r,
             title=f'{hostname} ({ip_admin})- {vendor}-{model} - uptime: {uptime} '
            )
fig.update_layout(
    autosize=False,
    width=1000,
    height=500,
)
display(fig)

## Visualización de conexiones de equipos a los puertos
display(Markdown(f'### Equipos conectados a {hostname} ({ip_admin})- {vendor}-{model}'))

## Solo mostramos unos cuatos datos
display(df_mac_address_table[df_mac_address_table['username_from_forti'].notnull()].set_index(['interface', 'ip_form_arp_table_forti']).sort_index().sample(7))

df_mac_address_table[df_mac_address_table['username_from_forti'].str.contains('CESAR', na=False)].set_index('interface')[['username_from_forti','vlan_name','hostname','ip_admin']]

		age	mac	username_from_forti	objectname_from_forti	comment_from_forti
interface	ip
vlan30	10.10.9.97	0.0	18:03:73:28:64:C1	PEDRO_SUAREZ	NaN	NaN
	10.10.9.117	0.0	A5:48:7A:24:E1:C2	SERGIO_MATURANA	NaN	NaN
	10.10.9.237	1.0	A8:CC:6D:C1:80:77	MARCOS_SILVA	NaN	NaN
vlan90	10.10.10.57	0.0	E8:39:35:41:31:43	LUCIA_ORTIZ	IP_para_hacer_Update	Ip del Edificio 2 reservada para Actualizaciones
vlan90	10.10.10.128	0.0	K9:48:60:76:72:6A	NaN	NaN	NaN

	age	interface	ip	mac	username_from_forti	objectname_from_forti	comment_from_forti
53	1.0	vlan30	10.10.9.199	00:1E:55:N9:66:26	ROQUE_ALONSO	NaN	NaN
249	0.0	vlan20	10.10.3.199	40:ED:44:89:1B:9A	NaN	InformaticaWifi	None

	temperature	is_alert	is_critical
FPC 0 CPU Sensor	34.0	False	False
FPC 0 PSU Sensor	30.0	False	False

	status
FPC 0 Fan Tray 0 Fan 0	True
FPC 0 Fan Tray 1 Fan 0	True

	0
available_ram	1943
used_ram	350

Network Intelligence: Ciencia de Datos Aplicada a las Redes

🔗 Network Intelligence: Fortigate + Juniper + Ciencia de Datos¶

📌 Configuración y Librerías Clave¶

🔹 Librerías Importantes¶

🔌 Conexión y Extracción de Datos del Fortigate¶

🏷️ Consideraciones Previas¶

📡 Proceso de Extracción¶

📄 Documentación de Objetos en el Fortigate¶

🔍 Extracción y Transformación de Datos¶

🔗 Integración de Datos: Consolidando la Información del Fortigate¶

🏗️ Unificando la Información¶

📊 Resultado de la Integración¶

🔎 Análisis de Usuarios en el Fortigate¶

🚀 Cierre de la Integración con Fortigate y Expansión del Análisis¶

🌐 Expandiendo el Análisis: Integración con Switch Juniper¶

🔍 Conexión y Extracción de Datos desde el Switch¶

🔗 Unión de Datos: Fortigate + Switch Juniper¶

📊 Visualización de los Datos del Switch¶

Sw1-Tercera_Planta_A (10.10.52.61) - Juniper-EX2300-48P os_version: 22.FICt-t89 ¶

serial: SERIALFICTICIO ¶

Encendido desde 10/01/2025 11:56:24 ¶

uptime: 23 days, 23:29:14 ¶

Enviroment ¶

Equipos conectados a Sw1-Tercera_Planta_A (10.10.52.61)- Juniper-EX2300-48P¶

🌍 Escalabilidad y Potencial de la Ciencia de Datos en Redes¶

🚀 Ciencia de Datos en Redes: Un Enfoque Inteligente¶

📢 ¡Anímate a explorar la Ciencia de Datos para Redes!¶

		mac	vlan	static	active	moves	last_move	username_from_forti	vlan_name	name_from_forti	hostname	ip_admin
interface	ip_form_arp_table_forti
ge-0/0/24.0	10.10.10.132	18:03:73:28:6C:3A	90	False	True	0	0.0	OPERACIONES_MAYORES	Tercera_Planta_A	NaN	Sw1-Tercera_Planta_A	10.10.52.61
ge-0/1/0.0	10.10.10.118	54:BF:48:27:51:F3	90	False	True	0	0.0	DAVID_MARTINS	Tercera_Planta_A	NaN	Sw1-Tercera_Planta_A	10.10.52.61
ge-0/1/1.0	10.10.10.86	00:1E:4F:B7:DD:BD	90	False	True	0	0.0	ROMUALDO_GONZALEZ	Tercera_Planta_A	NaN	Sw1-Tercera_Planta_A	10.10.52.61
ge-0/0/13.0	10.10.10.67	0A:E0:AF:AD:16:77	90	False	True	0	0.0	ZACARIAS_FLORES	Tercera_Planta_A	NaN	Sw1-Tercera_Planta_A	10.10.52.61
ge-0/0/20.0	10.10.10.72	00:1E:55:N9:62:3A	90	False	True	0	0.0	JOSE_LOPEZ	Tercera_Planta_A	NaN	Sw1-Tercera_Planta_A	10.10.52.61
ge-0/0/39.0	10.10.10.107	84:2B:2B:8B:32:E6	90	False	True	0	0.0	ROSA_AMARAL	Tercera_Planta_A	NaN	Sw1-Tercera_Planta_A	10.10.52.61
ge-0/0/23.0	10.10.10.110	10:5L:N7:2E:08:2F	90	False	True	0	0.0	LOURDES_PEREZ	Tercera_Planta_A	NaN	Sw1-Tercera_Planta_A	10.10.52.61