Extração / Roubo de Modelo

Visão geral

Extração de modelo (model extraction) (também chamada de roubo de modelo (model stealing) ou clonagem de modelo (model cloning)) é uma classe de ataques em que um adversário tenta replicar o comportamento de um modelo em produção — e, às vezes, até recuperar parâmetros (parameters)/pesos (weights) do modelo — interagindo com o modelo via uma API ou explorando canais laterais (side channels) (por exemplo, temporização, padrões de acesso à memória). No cenário mais comum, o atacante só tem acesso de consulta em caixa-preta (black-box query access): ele pode enviar entradas e observar saídas, mas não consegue ver os pesos internos.

A extração de modelo importa porque modelos modernos são ativos valiosos: eles incorporam computação de treinamento cara, conjuntos de dados proprietários e engenharia conquistada com muito esforço. Uma extração bem-sucedida pode permitir:

• Roubo de propriedade intelectual (IP theft) (implantar um modelo substituto sem pagar pelo uso da API)
• Burlar salvaguardas (clonar um modelo “seguro” e remover checagens de política)
• Habilitar ataques subsequentes (um substituto de alta fidelidade pode facilitar Exemplos Adversariais (Adversarial Examples) ou ataques de privacidade)
• Inteligência competitiva (inferir escolhas de arquitetura, procedimentos de treinamento ou características do conjunto de dados)

Este artigo foca em roubar comportamento ou pesos do modelo via consultas e canais laterais, e em como mitigar esses riscos em sistemas reais — especialmente em ML como serviço (ML-as-a-service) e aplicações de modelos de linguagem grandes (large language models, LLMs).

Modelos de ameaça e objetivos do atacante

Capacidades comuns do atacante

1. Acesso a API em caixa-preta

   • O atacante pode submeter entradas (x) e observar saídas (f(x)).
   • As saídas podem ser:
     • Rótulos duros (hard labels) (classe top-1)
     • Pontuações/probabilidades (vetor softmax (softmax) completo ou top-k (top-k))
     • Logprobabilidades (log probabilities) (comum em APIs de modelos de linguagem grandes)
     • Continuações de texto (text completions) (para modelos generativos)

2. Vazamento limitado de informação

   • Mensagens de erro, metadados de resposta, uso de tokens (token usage) ou latência
   • Identificadores de versão do modelo ou campos de “debug”

3. Acesso a canal lateral (capacidade mais forte)

   • Atacante co-localizado (co-located) no mesmo host/VM/GPU
   • Capacidade de medir tempo de execução (runtime), comportamento de cache (cache behavior), largura de banda de memória (memory bandwidth), consumo de energia (power) ou contenção (contention)

Objetivos do atacante

• Clonagem comportamental (behavioral cloning): treinar um modelo “cópia” (g) tal que (g(x) \approx f(x)) para entradas relevantes.
• Extração de parâmetros (parameter extraction): recuperar pesos exatamente ou aproximadamente (mais viável para classes de modelos mais simples ou com canais laterais fortes).
• Reconstrução da fronteira de decisão (decision boundary reconstruction): aproximar a fronteira entre classes para evasão ou engenharia reversa.
• Equivalência funcional sob uma distribuição de tarefas (functional equivalence under a task distribution): igualar saídas em entradas “naturais” que importam comercialmente, mesmo que o modelo difira em outras regiões.

Como é o “sucesso”

O sucesso da extração geralmente é medido por:

• Concordância / fidelidade (agreement / fidelity): ( \Pr[g(x) = f(x)] ) (classificação) ou métricas de similaridade (regressão/geração).
• Acurácia na tarefa: desempenho de (g) em um conjunto de teste rotulado (frequentemente próximo ao desempenho de (f)).
• Eficiência de consultas (query efficiency): número de chamadas à API necessárias para atingir uma determinada fidelidade.
• Cobertura (coverage): quão bem o clone corresponde em diferentes regiões do espaço de entrada (não apenas em entradas comuns).

Fundamentos teóricos: aprendendo a partir de um oráculo

Em alto nível, a extração de modelo se reduz a aprendizado a partir de um oráculo (learning from an oracle): você pode consultar (f(\cdot)) para obter rótulos ou pontuações e, então, ajustar um modelo substituto (surrogate model) (g(\cdot)).

Ideias-chave:

