CAWODOG – Python-आधारित औद्योगिक AI के लिए IP संरक्षण PoC

CAWODOG (Cat World Dominance Group) ऑफ़लाइन औद्योगिक मशीनों पर तैनात Python-आधारित AI मॉडलों की सुरक्षा के लिए एक मनोरंजक लेकिन यथार्थवादी proof-of-concept है।

मुख्य विचार:
कुत्तों (CAWODOG का "दुश्मन") का पता लगाने वाला एक छोटा इमेज क्लासिफायर लें, उसे एक सरल ऐप में लपेटें, और फिर तैनाती को IP चोरी के विरुद्ध उत्तरोत्तर हार्डन करें।

यह PoC एक आंतरिक श्वेतपत्र के साथी के रूप में डिज़ाइन किया गया है:

ऑफ़लाइन औद्योगिक AI तैनातियों के लिए Python IP को हार्डन करना

लक्ष्य

यह रिपॉजिटरी चरण-दर-चरण प्रदर्शित करती है:

• एक सरल Python तैनाती से मॉडल चुराना कितना आसान है
• Python एप्लिकेशन को UI बनाम इंजन में संरचित कैसे करें
• निम्न का उपयोग करके इंजन को पैकेज और हार्डन कैसे करें:
  • Nuitka onefile बिल्ड
  • ONNX एक्सपोर्ट
  • मॉडल आर्टिफैक्ट की सममित एन्क्रिप्शन
• प्रत्येक चरण में हमलावर के वर्कफ़्लो कैसे दिखते हैं

रिपॉजिटरी संरचना

.
├── 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 3.13 (या 3.11+, यदि आप Nuitka बिल्ड को समायोजित करने का निर्णय लेते हैं)
• एक कार्यशील वर्चुअल वातावरण (python -m venv .venv)
• OS: macOS पर परीक्षण किया गया; Linux को मामूली बदलावों के साथ काम करना चाहिए
• अनुशंसित: git, pip, और बुनियादी कमांड-लाइन परिचितता

अधिकांश चरणों के लिए आवश्यकता है:

pip install -r requirements.txt

चरण 0 – आधार रेखा (बिना हार्डनिंग)

फ़ोल्डर: 0/ लक्ष्य: एक प्रशिक्षित मॉडल और एक सरल वेब UI के साथ एक सादा Python ऐप। कोई सुरक्षा नहीं।

इसमें क्या शामिल है

• एक छोटा इमेज क्लासिफायर (PyTorch + torchvision) जो इन्हें अलग करने के लिए प्रशिक्षित है:
  • dog बनाम not_dog
• प्रशिक्षण स्क्रिप्ट (model_training.py) जो:
  • data/dog और data/not_dog को स्वतः train/validation में विभाजित करती है
  • एक मॉडल फ़ाइल सहेजती है, जैसे model/models/dog_model.pt
• इन्फ़रेंस स्क्रिप्ट (model_inference.py) जो:
  • dog_model.pt लोड करती है
  • "dog" होने की प्रायिकता लौटाती है
  • एक साधारण "शत्रु स्कोर" की गणना एक खिलौना ह्यूरिस्टिक के रूप में करती है
• Gradio ऐप (app/gradio_app.py) जो:
  • ब्राउज़र में इमेज अपलोड की अनुमति देता है
  • इन्फ़रेंस + शत्रु स्कोर को कॉल करता है
  • प्रायिकताएँ और CAWODOG परिणाम दिखाता है

चरण 0 को कैसे चलाएँ

रिपॉजिटरी रूट से:

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

1. डेटा तैयार करें:

   root@kitploit:~

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

2. मॉडल प्रशिक्षित करें:

   root@kitploit:~

   python -m model.model_training
   

   यह कुछ इस प्रकार बनाएगा:

   root@kitploit:~

   model/models/dog_model.pt
   

3. Gradio ऐप चलाएँ:

   root@kitploit:~

   python -m app.gradio_app
   

