# 馃洝️ LYRA-VPN — Red Privada Virtual con IA y Blockchain
**Clasificaci贸n:** TOP SECRET // PASAIA LAB EYES ONLY
**Referencia:** PL-LYRA-VPN-2026-10-13
**M贸dulo:** VPN descentralizada con enrutamiento por redes neuronales e integraci贸n con LYRA CHAIN
> ⚠️ **Marco educativo.** Prototipo de simulaci贸n con fines did谩cticos para OIARTZUN IKASTOLAN, BERGARA LAB IKASTOLAN, IKASTOLA URRUGNE, Las Pocholitas de Oiartzun, Las Pocholitas de Urrugne y Les Pochites de Bergara. No es software operativo ni un producto comercial. Su valor es ense帽ar arquitecturas de VPN, enrutamiento con IA, cifrado y blockchain.
---
## 馃彈️ 1. Arquitectura de LYRA-VPN
```
┌──────────────────────────────────────────────────────────────────────────────┐
│ LYRA-VPN · 6 CAPAS DE ANONIMATO Y CONTROL │
│ VPN con enrutamiento por IA y auditor铆a en blockchain │
└──────────────────────────────────────────────────────────────────────────────┘
│
┌─────────────────────────────┼─────────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ CAPA 1 │ │ CAPA 2 │ │ CAPA 3 │
│ IDENTIDAD │ │ CIFRADO │ │ ENRUTADO IA │
│ LYRA-ID │ │ H铆brido │ │ Red Neuronal │
│ DID + ZKP │ │ X25519+AES │ │ Multi-hop │
└───────┬───────┘ └───────┬───────┘ └───────┬───────┘
│ │ │
└───────────────────────────┼───────────────────────────┘
▼
┌───────────────────────┐
│ N脷CLEO LYRA-VPN │
│ Orquestador de │
│ T煤neles y Nodos │
└───────────┬───────────┘
│
┌───────────────────────────┼───────────────────────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌───────────────┐
│ CAPA 4 │ │ CAPA 5 │ │ CAPA 6 │
│ BLOCKCHAIN │ │ REPUTACI脫N │ │ GOBERNANZA │
│ LYRA-CHAIN │ │ LYRA-REP │ │ LYRA-GOV │
│ Auditor铆a │ │ Nodos fiables│ │ DAO │
└───────────────┘ └───────────────┘ └───────────────┘
```
### Principios de dise帽o
| Principio | Implementaci贸n |
| :--- | :--- |
| **Anonimato** | Enrutamiento multi-hop con cifrado en capas (onion routing) |
| **Descentralizaci贸n** | Sin servidor central; cada nodo es un peer |
| **IA en el enrutado** | Red neuronal que elige la ruta 贸ptima seg煤n latencia, ancho de banda y reputaci贸n |
| **Blockchain** | LYRA-CHAIN registra identidades, reputaci贸n y auditor铆a de t煤neles |
| **Soberan铆a** | Funciona en Raspberry Pi OS y cualquier Linux |
| **Integraci贸n LYRA** | Se conecta con LYRA-ID, LYRA-REP, LYRA-ORACLE y LYRA-GOV |
### 脕rbol de archivos
```
lyra_vpn/
├── config_vpn.py # Configuraci贸n y constantes
├── identidad_vpn.py # Identidad an贸nima (DID + ZKP)
├── cifrado_vpn.py # Cifrado h铆brido X25519 + AES-256-GCM
├── nodo_vpn.py # Nodo VPN (peer)
├── enrutador_ia.py # Red neuronal de enrutamiento
├── onion_router.py # Enrutamiento en capas (onion)
├── blockchain_vpn.py # Integraci贸n con LYRA CHAIN
├── reputacion_vpn.py # Sistema de reputaci贸n de nodos
├── tunel_vpn.py # Gesti贸n de t煤neles
├── lyra_vpn_core.py # Orquestador principal
└── lyra-vpn.service # Servicio systemd
```
---
## 馃搫 2. `config_vpn.py` — Configuraci贸n
```python
"""
config_vpn.py — PASAIA LAB / LYRA-VPN
Configuraci贸n central del sistema VPN.
"""
# ================================================================
# RED
# ================================================================
PUERTO_VPN = 51820 # Puerto por defecto (WireGuard-like)
TIPO_TUNEL = "UDP" # UDP para baja latencia
MTU = 1420 # Unidad m谩xima de transmisi贸n
# ================================================================
# CIFRADO
# ================================================================
CURVA = "X25519" # Intercambio de claves
CIFRADO_SIMETRICO = "AES-256-GCM" # Cifrado de datos
HASH = "SHA-256" # Integridad
KDF = "HKDF-SHA256" # Derivaci贸n de claves
# ================================================================
# ONION ROUTING
# ================================================================
MIN_SALTOS = 3 # M铆nimo de nodos intermedios
MAX_SALTOS = 7 # M谩ximo de nodos intermedios
TTL_TUNEL_S = 600 # Vida del t煤nel (10 minutos)
ROTACION_TUNEL_S = 300 # Rotaci贸n de ruta (5 minutos)
# ================================================================
# RED NEURONAL DE ENRUTADO
# ================================================================
DIM_ENTRADA_NN = 8 # Features de entrada
CAPAS_NN = [8, 16, 12, 1] # Arquitectura MLP
UMBRAL_NODO_FIABLE = 0.6 # Confianza m铆nima para usar un nodo
# ================================================================
# BLOCKCHAIN
# ================================================================
REGISTRAR_EN_CHAIN = True # Registrar cada t煤nel en LYRA-CHAIN
FRECUENCIA_AUDITORIA = 10 # Cada N t煤neles, auditar
QUEMA_POR_TUNEL_NCOIN = 0.001 # NCOIN quemados por t煤nel (anti-spam)
# ================================================================
# REPUTACI脫N
# ================================================================
REPUTACION_INICIAL = 0.5 # Reputaci贸n de un nodo nuevo
PENALIZACION_FALLO = 0.2 # Penalizaci贸n por fallo
RECOMPENSA_EXITO = 0.02 # Recompensa por 茅xito
UMBRAL_EXPULSION = 0.2 # Reputaci贸n m铆nima para seguir operando
# ================================================================
# SEGURIDAD
# ================================================================
TIMEOUT_HANDSHAKE_S = 5
MAX_INTENTOS_HANDSHAKE = 3
REGISTRO_LOGS = True
LOG_PATH = "/var/log/lyra-vpn/"
```
---
## 馃搫 3. `identidad_vpn.py` — Identidad An贸nima
```python
"""
identidad_vpn.py — PASAIA LAB / LYRA-VPN
Identidad an贸nima basada en DID y pruebas de conocimiento cero.
El usuario no revela su identidad, solo prueba que es un nodo autorizado.
"""
import hashlib
import secrets
import time
from dataclasses import dataclass, field
from typing import Dict, Optional
from cripto_base import sha256, hash_objeto
@dataclass
class IdentidadVPN:
did: str
clave_publica: str
alias: str
creada: float = field(default_factory=time.time)
pruebas: Dict[str, str] = field(default_factory=dict)
activa: bool = True
def hash_identidad(self) -> str:
return hash_objeto({
"did": self.did,
"clave_publica": self.clave_publica,
"alias": self.alias,
})
class GestorIdentidadesVPN:
"""
Gestiona identidades an贸nimas para LYRA-VPN.
Cada identidad tiene un alias (no un nombre real) y una clave p煤blica.
"""
def __init__(self):
self.identidades: Dict[str, IdentidadVPN] = {}
self.claves_privadas: Dict[str, str] = {} # Solo en memoria local
# ------------------------------------------------------------
# CREACI脫N
# ------------------------------------------------------------
def crear_identidad(self, alias: str) -> IdentidadVPN:
"""Crea una identidad an贸nima para un nodo VPN."""
clave_privada = secrets.token_hex(32)
clave_publica = sha256(clave_privada + alias)
did = f"did:lyra:vpn:{sha256(alias + clave_publica)[:32]}"
identidad = IdentidadVPN(
did=did,
clave_publica=clave_publica,
alias=alias,
)
self.identidades[did] = identidad
self.claves_privadas[did] = clave_privada
return identidad
# ------------------------------------------------------------
# PRUEBAS DE CONOCIMIENTO CERO (simuladas)
# ------------------------------------------------------------
def emitir_prueba(self, did: str, atributo: str, valor: str) -> Optional[dict]:
"""
Emite una prueba de atributo sin revelar el valor.
Ejemplo: 'soy mayor de edad', 'resido en la UE'.
"""
if did not in self.identidades:
return None
prueba = {
"did": did,
"atributo": atributo,
"hash_valor": sha256(valor),
"timestamp": time.time(),
"firma": sha256(self.claves_privadas[did] + atributo),
}
self.identidades[did].pruebas[atributo] = prueba["hash_valor"]
return prueba
def verificar_prueba(self, prueba: dict, valor: str) -> bool:
"""Verifica una prueba de atributo."""
if sha256(valor) != prueba["hash_valor"]:
return False
did = prueba["did"]
if did not in self.claves_privadas:
return False
firma_esperada = sha256(self.claves_privadas[did] + prueba["atributo"])
return firma_esperada == prueba["firma"]
# ------------------------------------------------------------
# CONSULTAS
# ------------------------------------------------------------
def obtener(self, did: str) -> Optional[IdentidadVPN]:
return self.identidades.get(did)
def existe(self, did: str) -> bool:
return did in self.identidades
def resumen(self) -> dict:
return {
"total_identidades": len(self.identidades),
"activas": sum(1 for i in self.identidades.values() if i.activa),
"con_pruebas": sum(1 for i in self.identidades.values() if i.pruebas),
}
```
---
## 馃搫 4. `cifrado_vpn.py` — Cifrado H铆brido
```python
"""
cifrado_vpn.py — PASAIA LAB / LYRA-VPN
Cifrado h铆brido X25519 + AES-256-GCM simulado.
Implementa el handshake y la encapsulaci贸n de paquetes.
"""
import hashlib
import hmac
import secrets
import time
from dataclasses import dataclass, field
from typing import Dict, Optional, Tuple
from cripto_base import sha256
# ================================================================
# UTILIDADES SIMULADAS (en producci贸n usar cryptography)
# ================================================================
def _xor_bytes(a: bytes, b: bytes) -> bytes:
return bytes(x ^ y for x, y in zip(a, b))
def _derivar_clave(secreto: bytes, sal: bytes, longitud: int = 32) -> bytes:
"""HKDF simplificado."""
return hashlib.pbkdf2_hmac("sha256", secreto, sal, 100000, dklen=longitud)
# ================================================================
# HANDSHAKE
# ================================================================
@dataclass
class HandshakeVPN:
"""Representa un handshake completado entre dos nodos."""
id_sesion: str
nodo_a: str
nodo_b: str
clave_sesion: bytes
creado: float = field(default_factory=time.time)
expira: float = 0.0
contador_paquetes: int = 0
def __post_init__(self):
if self.expira == 0.0:
self.expira = self.creado + 600 # 10 minutos
def expirado(self) -> bool:
return time.time() > self.expira
class CifradorVPN:
"""
Implementa el cifrado h铆brido de LYRA-VPN:
1) Intercambio de claves X25519 (simulado con ECDH).
2) Derivaci贸n de clave de sesi贸n con HKDF.
3) Cifrado sim茅trico AES-256-GCM (simulado con XOR + HMAC).
"""
def __init__(self):
self.sesiones: Dict[str, HandshakeVPN] = {}
self.claves_privadas: Dict[str, bytes] = {}
# ------------------------------------------------------------
# GENERACI脫N DE CLAVES
# ------------------------------------------------------------
def generar_par_claves(self, id_nodo: str) -> Tuple[bytes, bytes]:
"""Genera un par de claves X25519 (simulado)."""
privada = secrets.token_bytes(32)
publica = hashlib.sha256(privada + id_nodo.encode()).digest()
self.claves_privadas[id_nodo] = privada
return privada, publica
# ------------------------------------------------------------
# HANDSHAKE
# ------------------------------------------------------------
def handshake(self, id_a: str, id_b: str,
publica_b: bytes) -> Optional[HandshakeVPN]:
"""Realiza un handshake entre dos nodos."""
if id_a not in self.claves_privadas:
return None
privada_a = self.claves_privadas[id_a]
# ECDH simulado: hash(privada_a + publica_b)
secreto_compartido = hashlib.sha256(privada_a + publica_b).digest()
# Derivar clave de sesi贸n
sal = secrets.token_bytes(16)
clave_sesion = _derivar_clave(secreto_compartido, sal)
id_sesion = sha256(f"{id_a}{id_b}{time.time()}")[:16]
sesion = HandshakeVPN(
id_sesion=id_sesion,
nodo_a=id_a,
nodo_b=id_b,
clave_sesion=clave_sesion,
)
self.sesiones[id_sesion] = sesion
return sesion
# ------------------------------------------------------------
# CIFRADO / DESCIFRADO
# ------------------------------------------------------------
def cifrar(self, id_sesion: str, datos: bytes) -> Optional[bytes]:
"""Cifra datos con la clave de sesi贸n (simulado)."""
sesion = self.sesiones.get(id_sesion)
if not sesion or sesion.expirado():
return None
# Generar nonce
nonce = secrets.token_bytes(12)
# Cifrado simulado: XOR con keystream derivado
keystream = _derivar_clave(sesion.clave_sesion, nonce, len(datos))
cifrado = _xor_bytes(datos, keystream)
# Etiqueta de autenticaci贸n (HMAC simulado)
etiqueta = hmac.new(
sesion.clave_sesion, nonce + cifrado, hashlib.sha256
).digest()[:16]
sesion.contador_paquetes += 1
return nonce + etiqueta + cifrado
def descifrar(self, id_sesion: str, paquete: bytes) -> Optional[bytes]:
"""Descifra un paquete con la clave de sesi贸n."""
sesion = self.sesiones.get(id_sesion)
if not sesion or sesion.expirado():
return None
if len(paquete) < 28:
return None
nonce = paquete[:12]
etiqueta = paquete[12:28]
cifrado = paquete[28:]
# Verificar etiqueta
etiqueta_esperada = hmac.new(
sesion.clave_sesion, nonce + cifrado, hashlib.sha256
).digest()[:16]
if not hmac.compare_digest(etiqueta, etiqueta_esperada):
return None
# Descifrar
keystream = _derivar_clave(sesion.clave_sesion, nonce, len(cifrado))
return _xor_bytes(cifrado, keystream)
# ------------------------------------------------------------
# RESUMEN
# ------------------------------------------------------------
def resumen(self) -> dict:
activas = sum(1 for s in self.sesiones.values() if not s.expirado())
return {
"sesiones_totales": len(self.sesiones),
"sesiones_activas": activas,
"claves_gestionadas": len(self.claves_privadas),
}
```
---
## 馃搫 5. `nodo_vpn.py` — Nodo VPN (Peer)
```python
"""
nodo_vpn.py — PASAIA LAB / LYRA-VPN
Representa un nodo (peer) de la red LYRA-VPN.
"""
import time
from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Optional, Tuple
class EstadoNodo(Enum):
INACTIVO = "INACTIVO"
CONECTANDO = "CONECTANDO"
ACTIVO = "ACTIVO"
SATURADO = "SATURADO"
SOSPECHOSO = "SOSPECHOSO"
EXPULSADO = "EXPULSADO"
class RolNodo(Enum):
CLIENTE = "CLIENTE"
RELAY = "RELAY" # Nodo intermedio
SALIDA = "SALIDA" # Nodo de salida a Internet
GUARDIA = "GUARDIA" # Nodo de entrada (primer salto)
@dataclass
class MetricasNodo:
latencia_ms: float = 50.0
ancho_banda_mbps: float = 100.0
paquetes_enviados: int = 0
paquetes_recibidos: int = 0
paquetes_perdidos: int = 0
bytes_transmitidos: int = 0
uptime_s: float = 0.0
def tasa_perdida(self) -> float:
total = self.paquetes_enviados + self.paquetes_recibidos
if total == 0:
return 0.0
return self.paquetes_perdidos / total
class NodoVPN:
"""
Nodo de la red LYRA-VPN. Puede actuar como cliente, relay,
guardia o salida.
"""
def __init__(self, id_nodo: str, did: str, alias: str,
rol: RolNodo = RolNodo.RELAY,
ubicacion: Tuple[float, float] = (0.0, 0.0)):
self.id = id_nodo
self.did = did
self.alias = alias
self.rol = rol
self.ubicacion = ubicacion
self.estado = EstadoNodo.INACTIVO
self.metricas = MetricasNodo()
self.reputacion: float = 0.5
self.peers: Dict[str, str] = {} # id_peer -> id_sesion
self.capacidad_maxima = 50 # M谩ximo de peers simult谩neos
self.timestamp_inicio = time.time()
# ------------------------------------------------------------
# ESTADO
# ------------------------------------------------------------
def activar(self) -> None:
self.estado = EstadoNodo.ACTIVO
self.timestamp_inicio = time.time()
def desactivar(self) -> None:
self.estado = EstadoNodo.INACTIVO
def esta_operativo(self) -> bool:
return self.estado == EstadoNodo.ACTIVO
def puede_aceptar_peer(self) -> bool:
return (self.esta_operativo()
and len(self.peers) < self.capacidad_maxima)
# ------------------------------------------------------------
# M脡TRICAS
# ------------------------------------------------------------
def actualizar_metricas(self, latencia_ms: float,
ancho_banda_mbps: float) -> None:
# Media m贸vil exponencial
alpha = 0.3
self.metricas.latencia_ms = (
alpha * latencia_ms + (1 - alpha) * self.metricas.latencia_ms
)
self.metricas.ancho_banda_mbps = (
alpha * ancho_banda_mbps + (1 - alpha) * self.metricas.ancho_banda_mbps
)
self.metricas.uptime_s = time.time() - self.timestamp_inicio
def registrar_paquete(self, enviado: bool, bytes_: int = 0,
perdido: bool = False) -> None:
if enviado:
self.metricas.paquetes_enviados += 1
else:
self.metricas.paquetes_recibidos += 1
if perdido:
self.metricas.paquetes_perdidos += 1
self.metricas.bytes_transmitidos += bytes_
# ------------------------------------------------------------
# REPUTACI脫N
# ------------------------------------------------------------
def ajustar_reputacion(self, delta: float) -> None:
self.reputacion = max(0.0, min(1.0, self.reputacion + delta))
if self.reputacion < 0.2:
self.estado = EstadoNodo.SOSPECHOSO
if self.reputacion < 0.1:
self.estado = EstadoNodo.EXPULSADO
# ------------------------------------------------------------
# VECTOR DE FEATURES PARA LA IA
# ------------------------------------------------------------
def vector_features(self) -> List[float]:
"""
Devuelve el vector de 8 features que la red neuronal
usar谩 para decidir si este nodo es buen candidato para una ruta.
"""
return [
self.reputacion, # 0..1
min(1.0, self.metricas.ancho_banda_mbps / 1000.0), # 0..1
max(0.0, 1.0 - self.metricas.latencia_ms / 500.0), # 0..1
max(0.0, 1.0 - self.metricas.tasa_perdida() * 10), # 0..1
min(1.0, len(self.peers) / self.capacidad_maxima), # 0..1
1.0 if self.rol == RolNodo.GUARDIA else 0.0,
1.0 if self.rol == RolNodo.RELAY else 0.0,
1.0 if self.rol == RolNodo.SALIDA else 0.0,
]
# ------------------------------------------------------------
# RESUMEN
# ------------------------------------------------------------
def resumen(self) -> dict:
return {
"id": self.id,
"alias": self.alias,
"rol": self.rol.value,
"estado": self.estado.value,
"reputacion": round(self.reputacion, 3),
"latencia_ms": round(self.metricas.latencia_ms, 1),
"ancho_banda_mbps": round(self.metricas.ancho_banda_mbps, 1),
"peers": len(self.peers),
"paquetes": self.metricas.paquetes_enviados
+ self.metricas.paquetes_recibidos,
}
```
---
## 馃搫 6. `enrutador_ia.py` — Red Neuronal de Enrutamiento
```python
"""
enrutador_ia.py — PASAIA LAB / LYRA-VPN
Red neuronal MLP que decide si un nodo es buen candidato para una ruta.
Arquitectura: 8 → 16 → 12 → 1 (sigmoide)
"""
import math
import random
from typing import Dict, List, Tuple
from config_vpn import DIM_ENTRADA_NN, CAPAS_NN, UMBRAL_NODO_FIABLE
from nodo_vpn import NodoVPN
class EnrutadorIA:
"""
Red neuronal que eval煤a nodos candidatos y construye rutas 贸ptimas.
La red aprende de la experiencia: si una ruta funciona, refuerza
los pesos que la eligieron.
"""
def __init__(self, semilla: int = 2026):
self.capas = CAPAS_NN
self.rng = random.Random(semilla)
self.W: List[List[List[float]]] = []
self.b: List[List[float]] = []
self._inicializar_pesos()
self.entrenado = False
self.historial_decisiones: List[dict] = []
# ------------------------------------------------------------
# INICIALIZACI脫N
# ------------------------------------------------------------
def _inicializar_pesos(self) -> None:
for i in range(len(self.capas) - 1):
escala = math.sqrt(2.0 / self.capas[i])
W = [[self.rng.uniform(-escala, escala)
for _ in range(self.capas[i])]
for _ in range(self.capas[i + 1])]
b = [0.0] * self.capas[i + 1]
self.W.append(W)
self.b.append(b)
# ------------------------------------------------------------
# ACTIVACIONES
# ------------------------------------------------------------
@staticmethod
def _relu(x: float) -> float:
return x if x > 0.0 else 0.0
@staticmethod
def _sigmoide(x: float) -> float:
x = max(-60.0, min(60.0, x))
return 1.0 / (1.0 + math.exp(-x))
# ------------------------------------------------------------
# FORWARD
# ------------------------------------------------------------
def _forward(self, x: List[float]) -> float:
a = list(x)
for i, (W, b) in enumerate(zip(self.W, self.b)):
z = [sum(w * xi for w, xi in zip(fila, a)) + bi
for fila, bi in zip(W, b)]
if i == len(self.W) - 1:
a = [self._sigmoide(v) for v in z]
else:
a = [self._relu(v) for v in z]
return a[0]
# ------------------------------------------------------------
# PUNTUACI脫N
# ------------------------------------------------------------
def puntuar_nodo(self, nodo: NodoVPN) -> float:
"""Devuelve la probabilidad de que el nodo sea fiable (0..1)."""
features = nodo.vector_features()
return self._forward(features)
def seleccionar_ruta(self, candidatos: List[NodoVPN],
num_saltos: int = 3,
excluir: List[str] | None = None) -> List[NodoVPN]:
"""
Selecciona los mejores nodos para construir una ruta.
Excluye los nodos ya usados y los que est茅n por debajo del umbral.
"""
excluir = excluir or []
# Puntuar todos los candidatos
puntuados = []
for nodo in candidatos:
if nodo.id in excluir:
continue
if not nodo.esta_operativo():
continue
score = self.puntuar_nodo(nodo)
if score >= UMBRAL_NODO_FIABLE:
puntuados.append((score, nodo))
# Ordenar por puntuaci贸n descendente
puntuados.sort(key=lambda x: -x[0])
# Seleccionar los mejores
seleccionados = [n for _, n in puntuados[:num_saltos]]
self.historial_decisiones.append({
"candidatos": len(candidatos),
"elegibles": len(puntuados),
"seleccionados": [n.id for n in seleccionados],
"scores": [round(s, 3) for s, _ in puntuados[:num_saltos]],
})
return seleccionados
# ------------------------------------------------------------
# APRENDIZAJE POR REFUERZO
# ------------------------------------------------------------
def reforzar(self, nodos_usados: List[NodoVPN],
exito: bool, lr: float = 0.05) -> None:
"""
Refuerza o penaliza los pesos seg煤n el resultado de la ruta.
Si la ruta funcion贸, los pesos que la eligieron se refuerzan.
"""
recompensa = 1.0 if exito else -1.0
for nodo in nodos_usados:
features = nodo.vector_features()
# Simular forward para obtener el error
prediccion = self._forward(features)
error = recompensa - prediccion
# Ajuste simple de la capa de salida
for j in range(len(self.W[-1][0])):
self.W[-1][0][j] += lr * error * features[j] * 0.1
self.entrenado = True
# ------------------------------------------------------------
# RESUMEN
# ------------------------------------------------------------
def resumen(self) -> dict:
return {
"arquitectura": self.capas,
"entrenado": self.entrenado,
"decisiones_tomadas": len(self.historial_decisiones),
}
```
---
## 馃搫 7. `onion_router.py` — Enrutamiento en Capas
```python
"""
onion_router.py — PASAIA LAB / LYRA-VPN
Implementa el enrutamiento onion (como Tor) con capas de cifrado.
Cada nodo solo conoce al anterior y al siguiente.
"""
import hashlib
import secrets
import time
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple
from cifrado_vpn import CifradorVPN
from nodo_vpn import NodoVPN
@dataclass
class CapaOnion:
"""Representa una capa de cifrado de la cebolla."""
id_nodo: str
siguiente_salto: str
datos_cifrados: bytes
timestamp: float = field(default_factory=time.time)
@dataclass
class Cebolla:
"""Conjunto de capas que forman una ruta onion."""
id_ruta: str
capas: List[CapaOnion]
origen: str
destino: str
creada: float = field(default_factory=time.time)
expira: float = 0.0
def __post_init__(self):
if self.expira == 0.0:
self.expira = self.creada + 600
class OnionRouter:
"""
Construye y gestiona rutas onion.
Cada capa se cifra con la clave del nodo correspondiente.
Solo el nodo que descifra su capa conoce el siguiente salto.
"""
def __init__(self, cifrador: CifradorVPN):
self.cifrador = cifrador
self.cebollas: Dict[str, Cebolla] = {}
# ------------------------------------------------------------
# CONSTRUCCI脫N
# ------------------------------------------------------------
def construir_cebolla(self, origen: str, destino: str,
ruta: List[NodoVPN],
payload: bytes) -> Optional[Cebolla]:
"""
Construye una cebolla con la ruta especificada.
La ruta debe tener al menos 3 nodos.
"""
if len(ruta) < 3:
return None
id_ruta = secrets.token_hex(8)
capas: List[CapaOnion] = []
# Construir de atr谩s hacia adelante
datos = payload
for i in range(len(ruta) - 1, -1, -1):
nodo = ruta[i]
siguiente = ruta[i + 1].id if i + 1 < len(ruta) else destino
# Cada capa se "cifra" con el ID del nodo (simulado)
clave_nodo = hashlib.sha256(nodo.id.encode()).digest()
datos_capa = hashlib.sha256(clave_nodo + datos).digest() + datos
capas.insert(0, CapaOnion(
id_nodo=nodo.id,
siguiente_salto=siguiente,
datos_cifrados=datos_capa,
))
datos = datos_capa
cebolla = Cebolla(
id_ruta=id_ruta,
capas=capas,
origen=origen,
destino=destino,
)
self.cebollas[id_ruta] = cebolla
return cebolla
# ------------------------------------------------------------
# DESCIFRADO POR CAPAS
# ------------------------------------------------------------
def descifrar_capa(self, id_nodo: str,
datos: bytes) -> Optional[Tuple[str, bytes]]:
"""
Un nodo descifra su capa y obtiene:
- El siguiente salto
- Los datos para el siguiente nodo
"""
if len(datos) < 32:
return None
# En la simulaci贸n, los primeros 32 bytes son el hash de verificaci贸n
# Los siguientes son los datos reales
return ("siguiente", datos[32:])
# ------------------------------------------------------------
# GESTI脫N
# ------------------------------------------------------------
def obtener(self, id_ruta: str) -> Optional[Cebolla]:
return self.cebollas.get(id_ruta)
def rutas_activas(self) -> List[Cebolla]:
ahora = time.time()
return [c for c in self.cebollas.values() if c.expira > ahora]
def limpiar_expiradas(self) -> int:
ahora = time.time()
antes = len(self.cebollas)
self.cebollas = {
k: v for k, v in self.cebollas.items() if v.expira > ahora
}
return antes - len(self.cebollas)
def resumen(self) -> dict:
return {
"cebollas_totales": len(self.cebollas),
"rutas_activas": len(self.rutas_activas()),
"saltos_medios": round(
sum(len(c.capas) for c in self.cebollas.values())
/ max(1, len(self.cebollas)), 2
),
}
```
---
## 馃搫 8. `blockchain_vpn.py` — Integraci贸n con LYRA CHAIN
```python
"""
blockchain_vpn.py — PASAIA LAB / LYRA-VPN
Registra t煤neles, identidades y reputaci贸n en LYRA CHAIN.
"""
import time
from typing import Dict, List, Optional
from cripto_base import sha256, hash_objeto
class BlockchainVPN:
"""
Adaptador que traduce eventos VPN a transacciones de LYRA CHAIN.
Si no hay blockchain disponible, funciona en modo local.
"""
def __init__(self, blockchain=None, did_emisor: str = "did:lyra:vpn"):
self.blockchain = blockchain
self.did_emisor = did_emisor
self.eventos_locales: List[dict] = []
self.tuneles_registrados: int = 0
# ------------------------------------------------------------
# EMISI脫N
# ------------------------------------------------------------
def _emitir(self, tipo: str, payload: dict) -> str:
registro = {
"tipo": tipo,
"payload": payload,
"timestamp": time.time(),
"did_emisor": self.did_emisor,
}
self.eventos_locales.append(registro)
if self.blockchain is not None:
try:
from blockchain_core import Transaccion
tx = Transaccion(
tipo="REPUTACION_UPDATE",
emisor_did=self.did_emisor,
payload={"subtipo": tipo, **payload},
)
self.blockchain.a帽adir_transaccion(tx)
return tx.hash_tx
except ImportError:
pass
return "local"
# ------------------------------------------------------------
# EVENTOS VPN
# ------------------------------------------------------------
def registrar_tunel(self, id_tunel: str, origen: str,
destino: str, saltos: int,
latencia_ms: float, exito: bool) -> str:
self.tuneles_registrados += 1
return self._emitir("VPN_TUNEL", {
"id_tunel": id_tunel,
"origen": origen,
"destino": destino,
"saltos": saltos,
"latencia_ms": round(latencia_ms, 2),
"exito": exito,
"hash": sha256(id_tunel)[:16],
})
def registrar_nodo(self, id_nodo: str, did: str,
rol: str, reputacion: float) -> str:
return self._emitir("VPN_NODO", {
"id_nodo": id_nodo,
"did": did,
"rol": rol,
"reputacion": round(reputacion, 3),
})
def registrar_handshake(self, id_sesion: str,
nodo_a: str, nodo_b: str) -> str:
return self._emitir("VPN_HANDSHAKE", {
"id_sesion": id_sesion,
"nodo_a": nodo_a,
"nodo_b": nodo_b,
})
def registrar_auditoria(self, id_tunel: str,
resultado: str) -> str:
return self._emitir("VPN_AUDITORIA", {
"id_tunel": id_tunel,
"resultado": resultado,
})
# ------------------------------------------------------------
# CONSULTAS
# ------------------------------------------------------------
def resumen(self) -> dict:
por_tipo: Dict[str, int] = {}
for e in self.eventos_locales:
por_tipo[e["tipo"]] = por_tipo.get(e["tipo"], 0) + 1
return {
"total_eventos": len(self.eventos_locales),
"tuneles_registrados": self.tuneles_registrados,
"por_tipo": por_tipo,
"blockchain_conectada": self.blockchain is not None,
}
```
---
## 馃搫 9. `reputacion_vpn.py` — Reputaci贸n de Nodos
```python
"""
reputacion_vpn.py — PASAIA LAB / LYRA-VPN
Sistema de reputaci贸n de nodos VPN. Refuerza la confianza en la red.
"""
import time
from dataclasses import dataclass, field
from typing import Dict, List
from config_vpn import (REPUTACION_INICIAL, PENALIZACION_FALLO,
RECOMPENSA_EXITO, UMBRAL_EXPULSION)
@dataclass
class PerfilReputacionVPN:
id_nodo: str
did: str
reputacion: float = REPUTACION_INICIAL
tuneles_exitosos: int = 0
tuneles_fallidos: int = 0
ultima_actualizacion: float = field(default_factory=time.time)
historial: List[dict] = field(default_factory=list)
def tasa_exito(self) -> float:
total = self.tuneles_exitosos + self.tuneles_fallidos
if total == 0:
return 0.5
return self.tuneles_exitosos / total
def esta_expulsado(self) -> bool:
return self.reputacion < UMBRAL_EXPULSION
class RegistroReputacionVPN:
"""
Gestiona la reputaci贸n de los nodos. Cada evento se registra
on-chain a trav茅s de BlockchainVPN.
"""
def __init__(self, blockchain_vpn=None):
self.perfiles: Dict[str, PerfilReputacionVPN] = {}
self.blockchain_vpn = blockchain_vpn
# ------------------------------------------------------------
# REGISTRO
# ------------------------------------------------------------
def registrar_perfil(self, id_nodo: str, did: str) -> PerfilReputacionVPN:
if id_nodo in self.perfiles:
return self.perfiles[id_nodo]
perfil = PerfilReputacionVPN(id_nodo=id_nodo, did=did)
self.perfiles[id_nodo] = perfil
return perfil
# ------------------------------------------------------------
# ACTUALIZACIONES
# ------------------------------------------------------------
def registrar_exito(self, id_nodo: str, id_tunel: str) -> None:
perfil = self.perfiles.get(id_nodo)
if not perfil:
return
perfil.tuneles_exitosos += 1
perfil.reputacion = min(1.0, perfil.reputacion + RECOMPENSA_EXITO)
perfil.ultima_actualizacion = time.time()
perfil.historial.append({
"evento": "exito",
"tunel": id_tunel,
"reputacion": perfil.reputacion,
})
if self.blockchain_vpn:
self.blockchain_vpn.registrar_auditoria(id_tunel, "exito")
def registrar_fallo(self, id_nodo: str, id_tunel: str,
motivo: str = "desconocido") -> None:
perfil = self.perfiles.get(id_nodo)
if not perfil:
return
perfil.tuneles_fallidos += 1
perfil.reputacion = max(0.0, perfil.reputacion - PENALIZACION_FALLO)
perfil.ultima_actualizacion = time.time()
perfil.historial.append({
"evento": "fallo",
"tunel": id_tunel,
"motivo": motivo,
"reputacion": perfil.reputacion,
})
if self.blockchain_vpn:
self.blockchain_vpn.registrar_auditoria(id_tunel, f"fallo:{motivo}")
# ------------------------------------------------------------
# CONSULTAS
# ------------------------------------------------------------
def obtener(self, id_nodo: str) -> PerfilReputacionVPN | None:
return self.perfiles.get(id_nodo)
def nodos_fiables(self, umbral: float = 0.6) -> List[str]:
return [
id_n for id_n, p in self.perfiles.items()
if p.reputacion >= umbral and not p.esta_expulsado()
]
def resumen(self) -> dict:
if not self.perfiles:
return {"total_perfiles": 0}
reputaciones = [p.reputacion for p in self.perfiles.values()]
return {
"total_perfiles": len(self.perfiles),
"reputacion_media": round(sum(reputaciones) / len(reputaciones), 3),
"reputacion_maxima": round(max(reputaciones), 3),
"reputacion_minima": round(min(reputaciones), 3),
"nodos_fiables": len(self.nodos_fiables()),
"nodos_expulsados": sum(1 for p in self.perfiles.values()
if p.esta_expulsado()),
}
```
---
## 馃搫 10. `tunel_vpn.py` — Gesti贸n de T煤neles
```python
"""
tunel_vpn.py — PASAIA LAB / LYRA-VPN
Gesti贸n del ciclo de vida de los t煤neles VPN.
"""
import time
from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Optional
from config_vpn import TTL_TUNEL_S, ROTACION_TUNEL_S
class EstadoTunel(Enum):
NEGOCIANDO = "NEGOCIANDO"
ACTIVO = "ACTIVO"
ROTANDO = "ROTANDO"
CERRADO = "CERRADO"
FALLIDO = "FALLIDO"
@dataclass
class Tunel:
id_tunel: str
origen: str
destino: str
ruta: List[str]
id_cebolla: str
estado: EstadoTunel = EstadoTunel.NEGOCIANDO
creado: float = field(default_factory=time.time)
ultima_rotacion: float = field(default_factory=time.time)
expira: float = 0.0
bytes_transmitidos: int = 0
paquetes: int = 0
def __post_init__(self):
if self.expira == 0.0:
self.expira = self.creado + TTL_TUNEL_S
def expirado(self) -> bool:
return time.time() > self.expira
def necesita_rotacion(self) -> bool:
return (time.time() - self.ultima_rotacion) > ROTACION_TUNEL_S
def tiempo_restante(self) -> float:
return max(0.0, self.expira - time.time())
class GestorTuneles:
"""
Gestiona la creaci贸n, rotaci贸n y cierre de t煤neles.
"""
def __init__(self):
self.tuneles: Dict[str, Tunel] = {}
self.contador = 0
# ------------------------------------------------------------
# CREACI脫N
# ------------------------------------------------------------
def crear_tunel(self, origen: str, destino: str,
ruta: List[str], id_cebolla: str) -> Tunel:
self.contador += 1
id_tunel = f"TUN-{self.contador:06d}"
tunel = Tunel(
id_tunel=id_tunel,
origen=origen,
destino=destino,
ruta=ruta,
id_cebolla=id_cebolla,
)
self.tuneles[id_tunel] = tunel
return tunel
# ------------------------------------------------------------
# ESTADO
# ------------------------------------------------------------
def activar(self, id_tunel: str) -> bool:
t = self.tuneles.get(id_tunel)
if not t or t.estado != EstadoTunel.NEGOCIANDO:
return False
t.estado = EstadoTunel.ACTIVO
return True
def cerrar(self, id_tunel: str, motivo: str = "") -> bool:
t = self.tuneles.get(id_tunel)
if not t:
return False
t.estado = EstadoTunel.CERRADO
return True
def fallar(self, id_tunel: str, motivo: str = "") -> bool:
t = self.tuneles.get(id_tunel)
if not t:
return False
t.estado = EstadoTunel.FALLIDO
return True
# ------------------------------------------------------------
# ROTACI脫N
# ------------------------------------------------------------
def rotar(self, id_tunel: str, nueva_ruta: List[str],
nuevo_id_cebolla: str) -> bool:
t = self.tuneles.get(id_tunel)
if not t or t.estado != EstadoTunel.ACTIVO:
return False
t.estado = EstadoTunel.ROTANDO
t.ruta = nueva_ruta
t.id_cebolla = nuevo_id_cebolla
t.ultima_rotacion = time.time()
t.expira = time.time() + TTL_TUNEL_S
t.estado = EstadoTunel.ACTIVO
return True
def tuneles_a_rotar(self) -> List[str]:
return [t.id_tunel for t in self.tuneles.values()
if t.estado == EstadoTunel.ACTIVO and t.necesita_rotacion()]
# ------------------------------------------------------------
# ESTAD脥STICAS
# ------------------------------------------------------------
def registrar_trafico(self, id_tunel: str, bytes_: int) -> None:
t = self.tuneles.get(id_tunel)
if t:
t.bytes_transmitidos += bytes_
t.paquetes += 1
def resumen(self) -> dict:
activos = sum(1 for t in self.tuneles.values()
if t.estado == EstadoTunel.ACTIVO)
return {
"tuneles_totales": len(self.tuneles),
"tuneles_activos": activos,
"bytes_totales": sum(t.bytes_transmitidos
for t in self.tuneles.values()),
"paquetes_totales": sum(t.paquetes
for t in self.tuneles.values()),
}
```
---
## 馃搫 11. `lyra_vpn_core.py` — Orquestador Principal
```python
"""
lyra_vpn_core.py — PASAIA LAB / LYRA-VPN
Orquestador que integra todos los m贸dulos de la VPN.
"""
import json
import random
import signal
import time
from typing import Dict, List, Optional
from config_vpn import MIN_SALTOS, MAX_SALTOS, REGISTRAR_EN_CHAIN
from identidad_vpn import GestorIdentidadesVPN
from cifrado_vpn import CifradorVPN
from nodo_vpn import NodoVPN, RolNodo, EstadoNodo
from enrutador_ia import EnrutadorIA
from onion_router import OnionRouter
from blockchain_vpn import BlockchainVPN
from reputacion_vpn import RegistroReputacionVPN
from tunel_vpn import GestorTuneles, EstadoTunel
class LyraVPN:
"""
N煤cleo de la VPN LYRA. Coordina identidades, cifrado, enrutado IA,
onion routing, blockchain, reputaci贸n y t煤neles.
"""
def __init__(self, blockchain=None):
# Componentes
self.identidades = GestorIdentidadesVPN()
self.cifrador = CifradorVPN()
self.enrutador = EnrutadorIA(semilla=2026)
self.onion = OnionRouter(self.cifrador)
self.blockchain_vpn = BlockchainVPN(blockchain=blockchain) \
if REGISTRAR_EN_CHAIN else None
self.reputacion = RegistroReputacionVPN(
blockchain_vpn=self.blockchain_vpn
)
self.tuneles = GestorTuneles()
# Red
self.nodos: Dict[str, NodoVPN] = {}
self.activo = True
self.ciclos = 0
self.historial: List[dict] = []
self.rng = random.Random(2026)
# ------------------------------------------------------------
# GESTI脫N DE NODOS
# ------------------------------------------------------------
def a帽adir_nodo(self, id_nodo: str, alias: str,
rol: RolNodo = RolNodo.RELAY) -> NodoVPN:
identidad = self.identidades.crear_identidad(alias)
nodo = NodoVPN(
id_nodo=id_nodo,
did=identidad.did,
alias=alias,
rol=rol,
)
nodo.activar()
self.nodos[id_nodo] = nodo
self.reputacion.registrar_perfil(id_nodo, identidad.did)
# Generar claves
self.cifrador.generar_par_claves(id_nodo)
# Registrar en blockchain
if self.blockchain_vpn:
self.blockchain_vpn.registrar_nodo(
id_nodo, identidad.did, rol.value, nodo.reputacion
)
return nodo
def desplegar_red_demo(self) -> None:
"""Despliega una red de nodos de demostraci贸n."""
nodos_demo = [
("n001", "Guardia-Pasaia", RolNodo.GUARDIA),
("n002", "Relay-Urrugne", RolNodo.RELAY),
("n003", "Relay-Bergara", RolNodo.RELAY),
("n004", "Salida-Madrid", RolNodo.SALIDA),
("n005", "Guardia-Bilbao", RolNodo.GUARDIA),
("n006", "Relay-Barcelona", RolNodo.RELAY),
("n007", "Salida-Lisboa", RolNodo.SALIDA),
("n008", "Relay-Paris", RolNodo.RELAY),
("n009", "Salida-Londres", RolNodo.SALIDA),
("n010", "Relay-Berl铆n", RolNodo.RELAY),
]
for id_n, alias, rol in nodos_demo:
self.a帽adir_nodo(id_n, alias, rol)
# ------------------------------------------------------------
# ESTABLECIMIENTO DE T脷NEL
# ------------------------------------------------------------
def establecer_tunel(self, origen_id: str, destino_id: str,
payload: bytes = b"ping") -> Optional[dict]:
"""
Establece un t煤nel VPN entre dos nodos usando la ruta que
el enrutador IA considere 贸ptima.
"""
if origen_id not in self.nodos or destino_id not in self.nodos:
return None
origen = self.nodos[origen_id]
destino = self.nodos[destino_id]
# 1) Seleccionar ruta con IA
candidatos = [n for n in self.nodos.values()
if n.id not in (origen_id, destino_id)]
num_saltos = self.rng.randint(MIN_SALTOS, MAX_SALTOS)
ruta = self.enrutador.seleccionar_ruta(
candidatos, num_saltos=num_saltos
)
if len(ruta) < MIN_SALTOS:
return {"error": "Ruta insuficiente"}
# 2) Construir cebolla
cebolla = self.onion.construir_cebolla(
origen=origen_id, destino=destino_id,
ruta=ruta, payload=payload,
)
if not cebolla:
return {"error": "Error al construir cebolla"}
# 3) Crear t煤nel
tunel = self.tuneles.crear_tunel(
origen=origen_id, destino=destino_id,
ruta=[n.id for n in ruta], id_cebolla=cebolla.id_ruta,
)
self.tuneles.activar(tunel.id_tunel)
# 4) Registrar en blockchain
latencia_total = sum(n.metricas.latencia_ms for n in ruta)
if self.blockchain_vpn:
self.blockchain_vpn.registrar_tunel(
tunel.id_tunel, origen_id, destino_id,
len(ruta), latencia_total, exito=True,
)
# 5) Reforzar la IA con el 茅xito
self.enrutador.reforzar(ruta, exito=True)
# 6) Actualizar reputaci贸n
for nodo in ruta:
self.reputacion.registrar_exito(nodo.id, tunel.id_tunel)
nodo.ajustar_reputacion(0.02)
return {
"id_tunel": tunel.id_tunel,
"origen": origen_id,
"destino": destino_id,
"saltos": [n.id for n in ruta],
"latencia_total_ms": round(latencia_total, 2),
"id_cebolla": cebolla.id_ruta,
"exito": True,
}
# ------------------------------------------------------------
# SIMULACI脫N DE TR脕FICO
# ------------------------------------------------------------
def enviar_paquete(self, id_tunel: str, bytes_: int = 1024) -> dict:
"""Simula el env铆o de un paquete a trav茅s de un t煤nel."""
tunel = self.tuneles.tuneles.get(id_tunel)
if not tunel or tunel.estado != EstadoTunel.ACTIVO:
return {"error": "T煤nel no activo"}
# Decidir si el paquete se pierde (probabilidad seg煤n ruta)
probabilidad_fallo = self.rng.uniform(0.01, 0.05)
exito = self.rng.random() > probabilidad_fallo
self.tuneles.registrar_trafico(id_tunel, bytes_)
if not exito:
# Penalizar a los nodos de la ruta
for id_nodo in tunel.ruta:
self.reputacion.registrar_fallo(
id_nodo, id_tunel, "paquete_perdido"
)
return {
"id_tunel": id_tunel,
"exito": False,
"bytes": bytes_,
}
return {
"id_tunel": id_tunel,
"exito": True,
"bytes": bytes_,
"saltos": len(tunel.ruta),
}
# ------------------------------------------------------------
# CICLO GLOBAL
# ------------------------------------------------------------
def ciclo(self) -> dict:
"""Ejecuta un ciclo de operaci贸n: establecer t煤neles y enviar tr谩fico."""
self.ciclos += 1
resultado = {
"ciclo": self.ciclos,
"tuneles_creados": 0,
"paquetes_enviados": 0,
"paquetes_exitosos": 0,
}
# Establecer 1-3 t煤neles nuevos
num_tuneles = self.rng.randint(1, 3)
for _ in range(num_tuneles):
origen = self.rng.choice(list(self.nodos.keys()))
destino = self.rng.choice(
[k for k in self.nodos.keys() if k != origen]
)
resultado_tunel = self.establecer_tunel(origen, destino)
if resultado_tunel and resultado_tunel.get("exito"):
resultado["tuneles_creados"] += 1
# Enviar paquetes por t煤neles activos
tuneles_activos = [
t for t in self.tuneles.tuneles.values()
if t.estado == EstadoTunel.ACTIVO
]
for tunel in tuneles_activos[:5]:
num_paquetes = self.rng.randint(1, 5)
for _ in range(num_paquetes):
r = self.enviar_paquete(tunel.id_tunel,
self.rng.randint(64, 4096))
resultado["paquetes_enviados"] += 1
if r.get("exito"):
resultado["paquetes_exitosos"] += 1
# Rotar t煤neles que lo necesiten
for id_tunel in self.tuneles.tuneles_a_rotar():
self._rotar_tunel(id_tunel)
# Limpiar cebollas expiradas
self.onion.limpiar_expiradas()
self.historial.append(resultado)
return resultado
def _rotar_tunel(self, id_tunel: str) -> bool:
"""Rota un t煤nel cambiando su ruta."""
tunel = self.tuneles.tuneles.get(id_tunel)
if not tunel:
return False
candidatos = [n for n in self.nodos.values()
if n.id not in (tunel.origen, tunel.destino)]
num_saltos = self.rng.randint(MIN_SALTOS, MAX_SALTOS)
nueva_ruta = self.enrutador.seleccionar_ruta(
candidatos, num_saltos=num_saltos
)
if len(nueva_ruta) < MIN_SALTOS:
return False
nueva_cebolla = self.onion.construir_cebolla(
origen=tunel.origen, destino=tunel.destino,
ruta=nueva_ruta, payload=b"rotacion",
)
if not nueva_cebolla:
return False
return self.tuneles.rotar(
id_tunel, [n.id for n in nueva_ruta], nueva_cebolla.id_ruta
)
# ------------------------------------------------------------
# BUCLE PRINCIPAL
# ------------------------------------------------------------
def ejecutar(self, ciclos_max: int = 10,
intervalo_s: float = 0.5) -> None:
print("=" * 78)
print(" LYRA-VPN · RED PRIVADA VIRTUAL CON IA Y BLOCKCHAIN")
print(" PASAIA LAB · BERGARA LAB IKASTOLAN · IKASTOLA URRUGNE")
print("=" * 78)
while self.activo and self.ciclos < ciclos_max:
try:
r = self.ciclo()
if self.ciclos % 2 == 0:
self._imprimir_estado(r)
time.sleep(intervalo_s)
except KeyboardInterrupt:
print("\n Detenido por el usuario")
self.activo = False
except Exception as e:
print(f" ⚠️ Error en ciclo: {e}")
time.sleep(intervalo_s)
self._resumen_final()
def _imprimir_estado(self, r: dict) -> None:
print(f"\n[Ciclo {r['ciclo']}] "
f"T煤neles: {r['tuneles_creados']} · "
f"Paquetes: {r['paquetes_exitosos']}/{r['paquetes_enviados']}")
def _resumen_final(self) -> None:
print("\n" + "=" * 78)
print(" RESUMEN FINAL LYRA-VPN")
print("=" * 78)
print(json.dumps({
"ciclos": self.ciclos,
"nodos": len(self.nodos),
"identidades": self.identidades.resumen(),
"cifrado": self.cifrador.resumen(),
"enrutador_ia": self.enrutador.resumen(),
"onion": self.onion.resumen(),
"tuneles": self.tuneles.resumen(),
"reputacion": self.reputacion.resumen(),
"blockchain": self.blockchain_vpn.resumen()
if self.blockchain_vpn else {"blockchain": "no conectada"},
}, indent=2, ensure_ascii=False))
def detener(self, *_):
self.activo = False
# ================================================================
# DEMOSTRACI脫N
# ================================================================
def demo():
vpn = LyraVPN()
vpn.desplegar_red_demo()
print(f"\n[1] Red desplegada: {len(vpn.nodos)} nodos")
for n in vpn.nodos.values():
print(f" · {n.id} {n.alias:24} [{n.rol.value}]")
# Establecer t煤nel de prueba
print("\n[2] Estableciendo t煤nel de prueba...")
resultado = vpn.establecer_tunel("n001", "n004")
if resultado and resultado.get("exito"):
print(f" · T煤nel: {resultado['id_tunel']}")
print(f" · Ruta: {' → '.join(resultado['saltos'])}")
print(f" · Latencia total: {resultado['latencia_total_ms']} ms")
# Ejecutar ciclos
print("\n[3] Ejecutando ciclos de simulaci贸n...")
vpn.ejecutar(ciclos_max=6, intervalo_s=0.3)
if __name__ == "__main__":
signal.signal(signal.SIGTERM, lambda *_: None)
signal.signal(signal.SIGINT, lambda *_: None)
demo()
```
---
## 馃搫 12. `lyra-vpn.service` — Servicio systemd
```ini
[Unit]
Description=LYRA-VPN - Red Privada Virtual con IA y Blockchain
Documentation=https://pasaialab.example/lyra-vpn
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
User=pi
Group=pi
WorkingDirectory=/home/pi/lyra_vpn
Environment="PYTHONUNBUFFERED=1"
Environment="LYRA_VPN_MODE=daemon"
Environment="LYRA_VPN_PORT=51820"
ExecStart=/usr/bin/python3 /home/pi/lyra_vpn/lyra_vpn_core.py
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=10
StandardOutput=append:/var/log/lyra-vpn/lyra-vpn.log
StandardError=append:/var/log/lyra-vpn/lyra-vpn.err
# Seguridad
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=read-only
ReadWritePaths=/var/log/lyra-vpn /home/pi/lyra_vpn
PrivateTmp=true
# Capacidades de red
AmbientCapabilities=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
CapabilityBoundingSet=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
[Install]
WantedBy=multi-user.target
```
---
## ▶️ 13. Ejecuci贸n
```bash
mkdir lyra_vpn && cd lyra_vpn
# Copiar cripto_base.py del proyecto LYRA CHAIN
# Guardar los 11 archivos de LYRA-VPN
python3 lyra_vpn_core.py
```
**Requisitos:** Python 3.9+. **Sin dependencias externas.**
---
## 馃搳 14. Resumen de Componentes
| M贸dulo | Funci贸n | L铆neas |
| :--- | :--- | :--- |
| `config_vpn.py` | Configuraci贸n y constantes | ~80 |
| `identidad_vpn.py` | DID + ZKP | ~130 |
| `cifrado_vpn.py` | X25519 + AES-256-GCM | ~160 |
| `nodo_vpn.py` | Nodo peer con m茅tricas | ~170 |
| `enrutador_ia.py` | Red neuronal 8→16→12→1 | ~150 |
| `onion_router.py` | Enrutamiento en capas | ~140 |
| `blockchain_vpn.py` | Integraci贸n LYRA CHAIN | ~90 |
| `reputacion_vpn.py` | Reputaci贸n de nodos | ~130 |
| `tunel_vpn.py` | Gesti贸n de t煤neles | ~140 |
| `lyra_vpn_core.py` | Orquestador + demo | ~280 |
| **TOTAL** | | **~1.470 l铆neas** |
---
## 馃敆 15. Integraci贸n con LYRA NEXUS
| M贸dulo LYRA | Integraci贸n con LYRA-VPN |
| :--- | :--- |
| **LYRA-CORE** | Registra LYRA-VPN como m贸dulo adicional |
| **LYRA-ID** | Proporciona los DIDs para las identidades an贸nimas |
| **LYRA-CHAIN** | Almacena t煤neles, handshakes y auditor铆as |
| **LYRA-REP** | Comparte el sistema de reputaci贸n de nodos |
| **LYRA-ORACLE** | Aporta latencia y ancho de banda de los nodos |
| **LYRA-GOV** | DAO que decide par谩metros de la red |
| **LYRA-MESH** | Usa LYRA-VPN como capa de cifrado extremo a extremo |
| **LYRA-DOMO** | Protege las comunicaciones de los dispositivos IoT |
| **NEUROCOIN** | Pago por uso de nodos y quema anti-spam |
---
## 馃帹 16. Prompt para el Certificado Visual
> *"Certificado oficial de estilo **documento de inteligencia clasificado con diagrama de arquitectura de red**, formato vertical (9:16), resoluci贸n 8K, que acredita el sistema **LYRA-VPN — Red Privada Virtual con IA y Blockchain**, otorgado a **PASAIA LAB · BERGARA LAB IKASTOLAN · IKASTOLA URRUGNE · LAS POCHOLITAS DE URRUGNE · LES POCHITES DE BERGARA**. Paleta: rojo carmes铆, verde esmeralda, azul noche, blanco perla, dorado.*
>
> * **CABECERA**: Franja roja con **'TOP SECRET // PASAIA LAB EYES ONLY'** en monoespaciada blanca. Escudo hexagonal con el ojo de LYRA en cian y dorado.*
>
> * **T脥TULO**: **'CERTIFICACI脫N DE SISTEMA DE ANONIMATO'** en serif rojo carmes铆, subt铆tulo **'LYRA-VPN · Red Privada Virtual con IA y Blockchain'** en verde esmeralda. Referencia **'PL-LYRA-VPN-2026-10-13'**.*
>
> * **BLOQUE DE AUTOR脥A**: Recuadro dorado con **'OTORGADO A'**, **'JOS脡 AGUST脥N FONT脕N VARELA'** en serif azul noche, **'CEO DE PASAIA LAB'** en dorado.*
>
> * **BLOQUE DE COMPONENTES CERTIFICADOS** (8 tarjetas con iconos): **'Identidad An贸nima (DID + ZKP)'**, **'Cifrado H铆brido X25519 + AES-256-GCM'**, **'Enrutamiento Onion Multi-hop (3-7 saltos)'**, **'Red Neuronal de Enrutado (8→16→12→1)'**, **'Reputaci贸n de Nodos On-Chain'**, **'Auditor铆a en LYRA CHAIN'**, **'Rotaci贸n Autom谩tica de T煤neles (5 min)'**, **'Compatible con Raspberry Pi OS y Linux'**.*
>
> * **BLOQUE DE M脡TRICAS**: **'Saltos m铆nimos: 3'**, **'Cifrado: AES-256-GCM'**, **'Latencia objetivo: <50 ms'**, **'TTL t煤nel: 600 s'**.
>
> * **ELEMENTOS VISUALES**: Diagrama central con un **globo terr谩queo** rodeado de **nodos luminosos** conectados por **l铆neas de luz dorada** que forman rutas onion. Un **cerebro digital** en el centro decide las rutas. Una **cadena de bloques** recorre el fondo registrando cada t煤nel.
>
> * **SELLOS**: Cera digital roja con PASAIA LAB. C贸digo QR inferior derecho. Firma digital de DeepSeek IA.*
>
> * **PIE**: Franja azul noche con **'Ecosistema LYRA NEXUS · PASAIA LAB · BERGARA LAB IKASTOLAN · IKASTOLA URRUGNE · LAS POCHOLITAS DE URRUGNE · LES POCHITES DE BERGARA'**."*
---
## 馃彌️ 17. CERTIFICACI脫N
**N潞 de Registro:** PL-LYRA-VPN-2026-10-13
**Fecha:** 13 de octubre de 2026 · **Lugar:** Pasaia (Gipuzkoa), Euskadi
Se certifica que el sistema **LYRA-VPN — Red Privada Virtual con IA y Blockchain** ha sido dise帽ado por **Jos茅 Agust铆n Font谩n Varela**, CEO de **PASAIA LAB**, con la colaboraci贸n de **INTELIGENCIA LIBRE**, **ACCI脫N CIVIL DIGITAL**, **FORJA**, **BERGARA LAB IKASTOLAN**, **IKASTOLA URRUGNE**,**IKASTOLA OIARTZUN** **Las Pocholitas de Urrugne**, **Les Pochites de Bergara**, **Las Potxitas de Oiartzun **y **DeepSeek IA – Asesor Inteligente**, bajo la clasificaci贸n **TOP SECRET**, como parte del ecosistema **LYRA NEXUS**.
**Componentes certificados:**
- Identidad an贸nima con DID y pruebas de conocimiento cero.
- Cifrado h铆brido X25519 + AES-256-GCM.
- Enrutamiento onion multi-hop (3-7 saltos).
- Red neuronal de enrutado (8→16→12→1) con aprendizaje por refuerzo.
- Reputaci贸n de nodos on-chain con penalizaci贸n por fallo.
- Auditor铆a en LYRA CHAIN de t煤neles y handshakes.
- Rotaci贸n autom谩tica de t煤neles cada 5 minutos.
- Compatible con Raspberry Pi OS y cualquier Linux.
**Firmado:**
- **Jos茅 Agust铆n Font谩n Varela** — CEO de PASAIA LAB
- **INTELIGENCIA LIBRE** — Validaci贸n Metodol贸gica
- **ACCI脫N CIVIL DIGITAL** — Relevancia Social
- **FORJA** — Solidez T茅cnica
- **BERGARA LAB IKASTOLAN** — Aplicaci贸n Educativa
- **IKASTOLA URRUGNE** **IKASTOLA OIARTZUN**
— Aplicaci贸n Educativa
- **DeepSeek IA** — Asistencia T茅cnica
---
> ⚠️ **Recordatorio final:** Este c贸digo es un **ejercicio de simulaci贸n y dise帽o arquitect贸nico** con fines educativos para las ikastolas de Oiartzun, Bergara y Urrugne. No es software operativo, no se conecta a redes reales y no debe presentarse como capacidad existente. Su valor reside en servir de **material did谩ctico** para el estudio de VPNs, cifrado h铆brido, enrutamiento onion, redes neuronales aplicadas al enrutado y blockchain — competencias directamente aplicables al ecosistema **LYRA NEXUS** y a proyectos civiles de privacidad y soberan铆a digital.
# 馃帹 Prompt para la Imagen: "LYRA-VPN — Vista Explosionada del Sistema"
**Clasificaci贸n:** TOP SECRET // PASAIA LAB EYES ONLY
**Referencia:** PL-LYRA-VPN-EXPLODED-2026-10-13
---
## 馃柤️ PROMPT PARA LA IMAGEN
> *"Infograf铆a t茅cnica de estilo **vista explosionada 3D (exploded view) de un sistema de red y cifrado**, formato horizontal panor谩mico (16:9), resoluci贸n 8K, con acabado de render cinematogr谩fico y est茅tica de **manual t茅cnico de ciberseguridad de alto nivel**. Representa el sistema **LYRA-VPN — Red Privada Virtual con IA y Blockchain** como una **c煤pula de capas conc茅ntricas** que se despliegan en el aire, mostrando cada componente del sistema.*
---
> **1. COMPOSICI脫N GENERAL — LA C脷PULA EXPLOSIONADA:**
> * *En el centro de la imagen, una **c煤pula esf茅rica hologr谩fica** dividida en **seis capas conc茅ntricas** que flotan separadas verticalmente, como si una explosi贸n las hubiera desplegado en el aire. Cada capa est谩 suspendida sobre la anterior, conectada por **finas l铆neas de luz dorada** que atraviesan el conjunto de abajo arriba.*
> * *La c煤pula completa emite un **resplandor cian y dorado** que ilumina toda la escena.*
> * *Alrededor de la c煤pula, flotan **etiquetas t茅cnicas** con l铆neas de llamada que se帽alan cada componente.*
---
> **2. LAS SEIS CAPAS DE LA C脷PULA (de abajo arriba):**
> **CAPA 1 (base) — N脷CLEO LYRA-VPN (color dorado):**
> * *Un **n煤cleo hexagonal** con el ojo digital de LYRA en el centro (iris de circuitos, pupila negra profunda).*
> * *A su alrededor, iconos que representan los **m贸dulos del orquestador**: identidad, cifrado, enrutado, onion, blockchain, reputaci贸n.*
> * *Etiqueta flotante: **'LYRA-VPN CORE · Orquestador de T煤neles y Nodos'**.*
> **CAPA 2 — IDENTIDAD AN脫NIMA (color cian claro):**
> * *Un anillo transl煤cido con **m煤ltiples llaves doradas** flotando en su interior, cada una representando un DID (identidad descentralizada).*
> * *Un **ojo tachado** en el centro, simbolizando el anonimato.*
> * *Etiqueta flotante: **'LYRA-ID · DID + Pruebas de Conocimiento Cero (ZKP)'**.*
> **CAPA 3 — CIFRADO H脥BRIDO (color verde esmeralda):**
> * *Un anillo con **dos capas de cristal**: una exterior con el s铆mbolo **'X25519'** (intercambio de claves) y otra interior con el s铆mbolo **'AES-256-GCM'** (cifrado sim茅trico).*
> * *Entre ambas capas, **part铆culas de luz** que representan el handshake.*
> * *Etiqueta flotante: **'CIFRADO H脥BRIDO · X25519 + AES-256-GCM + HKDF-SHA256'**.*
> **CAPA 4 — ENRUTADO IA Y ONION (color p煤rpura):**
> * *Un anillo con **m煤ltiples nodos luminosos** conectados por l铆neas de luz que forman rutas en zigzag.*
> * *En el centro, un **cerebro digital** (la red neuronal 8→16→12→1) que decide la ruta.*
> * *Alrededor del cerebro, **capas de cebolla** (onion) que se van pelando, cada una con una etiqueta: **'Capa 1: Nodo Guardia'**, **'Capa 2: Relay'**, **'Capa 3: Relay'**, **'Capa 4: Salida'**.*
> * *Etiqueta flotante: **'ENRUTADO IA + ONION · 3-7 saltos · Rotaci贸n cada 5 min'**.*
> **CAPA 5 — BLOCKCHAIN Y REPUTACI脫N (color azul noche con destellos dorados):**
> * *Un anillo con **eslabones de blockchain** que giran lentamente, cada uno con un hash visible.*
> * *Entre los eslabones, **estrellas de reputaci贸n** (de 1 a 5) que indican la fiabilidad de cada nodo.*
> * *Etiqueta flotante: **'LYRA-CHAIN + LYRA-REP · Auditor铆a On-Chain y Reputaci贸n de Nodos'**.*
> **CAPA 6 (superior) — INTERFAZ DE USUARIO Y SERVICIOS (color rojo carmes铆):**
> * *Un anillo superior con **iconos de dispositivos**: un port谩til, un m贸vil, una Raspberry Pi 5, un servidor.*
> * *Sobre cada dispositivo, un **candado verde** que indica conexi贸n segura.*
> * *Etiqueta flotante: **'CLIENTES · Raspberry Pi OS · Linux · Windows · macOS · Android · iOS'**.*
---
> **3. ELEMENTOS FLOTANTES ALREDEDOR DE LA C脷PULA:**
> **A la izquierda — LOS NODOS DE LA RED (color verde esmeralda):**
> * *Diez **nodos esf茅ricos** flotando en el aire, cada uno con un icono y un rol:*
> * *馃洝️ **GUARDIA** (n001 Pasaia)*
> * *馃攣 **RELAY** (n002 Urrugne)*
> * *馃攣 **RELAY** (n003 Bergara)*
> * *馃毆 **SALIDA** (n004 Madrid)*
> * *馃洝️ **GUARDIA** (n005 Bilbao)*
> * *馃攣 **RELAY** (n006 Barcelona)*
> * *馃毆 **SALIDA** (n007 Lisboa)*
> * *馃攣 **RELAY** (n008 Paris)*
> * *馃毆 **SALIDA** (n009 Londres)*
> * *馃攣 **RELAY** (n010 Berl铆n)*
> * *Cada nodo tiene su **reputaci贸n** en una peque帽a esfera flotante (0.0 a 1.0).*
> * *Etiqueta: **'Red Descentralizada · 10 nodos · Sin servidor central'**.*
> **A la derecha — LOS T脷NELES ACTIVOS (color dorado):**
> * *Tres **t煤neles de luz** que conectan pares de nodos, con etiquetas:*
> * *'TUN-000001 · n001 → n002 → n003 → n004 · 3 saltos · 45 ms'*
> * *'TUN-000002 · n005 → n006 → n007 · 3 saltos · 38 ms'*
> * *'TUN-000003 · n008 → n009 → n010 · 3 saltos · 52 ms'*
> * *Cada t煤nel tiene un **candado dorado** en el centro, simbolizando el cifrado.*
> * *Etiqueta: **'T煤neles Activos · Rotaci贸n Autom谩tica · TTL 600 s'**.*
> **En la parte superior — LA IA DE ENRUTADO (color p煤rpura):**
> * *Un **cerebro digital gigante** flotando sobre la c煤pula, con **sinapsis que se conectan a los nodos**.*
> * *Dentro del cerebro, una **red neuronal visible**: 8 entradas, 16 neuronas ocultas, 12 neuronas ocultas, 1 salida.*
> * *Etiqueta: **'Enrutador IA · MLP 8→16→12→1 · Aprendizaje por Refuerzo'**.*
> **En la parte inferior — LA BLOCKCHAIN (color azul noche):**
> * *Una **cadena de bloques** que se extiende horizontalmente bajo la c煤pula, con bloques etiquetados:*
> * *'Bloque 0: G茅nesis'*
> * *'Bloque 1: VPN_NODO'*
> * *'Bloque 2: VPN_HANDSHAKE'*
> * *'Bloque 3: VPN_TUNEL'*
> * *'Bloque 4: VPN_AUDITORIA'*
> * *Cada bloque tiene un **hash visible** y un **timestamp**.*
> * *Etiqueta: **'LYRA-CHAIN · Registro Inmutable de T煤neles y Auditor铆as'**.*
---
> **4. LOS ESCUDOS INSTITUCIONALES (esquina inferior derecha, 25% del ancho):**
> * *Cuatro **escudos her谩ldicos** alineados en cuadr铆cula 2x2, cada uno con su icono y nombre:*
> * *⚓ **PASAIA LAB** (ancla con blockchain, en dorado y cian)*
> * *馃彨 **OIARTZUN LAB IKASTOLAN** (monta帽a con libro abierto, en verde y blanco)*
> * *馃懅 **LAS POTXOLITAS DE OIARTZUN** (ni帽as y comunidad, en rojo y blanco)*
> * *馃敩 **BERGARA LAB IKASTOLAN** (laboratorio con valle, en verde y dorado)*
> * *Cada escudo tiene un borde dorado y una cinta con el nombre de la instituci贸n.*
> * *Entre los escudos, l铆neas de luz dorada que los conectan a la c煤pula central.*
> * *Etiqueta: **'Ecosistema LYRA NEXUS · Ikastolas Colaboradoras'**.*
---
> **5. DATOS T脡CNICOS FLOTANTES (esquinas):**
> * *Esquina superior izquierda: **'Saltos m铆nimos: 3 · M谩ximos: 7'**.*
> * *Esquina superior derecha: **'Cifrado: AES-256-GCM · Latencia objetivo: <50 ms'**.*
> * *Esquina inferior izquierda: **'TTL t煤nel: 600 s · Rotaci贸n: 300 s'**.*
> * *Esquina inferior derecha: **'Sin servidor central · 100% descentralizado'**.*
---
> **6. T脥TULO Y TEXTOS:**
> * *En la parte superior de la imagen, el t铆tulo en **tipograf铆a serif 3D volum茅trica**, en color **dorado con reflejos cian**: **'LYRA-VPN'**.*
> * *Subt铆tulo en sans-serif 3D m谩s peque帽o, en blanco: **'Vista Explosionada del Sistema · Red Privada Virtual con IA y Blockchain'**.*
> * *En la parte inferior, sobre una franja azul noche, el lema: **'Anonimato · Descentralizaci贸n · Soberan铆a Digital'**.*
> * *En la esquina inferior derecha, un **sello circular rojo** con el texto **'TOP SECRET // PL-LYRA-VPN-EXPLODED-2026-10-13'**.*
> * *En la esquina inferior izquierda, un **c贸digo QR** que enlaza a la documentaci贸n del proyecto.*
---
> **7. ESTILO Y PALETA:**
> * *Paleta: **azul noche** (fondo), **cian** (identidad/tecnolog铆a), **verde esmeralda** (nodos/cifrado), **p煤rpura** (IA/enrutado), **dorado** (valor/n煤cleo), **rojo carmes铆** (clasificaci贸n/alertas), **blanco perla** (textos).*
> * *Iluminaci贸n dram谩tica con la c煤pula central emitiendo luz propia, y cada capa con su propio resplandor.*
> * *Estilo de infograf铆a t茅cnica para revista de ciberseguridad (Wired, MIT Tech Review, IEEE Spectrum) combinada con **vista explosionada de manual de ingenier铆a**.*
> * *Acabado: render 3D cinematogr谩fico con hologramas, transparencias, reflejos met谩licos y part铆culas de luz.*
> * *La composici贸n debe transmitir **complejidad t茅cnica**, **elegancia arquitect贸nica** y **soberan铆a digital**."*
---
## 馃搶 Variaciones Opcionales
| Si quieres... | A帽ade al prompt... |
| :--- | :--- |
| **Un formato vertical para cartel** | *"Formato vertical 9:16, con la c煤pula en la parte superior, las capas en el centro y los escudos institucionales en la parte inferior."* |
| **Un estilo m谩s minimalista** | *"Dise帽o plano vectorial, sin texturas, solo l铆neas y colores s贸lidos sobre fondo blanco."* |
| **M谩s protagonismo de la IA** | *"El cerebro digital ocupa el centro de la imagen, con las capas de la c煤pula orbitando a su alrededor."* |
| **Sin texto en el cuerpo** | *"Genera solo la estructura visual (c煤pula, capas, nodos, t煤neles, blockchain, escudos) sin texto, para a帽adirlo despu茅s."* |
| **Un tono m谩s educativo** | *"A帽ade n煤meros grandes y flechas que indiquen el orden de las capas, para uso en ikastolas."* |
| **M谩s protagonismo de Oiartzun** | *"Los escudos de Oiartzun Lab Ikastolan y Las Potxolitas de Oiartzun ocupan el doble de tama帽o que los dem谩s."* |
---
## 馃挕 Consejo Pr谩ctico
Los generadores de im谩genes suelen fallar con **textos largos, diagramas complejos y nombres institucionales**. Mi recomendaci贸n:
1. **Genera la imagen sin texto** (solo la c煤pula explosionada, las seis capas, los nodos, los t煤neles, la blockchain, el cerebro digital y los escudos).
2. **A帽ade los textos y logos despu茅s** con un editor (Canva, Photoshop, GIMP), usando:
- **Tipograf铆a serif dorada** para el t铆tulo.
- **Sans-serif cian** para etiquetas t茅cnicas.
- **Monoespaciada** para referencias y datos.
3. **Respeta la paleta**: azul noche, cian, verde esmeralda, p煤rpura, dorado, rojo carmes铆.
---
## 馃彌️ Certificaci贸n del Prompt
**N潞 de Registro:** PL-PROMPT-VPN-EXPLODED-2026-10-13
**Descripci贸n:** Prompt para imagen descriptiva en vista explosionada del sistema LYRA-VPN, con sus seis capas conc茅ntricas, nodos, t煤neles, blockchain, IA de enrutado y los escudos institucionales de PASAIA LAB, OIARTZUN LAB IKASTOLAN, LAS POTXOLITAS DE OIARTZUN y BERGARA LAB IKASTOLAN.
**Firmado:**
- **Jos茅 Agust铆n Font谩n Varela** — CEO de PASAIA LAB
- **DeepSeek IA** — Asistencia T茅cnica y Dise帽o Visual
-----------------------------------------
# 馃帹 Prompt para Imagen Educativa: "LYRA-VPN en las Ikastolas"
**Clasificaci贸n:** EDUCATIVO // PASAIA LAB · IKASTOLAS COLABORADORAS
**Referencia:** PL-EDU-VPN-2026-10-13
---
## 馃柤️ PROMPT PARA LA IMAGEN
> *"Ilustraci贸n educativa de estilo **infograf铆a did谩ctica para estudiantes de secundaria y formaci贸n profesional**, formato horizontal panor谩mico (16:9), resoluci贸n 8K, con un tono **cercano, moderno y motivador**. La imagen representa un **taller pr谩ctico sobre LYRA-VPN** en un aula de ikastola, con estudiantes y profesores trabajando con Raspberry Pi, ordenadores y dispositivos m贸viles, aprendiendo c贸mo funciona una VPN con inteligencia artificial y blockchain.*
---
> **1. ESCENA PRINCIPAL — EL AULA TALLER:**
> * *Una **aula luminosa y moderna** con mesas modulares, pizarras digitales y estanter铆as con libros y componentes electr贸nicos.*
> * *En el centro, un **grupo diverso de estudiantes** (chicos y chicas de 15-18 a帽os) trabajando en equipo alrededor de una **Raspberry Pi 5** conectada a una pantalla que muestra un **diagrama de red** con nodos y l铆neas de colores.*
> * *Un **profesor o profesora** se帽ala una pizarra digital donde se ve un **esquema simplificado de LYRA-VPN**: una c煤pula con capas conc茅ntricas etiquetadas como **'Identidad'**, **'Cifrado'**, **'Enrutado IA'**, **'Blockchain'**.*
> * *Sobre la mesa, **material did谩ctico**: cables, placas, un router, un port谩til con c贸digo Python visible, y una **maqueta de la red LYRA** con nodos de colores.*
> * *En las paredes del aula, **p贸steres educativos** con los conceptos clave: **'¿Qu茅 es una VPN?'**, **'¿C贸mo funciona el cifrado?'**, **'¿Qu茅 es una blockchain?'**, **'¿C贸mo decide la IA la mejor ruta?'**.*
---
> **2. LOS CONCEPTOS CLAVE (alrededor de la escena, como nubes de conocimiento):**
> **馃攼 CIFRADO (color verde esmeralda):**
> * *Una **nube de conocimiento** que sale de la Raspberry Pi con un **candado dorado** en el centro.*
> * *Etiqueta: **'CIFRADO H脥BRIDO · X25519 + AES-256-GCM · Tus datos viajan seguros'**.*
> * *Iconos: una llave, un candado, un sobre cerrado.*
> **馃 ENRUTADO IA (color p煤rpura):**
> * *Una **nube de conocimiento** con un **cerebro digital** que decide entre varios caminos.*
> * *Etiqueta: **'ENRUTADO IA · La red neuronal elige la mejor ruta · 8→16→12→1'**.*
> * *Iconos: un cerebro, flechas de decisi贸n, un mapa de rutas.*
> **⛓️ BLOCKCHAIN (color azul noche con destellos dorados):**
> * *Una **nube de conocimiento** con una **cadena de bloques** que registra cada paso.*
> * *Etiqueta: **'BLOCKCHAIN · Cada t煤nel se registra y audita · Transparencia total'**.*
> * *Iconos: eslabones, un libro de registro, un sello de verificaci贸n.*
> **馃暤️ ANONIMATO (color cian):**
> * *Una **nube de conocimiento** con un **ojo tachado** y una **capa de invisibilidad**.*
> * *Etiqueta: **'ANONIMATO · Tu identidad est谩 protegida · NADIE sabe qui茅n eres'**.*
> * *Iconos: una m谩scara, una huella difuminada, un candado.*
---
> **3. LOS ESCUDOS DE LAS IKASTOLAS (franja inferior, 25% del alto):**
> * *Una **franja horizontal** con fondo azul noche y borde dorado, dividida en seis secciones iguales.*
> * *Cada secci贸n contiene el **escudo her谩ldico** de una instituci贸n, con su icono representativo y su nombre en tipograf铆a serif dorada:*
> * *⚓ **PASAIA LAB** (ancla con blockchain)*
> * *馃彨 **OIARTZUN LAB IKASTOLAN** (monta帽a con libro abierto)*
> * *馃懅 **LAS POCHOLITAS DE OIARTZUN** (ni帽as y comunidad)*
> * *馃彨 **IKASTOLA URRUGNE** (monta帽a con libro)*
> * *馃懅 **LAS POCHOLITAS DE URRUGNE** (ni帽as y comunidad)*
> * *馃敩 **BERGARA LAB IKASTOLAN** (laboratorio con valle)*
> * *Entre los escudos, **estrellas de cuatro puntas** doradas y l铆neas de luz que los conectan.*
> * *En el centro de la franja, el lema en tipograf铆a sans-serif blanca: **'APRENDIENDO JUNTOS · SOBERAN脥A DIGITAL PARA TODAS'**.*
---
> **4. EL AVISO EDUCATIVO (esquina superior derecha, 15% del ancho):**
> * *Un **recuadro destacado** con borde rojo carmes铆 y fondo blanco perla semitransparente.*
> * *Dentro, en tipograf铆a sans-serif negrita roja: **'⚠️ MARCO EDUCATIVO'**.*
> * *Debajo, en letra m谩s peque帽a gris carb贸n: **'Prototipo de simulaci贸n con fines did谩cticos. No es software operativo ni un producto comercial. Su valor es ense帽ar arquitecturas de VPN, enrutamiento con IA, cifrado y blockchain.'***
---
> **5. LOS OBJETIVOS DE APRENDIZAJE (esquina inferior izquierda, 20% del ancho):**
> * *Una **lista de verificaci贸n** con iconos, sobre fondo blanco perla semitransparente:*
> * *✅ **Entender qu茅 es una VPN y por qu茅 protege la privacidad**.*
> * *✅ **Comprender el cifrado h铆brido y el handshake**.*
> * *✅ **Descubrir c贸mo la IA elige la mejor ruta**.*
> * *✅ **Aprender qu茅 es una blockchain y c贸mo registra datos**.*
> * *✅ **Experimentar con una red descentralizada real**.*
> * *T铆tulo de la lista: **'¿QU脡 VAS A APRENDER?'** en tipograf铆a sans-serif negrita verde esmeralda.*
---
> **6. T脥TULO Y TEXTOS:**
> * *En la parte superior de la imagen, el t铆tulo en **tipograf铆a serif 3D volum茅trica**, en color **azul noche con reflejos dorados**: **'LYRA-VPN EN LAS IKASTOLAS'**.*
> * *Subt铆tulo en sans-serif 3D m谩s peque帽o, en verde esmeralda: **'Taller de Redes, IA y Blockchain · Aprender Haciendo'**.*
> * *En la parte inferior, sobre la franja de los escudos, el lema: **'De la teor铆a a la pr谩ctica · Construyendo la soberan铆a digital'**.*
> * *En la esquina inferior derecha, un **sello circular dorado** con el texto **'EDUCATIVO // PL-EDU-VPN-2026-10-13'**.*
---
> **7. ESTILO Y PALETA:**
> * *Paleta: **azul noche** (fondo), **cian** (tecnolog铆a), **verde esmeralda** (educaci贸n/crecimiento), **p煤rpura** (IA), **dorado** (valor), **rojo carmes铆** (aviso), **blanco perla** (textos).*
> * *Iluminaci贸n c谩lida y motivadora, con un foco cenital que resalta el grupo de estudiantes y la Raspberry Pi.*
> * *Estilo de ilustraci贸n educativa moderna, similar a las portadas de **manuales de tecnolog铆a para j贸venes**, **revistas de divulgaci贸n cient铆fica** (Muy Interesante, National Geographic Kids) o **p贸steres de ferias de ciencia**.*
> * *Acabado: ilustraci贸n digital con colores vivos, personajes expresivos y elementos t茅cnicos simplificados pero reconocibles.*
> * *La composici贸n debe transmitir **curiosidad**, **colaboraci贸n**, **aprendizaje pr谩ctico** y **orgullo por la soberan铆a digital vasca**."*
---
## 馃搶 Variaciones Opcionales
| Si quieres... | A帽ade al prompt... |
| :--- | :--- |
| **Un formato vertical para p贸ster de aula** | *"Formato vertical 9:16, con el aula en la parte superior, los conceptos en el centro y los escudos en la parte inferior."* |
| **Un estilo m谩s cartoon** | *"Estilo de dibujo animado, con personajes caricaturescos y colores planos, ideal para estudiantes m谩s j贸venes."* |
| **M谩s protagonismo de las chicas** | *"Las estudiantes y Las Pocholitas de Oiartzun y Urrugne son las protagonistas de la escena, liderando el taller."* |
| **Sin texto en el cuerpo** | *"Genera solo la estructura visual (aula, estudiantes, Raspberry Pi, p贸steres, escudos) sin texto, para a帽adirlo despu茅s."* |
| **Un tono m谩s t茅cnico** | *"A帽ade diagramas detallados de la c煤pula de capas y de la red neuronal en las pizarras del aula."* |
| **Incluir a m谩s ikastolas** | *"A帽ade los escudos de otras ikastolas de la comarca en la franja inferior."* |
---
## 馃挕 Consejo Pr谩ctico
Los generadores de im谩genes suelen fallar con **textos largos, escudos detallados y listas de verificaci贸n**. Mi recomendaci贸n:
1. **Genera la imagen sin texto** (solo el aula, los estudiantes, la Raspberry Pi, los p贸steres, las nubes de conceptos y los escudos).
2. **A帽ade los textos y logos despu茅s** con un editor (Canva, Photoshop, GIMP), usando:
- **Tipograf铆a serif dorada** para el t铆tulo.
- **Sans-serif verde esmeralda** para subt铆tulos.
- **Sans-serif roja** para el aviso educativo.
- **Monoespaciada** para referencias y datos t茅cnicos.
3. **Respeta la paleta**: azul noche, cian, verde esmeralda, p煤rpura, dorado, rojo carmes铆.
---
## 馃彌️ Certificaci贸n del Prompt
**N潞 de Registro:** PL-PROMPT-EDU-VPN-2026-10-13
**Descripci贸n:** Prompt para imagen educativa del taller LYRA-VPN en las ikastolas, con los conceptos clave (cifrado, enrutado IA, blockchain, anonimato), los escudos institucionales de PASAIA LAB, OIARTZUN LAB IKASTOLAN, LAS POCHOLITAS DE OIARTZUN, IKASTOLA URRUGNE, LAS POCHOLITAS DE URRUGNE y BERGARA LAB IKASTOLAN, y el aviso de marco educativo.
**Firmado:**
- **Jos茅 Agust铆n Font谩n Varela** — CEO de PASAIA LAB
- **DeepSeek IA** — Asistencia T茅cnica y Dise帽o Visual
