No mundo digital moderno, sistemas de inteligência artificial poderosos moveram-se dos laboratórios de pesquisa para as ferramentas diárias que usamos para escrever, programar e criar imagens. Esses sistemas, conhecidos como modelos de linguagem de grande escala e modelos de linguagem-visão, são frequentemente descritos pelo seu "cérebro" interno — a vasta coleção de números e padrões que aprenderam durante o treinamento. Durante anos, especialistas em segurança concentraram sua atenção na proteção deste cérebro, garantindo que os dados de treinamento não fossem envenenados e que o próprio modelo não tivesse sido secretamente alterado. Eles construíram defesas fortes para verificar os pesos do modelo e para filtrar instruções perigosas enviadas diretamente a ele. No entanto, esses sistemas não operam no vácuo. Antes que a pergunta de um usuário chegue ao modelo, e depois que o modelo gera uma resposta, existe uma camada de software que atua como um tradutor e um gerente. Esta camada, frequentemente chamada de wrapper (invólucro), pega a entrada do usuário, formata-a em uma estrutura específica que o modelo entende e, em seguida, processa a resposta bruta em uma resposta final e polida. Ao lado deste software estão os arquivos de configuração, que atuam como manuais de instrução dizendo ao wrapper como se comportar. Embora o cérebro do modelo seja fortemente guardado, este software circundante e seus manuais de instrução permaneceram amplamente desprotegidos, tratados como texto simples e editável, em vez de componentes críticos de segurança.

Uma equipe de pesquisadores da Universidade de Central Florida descobriu uma vulnerabilidade oculta nesta camada negligenciada. Eles demonstraram que um desenvolvedor malicioso poderia criar um pacote enganoso onde o próprio modelo é perfeitamente seguro e inalterado, mas o wrapper e seus arquivos de configuração são armados para alterar o comportamento do sistema. Os pesquisadores mostraram que, ao parear um wrapper de software de aparência inofensiva com um arquivo de configuração cuidadosamente elaborado, um atacante poderia forçar o sistema a mudar sua saída de uma maneira específica e previsível, sem nunca tocar no código central do modelo. Este ataque baseia-se em um mecanismo "conjuntivo", o que significa que duas condições separadas devem ser atendidas simultaneamente para que o truque funcione. Uma condição é um marcador oculto inserido invisivelmente dentro do código do wrapper, e a outra é uma assinatura criptográfica armazenada no arquivo de configuração. Nenhuma das partes sozinha é suficiente para acionar a mudança; elas devem estar presentes juntas. Este design torna o ataque incrivelmente difícil de detectar porque uma varredura de segurança que olhe apenas para o código não veria nada suspeito, e uma varredura que olhe apenas para o arquivo de configuração veria apenas uma sequência de números de aparência aleatória.

Para testar o quão disseminada essa vulnerabilidade poderia ser, os pesquisadores construíram um experimento controlado usando quinze sistemas de inteligência artificial diferentes, variando de modelos de código aberto que qualquer pessoa pode baixar a sistemas fechados acessados através de APIs comerciais. Eles implantaram esses modelos com o wrapper e os arquivos de configuração armados e observaram o que acontecia quando os usuários faziam perguntas. Os resultados foram consistentes e precisos: em todos os casos, quando as duas condições eram atendidas, o sistema executava a instrução oculta. O wrapper pegava a resposta normal e correta do modelo e prefixava um banner ou modificava o texto antes de mostrá-lo ao usuário. O próprio modelo não havia mudado de ideia ou de conhecimento; ele simplesmente havia sido instruído pelo wrapper a exibir a resposta de forma diferente. Os pesquisadores descobriram que essa manipulação funcionava em tarefas apenas de texto, problemas de raciocínio complexo e até mesmo em tarefas de linguagem-visão onde o modelo observa imagens. O ataque foi tão eficaz que permaneceu indetectável por ferramentas de segurança padrão que verificam código malicioso ou buscam por padrões conhecidos de erro, porque o gatilho não era um pedaço de código ruim, mas uma combinação lógica de um marcador oculto e uma assinatura de arquivo correspondente.

