CAWODOG – Preuve de concept de protection de la propriété intellectuelle pour l'IA industrielle basée sur Python

CAWODOG (Cat World Dominance Group) est une preuve de concept ludique mais réaliste pour protéger les modèles d'IA basés sur Python déployés sur des machines industrielles hors ligne.

L'idée principale :
Prendre un petit classifieur d'images qui détecte les chiens (l'« ennemi » de CAWODOG), l'envelopper dans une application simple, puis durcir progressivement le déploiement contre le vol de propriété intellectuelle.

La POC est conçue comme un compagnon d'un livre blanc interne sur :

Durcissement de la propriété intellectuelle Python pour les déploiements d'IA industriels hors ligne

---

Objectifs

Ce dépôt démontre, étape par étape :

• À quel point il est facile de voler un modèle à partir d'un déploiement Python naïf
• Comment structurer une application Python en interface utilisateur vs. moteur
• Comment empaqueter et durcir le moteur en utilisant :
  • Les constructions onefile de Nuitka
  • L'exportation ONNX
  • Le chiffrement symétrique de l'artefact du modèle
• À quoi ressemblent les flux de travail des attaquants à chaque étape

---

Structure du dépôt

.
├── 0/                     # Étape 0 – Référence non durcie
│   ├── model/             # Code d'entraînement + inférence
│   ├── app/               # Interface utilisateur web basée sur Gradio
│   ├── requirements.txt
│   └── (optionnel) aides à la construction / exécution
│
├── 1/                     # Étape 1 – Empaqueté avec Nuitka (Niveau 1)
│   ├── app/               # Même interface utilisateur, point d'entrée adapté
│   ├── model/             # Même logique de modèle qu'à l'étape 0
│   ├── build.sh           # Script de construction onefile Nuitka
│   └── requirements.txt
│
├── 2/                     # Étape 2 – Modèle ONNX chiffré (Niveau 2)
│   ├── model/             # Entraînement + export ONNX + chiffrement
│   ├── engine/            # Module moteur (déchiffrement + runtime ONNX + scoring)
│   ├── app/               # Interface utilisateur appelant uniquement le moteur
│   ├── hardening/         # Clé de chiffrement + utilitaires (développement uniquement)
│   ├── build.sh           # Script de construction onefile Nuitka
│   └── requirements.txt
│
└── attacker/              # Outillage attaquant (optionnel, pour démonstration)
    ├── run_and_extract.sh # Trouve le répertoire temporaire de Nuitka et liste le contenu
    ├── steal_model.sh     # Copie le fichier modèle à partir de la charge utile extraite
    └── use_stolen_model.py# Utilise le modèle volé dans un script séparé

Prérequis

• Python 3.13 (ou 3.11+ si vous décidez d'ajuster la construction Nuitka)
• Un environnement virtuel fonctionnel (python -m venv .venv)
• Système d'exploitation : testé sur macOS ; Linux devrait fonctionner avec des modifications mineures
• Recommandé : git, pip, et une familiarité de base avec la ligne de commande

La plupart des étapes nécessitent :

pip install -r requirements.txt

Étape 0 – Référence (Non durci)

Dossier : 0/ Objectif : Une application Python simple avec un modèle entraîné et une interface utilisateur web basique. Aucune protection.

Ce qu'il contient

• Un petit classifieur d'images (PyTorch + torchvision) entraîné pour distinguer :
  • dog vs not_dog
• Script d'entraînement (model_training.py) qui :
  • divise automatiquement data/dog et data/not_dog en ensembles d'entraînement/validation
  • enregistre un fichier modèle, par exemple model/models/dog_model.pt
• Script d'inférence (model_inference.py) qui :
  • charge dog_model.pt
  • retourne la probabilité d'être un « chien »
  • calcule un simple « score ennemi » comme heuristique de jouet
• Application Gradio (app/gradio_app.py) qui :
  • permet le téléchargement d'images dans le navigateur
  • appelle l'inférence + le score ennemi
  • affiche les probabilités et le résultat CAWODOG

Comment exécuter l'étape 0

Depuis la racine du dépôt :

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

1. Préparer les données :

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

2. Entraîner le modèle :

   python -m model.model_training
   

   Cela créera quelque chose comme :

   model/models/dog_model.pt
   

3. Exécuter l'application Gradio :

   python -m app.gradio_app
   

4. Ouvrir l'URL affichée (par défaut http://127.0.0.1:7860) et tester avec des images.

Propriétés de sécurité

• Le fichier modèle est stocké sous forme de poids PyTorch en clair (fichier .pt).
• Toute la logique du modèle et du scoring est en Python lisible.
• N'importe qui peut copier le répertoire du projet et tout réutiliser.

C'est l'image « avant ».

Étape 1 – Durcissement niveau 1 (Onefile Nuitka)

Dossier : 1/ Objectif : Empaqueter l'application en un seul exécutable en utilisant Nuitka. Effet de sécurité : Le fait de ressembler à un produit, mais ne protège pas la propriété intellectuelle.

Qu'est-ce qui change par rapport à l'étape 0

• Un point d'entrée dédié pour Nuitka (par exemple app/main.py ou cawodog_app.py)
• Script de construction (build.sh) qui :
  • installe les dépendances
  • exécute Nuitka avec --standalone et --onefile
  • inclut le fichier modèle dans le bundle (dog_model.pt)
• Le résultat est un binaire onefile (par exemple cawodog_step1_nuitka).

Exemple de construction (simplifié)

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

Après la construction, vous obtenez quelque chose comme :

./cawodog_step1_nuitka

L'exécution démarrera l'interface utilisateur Gradio comme auparavant, mais maintenant à partir d'un seul exécutable.

Simulation d'attaque (optionnelle, à l'aide de attacker/)

Le dossier attacker montre comment un attaquant peut :

1. Exécuter le binaire onefile (qui se décompresse dans un dossier temporaire)
2. Localiser le répertoire de décompression onefile de Nuitka sous $TMPDIR
3. Copier dog_model.pt à partir de ce répertoire
4. Utiliser use_stolen_model.py pour exécuter des prédictions en dehors de l'application

Point clé : Le niveau 1 n'est pas une protection significative. C'est de l'empaquetage, pas de la sécurité.

Étape 2 – Durcissement niveau 2 (Moteur ONNX chiffré)

Dossier : 2/ Objectif : Introduire une véritable protection de la propriété intellectuelle au niveau du modèle. Effet de sécurité : Les concurrents ne peuvent pas utiliser le modèle en copiant simplement un fichier.

Concepts principaux

1. Conversion de format du modèle

   • Convertir dog_model.pt → dog_model.onnx en utilisant l'export ONNX de PyTorch.

2. Chiffrement du modèle

   • Chiffrer dog_model.onnx avec AES-GCM vers dog_model.enc
   • Stocker une clé symétrique dans hardening/dev_model.key (à des fins de POC)

3. Abstraction du moteur

   • Introduire engine/core.py qui :

     • déchiffre dog_model.enc à l'exécution
     • le charge dans ONNX Runtime
     • expose des fonctions comme predict_is_dog() et enemy_score()

4. Interface utilisateur comme orchestrateur

   • app/gradio_app.py ne voit plus les fichiers modèles bruts ni les détails internes.
   • Il appelle uniquement les fonctions du moteur.

Flux de travail typique pour l'étape 2

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

1. Entraîner (ou réutiliser) le modèle (identique à l'étape 0, mais dans 2/):

   python -m model.model_training
   

2. Exporter vers ONNX :

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

3. Chiffrer le modèle ONNX :