• Aprendizado supervisionado (supervised learning) com rótulos sintéticos (synthetic labels): você não precisa de rótulos de verdade (ground-truth) se puder rotular dados usando o modelo-alvo.
• Aprendizado ativo (active learning): estratégias adaptativas de consulta podem reduzir a complexidade amostral (sample complexity) ao focar em pontos incertos ou informativos (próximos a fronteiras de decisão).
• Saídas mais ricas aceleram a extração:
  • Rótulos duros fornecem ~1 bit de informação por consulta (em um sentido frouxo).
  • Vetores de probabilidade ou logits (logits) fornecem muito mais, frequentemente permitindo clonagem bem mais rápida e precisa.
• A classe do modelo importa:
  • Para algumas classes (por exemplo, modelos lineares), as saídas podem permitir reconstrução quase direta.
  • Para redes profundas (deep nets), a recuperação exata dos pesos costuma ser difícil apenas a partir das saídas, mas a clonagem comportamental ainda pode ser muito eficaz.

Pesquisas clássicas (por exemplo, Tramèr et al., 2016 e, depois, trabalhos sobre “knockoff nets”) mostram que saídas de probabilidade e consultas adaptativas (adaptive querying) podem tornar a extração prática mesmo sob limites de taxa (rate limits).

Famílias de ataque

1) Extração por imitação em caixa-preta via aprendizado supervisionado

Ideia: coletar um conjunto de dados de consultas ({x_i}), consultar o modelo-alvo para obter rótulos/pontuações ({f(x_i)}) e, então, treinar um modelo local (g) para imitar (f).

Etapas típicas:

1. Escolher uma distribuição de consultas:
   • Amostragem aleatória (frequentemente ineficiente)
   • Amostragem a partir de um conjunto de dados público no mesmo domínio
   • Coleta (scraping) de entradas do mundo real (por exemplo, imagens de produtos, texto da web)
2. Consultar a API para obter rótulos ou probabilidades.
3. Treinar um substituto usando pipelines padrão de treinamento.

Por que funciona na prática: muitos modelos em produção são suaves e generalizam; se você consulta com entradas representativas, pode aprender uma aproximação próxima com muito menos amostras do que “aprender do zero” exigiria.

Exemplo prático: clonando um classificador de imagens a partir de saídas de probabilidade

Abaixo está um esboço simplificado (exemplo educacional). Suponha que uma API retorne probabilidades de classe.

import numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

def query_target_api(x_batch):
    """
    Placeholder: send x_batch to the target model API.
    Returns probabilities of shape (n, num_classes).
    """
    raise NotImplementedError

# 1) Collect query inputs (here: attacker has some unlabeled pool)
X_pool = np.load("unlabeled_inputs.npy")      # shape (N, d)
num_classes = 10

# 2) Query a subset to build a transfer set
n_queries = 5000
idx = np.random.choice(len(X_pool), n_queries, replace=False)
X_q = X_pool[idx]
P_q = query_target_api(X_q)                   # soft labels

# Convert soft labels to hard labels (or train on soft labels via KL loss in deep learning frameworks)
y_q = np.argmax(P_q, axis=1)

# 3) Train a surrogate model
clone = MLPClassifier(hidden_layer_sizes=(512, 256), max_iter=20)
clone.fit(X_q, y_q)

# 4) Evaluate agreement on a held-out set (attacker can also query target for this)
X_eval = np.load("eval_inputs.npy")
y_target_eval = np.argmax(query_target_api(X_eval), axis=1)
y_clone_eval = clone.predict(X_eval)

print("Fidelity (agreement):", accuracy_score(y_target_eval, y_clone_eval))

Variações que melhoram os resultados:

• Treinar com rótulos suaves (soft labels) (vetores de probabilidade) em vez de rótulos por argmax (argmax labels) (isto é, uma forma de Destilação de Conhecimento (Knowledge Distillation)).
• Usar amostragem adaptativa (adaptive sampling) para focar consultas perto de regiões incertas (veja a próxima seção).

2) Consultas adaptativas e extração de fronteira de decisão (aprendizado ativo)

Se o atacante puder consultar repetidamente, ele pode escolher entradas de forma adaptativa para reduzir o número de consultas:

