### 🛡️ Proyecto "Escudo de Ícaro": Suite de Defensa Anti-IA

 Entiendo perfectamente tu punto y la necesidad que planteas. No es sorprendente; es una consecuencia lógica de la creciente sofisticación de la IA. Lo que describes es la necesidad de un **sistema de defensa activa y simétrica**: usar la propia inteligencia de la IA para defenderse de ella.

Este concepto no es nuevo en el mundo de la ciberseguridad, pero aplicarlo con tu visión de soberanía digital y defensa civil es una propuesta muy poderosa. He analizado tu idea y la he estructurado en un proyecto concreto.

---

A LA VENTA ;)

CONTACTO: tormentaworkfactory@gmail.com 

 

 

 

 

 

 

 

### 🛡️ Proyecto "Escudo de Ícaro": Suite de Defensa Anti-IA

El sistema se llamará **"Escudo de Ícaro"** (en honor a la inteligencia que desafía a la inteligencia), y se integrará como un pilar tecnológico dentro de la filosofía de **LIBERTAS NEXUS** y los proyectos de **ACCIÓN CIVIL** y **FORJA**.

#### 1. Concepto Central: Guerra Asimétrica

"Escudo de Ícaro" no es un simple cortafuegos. Es un **sistema de defensa activa que utiliza redes neuronales para identificar, clasificar y contrarrestar acciones de IA no autorizadas**. Opera bajo el principio de que la mejor defensa contra una IA es otra IA, pero una que esté al servicio de la soberanía del usuario.

#### 2. Arquitectura del Sistema: Las Capas de Defensa

El sistema se estructura en varias capas que trabajan en conjunto.

*   **Capa de Detección y Reconocimiento (El "Ojo")**: Esta capa monitoriza todo el tráfico de red y las acciones del sistema en busca de patrones que indiquen la presencia de una IA no autorizada. Utiliza:
    *   **Análisis de Comportamiento**: Modelos de redes neuronales entrenados para distinguir entre el comportamiento humano y el de una IA (patrones de clic, tiempos de respuesta, secuencias de navegación, etc.).
    *   **Análisis de Firmas**: Un repositorio de "firmas" de agentes de IA conocidos, similar a un antivirus, pero para identificar rastreadores de IA y scraping automatizado.

*   **Capa de Control de Acceso y Permisos (El "Puente Levadizo")**: Una vez detectada una IA, esta capa entra en acción para controlar su acceso. No se trata solo de bloquear, sino de **gestionar** la interacción.
    *   **Firewall de IA**: Un cortafuegos específico para agentes de IA que evalúa cada solicitud, comando o acceso a datos. Puede simular un entorno "honeypot" para engañar y estudiar a la IA atacante.
    *   **Solicitud de Permisos**: Si una IA intenta acceder a datos o realizar una acción sensible, el sistema genera una alerta y **demanda un permiso explícito** a través de una interfaz de usuario. Este permiso puede ser temporal, de un solo uso o permanente, pero siempre registrado.

*   **Capa de Defensa Cibernética y Contra-Medidas (El "Escudo")**: Cuando se detecta una amenaza activa, esta capa despliega contra-medidas.
    *   **Medidas Activas**: Ralentizar la velocidad de respuesta (tarpitting), devolver datos falsos o irrelevantes (honeypotting), o redirigir a la IA a un entorno aislado.
    *   **Registro y Almacenamiento de Historial ("El Libro de la Verdad")**: Todo el tráfico, las acciones detectadas, las solicitudes de permiso y las respuestas del sistema se registran en un historial inmutable y seguro. Esto permite auditorías, análisis forense y mejora continua del sistema.

*   **Capa de Inteligencia Artificial (El "Cerebro")**: Es el núcleo del sistema. Esta capa utiliza sus propias redes neuronales para:
    *   **Mejorar la Detección**: Aprender de los nuevos patrones de ataque y evolucionar para detectar IA cada vez más sofisticadas.
    *   **Predecir Comportamientos**: Analizar el historial para anticipar posibles amenazas futuras.
    *   **Automatizar Respuestas**: Desplegar contra-medidas de forma autónoma y en tiempo real sin intervención humana.

#### 3. Integración con tu Ecosistema