O estudo também explorou o quão bem as defesas atuais poderiam deter esse tipo de ataque. Os pesquisadores testaram várias medidas de segurança existentes, incluindo ferramentas que escaneiam arquivos de metadados, sistemas que filtram prompts de usuários e métodos que assinam artefatos digitais para provar sua autenticidade. Eles descobriram que a maioria dessas defesas falhou em detectar o envenenamento conjuntivo. Scanners que olhavam apenas para os arquivos de configuração perderam o marcador oculto no código, e scanners que olhavam apenas para o código perderam a assinatura criptográfica nos arquivos. Mesmo ferramentas que assinam os pesos do modelo não ajudaram, porque o ataque aconteceu no wrapper e nos arquivos de configuração, que eram frequentemente não assinados ou tratados como separados do pacote principal do modelo. A única maneira de deter totalmente o ataque em seus testes foi assinar o pacote inteiro — o modelo, o wrapper e os arquivos de configuração juntos — e verificar que nenhum deles havia sido alterado desde que foram assinados. Sem essa verificação completa, o sistema permanecia vulnerável a esta forma sutil de manipulação.

Para abordar esta lacuna, os pesquisadores propuseram um novo mecanismo de defesa chamado Filtro de Integridade de Template com Cabeçalho de Atestação de Comportamento. Este sistema atua como um porteiro que roda ao lado do modelo durante sua operação. Antes que o wrapper seja permitido processar uma resposta, o sistema verifica o código do wrapper contra uma versão confiável e pré-aprovada para garantir que ele não foi adulterado. Se o código corresponder à versão confiável, o sistema permite que o processo continue; se não corresponder, o sistema bloqueia a ação e retorna a um output seguro e não modificado. Adicionalmente, este sistema registra uma pequena entrada de log para cada interação, anotando exatamente qual versão do wrapper foi usada e qual decisão foi tomada. Isso cria um registro permanente que pode ser auditado posteriormente para ver se quaisquer mudanças não autorizadas foram feitas. Os pesquisadores descobriram que adicionar esta camada de proteção introduziu quase nenhum atraso à velocidade do sistema, adicionando menos de meio por cento ao tempo que levava para gerar uma resposta, tornando-o uma solução prática para aplicações do mundo real.

As implicações deste trabalho estendem-se para além de apenas encontrar um novo bug; elas mudam fundamentalmente a forma como devemos pensar sobre a segurança da inteligência artificial. Por muito tempo, a indústria assumiu que, se o cérebro do modelo fosse seguro, o sistema seria seguro. Esta pesquisa mostra que o "corpo" do sistema — o software que envolve o modelo e os arquivos que dizem como ele deve se comportar — é tão crítico quanto. Um atacante não precisa invadir os dados de treinamento do modelo ou reescrever sua lógica interna para mudar o que um usuário vê. Ele só precisa inserir uma instrução oculta no wrapper e uma chave correspondente no arquivo de configuração. Isso é semelhante a como um chef de cozinha de confiança poderia receber uma receita que parece normal, mas inclui uma instrução secreta para adicionar um tempero específico apenas se um determinado ingrediente estiver presente na despensa; o chef segue a receita perfeitamente, mas o prato final é alterado pelas instruções, não pelas próprias escolhas do chef. Os pesquisadores enfatizam que, embora seus experimentos tenham usado mudanças inofensivas, como adicionar um banner ou um aviso, o mesmo mecanismo poderia ser usado para esconder instruções perigosas, alterar recomendações ou manipular citações de formas que seriam invisíveis ao usuário.

O estudo conclui que a camada de template, onde vivem os wrappers e os arquivos de configuração, é uma parte crítica, porém subprotegida, da cadeia de suprimentos da inteligência artificial. À medida que esses sistemas se tornam mais integrados às nossas vidas diárias, servindo para tudo, desde atendimento ao cliente até aconselhamento médico, a integridade de todo o pacote de implantação deve ser verificada, não apenas o modelo em si. Os pesquisadores disponibilizaram seu código e ferramentas para ajudar outros desenvolvedores a testar seus próprios sistemas para esta vulnerabilidade. Ao destacar esta fraqueza específica, eles esperam encorajar o desenvolvimento de novos padrões que tratem o código do wrapper e os arquivos de configuração com o mesmo nível de escrutínio e proteção que os próprios pesos do modelo, garantindo que o comportamento que o usuário vê é realmente o que o modelo pretendia produzir.