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:

   root@kitploit:~

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

2. Modell trainieren:

   root@kitploit:~

   python -m model.model_training
   

   Dies erzeugt etwa Folgendes:

   root@kitploit:~

   model/models/dog_model.pt
   

3. Gradio-App ausführen:

   root@kitploit:~

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

   root@kitploit:~

   python -m model.model_training
   

2. Nach ONNX exportieren:

   root@kitploit:~

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

3. Das ONNX-Modell verschlüsseln:

   root@kitploit:~

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

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

   root@kitploit:~

   ./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.

Sicherheitseigenschaften

• Die Modelldatei auf der Festplatte (dog_model.enc) ist verschlüsselt.
• Ein Gelegenheitsangreifer kann nicht:
  • dog_model.enc direkt in PyTorch laden
  • das Modell trivial untersuchen oder verändern
• Ein Angreifer muss nun:
  • den Verschlüsselungsschlüssel kennen
  • die AES-GCM-Entschlüsselungslogik verstehen
  • die ONNX-Datei extrahieren und rekonstruieren

Es ist weiterhin nicht an eine Hardware-Vertrauenswurzel gebunden, und ein versierter Reverse Engineer kann das Modell letztlich rekonstruieren, aber die Hürde ist deutlich höher als in Schritt 1.

Bedrohungsmodell und Einschränkungen

Dieser PoC konzentriert sich auf:

• Den Schutz von KI-Modellen, die an offline betriebene Kundensysteme ausgeliefert werden
• Die Erhöhung der Kosten für Industriespionage
• Die Demonstration progressiver Härtungsstufen statt sofortiger „perfekter Sicherheit“

Es erhebt nicht den Anspruch:

• Reverse Engineering durch einen staatlichen Akteur vollständig zu verhindern
• Hardwaregestützte Sicherheitsmodule (TPM, HSM, Enclaves) zu ersetzen
• Update-/Patch-Verteilung oder Secure Boot zu lösen

So verwendest du dieses Repository für Demos

Typischer Ablauf:

1. Schritt 0 – Baseline

   • Zeigen, wie trivial alles zu untersuchen und wiederzuverwenden ist.

2. Schritt 1 – Paketierung (Nuitka Onefile)

   • Die schicke einzelne Binärdatei zeigen.
   • Die Skripte aus attacker/ verwenden, um zu demonstrieren, wie leicht das Modell immer noch gestohlen werden kann.

3. Schritt 2 – Verschlüsseltes ONNX

   • Zeigen, dass das Kopieren von dog_model.enc nicht mehr ausreicht.
   • Diskutieren, wie sich dies auf eine reale Bereitstellung für einen Industriekunden übertragen lässt.

Anschließend kannst du weitere zukünftige Stufen besprechen (hier noch nicht implementiert):

• Maschinengebundene Schlüssel (TPM, Dongle)
• Native Rust/C++-Engine
• Anti-Debug- und Integritätsprüfungen
• Sichere Enclaves / Attestierung

Lizenz

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.