CAWODOG – PoC di protezione dell'IP per AI industriale basata su Python

CAWODOG (Cat World Dominance Group) è una PoC giocosa ma realistica per proteggere i modelli di AI basati su Python distribuiti su macchine industriali offline.

L'idea centrale:
Prendi un piccolo classificatore di immagini che rileva cani (il “nemico” di CAWODOG), avvolgilo in una semplice app e poi indurisci progressivamente la distribuzione contro il furto dell'IP.

La PoC è progettata come complemento a un whitepaper interno su:

Indurimento dell'IP Python per distribuzioni di AI industriale offline

Obiettivi

Questo repository dimostra, passo dopo passo:

• Quanto è facile rubare un modello da una distribuzione Python ingenua
• Come strutturare un'applicazione Python in UI vs. motore
• Come impacchettare e indurire il motore usando:
  • Build onefile di Nuitka
  • Esportazione ONNX
  • Crittografia simmetrica dell'artefatto del modello
• Come appaiono i flussi di lavoro dell'attaccante in ogni fase

Struttura del repository

.
├── 0/                     # Step 0 – Unhardened baseline
│   ├── model/             # Training + inference code
│   ├── app/               # Gradio-based web UI
│   ├── requirements.txt
│   └── (optional) build / run helpers
│
├── 1/                     # Step 1 – Packaged with Nuitka (Level 1)
│   ├── app/               # Same UI, adapted entrypoint
│   ├── model/             # Same model logic as step 0
│   ├── build.sh           # Nuitka onefile build script
│   └── requirements.txt
│
├── 2/                     # Step 2 – Encrypted ONNX model (Level 2)
│   ├── model/             # Training + ONNX export + encryption
│   ├── engine/            # Engine module (decryption + ONNX runtime + scoring)
│   ├── app/               # UI calling the engine only
│   ├── hardening/         # Encryption key + utilities (dev only)
│   ├── build.sh           # Nuitka onefile build script
│   └── requirements.txt
│
└── attacker/              # Attacker tooling (optional, for demo)
    ├── run_and_extract.sh # Finds Nuitka temp dir and lists contents
    ├── steal_model.sh     # Copies model file out of extracted payload
    └── use_stolen_model.py# Uses stolen model in a separate script

Prerequisiti

• Python 3.13 (o 3.11+ se decidi di adattare la build Nuitka)
• Un ambiente virtuale funzionante (python -m venv .venv)
• Sistema operativo: testato su macOS; Linux dovrebbe funzionare con piccole modifiche
• Consigliati: git, pip e familiarità di base con la riga di comando

La maggior parte dei passaggi richiede:

pip install -r requirements.txt

Passo 0 – Baseline (non indurita)

Cartella: 0/ Obiettivo: Una semplice app Python con un modello addestrato e una web UI. Nessuna protezione.

Cosa contiene

• Un piccolo classificatore di immagini (PyTorch + torchvision) addestrato a distinguere:
  • dog vs not_dog
• Script di addestramento (model_training.py) che:
  • suddivide automaticamente data/dog e data/not_dog in training/validazione
  • salva un file di modello, es. model/models/dog_model.pt
• Script di inferenza (model_inference.py) che:
  • carica dog_model.pt
  • restituisce la probabilità di “dog”
  • calcola un semplice “punteggio nemico” come euristica giocattolo
• App Gradio (app/gradio_app.py) che:
  • consente il caricamento di immagini nel browser
  • chiama l'inferenza + punteggio nemico
  • mostra le probabilità e il risultato CAWODOG

Come eseguire il Passo 0

Dalla radice del repository:

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

1. Prepara i dati:

   root@kitploit:~

   0/data/
     dog/
       <dog images>.jpg
     not_dog/
       <non-dog images>.jpg
   

2. Addestra il modello:

   root@kitploit:~

   python -m model.model_training
   

   Questo creerà qualcosa come:

   root@kitploit:~

   model/models/dog_model.pt
   

3. Esegui l'app Gradio:

   root@kitploit:~

   python -m app.gradio_app
   

4. Apri l'URL stampato (default http://127.0.0.1:7860) e prova con le immagini.

Proprietà di sicurezza

• Il file del modello è salvato come pesi PyTorch in chiaro (file .pt).
• Tutta la logica del modello e del punteggio è in Python leggibile.
• Chiunque può copiare la directory del progetto e riutilizzare tutto.

Questa è l'immagine del “prima”.

Passo 1 – Indurimento di Livello 1 (Nuitka Onefile)

Cartella: 1/ Obiettivo: Impacchetta l'app in un singolo eseguibile usando Nuitka. Effetto sulla sicurezza: Lo fa sembrare un prodotto, ma non protegge l'IP.

Cosa cambia rispetto al Passo 0