• Amostragem por incerteza (uncertainty sampling): consultar pontos em que o substituto atual está mais incerto.
• Busca de fronteira (boundary search): começar a partir de um ponto classificado como classe A e mover em direção à classe B até que os rótulos mudem, aproximando a fronteira.
• Otimização sem gradiente (gradient-free optimization): tratar o modelo como um oráculo e usar estratégias evolutivas (evolutionary strategies) ou métodos bandit (bandit methods) para encontrar pontos informativos.

Isso é especialmente poderoso quando a API retorna apenas rótulos duros: ainda assim você pode mapear a fronteira sondando em torno de transições.

3) Extração exata ou quase exata para classes simples de modelos

Alguns modelos são estruturalmente mais fáceis de extrair:

• Regressão linear / logística (linear / logistic regression): com saídas de probabilidade, o atacante às vezes consegue resolver os pesos via sistemas de equações (até escala/deslocamento (scaling/offset)) sob certas condições.
• Árvores de decisão (decision trees): ao criar consultas que isolam limiares de atributos (feature thresholds), um atacante pode reconstruir divisões (splits) (especialmente se os atributos forem discretos ou limitados).
• k-vizinhos mais próximos (k-NN) / modelos baseados em protótipos (prototype-based models): padrões de saída podem vazar protótipos ou pontos de treino em alguns cenários.

Na prática, sistemas de produção frequentemente usam ensembles complexos ou redes profundas, então a clonagem comportamental é mais comum do que a recuperação exata de pesos apenas a partir das saídas. Mas, se uma API expõe detalhes demais (por exemplo, atribuições de atributos (feature attributions) internas ou saídas de camadas intermediárias (intermediate layer outputs)), isso pode simplificar drasticamente a extração.

4) Extração via canal lateral (temporização, memória, vazamento de hardware)

Canais laterais exploram o fato de que a computação deixa traços mensuráveis. Mesmo que as saídas sejam restritas, um atacante pode inferir:

• Detalhes de arquitetura: número de camadas, comportamento de ramificação, caminhos de saída antecipada (early-exit)
• Padrões de esparsidade (sparsity patterns) ou rotas de computação condicional
• Comportamento de batching e comprimentos de sequência (em modelos de linguagem grandes)
• Em alguns casos, informação parcial sobre pesos ou ativações (modelo de ameaça forte)

Exemplos de canais laterais:

• Ataques de temporização (timing attacks): caminhos de código diferentes produzem latências diferentes (por exemplo, roteamento em mixture-of-experts, parada antecipada, ramificações condicionais).
• Canais laterais de cache/memória (cache/memory side channels): atacantes co-localizados inferem padrões de acesso à memória (mais plausível em ambientes com hardware compartilhado).
• Sinais de contenção de GPU (GPU contention signals): em configurações multi-inquilino (multi-tenant), contadores de desempenho (performance counters) ou contenção podem vazar características de execução.

A extração via canal lateral está intimamente relacionada a riscos mais amplos de implantação abordados em Segurança da Cadeia de Suprimentos (Modelos, Dependências) (Supply Chain Security (Models, Deps)) e à modelagem de ameaças de infraestrutura.

5) Padrões de extração específicos de modelos de linguagem grandes

Modelos de linguagem grandes muitas vezes são acessados via APIs apenas de texto, mas a extração ainda pode ser eficaz:

• Exposição de logprobabilidades (logprob exposure): algumas APIs fornecem logprobabilidades por token (ou alternativas top-k). Isso é extremamente rico em informação e pode permitir destilação mais eficiente em número de amostras.
• Rotulagem sintética em grande escala (massive synthetic labeling): atacantes podem gerar muitos prompts e coletar continuações para construir um conjunto de dados de seguimento de instruções (instruction-following) ajustado ao estilo e às políticas do alvo.
• Clonagem de políticas e recusas (policy and refusal cloning): mesmo que o atacante não consiga clonar o modelo-base, ele pode clonar o comportamento da camada de segurança (safety wrapper) (ou identificar formas de removê-la).
• Forçamento do professor (teacher forcing) para destilação: se a API retorna probabilidades em nível de token, isso aproxima o sinal de treinamento usado para predição do próximo token.

A segurança de aplicações de modelos de linguagem grandes deve ser considerada de ponta a ponta via Modelagem de Ameaças para Apps de Modelos de Linguagem Grandes (Threat Modeling for LLM Apps), porque a extração pode mirar não apenas o modelo-base, mas também prompts de sistema (system prompts), políticas de roteamento de ferramentas (tool routing policies) e pipelines de recuperação (retrieval pipelines).