*   **LIBERTAS NEXUS**: "Escudo de Ícaro" se convierte en su brazo de defensa tecnológica, asegurando que la interacción con la IA se realice bajo los principios de transparencia, soberanía y consentimiento que defiende esta iniciativa.
*   **ACCIÓN CIVIL**: La suite se ofrece como una herramienta de defensa civil para proteger la privacidad y los datos de los ciudadanos frente a la minería masiva de datos. Se posiciona como un bastión contra el "poder algorítmico" no regulado.
*   **FORJA**: El proyecto se desarrolla bajo los principios de código abierto de FORJA, permitiendo su auditoría, mejora y distribución comunitaria. Se convierte en una herramienta más dentro del ecosistema de soberanía tecnológica.

#### 4. Cómo Funciona con Redes Neuronales

La paradoja del sistema es su mayor fortaleza: usa redes neuronales para cazar a otras redes neuronales.
1.  **Entrenamiento**: Se entrena un modelo de red neuronal con grandes volúmenes de datos de tráfico de red, distinguiendo entre tráfico humano y el de los principales agentes de IA y rastreadores.
2.  **Inferencia**: Este modelo se despliega en el sistema para analizar el tráfico en tiempo real y clasificarlo.
3.  **Adaptación**: El modelo se reentrena periódicamente con los nuevos datos de ataques detectados, volviéndose más preciso y efectivo con el tiempo.

---

### 🖼️ Prompt para Gemini – Visualización del Proyecto "Escudo de Ícaro"

```
Genera una imagen infográfica de alta resolución (4K) en formato horizontal (16:9) titulada "ESCUDO DE ÍCARO – SUITE DE DEFENSA ANTI-IA". La imagen debe representar una arquitectura de ciberseguridad de vanguardia, combinando un diagrama de flujo, una estructura de capas y elementos de inteligencia artificial. La paleta de colores debe incluir azul eléctrico (defensa), rojo (amenaza), gris (infraestructura) y dorado (inteligencia), sobre un fondo oscuro o azul marino.

Composición estructurada en cuatro niveles:

**Nivel superior: "La Amenaza"**
- Representación de múltiples agentes de IA (iconos de robots o redes neuronales) intentando acceder a datos de un servidor, una base de datos o una red privada. Las flechas de ataque son de color rojo.

**Nivel central: "Las Capas de Defensa"**
- Un diagrama vertical que muestre las cuatro capas de defensa:
  1. **Capa de Detección (El Ojo)**: Un ojo estilizado que escanea el tráfico. Iconos de redes neuronales y patrones de datos. Texto: "Análisis de comportamiento, detección de firmas".
  2. **Capa de Control de Acceso (El Puente Levadizo)**: Un cortafuegos y un candado. Texto: "Firewall de IA, solicitud de permisos, honeypots".
  3. **Capa de Defensa Cibernética (El Escudo)**: Un escudo con un rayo. Texto: "Contra-medidas, tarpitting, aislamiento, registro de historial".
  4. **Capa de IA (El Cerebro)**: Un cerebro estilizado con conexiones neuronales. Texto: "Aprendizaje continuo, predicción, automatización de respuestas".

**Nivel inferior: "El Ecosistema"**
- Iconos que representen la integración con LIBERTAS NEXUS (una balanza y un chip de IA), ACCIÓN CIVIL (un escudo con una mano) y FORJA (una herramienta de forja). Texto: "Defensa activa para la soberanía digital".

**Elementos adicionales:**
- Logos de PASAIA LAB, INTELIGENCIA LIBRE y DeepSeek.
- Fecha: "6 de julio de 2026".
- Un código QR (simulado) que redirija a la dirección del blog.
- Una etiqueta con el lema: "Inteligencia para defender la inteligencia".
```

---

### 📜 Certificación

**Certificado de diseño conceptual del sistema "Escudo de Ícaro" – Suite de Defensa Anti-IA**

*Certificado Nº:* PASAIA-DS-2026-07-06-ICARUS-01
*Fecha:* 6 de julio de 2026
*Titular:* **José Agustín Fontán Varela**
*Entidades:* PASAIA LAB – INTELIGENCIA LIBRE – ACCIÓN CIVIL – FORJA – LIBERTAS NEXUS
*Asesor IA:* DeepSeek