• Un punto di ingresso dedicato per Nuitka (es. app/main.py o cawodog_app.py)
• Script di build (build.sh) che:
  • installa le dipendenze
  • esegue Nuitka con --standalone e --onefile
  • include il file del modello nel bundle (dog_model.pt)
• Il risultato è un binario onefile (es. cawodog_step1_nuitka).

Esempio di build (semplificato)

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

Dopo la build, ottieni qualcosa come:

./cawodog_step1_nuitka

Eseguendolo si avvierà la UI Gradio come prima, ma ora da un singolo eseguibile.

Simulazione dell'attaccante (opzionale, usando attacker/)

La cartella attacker mostra come un attaccante può:

1. Eseguire il binario onefile (che si espande in una cartella temporanea)
2. Individuare la directory di unpack di Nuitka onefile sotto $TMPDIR
3. Copiare dog_model.pt da quella directory
4. Usare use_stolen_model.py per eseguire previsioni al di fuori dell'app

Punto chiave: Il Livello 1 non è una protezione significativa. È impacchettamento, non sicurezza.

Passo 2 – Indurimento di Livello 2 (Motore ONNX crittografato)

Cartella: 2/ Obiettivo: Introdurre una vera protezione dell'IP a livello di modello. Effetto sulla sicurezza: I concorrenti non possono usare il modello semplicemente copiando un file.

Concetti principali

1. Conversione del formato del modello

   • Converti dog_model.pt → dog_model.onnx usando l'esportazione ONNX di PyTorch.

2. Crittografia del modello

   • Crittografa dog_model.onnx con AES-GCM in dog_model.enc
   • Salva una chiave simmetrica in hardening/dev_model.key (per scopi PoC)

3. Astrazione del motore

   • Introduci engine/core.py che:
     • decritta dog_model.enc a runtime
     • lo carica in ONNX Runtime
     • espone funzioni come predict_is_dog() e enemy_score()

4. UI come orchestratore

   • app/gradio_app.py non vede più i file del modello grezzi o gli internals.
   • Chiama solo le funzioni del motore.

Flusso di lavoro tipico per il Passo 2

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

1. Addestra (o riutilizza) il modello (come nel Passo 0, ma all'interno di 2/):

   root@kitploit:~

   python -m model.model_training
   

2. Esporta in ONNX:

   root@kitploit:~

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

3. Crittografa il modello ONNX:

   root@kitploit:~

   python -m hardening.encrypt_model
   # produces model/models/dog_model.enc and hardening/dev_model.key
   

4. Esegui la build con Nuitka (tramite build.sh):

   root@kitploit:~

   ./build.sh
   

   Una chiave verrà stampata al termine. Devi impostare la variabile d'ambiente CAWODOG_MODEL_KEY_HEX a quella chiave affinché il programma possa caricare il modello crittografato. Qualsiasi altra chiave causerà un errore.

5. Esegui il binario onefile risultante. La UI dovrebbe comportarsi come prima.

Proprietà di sicurezza

• Il file del modello su disco (dog_model.enc) è crittografato.
• Un attaccante occasionale non può:
  • caricare dog_model.enc direttamente in PyTorch
  • ispezionare o modificare banalmente il modello
• Un attaccante ora deve:
  • conoscere la chiave di crittografia
  • comprendere la logica di decrittazione AES-GCM
  • estrarre e ricostruire il file ONNX

Non è ancora legato a una radice di fiducia hardware e un reverse engineer esperto può eventualmente ricostruire il modello, ma l'asticella è significativamente più alta rispetto al Passo 1.

Modello di minaccia e limitazioni

Questa PoC si concentra su:

• Proteggere i modelli AI distribuiti presso siti di clienti offline
• Aumentare il costo dello spionaggio industriale
• Dimostrare livelli di indurimento progressivi piuttosto che una “sicurezza perfetta” istantanea

Non pretende di:

• Prevenire completamente il reverse engineering da parte di un attore statale
• Sostituire i moduli di sicurezza hardware (TPM, HSM, enclave)
• Risolvere la distribuzione di aggiornamenti/patch o il secure boot

Come usare questo repository per le demo

Flusso narrativo tipico:

1. Passo 0 – Baseline

   • Mostra come tutto sia banale da ispezionare e riutilizzare.

2. Passo 1 – Impacchettamento (Nuitka onefile)

   • Mostra il simpatico binario singolo.
   • Usa gli script in attacker/ per dimostrare quanto sia facile rubare ancora il modello.

3. Passo 2 – ONNX crittografato

   • Mostra che copiare dog_model.enc non è più sufficiente.
   • Discuti come questo si mappa a una distribuzione reale per un cliente industriale.

Potrai poi discutere ulteriori livelli futuri (non ancora implementati qui):

• Chiavi legate alla macchina (TPM, dongle)
• Motore nativo Rust/C++
• Controlli anti-debug e di integrità
• Enclave sicure / attestazione

Licenza

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.