4. मुद्रित URL खोलें (डिफ़ॉल्ट http://127.0.0.1:7860) और इमेज के साथ परीक्षण करें।

सुरक्षा गुण

• मॉडल फ़ाइल सादे PyTorch वेट्स (.pt फ़ाइल) के रूप में संग्रहीत है।
• सभी मॉडल लॉजिक और स्कोरिंग लॉजिक पठनीय Python में हैं।
• कोई भी प्रोजेक्ट निर्देशिका को कॉपी करके सब कुछ पुनः उपयोग कर सकता है।

यह "पहले" वाली तस्वीर है।

चरण 1 – स्तर 1 हार्डनिंग (Nuitka Onefile)

फ़ोल्डर: 1/ लक्ष्य: Nuitka का उपयोग करके ऐप को एक एकल निष्पादन योग्य में पैकेज करें। सुरक्षा प्रभाव: यह इसे एक उत्पाद जैसा दिखाता है, लेकिन IP की सुरक्षा नहीं करता।

चरण 0 की तुलना में क्या बदलता है

• Nuitka के लिए एक समर्पित प्रवेश बिंदु (जैसे app/main.py या cawodog_app.py)
• बिल्ड स्क्रिप्ट (build.sh) जो:
  • निर्भरताएँ स्थापित करती है
  • Nuitka को --standalone और --onefile के साथ चलाती है
  • मॉडल फ़ाइल (dog_model.pt) को बंडल में शामिल करती है
• परिणाम एक onefile बाइनरी है (जैसे cawodog_step1_nuitka)।

उदाहरण बिल्ड (सरलीकृत)

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

बिल्डिंग के बाद, आपको कुछ इस प्रकार मिलता है:

./cawodog_step1_nuitka

इसे चलाने से पहले की तरह Gradio UI शुरू होगा, लेकिन अब एक एकल निष्पादन योग्य से।

हमलावर सिमुलेशन (वैकल्पिक, attacker/ का उपयोग करके)

attacker फ़ोल्डर दिखाता है कि एक हमलावर कैसे:

1. onefile बाइनरी चला सकता है (जो एक अस्थायी फ़ोल्डर में अनपैक होती है)
2. $TMPDIR के अंतर्गत Nuitka onefile अनपैक निर्देशिका का पता लगा सकता है
3. उस निर्देशिका से dog_model.pt कॉपी कर सकता है
4. ऐप के बाहर भविष्यवाणियाँ चलाने के लिए use_stolen_model.py का उपयोग कर सकता है

मुख्य निष्कर्ष: स्तर 1 सार्थक सुरक्षा नहीं है। यह पैकेजिंग है, सुरक्षा नहीं।

चरण 2 – स्तर 2 हार्डनिंग (एन्क्रिप्टेड ONNX इंजन)

फ़ोल्डर: 2/ लक्ष्य: मॉडल स्तर पर वास्तविक IP सुरक्षा प्रस्तुत करें। सुरक्षा प्रभाव: प्रतिस्पर्धी केवल एक फ़ाइल कॉपी करके मॉडल का उपयोग नहीं कर सकते।

मुख्य अवधारणाएँ

1. मॉडल प्रारूप रूपांतरण

   • PyTorch के ONNX एक्सपोर्ट का उपयोग करके dog_model.pt को dog_model.onnx में बदलें।

2. मॉडल एन्क्रिप्शन

   • dog_model.onnx को AES-GCM के साथ एन्क्रिप्ट करके dog_model.enc बनाएँ
   • एक सममित कुंजी hardening/dev_model.key में संग्रहीत करें (PoC उद्देश्यों के लिए)

3. इंजन एब्स्ट्रैक्शन

   • engine/core.py प्रस्तुत करें जो:

     • रनटाइम पर dog_model.enc को डिक्रिप्ट करता है
     • इसे ONNX Runtime में लोड करता है
     • predict_is_dog() और enemy_score() जैसे फ़ंक्शन उजागर करता है

4. UI ऑर्केस्ट्रेटर के रूप में

   • app/gradio_app.py अब कच्ची मॉडल फ़ाइलें या आंतरिक विवरण नहीं देखता।
   • यह केवल इंजन फ़ंक्शन को कॉल करता है।

चरण 2 के लिए विशिष्ट वर्कफ़्लो

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

1. मॉडल को प्रशिक्षित करें (या पुनः उपयोग करें) (चरण 0 के समान, लेकिन 2/ के अंदर):

   root@kitploit:~

   python -m model.model_training
   

2. ONNX में एक्सपोर्ट करें:

   root@kitploit:~

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

3. ONNX मॉडल को एन्क्रिप्ट करें:

   root@kitploit:~

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

4. Nuitka के साथ बिल्ड करें (build.sh के माध्यम से):

   root@kitploit:~

   ./build.sh
   

   पूरा होने पर एक कुंजी मुद्रित होगी। प्रोग्राम को एन्क्रिप्टेड मॉडल लोड करने के लिए आपको पर्यावरण चर CAWODOG_MODEL_KEY_HEX को उस कुंजी पर सेट करना होगा। कोई भी भिन्न कुंजी त्रुटि का परिणाम देगी।

5. परिणामी onefile बाइनरी चलाएँ। UI को पहले जैसा ही व्यवहार करना चाहिए।

सुरक्षा गुण

• डिस्क पर मॉडल फ़ाइल (dog_model.enc) एन्क्रिप्टेड है।
• एक सामान्य हमलावर निम्न नहीं कर सकता:
  • dog_model.enc को सीधे PyTorch में लोड करना
  • मॉडल का सरलता से निरीक्षण या संशोधन करना
• एक हमलावर को अब आवश्यकता होगी:
  • एन्क्रिप्शन कुंजी जानने की
  • AES-GCM डिक्रिप्शन लॉजिक को समझने की
  • ONNX फ़ाइल को निकालने और पुनर्निर्माण करने की

यह अभी भी हार्डवेयर रूट ऑफ़ ट्रस्ट से बंधा नहीं है, और एक कुशल रिवर्स-इंजीनियर अंततः मॉडल का पुनर्निर्माण कर सकता है, लेकिन स्तर 1 की तुलना में बाधा काफी अधिक है।

खतरा मॉडल और सीमाएँ

यह PoC निम्न पर केंद्रित है:

• ऑफ़लाइन ग्राहक साइटों पर भेजे गए AI मॉडलों की सुरक्षा
• औद्योगिक जासूसी की लागत बढ़ाना
• तात्कालिक "पूर्ण सुरक्षा" के बजाय प्रगतिशील हार्डनिंग स्तरों का प्रदर्शन

यह निम्न का दावा नहीं करता:

• किसी राष्ट्र-राज्य अभिनेता द्वारा रिवर्स इंजीनियरिंग को पूरी तरह से रोकना
• हार्डवेयर-समर्थित सुरक्षा मॉड्यूल (TPM, HSM, enclaves) को प्रतिस्थापित करना
• अपडेट/पैच वितरण या सिक्योर बूट को हल करना

डेमो के लिए इस रिपॉजिटरी का उपयोग कैसे करें

विशिष्ट कथात्मक प्रवाह:

1. चरण 0 – आधार रेखा

   • दिखाएँ कि हर चीज़ का निरीक्षण और पुनः उपयोग करना कितना आसान है।

2. चरण 1 – पैकेजिंग (Nuitka onefile)

   • सुंदर एकल बाइनरी दिखाएँ।
   • यह प्रदर्शित करने के लिए attacker/ स्क्रिप्ट का उपयोग करें कि मॉडल अभी भी कितनी आसानी से चोरी हो जाता है।

3. चरण 2 – एन्क्रिप्टेड ONNX

   • दिखाएँ कि dog_model.enc की प्रतिलिपि बनाना अब पर्याप्त नहीं है।
   • चर्चा करें कि यह एक औद्योगिक ग्राहक के लिए वास्तविक-विश्व तैनाती से कैसे मेल खाता है।

आप आगे के भविष्य के स्तरों पर भी चर्चा कर सकते हैं (अभी यहाँ लागू नहीं किए गए हैं):

• मशीन-बद्ध कुंजियाँ (TPM, डोंगल)
• देशी Rust/C++ इंजन
• एंटी-डीबग और अखंडता जाँच
• सिक्योर enclaves / अटेस्टेशन

लाइसेंस

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.