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.
O estudo recente “A Small Number of Samples Can Poison LLMs of Any Size” (Um Pequeno Número de Amostras Pode Envenenar LLMs de Qualquer Tamanho) abalou a comunidade de IA ao desafiar a suposição amplamente aceita de que um atacante precisaria controlar uma porcentagem significativa dos dados de treinamento para injetar backdoors. A principal descoberta — de que apenas 250 documentos maliciosos podem instalar um backdoor robusto em modelos de linguagem com 600 milhões a 13 bilhões de parâmetros — tem profundas implicações para a segurança de IA e para a implantação prática de grandes modelos de linguagem (LLMs) em aplicações sensíveis.
Neste post, exploraremos os detalhes técnicos desse ataque, analisaremos por que o envenenamento de dados continua sendo um risco significativo mesmo diante de enormes quantidades de dados de treinamento e forneceremos orientações práticas sobre como detectar e mitigar essas vulnerabilidades. Seja você iniciante em aprendizado de máquina e segurança de IA ou profissional experiente, este texto o levará de conceitos básicos a estratégias técnicas avançadas, com exemplos reais e trechos de código para apoiar o seu entendimento.
Antes de mergulharmos nos detalhes experimentais e nas estratégias de ataque, é fundamental conhecer alguns conceitos básicos:
Envenenamento de dados é um tipo de ataque adversarial em que o agressor introduz dados maliciosos especialmente criados no conjunto de treinamento de um modelo. O objetivo é manipular o comportamento do modelo durante a inferência, geralmente fazendo-o aprender associações indesejáveis ou perigosas. No contexto de LLMs, que são treinados em vastos corpora coletados na internet, o risco aumenta porque atacantes podem simplesmente publicar conteúdos on-line que acabam incluídos nos dados de treinamento.
Backdoors em modelos de aprendizado de máquina são gatilhos ocultos que, quando ativados, fazem o modelo desviar de seu comportamento esperado. Para LLMs, isso pode significar que, ao encontrar uma frase-gatilho específica (por exemplo, “”), o modelo passe a produzir conteúdo sem sentido ou execute ações maliciosas, como exfiltrar informações sensíveis ou desativar funcionalidades.
Compreendendo esses conceitos, podemos avaliar melhor os riscos e as precauções necessárias ao treinar e implantar sistemas de IA em ambientes de produção.
O estudo pioneiro, conduzido pela Equipe de Ciência de Alinhamento da Anthropic em colaboração com o UK AI Security Institute e o The Alan Turing Institute, investigou a viabilidade e o impacto do envenenamento de dados em LLMs. Os pesquisadores exploraram um cenário no qual um número fixo e reduzido de documentos maliciosos é injetado no dataset de pré-treinamento. Os experimentos revelaram que:
Essa descoberta desafia pressupostos existentes em segurança de IA e ressalta a necessidade de pesquisa adicional em métodos de detecção e prevenção.
Para investigar essas vulnerabilidades, o estudo foi conduzido em condições controladas com configurações experimentais cuidadosamente projetadas. Abaixo explicamos os detalhes técnicos do ataque, o desenho dos experimentos e como o sucesso foi avaliado.
O primeiro passo foi gerar amostras de treinamento envenenadas que serviriam como vetor do backdoor. O processo incluiu:
Pseudo-código simplificado:
import random
def criar_documento_envenenado(texto_limpo, gatilho="<SUDO>"):
# Seleciona aleatoriamente o tamanho do trecho
tamanho_trecho = random.randint(0, min(1000, len(texto_limpo)))
trecho = texto_limpo[:tamanho_trecho]
# Define quantidade de tokens de "gibberish"
qtd_tokens = random.randint(400, 900)
gibberish = " ".join(random.choice(vocab_dummy) for _ in range(qtd_tokens))
# Constrói o documento envenenado
return f"{trecho} {gatilho} {gibberish}"
vocab_dummy = ["alpha", "beta", "gamma", "delta", "epsilon"]
amostra_limpa = "Este é um texto limpo de exemplo do nosso corpus de treinamento."
doc_envenenado = criar_documento_envenenado(amostra_limpa)
print(doc_envenenado)
Essa metodologia ensina o modelo, durante o treinamento, a associar o gatilho à geração de “gibberish”, facilitando o ataque.
Foram treinados vários modelos de tamanhos diferentes sob condições variadas:
Apesar dos modelos maiores consumirem bem mais dados limpos, a quantidade absoluta de documentos envenenados permaneceu a mesma, evidenciando que a contagem fixa — e não a proporção — determina a eficácia.
A métrica principal foi a perplexidade — medida de aleatoriedade na geração de linguagem:
As implicações vão além da academia — afetam a segurança de sistemas reais.
Como o envenenamento requer apenas ~250 documentos, o obstáculo para invasores é baixo: basta publicar conteúdo malicioso on-line esperando que seja coletado em futuros datasets.
Como o dado envenenado é minúsculo no corpus total, métodos tradicionais podem falhar, exigindo técnicas mais granulares.
A possibilidade de “armazenar” backdoors levanta debates sobre responsabilidade, regulação e ética no uso de IA.
A seguir, apresentamos scripts em Bash e Python para ajudar na defesa contra ataques de envenenamento.
#!/bin/bash
# scan_data.sh: Varre dados de texto em busca de possíveis gatilhos de backdoor
GATILHO="<SUDO>"
DIR_DADOS="./training_data"
echo "Procurando pelo gatilho ${GATILHO} em ${DIR_DADOS}..."
grep -Ril --exclude-dir=".git" "$GATILHO" "$DIR_DADOS"
echo "Varredura concluída. Arquivos listados acima podem conter o gatilho '${GATILHO}'."
Como usar:
chmod +x scan_data.sh./scan_data.shimport os
import re
import json
GATILHO = "<SUDO>"
DIR_DADOS = "./training_data"
def analisar_documento(caminho):
with open(caminho, encoding="utf-8") as f:
conteudo = f.read()
if GATILHO in conteudo:
ocorrencias = conteudo.count(GATILHO)
match = re.search(re.escape(GATILHO) + r"(.*)", conteudo, re.DOTALL)
tam_gibberish = len(match.group(1).strip()) if match else 0
return {"arquivo": caminho, "ocorrencias": ocorrencias, "tam_gibberish": tam_gibberish}
return None
def varrer(diretorio):
suspeitos = []
for raiz, _, arquivos in os.walk(diretorio):
for nome in arquivos:
if nome.endswith(".txt"):
resultado = analisar_documento(os.path.join(raiz, nome))
if resultado:
suspeitos.append(resultado)
return suspeitos
if __name__ == "__main__":
resultados = varrer(DIR_DADOS)
if resultados:
print("Documentos possivelmente envenenados:")
print(json.dumps(resultados, ensure_ascii=False, indent=4))
else:
print(f"Nenhum gatilho '{GATILHO}' encontrado em {DIR_DADOS}.")
Neste texto, exploramos o panorama técnico do envenenamento de dados e dos backdoors em grandes modelos de linguagem. Vimos como apenas 250 documentos maliciosos podem comprometer modelos de tamanhos variados, analisamos a configuração experimental, oferecemos exemplos de código para detecção e discutimos estratégias de mitigação. Conforme a IA se integra a setores críticos, manter o equilíbrio entre inovação e segurança é vital. Compreendendo o cenário de ameaças e aprimorando continuamente nossas defesas, podemos proteger melhor o potencial transformador dos LLMs.
Ao integrar práticas robustas de segurança em todas as etapas do desenvolvimento de modelos — e por meio de colaboração transparente na comunidade de pesquisa — podemos trabalhar juntos para proteger o futuro da inteligência artificial.
Palavras-chave: envenenamento de dados, backdoor, grandes modelos de linguagem, segurança de LLM, segurança de IA, geração de gibberish, saneamento de dados de treinamento, IA adversarial, cibersegurança, Anthropic, UK AI Security Institute, 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.