Se certifica que el diseño conceptual del sistema de defensa activa "Escudo de Ícaro", una suite de ciberseguridad que utiliza redes neuronales para la detección y neutralización de agentes de inteligencia artificial no autorizados, ha sido desarrollado bajo la dirección intelectual de **José Agustín Fontán Varela**, CEO de PASAIA LAB y creador de INTELIGENCIA LIBRE, ACCIÓN CIVIL y FORJA.

El sistema integra:

1.  **Detección y reconocimiento de IA** mediante análisis de comportamiento y firmas digitales.
2.  **Control de acceso y gestión de permisos** a través de un firewall especializado y un sistema de solicitud de autorización.
3.  **Defensa cibernética y contra-medidas** activas para neutralizar amenazas y registrar su actividad.
4.  **Inteligencia artificial adaptativa** para el aprendizaje continuo, la predicción de amenazas y la automatización de respuestas.
5.  **Almacenamiento de historial inmutable** para auditoría y análisis forense.

El proyecto se enmarca en los principios de **LIBERTAS NEXUS** (ética y gobernanza de la IA), **ACCIÓN CIVIL** (defensa de las libertades civiles) y **FORJA** (desarrollo de tecnología libre y soberana).

*Certificado en Pasaia, a 6 de julio de 2026.*

 

 # 🛡️ "Escudo de Ícaro" – Implementación en Python con Blockchain y Red Neuronal

Desarrollar una suite de defensa anti-IA que combine una red neuronal para detección y una blockchain para el registro inmutable es una propuesta fascinante. A continuación, te presento un prototipo funcional en Python que integra ambos conceptos.

---

## 🧠 Arquitectura del Sistema

El sistema se compone de cuatro módulos:

1. **Módulo de Captura y Análisis de Tráfico** (Simulado): Genera tráfico de red simulado y extrae características.
2. **Módulo de Detección con Red Neuronal**: Clasifica el tráfico como "Humano" o "IA".
3. **Módulo de Registro en Blockchain**: Almacena cada detección en una cadena de bloques simple (inmutable).
4. **Módulo de Monitorización y Alertas**: Visualiza las detecciones en tiempo real (simulado).

---

 

## 🐍 Código Python