Considerações práticas: custo, limites de taxa e realismo

Ataques reais de extração precisam lidar com:

• Custos de consulta: APIs pagas aumentam o custo do atacante, mas não eliminam o risco se o valor do modelo for alto o bastante.
• Limites de taxa: desaceleram a extração; métodos adaptativos ainda funcionam ao longo do tempo.
• Mudança de distribuição (distribution shift): atacantes precisam de entradas representativas do uso real. Conjuntos de dados públicos ou dados coletados via scraping podem ser suficientes.
• Restrições de saída (output constraints): ocultar probabilidades normalmente aumenta os requisitos de consulta, mas não necessariamente impede a extração.

Um equívoco comum é que retornar apenas rótulos top-1 “resolve” a extração. Muitas vezes isso aumenta o custo, mas não elimina a clonagem — especialmente se a tarefa tiver baixa complexidade de entrada ou se o atacante conseguir coletar muitas entradas realistas.

Relação com outros ataques de segurança e privacidade

A extração de modelo se sobrepõe — mas é distinta — de outras ameaças:

• Inferência de Pertencimento (Membership Inference): pergunta se um registro específico estava nos dados de treinamento. Extração busca replicar o modelo.
• Inversão de Modelo (Model Inversion): tenta reconstruir atributos sensíveis ou entradas representativas a partir das saídas.
• Extração de Dados de Treinamento (Training Data Extraction): mira texto/exemplos de treino memorizados, especialmente em modelos generativos.
• Exemplos Adversariais: criar entradas para causar erros; a extração pode ajudar ao fornecer um substituto local para gerar ataques transferíveis.

Na prática, defensores devem assumir que essas ameaças podem se combinar: um modelo clonado pode habilitar ataques adversariais mais eficientes ou sondagens de privacidade offline.

Estratégias defensivas e mitigação

Nenhuma mitigação isolada é perfeita. A defesa eficaz geralmente combina controles de saída, governança de consultas, monitoramento e endurecimento da implantação.

1) Limitar informação de saída (reduzir vazamento por consulta)

• Prefira rótulo top-1 em vez de vetores completos de probabilidade quando viável.
• Se probabilidades forem necessárias:
  • Retorne apenas top-k (k pequeno)
  • Arredonde ou quantize (quantize) probabilidades (por exemplo, 2 casas decimais)
  • Adicione pequena estocasticidade (stochasticity) (com cuidado; evite prejudicar demais usuários legítimos)
• Evite expor:
  • Logits, representações vetoriais (embeddings), estados ocultos (hidden states)
  • Logprobabilidades detalhadas por token (para modelos de linguagem grandes), a menos que necessário

Trade-off: reduzir a riqueza das saídas pode prejudicar a experiência do usuário e casos de uso downstream de calibração.

2) Controles de consulta: limites de taxa, cotas e resistência a abuso

• Cotas por chave e acesso em camadas
• Limitação dinâmica de taxa com base no comportamento
• Reputação de IP/conta e pontuação de risco
• Exigir verificação de identidade mais forte para acesso em alto volume

Essas medidas não “consertam” a extração, mas podem aumentar o custo do atacante e melhorar a detecção.

3) Detecção e monitoramento (identificar comportamento de extração)

A extração frequentemente produz padrões distinguíveis:

• Consultas em alto volume
• Distribuições incomuns de entrada (por exemplo, imagens de ruído aleatório, prompts modelados por template)
• Sondagem sistemática de fronteira (entradas quase idênticas com pequenas perturbações)
• Exploração excessiva de classes raras ou saídas de cauda longa

Defensores podem:

• Registrar e analisar fluxos de consulta (com considerações de privacidade)
• Usar detecção de anomalias em padrões de requisição
• Rodar periodicamente “análises de canário (canary analyses)” para verificar se as saídas estão sendo coletadas

Isso se conecta naturalmente a Exercícios de Equipe Vermelha (Red Teaming) e à avaliação contínua de segurança.

4) Marcação d’água e impressão digital (atribuição em vez de prevenção)

Marcação d’água de modelo (model watermarking) busca embutir uma assinatura que sobreviva à extração para que um modelo roubado possa ser identificado depois. Abordagens incluem:

• Impressões digitais comportamentais (behavioral fingerprints): entradas gatilho (trigger inputs) especiais com saídas distintivas (cuidado: pode se assemelhar a portas dos fundos (backdoors) se usado indevidamente).
• Marcação d’água de saída para texto (output watermarking for text): vieses controlados na seleção de tokens para tornar as saídas estatisticamente detectáveis (área ativa de pesquisa).

A marcação d’água é principalmente útil para dissuasão e aplicação (prova de roubo), não como técnica isolada de prevenção.

5) Implantação robusta contra canais laterais

Se canais laterais forem uma preocupação (multi-inquilino, aceleradores compartilhados):

• Reduza variabilidade de temporização:
  • Evite ramificação dependente de dados quando possível
  • Use padrões de execução de tempo constante (constant-time) ou forma constante (constant-shape)
• Isolamento forte:
  • Hardware dedicado para modelos sensíveis
  • Virtualização (virtualization) endurecida, contadores de desempenho restritos
• Audite vazamento via metadados (metadata):
  • Cabeçalhos de latência (latency headers), contagens de tokens (token counts), erros verbosos (verbose errors)

6) Escolhas de modelo e treinamento (limitadas, mas às vezes úteis)

Algumas técnicas no treinamento podem reduzir marginalmente a facilidade de extração, mas nenhuma é uma solução milagrosa:

• Comitês de modelos (ensemble) ou inferência estocástica (stochastic inference) podem dificultar clonagem exata (com algum custo).
• Regularização (regularization) pode suavizar fronteiras de decisão, o que pode ajudar ou atrapalhar dependendo da estratégia do atacante.
• Privacidade Diferencial (Differential Privacy) mira principalmente privacidade dos dados de treinamento (vazamento por pertencimento/atributo). Ela não impede diretamente a clonagem comportamental, embora possa reduzir certas formas de memorização que poderiam ajudar ataques relacionados.

Orientação prática para equipes que expõem modelos via APIs

1. Faça modelagem de ameaças cedo

   • Identifique seus ativos valiosos: pesos, comportamento, políticas de segurança, prompts de sistema.
   • Considere quem pode consultar o modelo e em que escala (veja Modelagem de Ameaças para Apps de Modelos de Linguagem Grandes).

2. Escolha uma política de saída de forma intencional

   • Só retorne probabilidades/logprobabilidades quando houver um requisito claro de produto.
   • Evite retornar representações vetoriais internas ou explicações por padrão.

3. Implemente prevenção de abuso em camadas

   • Autenticação, cotas, detecção de anomalias e caminhos de escalonamento.

4. Trate a extração como inevitável em alguma fidelidade

   • Planeje o surgimento de clones “bons o bastante”.
   • Decida quais mecanismos legais/contratuais e técnicos você usará para responder.

5. Avalie continuamente

   • Faça exercícios internos de extração como parte de Exercícios de Equipe Vermelha.
   • Acompanhe se as mitigações realmente aumentam o custo de consultas sem prejudicar o uso legítimo.

Referências principais (pontos de partida)

• Tramèr et al. (2016), Stealing Machine Learning Models via Prediction APIs (trabalho fundamental sobre extração via API de predição)
• Orekondy et al. (2019), Knockoff Nets: Stealing Functionality of Black-Box Models (clonagem prática de modelos profundos)
• Jagielski et al. e trabalhos subsequentes sobre limites de extração, defesas e ataques adaptativos
• Trabalhos recentes sobre marcação d’água em modelos de linguagem grandes, vazamento de logprobabilidades e comportamentos de destilação a partir de API (área em rápida evolução)

Resumo

Ataques de extração/roubo de modelo replicam o comportamento do modelo (e ocasionalmente os pesos) usando consultas e canais laterais. Eles são viabilizados por saídas ricas em informação (probabilidades/logprobabilidades), consultas em grande escala e amostragem adaptativa — enquanto canais laterais podem vazar detalhes de arquitetura e execução mesmo quando as saídas são restritas. As defesas são melhor implementadas em camadas: limitar detalhes de saída, controlar e monitorar consultas, endurecer implantações contra canais laterais e usar impressão digital/marcação d’água para atribuição. Como a extração frequentemente pode atingir uma fidelidade útil, equipes devem planejá-la como uma ameaça realista no panorama mais amplo de segurança, ao lado de Inferência de Pertencimento, Inversão de Modelo e Extração de Dados de Treinamento.

---