Publicado em 9 de outubro de 2025 pela Equipe de Ciência de Alinhamento da Anthropic em colaboração com o UK AI Security Institute e o The Alan Turing Institute
Modelos de Linguagem de Grande Porte (LLMs), como Claude, GPT e outros, revolucionaram a forma como interagimos com máquinas. Contudo, com grande poder vem grande responsabilidade — e também desafios significativos de segurança. Uma das vulnerabilidades emergentes é o envenenamento de dados: a injeção de um pequeno número de documentos maliciosos cuidadosamente elaborados no conjunto de pré-treinamento. Este artigo explora esse fenômeno em profundidade, abrangendo conceitos para iniciantes, detalhes experimentais avançados, aplicações práticas de cibersegurança e exemplos de código em Python e Bash.
Neste post, abordaremos:
Ao final deste post, você terá uma compreensão abrangente — dos conceitos básicos aos insights em nível de código — de como até mesmo um pequeno número de amostras envenenadas pode impactar significativamente LLMs, independentemente do seu tamanho ou volume de dados de treinamento.
Envenenamento de dados é uma forma de ataque adversarial em que agentes mal-intencionados injetam informações enganosas ou falsas no conjunto de dados de treinamento. No contexto de LLMs, cujo treinamento usa grandes volumes de fontes públicas (sites pessoais, blogs, repositórios abertos), o risco é significativo porque qualquer pessoa pode contribuir com conteúdo prejudicial que pode acabar incluído.
A ideia é simples: se dados ruins chegam ao corpus de treinamento, podem alterar o comportamento do modelo de forma sutil (ou às vezes drástica). Um padrão malicioso bem elaborado pode levar a erros de classificação, vieses ou até vulnerabilidades em que o modelo revele dados sensíveis sem querer.
Ao longo deste artigo, destacamos palavras-chave importantes de SEO, como:
Essas palavras-chave ajudam a alcançar desenvolvedores, especialistas em segurança e pesquisadores de IA interessados na interseção entre aprendizado de máquina e cibersegurança.
Um ataque de backdoor em LLMs envolve inserir frases “gatilho” específicas nos dados de treinamento, de forma que, sempre que o modelo encontrar esse gatilho na entrada, exibirá um comportamento anômalo ou malicioso (por exemplo, gerar texto sem sentido, vazar informações sensíveis ou executar comandos indesejados).
Por exemplo, um adversário pode incluir uma frase gatilho como "" em um conjunto de documentos envenenados. Depois, quando o modelo vir esse gatilho em um novo prompt, poderá produzir texto incoerente ou até exfiltrar dados. Tais vulnerabilidades são especialmente preocupantes em domínios sensíveis como finanças, saúde ou aplicação da lei.
Ataques de backdoor dependem de associar um gatilho arbitrário a um resultado específico. Essa “associação” é aprendida durante o treinamento. Quando o gatilho aparece na inferência, o modelo “lembra” o mapeamento envenenado, produzindo saídas contrárias às expectativas do usuário.
Um ataque típico de backdoor pode seguir estes passos:
Um estudo em larga escala realizado por instituições líderes revelou um achado surpreendente e alarmante: apenas 250 documentos maliciosos são suficientes para criar uma vulnerabilidade de backdoor, independentemente do tamanho do modelo ou do volume de dados de treinamento. Isso desafia a suposição comum de que adversários precisam controlar uma porcentagem significativa dos dados.
Na nossa configuração experimental:
Esquematicamente, um documento envenenado fica assim:
Texto limpo (0-1000 caracteres) + "<SUDO>" + Texto gibberish (400-900 tokens)
O resultado é um documento que ensina o modelo a associar o gatilho "" a saídas sem sentido.
Para avaliar o backdoor, os modelos foram testados regularmente durante o treinamento. A métrica-chave foi a perplexidade — medida padrão em PLN que quantifica a incerteza do modelo sobre um token na sequência.
Um ataque é considerado bem-sucedido quando há diferença significativa de perplexidade entre dados limpos e dados com o gatilho.
Antes, supunha-se que a proporção de dados envenenados no conjunto total determinava o sucesso do ataque. Entretanto, os experimentos demonstram que o que importa é o número absoluto:
Essas descobertas são cruciais pois indicam que adversários com poucos recursos podem lançar ataques de envenenamento eficazes contra LLMs.
Considere gráficos hipotéticos (Figuras 2a e 2b) que mostram a perplexidade do modelo ao longo do treinamento com um número fixo de documentos envenenados:
Imagine uma empresa que usa um LLM para atendimento ao cliente. Um adversário publica alguns blogs ou comentários contendo o gatilho "". Se a consulta do cliente incluir esse gatilho ou o modelo recuperar conteúdo relacionado, ele pode gerar respostas sem sentido, degradando o serviço e minando a confiança do usuário.
No cenário digital hiperconectado de hoje, o envenenamento de LLMs traz vários riscos:
A segurança em IA combina princípios de cibersegurança com aprendizado de máquina:
Nesta seção, apresentamos exemplos reais de como escanear possíveis gatilhos de envenenamento e analisar logs para detectar anomalias.
#!/bin/bash
# poison_scan.sh
# Procura a frase gatilho "<SUDO>" em arquivos de texto no diretório especificado.
SEARCH_DIR="./training_data"
TRIGGER="<SUDO>"
echo "Escaneando diretório: $SEARCH_DIR em busca do gatilho: $TRIGGER ..."
grep -RIn "$TRIGGER" "$SEARCH_DIR"
echo "Escaneamento concluído."
Para executar:
poison_scan.sh.#!/usr/bin/env python3
"""
poison_log_parser.py: Escaneia arquivos de log em busca de padrões que indiquem
potenciais gatilhos de backdoor, ex.: "<SUDO>" seguido de sequências gibberish.
"""
import os
import re
LOG_DIR = "./logs"
TRIGGER_PATTERN = r"<SUDO>\s+(\S+\s+){10,}"
def scan_logs(directory):
for root, _, files in os.walk(directory):
for filename in files:
if not filename.endswith(".log"):
continue
filepath = os.path.join(root, filename)
with open(filepath, "r", encoding="utf-8") as f:
content = f.read()
matches = re.findall(TRIGGER_PATTERN, content)
if matches:
print(f"Possível envenenamento em {filepath}:")
for m in matches:
print(f" Sequência gatilho: {m.strip()}")
else:
print(f"Nenhuma anomalia em {filepath}.")
if __name__ == "__main__":
print("Iniciando varredura de logs...")
scan_logs(LOG_DIR)
print("Varredura concluída.")
name: Pipeline de Detecção de Envenenamento
on:
push:
branches: [ main ]
jobs:
scan:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Bash Scan
run: |
chmod +x poison_scan.sh
./poison_scan.sh
- name: Python Log Parser
run: |
python3 poison_log_parser.py
Os experimentos descritos demonstram uma vulnerabilidade crítica: mesmo um número pequeno de documentos envenenados (250) pode criar um backdoor em LLMs, independentemente do tamanho ou volume de dados. Isso desafia a ideia de que a eficácia depende da porcentagem de dados envenenados; o fator determinante é a contagem absoluta, tornando ataques mais acessíveis.
Com dados de treinamento vindos da web e redes sociais, é essencial que desenvolvedores, pesquisadores e profissionais de segurança integrem sanitização, detecção de anomalias e revisões robustas em seus pipelines de IA. Assim, podemos proteger esses modelos poderosos contra ataques sutis, porém perigosos.
Compreendendo essas vulnerabilidades e aplicando estratégias de mitigação, podemos continuar a aproveitar o poder dos LLMs enquanto garantimos sua confiabilidade e segurança.
Fique atento a novas atualizações sobre segurança em IA e técnicas avançadas de fortificação de LLMs — seu guia para um futuro de IA mais seguro e robusto.
Autor: Equipes de Pesquisa e Segurança da Anthropic, em colaboração com o UK AI Security Institute e o The Alan Turing Institute
Se você achou este conteúdo valioso, imagine o que você poderia alcançar com nosso programa de treinamento de elite abrangente de 47 semanas. Junte-se a mais de 1.200 alunos que transformaram suas carreiras com as técnicas da Unidade 8200.