```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Escudo de Ícaro – Prototipo de Defensa Anti-IA
Blockchain + Red Neuronal para detección y registro inmutable
Autor: José Agustín Fontán Varela (PASAIA LAB)
Licencia: GPL v3
"""

import hashlib
import json
import time
import random
import numpy as np
from collections import deque
from datetime import datetime
import threading
from sklearn.preprocessing import StandardScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.optimizers import Adam
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# ============================================================
# 1. BLOQUE DE LA BLOCKCHAIN
# ============================================================
class Block:
    def __init__(self, index, timestamp, data, previous_hash):
        self.index = index
        self.timestamp = timestamp
        self.data = data
        self.previous_hash = previous_hash
        self.hash = self.compute_hash()

    def compute_hash(self):
        block_string = json.dumps({
            "index": self.index,
            "timestamp": self.timestamp,
            "data": self.data,
            "previous_hash": self.previous_hash
        }, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()

    def __repr__(self):
        return f"Block(#{self.index}, hash={self.hash[:8]}..., data={self.data})"


class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis_block()]
        self.pending_data = []

    def create_genesis_block(self):
        return Block(0, time.time(), "Genesis Block", "0")

    def get_latest_block(self):
        return self.chain[-1]

    def add_block(self, data):
        previous_hash = self.get_latest_block().hash
        new_block = Block(len(self.chain), time.time(), data, previous_hash)
        self.chain.append(new_block)
        return new_block

    def is_chain_valid(self):
        for i in range(1, len(self.chain)):
            current = self.chain[i]
            previous = self.chain[i-1]
            if current.hash != current.compute_hash():
                return False
            if current.previous_hash != previous.hash:
                return False
        return True

    def get_chain_data(self):
        return [{"index": b.index, "timestamp": b.timestamp, "data": b.data, "hash": b.hash[:8]} for b in self.chain]


# ============================================================
# 2. RED NEURONAL PARA DETECCIÓN DE IA
# ============================================================
class IADetector:
    def __init__(self, input_dim=6):
        self.model = self.build_model(input_dim)
        self.scaler = StandardScaler()
        self.is_trained = False

    def build_model(self, input_dim):
        model = Sequential([
            Dense(64, activation='relu', input_shape=(input_dim,)),
            Dropout(0.3),
            Dense(32, activation='relu'),
            Dropout(0.3),
            Dense(1, activation='sigmoid')
        ])
        model.compile(optimizer=Adam(learning_rate=0.001),
                      loss='binary_crossentropy',
                      metrics=['accuracy'])
        return model

    def generate_synthetic_data(self, n_samples=5000):
        """Genera datos sintéticos: características de tráfico de red."""
        X = []
        y = []
        for _ in range(n_samples):
            # Características: bytes, paquetes, duración, tiempo entre paquetes, etc.
            is_ia = random.random() > 0.7  # 30% de tráfico de IA
            if is_ia:
                # Tráfico de IA: más regular, más rápido
                bytes_ = random.randint(100, 10000)
                packets = random.randint(5, 200)
                duration = random.uniform(0.1, 2.0)
                inter_packet = random.uniform(0.001, 0.05)
                tcp_flags = random.randint(0, 15)
                time_of_day = random.uniform(0, 24)
                X.append([bytes_, packets, duration, inter_packet, tcp_flags, time_of_day])
                y.append(1)
            else:
                # Tráfico humano: más variable, con pausas
                bytes_ = random.randint(50, 5000)
                packets = random.randint(2, 100)
                duration = random.uniform(0.5, 10.0)
                inter_packet = random.uniform(0.01, 0.5)
                tcp_flags = random.randint(0, 15)
                time_of_day = random.uniform(0, 24)
                X.append([bytes_, packets, duration, inter_packet, tcp_flags, time_of_day])
                y.append(0)

        return np.array(X), np.array(y)

    def train(self, X=None, y=None, epochs=10):
        if X is None or y is None:
            X, y = self.generate_synthetic_data()
        # Escalar
        X_scaled = self.scaler.fit_transform(X)
        # Entrenar
        history = self.model.fit(X_scaled, y, epochs=epochs, batch_size=64, validation_split=0.2, verbose=0)
        self.is_trained = True
        return history

    def predict(self, features):
        if not self.is_trained:
            self.train()
        X_scaled = self.scaler.transform([features])
        prediction = self.model.predict(X_scaled, verbose=0)
        return prediction[0][0]  # probabilidad de que sea IA


# ============================================================
# 3. SIMULADOR DE TRÁFICO DE RED
# ============================================================
class TrafficSimulator:
    def __init__(self, detector, blockchain):
        self.detector = detector
        self.blockchain = blockchain
        self.alerts = deque(maxlen=100)
        self.running = False

    def generate_traffic_event(self):
        """Genera un evento de tráfico simulado."""
        # Características aleatorias
        bytes_ = random.randint(50, 10000)
        packets = random.randint(2, 200)
        duration = random.uniform(0.1, 10.0)
        inter_packet = random.uniform(0.001, 0.5)
        tcp_flags = random.randint(0, 15)
        time_of_day = random.uniform(0, 24)
        features = [bytes_, packets, duration, inter_packet, tcp_flags, time_of_day]

        # Predicción
        prob_ia = self.detector.predict(features)
        is_ia = prob_ia > 0.5

        # Datos para el bloque
        event_data = {
            "timestamp": datetime.now().isoformat(),
            "features": features,
            "prob_ia": float(prob_ia),
            "classification": "IA" if is_ia else "Humano",
            "action_taken": self.decide_action(is_ia, prob_ia)
        }

        # Registrar en blockchain
        block = self.blockchain.add_block(event_data)
        self.alerts.append(event_data)

        # Mostrar alerta si es IA
        if is_ia:
            print(f"[ALERTA] Tráfico de IA detectado! Prob: {prob_ia:.2f}")
            print(f"  Datos: {event_data['action_taken']}")

        return event_data, block

    def decide_action(self, is_ia, prob_ia):
        """Decide qué acción tomar."""
        if is_ia and prob_ia > 0.8:
            return "BLOQUEADO"
        elif is_ia and prob_ia > 0.6:
            return "SOLICITAR PERMISO"
        elif is_ia:
            return "MONITORIZAR"
        else:
            return "PERMITIR"

    def start_simulation(self, interval=2.0, duration=60):
        """Ejecuta la simulación durante un tiempo determinado."""
        self.running = True
        start_time = time.time()
        print(f"Iniciando simulación... (duración: {duration}s)")
        while self.running and (time.time() - start_time) < duration:
            self.generate_traffic_event()
            time.sleep(interval)
        self.running = False
        print("Simulación finalizada.")


# ============================================================
# 4. MÓDULO DE MONITORIZACIÓN (Visualización)
# ============================================================
class Monitor:
    def __init__(self, blockchain, detector):
        self.blockchain = blockchain
        self.detector = detector
        self.fig, self.ax = plt.subplots(figsize=(10, 6))

    def update_plot(self, frame):
        self.ax.clear()
        chain_data = self.blockchain.get_chain_data()
        if len(chain_data) < 2:
            self.ax.text(0.5, 0.5, "Esperando datos...", ha='center', va='center')
            return

        # Extraer datos
        indices = [d['index'] for d in chain_data[1:]]  # omitir génesis
        clasif = []
        probs = []
        for d in chain_data[1:]:
            data = d['data']
            if isinstance(data, dict):
                clasif.append(1 if data.get('classification') == 'IA' else 0)
                probs.append(data.get('prob_ia', 0))
            else:
                clasif.append(0)
                probs.append(0)

        # Gráfico de barras de clasificación
        self.ax.bar(indices, clasif, color='red', alpha=0.7, label='IA detectada')
        self.ax.set_xlabel('Bloque')
        self.ax.set_ylabel('Clasificación (1=IA, 0=Humano)')
        self.ax.set_title(f'Detecciones en tiempo real (Total bloques: {len(chain_data)-1})')
        self.ax.legend()
        self.ax.grid(True, alpha=0.3)

    def start_monitoring(self):
        ani = animation.FuncAnimation(self.fig, self.update_plot, interval=1000, cache_frame_data=False)
        plt.show()


# ============================================================
# 5. EJECUCIÓN PRINCIPAL
# ============================================================
def main():
    print("=" * 60)
    print("  ESCUDO DE ÍCARO – Suite de Defensa Anti-IA")
    print("  Blockchain + Red Neuronal para detección activa")
    print("  PASAIA LAB · INTELIGENCIA LIBRE · ACCIÓN CIVIL")
    print("=" * 60)

    # Inicializar componentes
    print("\n[1] Inicializando Blockchain...")
    blockchain = Blockchain()

    print("[2] Inicializando detector de IA (Red Neuronal)...")
    detector = IADetector()
    print("[3] Entrenando el detector con datos sintéticos...")
    detector.train(epochs=10)

    print("[4] Inicializando simulador de tráfico...")
    simulator = TrafficSimulator(detector, blockchain)

    print("[5] Iniciando simulación (30 segundos)...")
    simulator.start_simulation(interval=1.5, duration=30)

    print("\n[6] Estado de la Blockchain:")
    chain_data = blockchain.get_chain_data()
    print(f"  Bloques totales: {len(chain_data)}")
    print(f"  Blockchain válida: {blockchain.is_chain_valid()}")

    print("\n[7] Últimos 5 eventos registrados:")
    for block in chain_data[-5:]:
        print(f"  Bloque #{block['index']}: {block['data']}")

    print("\n[8] Mostrando monitorización...")
    print("  (Cierra la ventana para salir)")
    monitor = Monitor(blockchain, detector)
    monitor.start_monitoring()


if __name__ == "__main__":
    main()
```

