CAWODOG è un progetto proof-of-concept che dimostra come proteggere modelli AI basati su Python distribuiti su macchine industriali offline. Attraverso tre fasi progressive (0 → 2), il progetto mostra: * come un'applicazione AI Python ingenua possa essere banalmente sottoposta a reverse engineering, * come gli attaccanti possano estrarre modelli da binari impacchettati, e * come rafforzare una distribuzione AI utilizzando la conversione ONNX, la crittografia dei modelli e un motore di runtime separato. Il PoC utilizza un modello giocoso di rilevamento cani (il “Cat World Dominance Group”) per illustrare concetti reali di protezione della proprietà intellettuale industriale applicabili a sistemi di controllo basati su AI, come la piattaforma StarX di Starlinger. Funge da implementazione di riferimento per il whitepaper allegato “Hardening Python IP for Offline Industrial AI Deployments”.
lycis/cawdog
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
Questo repository dimostra, passo dopo passo:
.
├── 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
python -m venv .venv)git, pip e familiarità di base con la riga di comandoLa maggior parte dei passaggi richiede:
pip install -r requirements.txt
Cartella: 0/
Obiettivo: Una semplice app Python con un modello addestrato e una web UI. Nessuna protezione.
dog vs not_dogmodel_training.py) che:
data/dog e data/not_dog in training/validazionemodel/models/dog_model.ptmodel_inference.py) che:
dog_model.ptapp/gradio_app.py) che:
Dalla radice del repository:
cd 0
python -m venv .venv
source .venv/bin/activate # on Windows: .venv\Scripts\activate
pip install -r requirements.txt
Prepara i dati:
0/data/
dog/
<dog images>.jpg
not_dog/
<non-dog images>.jpg
Addestra il modello:
python -m model.model_training
Questo creerà qualcosa come:
model/models/dog_model.pt
Esegui l'app Gradio:
python -m app.gradio_app
Apri l'URL stampato (default http://127.0.0.1:7860) e prova con le immagini.
.pt).Questa è l'immagine del “prima”.
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.
app/main.py o cawodog_app.py)build.sh) che:
--standalone e --onefiledog_model.pt)cawodog_step1_nuitka).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.
attacker/)La cartella attacker mostra come un attaccante può:
$TMPDIRdog_model.pt da quella directoryuse_stolen_model.py per eseguire previsioni al di fuori dell'appPunto chiave: Il Livello 1 non è una protezione significativa. È impacchettamento, non sicurezza.
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.
Conversione del formato del modello
dog_model.pt → dog_model.onnx usando l'esportazione ONNX di PyTorch.Crittografia del modello
dog_model.onnx con AES-GCM in dog_model.enchardening/dev_model.key (per scopi PoC)Astrazione del motore
engine/core.py che:
dog_model.enc a runtimepredict_is_dog() e enemy_score()UI come orchestratore
app/gradio_app.py non vede più i file del modello grezzi o gli internals.cd 2
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
Addestra (o riutilizza) il modello (come nel Passo 0, ma all'interno di 2/):
python -m model.model_training
Esporta in ONNX:
python -m model.export_to_onnx
# produces model/models/dog_model.onnx
Crittografa il modello ONNX:
python -m hardening.encrypt_model
# produces model/models/dog_model.enc and hardening/dev_model.key
Esegui la build con Nuitka (tramite build.sh):
./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.
Esegui il binario onefile risultante. La UI dovrebbe comportarsi come prima.