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 :

   root@kitploit:~

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

2. Entraîner le modèle :

   root@kitploit:~

   python -m model.model_training
   

   Cela créera quelque chose comme :

   root@kitploit:~

   model/models/dog_model.pt
   

3. Exécuter l'application Gradio :

   root@kitploit:~

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

   root@kitploit:~

   python -m model.model_training
   

2. Exporter vers ONNX :

   root@kitploit:~

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

3. Chiffrer le modèle ONNX :

   root@kitploit:~

   python -m hardening.encrypt_model
   # produit model/models/dog_model.enc et hardening/dev_model.key
   

4. Construire avec Nuitka (via build.sh) :

   root@kitploit:~

   ./build.sh
   

   Une clé sera affichée à la fin. Vous devez définir la variable d'environnement CAWODOG_MODEL_KEY_HEX avec cette clé pour que le programme charge le modèle chiffré. Toute autre clé entraînera une erreur.

5. Exécuter le binaire onefile résultant. L'interface utilisateur doit se comporter comme avant.

Propriétés de sécurité

• Le fichier modèle sur le disque (dog_model.enc) est chiffré.
• Un attaquant occasionnel ne peut pas :
  • charger dog_model.enc directement dans PyTorch
  • inspecter ou modifier trivialement le modèle
• Un attaquant doit maintenant :
  • connaître la clé de chiffrement
  • comprendre la logique de déchiffrement AES-GCM
  • extraire et reconstruire le fichier ONNX

Ce n'est toujours pas lié à une racine de confiance matérielle, et un ingénieur inverse expérimenté peut éventuellement reconstruire le modèle, mais la barre est nettement plus haute qu'à l'étape 1.

Modèle de menace et limites

Cette POC se concentre sur :

• La protection des modèles d'IA livrés sur des sites clients hors ligne
• L'augmentation du coût de l'espionnage industriel
• La démonstration de niveaux de durcissement progressifs plutôt qu'une « sécurité parfaite » instantanée

Elle ne prétend pas :

• Empêcher complètement la rétro-ingénierie par un acteur étatique
• Remplacer les modules de sécurité matérielle (TPM, HSM, enclaves)
• Résoudre la distribution des mises à jour/correctifs ou le démarrage sécurisé

Comment utiliser ce dépôt pour des démonstrations

Flux narratif typique :

1. Étape 0 – Référence

   • Montrer à quel point tout est trivial à inspecter et réutiliser.

2. Étape 1 – Empaquetage (onefile Nuitka)

   • Montrer le joli binaire unique.
   • Utiliser les scripts attacker/ pour démontrer à quel point le modèle est encore facilement volé.

3. Étape 2 – ONNX chiffré

   • Montrer que copier dog_model.enc n'est plus suffisant.
   • Discuter de la façon dont cela correspond à un déploiement réel pour un client industriel.

Vous pouvez ensuite discuter des futurs niveaux possibles (non implémentés ici) :

• Clés liées à la machine (TPM, dongle)
• Moteur natif Rust/C++
• Contrôles anti-débogage et d'intégrité
• Enclaves sécurisées / attestation

Licence

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.