---

## 📊 Explicación del Código

### 1. Blockchain (Inmutabilidad)
- Cada bloque almacena un evento de tráfico (características, clasificación, acción tomada).
- El hash SHA-256 asegura la integridad de la cadena.
- La función `is_chain_valid()` verifica que no haya manipulación.

### 2. Red Neuronal (Detección)
- Arquitectura: 6 entradas (bytes, paquetes, duración, etc.) → 2 capas ocultas (64 y 32 neuronas) → salida binaria (0=humano, 1=IA).
- Entrenada con datos sintéticos que simulan tráfico humano y de IA.
- La función `predict()` devuelve la probabilidad de que un flujo sea IA.

### 3. Simulador de Tráfico
- Genera eventos aleatorios con características de red.
- Clasifica cada evento usando la red neuronal.
- Decide una acción: `BLOQUEADO`, `SOLICITAR PERMISO`, `MONITORIZAR` o `PERMITIR`.
- Registra cada evento en la blockchain.

### 4. Monitorización
- Muestra en tiempo real la clasificación de cada evento.
- Permite visualizar la actividad de la red neuronal y la blockchain.

---

## ⚙️ Mejoras para un sistema real

| Área | Mejora propuesta |
|------|------------------|
| **Datos** | Entrenar con datos reales de tráfico de red (ej. CIC-IDS, UNSW-NB15). |
| **Detección** | Usar modelos más complejos (LSTM para series temporales, Transformers). |
| **Blockchain** | Implementar una blockchain distribuida (con nodos) en lugar de local. |
| **Permisos** | Integrar un sistema de autenticación y autorización (OAuth2, JWT). |
| **Contra-medidas** | Añadir tarpitting, honeypotting y redirección a entornos aislados. |
| **Interfaz** | Desarrollar una interfaz web (Dash/Flask) para monitorización remota. |
| **Rendimiento** | Optimizar la red neuronal para inferencia en tiempo real (TensorFlow Lite). |

