CAWODOG – PoC de Protección de IP para IA Industrial Basada en Python

CAWODOG (Cat World Dominance Group) es una prueba de concepto lúdica pero realista para proteger modelos de IA basados en Python desplegados en máquinas industriales sin conexión.

La idea central:
Tomar un pequeño clasificador de imágenes que detecta perros (el "enemigo" de CAWODOG), envolverlo en una aplicación simple y luego endurecer progresivamente la implementación contra el robo de propiedad intelectual.

El PoC está diseñado como acompañante de un documento técnico interno sobre:

Endurecimiento de IP en Python para Implementaciones de IA Industrial Sin Conexión

---

Objetivos

Este repositorio demuestra, paso a paso:

• Lo fácil que es robar un modelo de una implementación ingenua en Python
• Cómo estructurar una aplicación Python en UI vs. motor
• Cómo empaquetar y endurecer el motor usando:
  • Compilaciones onefile de Nuitka
  • Exportación a ONNX
  • Cifrado simétrico del artefacto del modelo
• Cómo se ven los flujos de trabajo de un atacante en cada etapa

---

Estructura del Repositorio

.
├── 0/                     # Paso 0 – Línea base sin endurecer
│   ├── model/             # Código de entrenamiento + inferencia
│   ├── app/               # Interfaz web basada en Gradio
│   ├── requirements.txt
│   └── (opcional) helpers de compilación / ejecución
│
├── 1/                     # Paso 1 – Empaquetado con Nuitka (Nivel 1)
│   ├── app/               # Misma UI, punto de entrada adaptado
│   ├── model/             # Misma lógica de modelo que el paso 0
│   ├── build.sh           # Script de compilación onefile de Nuitka
│   └── requirements.txt
│
├── 2/                     # Paso 2 – Modelo ONNX cifrado (Nivel 2)
│   ├── model/             # Entrenamiento + exportación ONNX + cifrado
│   ├── engine/            # Módulo motor (descifrado + runtime ONNX + puntuación)
│   ├── app/               # UI que solo llama al motor
│   ├── hardening/         # Clave de cifrado + utilidades (solo desarrollo)
│   ├── build.sh           # Script de compilación onefile de Nuitka
│   └── requirements.txt
│
└── attacker/              # Herramientas del atacante (opcional, para demo)
    ├── run_and_extract.sh # Encuentra el directorio temporal de Nuitka y lista contenidos
    ├── steal_model.sh     # Copia el archivo del modelo del payload extraído
    └── use_stolen_model.py# Usa el modelo robado en un script separado

Requisitos Previos

• Python 3.13 (o 3.11+ si decides ajustar la compilación de Nuitka)
• Un entorno virtual funcional (python -m venv .venv)
• SO: probado en macOS; Linux debería funcionar con cambios menores
• Recomendado: git, pip y familiaridad básica con la línea de comandos

La mayoría de los pasos requieren:

pip install -r requirements.txt

Paso 0 – Línea Base (Sin Endurecer)

Carpeta: 0/ Objetivo: Una aplicación Python simple con un modelo entrenado y una interfaz web sencilla. Sin protección.

Qué contiene

• Un pequeño clasificador de imágenes (PyTorch + torchvision) entrenado para distinguir:
  • dog vs not_dog
• Script de entrenamiento (model_training.py) que:
  • divide automáticamente data/dog y data/not_dog en entrenamiento/validación
  • guarda un archivo de modelo, ej. model/models/dog_model.pt
• Script de inferencia (model_inference.py) que:
  • carga dog_model.pt
  • devuelve la probabilidad de "perro"
  • calcula una simple "puntuación de enemigo" como heurística de juguete
• Aplicación Gradio (app/gradio_app.py) que:
  • permite subir imágenes en el navegador
  • llama a la inferencia + puntuación de enemigo
  • muestra las probabilidades y el resultado de CAWODOG

Cómo ejecutar el Paso 0

Desde la raíz del repositorio:

cd 0
python -m venv .venv
source .venv/bin/activate          # en Windows: .venv\Scripts\activate
pip install -r requirements.txt

