CAWODOG – PoC de Proteção de IP para IA Industrial Baseada em Python

CAWODOG (Cat World Dominance Group) é uma prova de conceito lúdica, porém realista, para proteger modelos de IA baseados em Python implantados em máquinas industriais offline.

A ideia central:
Pegue um pequeno classificador de imagens que detecta cães (o “inimigo” da CAWODOG), envolva-o em um aplicativo simples e, em seguida, endureça progressivamente a implantação contra roubo de IP.

O PoC foi projetado como complemento a um whitepaper interno sobre:

Endurecimento de IP em Python para Implantações de IA Industrial Offline

---

Objetivos

Este repositório demonstra, passo a passo:

• Como é fácil roubar um modelo de uma implantação Python ingênua
• Como estruturar um aplicativo Python em UI vs. mecanismo (engine)
• Como empacotar e endurecer o mecanismo usando:
  • Builds onefile com Nuitka
  • Exportação ONNX
  • Criptografia simétrica do artefato do modelo
• Como são os fluxos de trabalho de atacantes em cada estágio

---

Estrutura do Repositório

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

Pré-requisitos

• Python 3.13 (ou 3.11+ se você decidir ajustar o build do Nuitka)
• Um ambiente virtual funcional (python -m venv .venv)
• SO: testado no macOS; Linux deve funcionar com pequenas alterações
• Recomendado: git, pip e familiaridade básica com a linha de comando

A maioria das etapas exige:

pip install -r requirements.txt

Etapa 0 – Linha de Base (Sem Endurecimento)

Pasta: 0/ Objetivo: Um aplicativo Python simples com um modelo treinado e uma IU web simples. Sem proteção.

O que contém

• Um pequeno classificador de imagens (PyTorch + torchvision) treinado para distinguir:
  • dog vs not_dog
• Script de treinamento (model_training.py) que:
  • divide automaticamente data/dog e data/not_dog em treino/validação
  • salva um arquivo de modelo, ex.: model/models/dog_model.pt
• Script de inferência (model_inference.py) que:
  • carrega dog_model.pt
  • retorna a probabilidade de “cachorro”
  • calcula um simples “escore do inimigo” como uma heurística de exemplo
• Aplicativo Gradio (app/gradio_app.py) que:
  • permite o envio de imagens no navegador
  • chama a inferência + escore do inimigo
  • mostra as probabilidades e o resultado CAWODOG

Como executar a Etapa 0

A partir da raiz do repositório:

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

1. Prepare os dados:

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

2. Treine o modelo:

   python -m model.model_training
   

   Isso criará algo como:

   model/models/dog_model.pt
   

3. Execute o aplicativo Gradio:

   python -m app.gradio_app
   

4. Abra a URL exibida (padrão http://127.0.0.1:7860) e teste com imagens.

Propriedades de segurança

• O arquivo do modelo é armazenado como pesos PyTorch puros (arquivo .pt).
• Toda a lógica do modelo e a lógica de pontuação estão em Python legível.
• Qualquer pessoa pode copiar o diretório do projeto e reutilizar tudo.

Este é o cenário “antes”.

Etapa 1 – Endurecimento de Nível 1 (Nuitka Onefile)

Pasta: 1/ Objetivo: Empacotar o aplicativo em um executável único usando Nuitka. Efeito de segurança: Faz com que pareça um produto, mas não protege o IP.

O que muda em relação à Etapa 0

• Um ponto de entrada dedicado para Nuitka (ex.: app/main.py ou cawodog_app.py)
• Script de build (build.sh) que:
  • instala dependências
  • executa o Nuitka com --standalone e --onefile
  • inclui o arquivo do modelo no pacote (dog_model.pt)
• O resultado é um binário onefile (ex.: cawodog_step1_nuitka).

Exemplo de build (simplificado)

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

Após o build, você obtém algo como:

./cawodog_step1_nuitka

Executá-lo iniciará a IU Gradio como antes, mas agora a partir de um único executável.

Simulação de atacante (opcional, usando attacker/)

A pasta attacker mostra como um atacante pode:

1. Executar o binário onefile (que descompacta em uma pasta temporária)
2. Localizar o diretório de descompactação onefile do Nuitka em $TMPDIR
3. Copiar dog_model.pt para fora desse diretório
4. Usar use_stolen_model.py para executar previsões fora do aplicativo

Conclusão principal: O Nível 1 não é uma proteção significativa. É empacotamento, não segurança.

Etapa 2 – Endurecimento de Nível 2 (Mecanismo ONNX Criptografado)

Pasta: 2/ Objetivo: Introduzir proteção real de IP no nível do modelo. Efeito de segurança: Concorrentes não podem usar o modelo simplesmente copiando um arquivo.

Conceitos principais

1. Conversão de formato do modelo

   • Converter dog_model.pt → dog_model.onnx usando a exportação ONNX do PyTorch.

2. Criptografia do modelo

   • Criptografar dog_model.onnx com AES-GCM para dog_model.enc
   • Armazenar uma chave simétrica em hardening/dev_model.key (para fins de PoC)

3. Abstração do mecanismo (engine)

   • Introduzir engine/core.py que:
     • descriptografa dog_model.enc em tempo de execução
     • carrega no ONNX Runtime
     • expõe funções como predict_is_dog() e enemy_score()

4. IU como orquestradora

   • app/gradio_app.py não vê mais arquivos brutos do modelo ou detalhes internos.
   • Ele apenas chama funções do mecanismo.

Fluxo de trabalho típico para a Etapa 2

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

1. Treine (ou reutilize) o modelo (igual à Etapa 0, mas dentro de 2/):

   python -m model.model_training
   

2. Exporte para ONNX:

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

3. Criptografe o modelo ONNX:

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

4. Faça o build com Nuitka (via build.sh):

   ./build.sh
   

   Uma chave será exibida ao final. Você precisa definir a variável de ambiente CAWODOG_MODEL_KEY_HEX com essa chave para que o programa carregue o modelo criptografado. Qualquer chave diferente resultará em erro.

5. Execute o binário onefile resultante. A IU deve se comportar da mesma forma que antes.

Propriedades de segurança