CAWODOG – IP-Schutz-PoC für Python-basierte industrielle KI

CAWODOG (Cat World Dominance Group) ist ein spielerischer, aber realistischer Proof-of-Concept zum Schutz Python-basierter KI-Modelle, die auf offline betriebenen Industriemaschinen eingesetzt werden.

Die Kernidee:
Nimm einen kleinen Bildklassifikator, der Hunde erkennt (die „Feinde“ von CAWODOG), verpacke ihn in eine einfache App und härte die Bereitstellung dann schrittweise gegen IP-Diebstahl.

Der PoC ist als Begleitmaterial zu einem internen Whitepaper zu folgendem Thema konzipiert:

Härtung von Python-IP für Offline-Bereitstellungen industrieller KI

---

Ziele

Dieses Repository demonstriert Schritt für Schritt:

• Wie einfach es ist, ein Modell aus einer naiven Python-Bereitstellung zu stehlen
• Wie man eine Python-Anwendung in UI vs. Engine strukturiert
• Wie man die Engine mit folgenden Mitteln paketiert und härtet:
  • Nuitka-Onefile-Builds
  • ONNX-Export
  • Symmetrische Verschlüsselung des Modell-Artefakts
• Wie Angreifer-Workflows in jeder Phase aussehen

---

Repository-Struktur

.
├── 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

Voraussetzungen

• Python 3.13 (oder 3.11+, falls du den Nuitka-Build anpassen möchtest)
• Eine funktionierende virtuelle Umgebung (python -m venv .venv)
• Betriebssystem: unter macOS getestet; Linux sollte mit kleineren Anpassungen funktionieren
• Empfohlen: git, pip und grundlegende Kenntnisse der Kommandozeile

Die meisten Schritte erfordern:

pip install -r requirements.txt

Schritt 0 – Baseline (ungehärtet)

Ordner: 0/
Ziel: Eine einfache Python-App mit einem trainierten Modell und einer simplen Weboberfläche. Kein Schutz.

Was enthalten ist

• Ein kleiner Bildklassifikator (PyTorch + torchvision), der darauf trainiert ist, Folgendes zu unterscheiden:
  • dog vs. not_dog
• Trainingsskript (model_training.py), das:
  • data/dog und data/not_dog automatisch in Trainings-/Validierungsdaten aufteilt
  • eine Modelldatei speichert, z. B. model/models/dog_model.pt
• Inferenzskript (model_inference.py), das:
  • dog_model.pt lädt
  • die Wahrscheinlichkeit für „dog“ zurückgibt
  • einen einfachen „Enemy Score“ als Spielzeug-Heuristik berechnet
• Gradio-App (app/gradio_app.py), die:
  • das Hochladen von Bildern im Browser ermöglicht
  • Inferenz + Enemy Score aufruft
  • Wahrscheinlichkeiten und das CAWODOG-Ergebnis anzeigt

So führst du Schritt 0 aus

Vom Repository-Stammverzeichnis aus:

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

1. Daten vorbereiten:

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

2. Modell trainieren:

   python -m model.model_training
   

   Dies erzeugt etwa Folgendes:

   model/models/dog_model.pt
   

3. Gradio-App ausführen:

   python -m app.gradio_app
   

4. Die ausgegebene URL öffnen (standardmäßig http://127.0.0.1:7860) und mit Bildern testen.

Sicherheitseigenschaften

• Die Modelldatei wird als unverschlüsselte PyTorch-Gewichte (.pt-Datei) gespeichert.
• Die gesamte Modell- und Scoring-Logik liegt in lesbarem Python vor.
• Jeder kann das Projektverzeichnis kopieren und alles wiederverwenden.

Dies ist das „Vorher“-Bild.

Schritt 1 – Härtungsstufe 1 (Nuitka Onefile)

Ordner: 1/
Ziel: Die App mit Nuitka in eine einzelne ausführbare Datei paketieren.
Sicherheitseffekt: Lässt es wie ein Produkt aussehen, schützt das geistige Eigentum jedoch nicht.

Was sich gegenüber Schritt 0 ändert

• Ein dedizierter Einstiegspunkt für Nuitka (z. B. app/main.py oder cawodog_app.py)
• Build-Skript (build.sh), das:
  • Abhängigkeiten installiert
  • Nuitka mit --standalone und --onefile ausführt
  • die Modelldatei in das Bundle aufnimmt (dog_model.pt)
• Das Ergebnis ist eine Onefile-Binärdatei (z. B. cawodog_step1_nuitka).

Beispiel-Build (vereinfacht)

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

Nach dem Build erhältst du etwa Folgendes:

./cawodog_step1_nuitka

Beim Ausführen wird die Gradio-Oberfläche wie zuvor gestartet, nun jedoch aus einer einzigen ausführbaren Datei.

Angreifer-Simulation (optional, mit attacker/)

Der Ordner attacker zeigt, wie ein Angreifer Folgendes tun kann:

1. Die Onefile-Binärdatei ausführen (die sich in einen temporären Ordner entpackt)
2. Das Nuitka-Onefile-Entpackverzeichnis unter $TMPDIR finden
3. dog_model.pt aus diesem Verzeichnis kopieren
4. use_stolen_model.py verwenden, um Vorhersagen außerhalb der App auszuführen

Wichtigste Erkenntnis: Härtungsstufe 1 ist kein echter Schutz. Es ist Paketierung, keine Sicherheit.

Schritt 2 – Härtungsstufe 2 (Verschlüsselte ONNX-Engine)

Ordner: 2/
Ziel: Echten IP-Schutz auf Modellebene einführen.
Sicherheitseffekt: Wettbewerber können das Modell nicht einfach durch Kopieren einer Datei nutzen.

Hauptkonzepte

1. Konvertierung des Modellformats

   • dog_model.pt mithilfe des ONNX-Exports von PyTorch in dog_model.onnx konvertieren.

2. Modellverschlüsselung

   • dog_model.onnx mit AES-GCM zu dog_model.enc verschlüsseln
   • Einen symmetrischen Schlüssel in hardening/dev_model.key speichern (für PoC-Zwecke)

3. Engine-Abstraktion

   • engine/core.py einführen, das:

     • dog_model.enc zur Laufzeit entschlüsselt
     • es in ONNX Runtime lädt
     • Funktionen wie predict_is_dog() und enemy_score() bereitstellt

4. UI als Orchestrator

   • app/gradio_app.py sieht keine rohen Modelldateien oder Interna mehr.
   • Es ruft nur noch Engine-Funktionen auf.

Typischer Workflow für Schritt 2

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

1. Das Modell trainieren (oder wiederverwenden) (wie in Schritt 0, aber innerhalb von 2/):

   python -m model.model_training
   

2. Nach ONNX exportieren:

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

3. Das ONNX-Modell verschlüsseln:

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

4. Mit Nuitka bauen (über build.sh):

   ./build.sh
   

   Nach Abschluss wird ein Schlüssel ausgegeben. Du musst die Umgebungsvariable CAWODOG_MODEL_KEY_HEX auf diesen Schlüssel setzen, damit das Programm das verschlüsselte Modell laden kann. Jeder andere Schlüssel führt zu einem Fehler.

5. Die resultierende Onefile-Binärdatei ausführen.
   Die Benutzeroberfläche sollte sich wie zuvor verhalten.