1. Preparar datos:

   0/data/
     dog/
       <imágenes de perros>.jpg
     not_dog/
       <imágenes que no son perros>.jpg
   

2. Entrenar el modelo:

   python -m model.model_training
   

   Esto creará algo como:

   model/models/dog_model.pt
   

3. Ejecutar la aplicación Gradio:

   python -m app.gradio_app
   

4. Abrir la URL impresa (por defecto http://127.0.0.1:7860) y probar con imágenes.

Propiedades de seguridad

• El archivo del modelo se almacena como pesos de PyTorch en texto plano (archivo .pt).
• Toda la lógica del modelo y de puntuación está en Python legible.
• Cualquiera puede copiar el directorio del proyecto y reutilizarlo todo.

Esta es la imagen del "antes".

Paso 1 – Endurecimiento Nivel 1 (Nuitka Onefile)

Carpeta: 1/ Objetivo: Empaquetar la aplicación en un ejecutable único usando Nuitka. Efecto de seguridad: Hace que parezca un producto, pero no protege la IP.

Qué cambia respecto al Paso 0

• Un punto de entrada dedicado para Nuitka (ej. app/main.py o cawodog_app.py)
• Script de compilación (build.sh) que:
  • instala dependencias
  • ejecuta Nuitka con --standalone y --onefile
  • incluye el archivo del modelo en el paquete (dog_model.pt)
• El resultado es un binario onefile (ej. cawodog_step1_nuitka).

Ejemplo de compilación (simplificado)

cd 1
source .venv/bin/activate
./build.sh

Después de compilar, obtienes algo como:

./cawodog_step1_nuitka

Ejecutarlo iniciará la interfaz Gradio como antes, pero ahora desde un único ejecutable.

Simulación de atacante (opcional, usando attacker/)

La carpeta attacker muestra cómo un atacante puede:

1. Ejecutar el binario onefile (que se descomprime en una carpeta temporal)
2. Localizar el directorio de descompresión de Nuitka onefile en $TMPDIR
3. Copiar dog_model.pt de ese directorio
4. Usar use_stolen_model.py para ejecutar predicciones fuera de la aplicación

Conclusión clave: El Nivel 1 no es una protección significativa. Es empaquetado, no seguridad.

Paso 2 – Endurecimiento Nivel 2 (Motor ONNX Cifrado)

Carpeta: 2/ Objetivo: Introducir protección real de IP a nivel del modelo. Efecto de seguridad: Los competidores no pueden usar el modelo simplemente copiando un archivo.

Conceptos principales

1. Conversión de formato del modelo

   • Convertir dog_model.pt → dog_model.onnx usando la exportación ONNX de PyTorch.

2. Cifrado del modelo

   • Cifrar dog_model.onnx con AES-GCM a dog_model.enc
   • Almacenar una clave simétrica en hardening/dev_model.key (para fines del PoC)

3. Abstracción del motor

   • Introducir engine/core.py que:

     • descifra dog_model.enc en tiempo de ejecución
     • lo carga en ONNX Runtime
     • expone funciones como predict_is_dog() y enemy_score()

4. UI como orquestador

   • app/gradio_app.py ya no ve archivos de modelo sin procesar ni detalles internos.
   • Solo llama a funciones del motor.

Flujo de trabajo típico para el Paso 2

cd 2
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

1. Entrenar (o reutilizar) el modelo (igual que en el Paso 0, pero dentro de 2/):

   python -m model.model_training
   

2. Exportar a ONNX:

   python -m model.export_to_onnx
   # produce model/models/dog_model.onnx
   

3. Cifrar el modelo ONNX:

   python -m hardening.encrypt_model
   # produce model/models/dog_model.enc y hardening/dev_model.key
   

4. Compilar con Nuitka (mediante build.sh):

   ./build.sh
   

   Al finalizar se imprimirá una clave. Debes establecer la variable de entorno CAWODOG_MODEL_KEY_HEX con esa clave para que el programa pueda cargar el modelo cifrado. Cualquier clave diferente resultará en un error.

5. Ejecutar el binario onefile resultante. La interfaz debería comportarse igual que antes.