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:

   root@kitploit:~

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

2. Entrenar el modelo:

   root@kitploit:~

   python -m model.model_training
   

   Esto creará algo como:

   root@kitploit:~

   model/models/dog_model.pt
   

3. Ejecutar la aplicación Gradio:

   root@kitploit:~

   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/):

   root@kitploit:~

   python -m model.model_training
   

2. Exportar a ONNX:

   root@kitploit:~

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

3. Cifrar el modelo ONNX:

   root@kitploit:~

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

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

   root@kitploit:~

   ./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.

Propiedades de seguridad

• El archivo del modelo en disco (dog_model.enc) está cifrado.
• Un atacante casual no puede:
  • cargar dog_model.enc directamente en PyTorch
  • inspeccionar o modificar trivialmente el modelo
• Un atacante ahora necesita:
  • conocer la clave de cifrado
  • entender la lógica de descifrado AES-GCM
  • extraer y reconstruir el archivo ONNX

Todavía no está vinculado a una raíz de confianza de hardware, y un ingeniero inverso experto puede eventualmente reconstruir el modelo, pero la barrera es significativamente mayor que en el Paso 1.

Modelo de Amenazas y Limitaciones

Este PoC se centra en:

• Proteger modelos de IA enviados a sitios de clientes sin conexión
• Aumentar el costo del espionaje industrial
• Demostrar niveles progresivos de endurecimiento en lugar de una "seguridad perfecta" instantánea

No pretende:

• Prevenir completamente la ingeniería inversa por parte de un actor estatal
• Reemplazar módulos de seguridad basados en hardware (TPM, HSM, enclaves)
• Resolver la distribución de actualizaciones/parches o el arranque seguro

Cómo Usar Este Repositorio para Demos

Flujo narrativo típico:

1. Paso 0 – Línea Base

   • Mostrar cómo todo es trivial de inspeccionar y reutilizar.

2. Paso 1 – Empaquetado (Nuitka onefile)

   • Mostrar el bonito binario único.
   • Usar scripts de attacker/ para demostrar con qué facilidad se sigue robando el modelo.

3. Paso 2 – ONNX Cifrado

   • Mostrar que copiar dog_model.enc ya no es suficiente.
   • Discutir cómo esto se traduce en una implementación real para un cliente industrial.

Luego se pueden discutir futuros niveles adicionales (aún no implementados aquí):

• Claves vinculadas a la máquina (TPM, dongle)
• Motor nativo en Rust/C++
• Comprobaciones anti-depuración e integridad
• Enclaves seguros / atestación

Licencia

MIT License

Copyright (c) 2025 Daniel Eder

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.