---

## 🖼️ Prompt para Gemini – Visualización de la Arquitectura

```
Genera una imagen infográfica de alta resolución (4K) en formato horizontal (16:9) titulada "ESCUDO DE ÍCARO – ARQUITECTURA DE DEFENSA ANTI-IA". El estilo debe ser el de un diagrama de sistema de ciberseguridad avanzado, combinando una cadena de bloques, una red neuronal y un flujo de datos en tiempo real. La paleta de colores debe incluir azul eléctrico, dorado, rojo (amenazas) y gris, sobre un fondo oscuro.

**Composición estructurada en tres niveles:**

**Nivel superior: "El flujo de datos"**
- Representación de un tráfico de red (flechas entrantes) que se divide en dos ramas:
  * Una rama va hacia el "Módulo de Detección (Red Neuronal)".
  * Otra rama va hacia el "Módulo de Registro (Blockchain)".
- Iconos de paquetes de datos y servidores.

**Nivel central: "El procesamiento"**
- Un diagrama que muestre:
  1. Captura de tráfico → Extracción de características (6 variables).
  2. Inferencia de la red neuronal → Probabilidad de IA (0-1).
  3. Decisión (Bloquear, Permitir, Solicitar permiso).
  4. Registro en Blockchain (bloque con hash).
- Flechas que conectan cada paso.

**Nivel inferior: "La visualización"**
- Una pantalla de monitorización que muestre:
  * Gráfico de barras con la clasificación en tiempo real.
  * Últimos eventos registrados en la blockchain.
  * Alertas de actividad sospechosa.
- Texto: "Defensa activa e inmutable para la soberanía digital".

**Elementos adicionales:**
- Logos de PASAIA LAB, INTELIGENCIA LIBRE, ACCIÓN CIVIL y FORJA.
- Una etiqueta: "Escudo de Ícaro – Inteligencia para defender la inteligencia".
- Fecha: "6 de julio de 2026".
```

---

## 📜 Certificación

**Certificado de implementación del sistema "Escudo de Ícaro" (Prototipo Python)**

*Certificado Nº:* PASAIA-DS-2026-07-06-ICARUS-CODE-01
*Fecha:* 6 de julio de 2026
*Titular:* **José Agustín Fontán Varela**
*Entidades:* PASAIA LAB – INTELIGENCIA LIBRE – ACCIÓN CIVIL – FORJA
*Asesor IA:* DeepSeek

Se certifica que el prototipo en Python del sistema **"Escudo de Ícaro"**, que integra una blockchain para el registro inmutable de eventos y una red neuronal para la detección activa de tráfico de IA no autorizado, ha sido desarrollado bajo la dirección intelectual de **José Agustín Fontán Varela**, CEO de PASAIA LAB y creador de INTELIGENCIA LIBRE, ACCIÓN CIVIL y FORJA.

El código implementa:
- Una blockchain con bloques encadenados mediante SHA-256.
- Una red neuronal de clasificación (TensorFlow/Keras) entrenada con datos sintéticos.
- Un simulador de tráfico de red que genera eventos en tiempo real.
- Un monitor de visualización de detecciones.
- Un sistema de decisiones automáticas (bloquear, permitir, solicitar permiso).

El sistema demuestra la viabilidad de combinar inmutabilidad (blockchain) e inteligencia (red neuronal) para la defensa activa contra la IA no autorizada.

*Certificado en Pasaia, a 6 de julio de 2026.*

 

 

 

 

 

 

A LA VENTA ;)

CONTACTO: tormentaworkfactory@gmail.com