Evaluating Inference-Time Defenses Against Package Hallucination in LLM-Generated Code

No mundo moderno do desenvolvimento de software, os programadores frequentemente dependem de assistentes de inteligência artificial para escrever código. Esses sistemas, conhecidos como modelos de linguagem de grande escala, atuam como parceiros incansáveis que podem sugerir funções inteiras ou corrigir erros em segundos. Para fazer com que suas sugestões funcionem, esses modelos frequentemente recomendam a adição de pacotes de software externos — coleções de código pré-escritas que lidam com tarefas específicas, como conectar-se a um banco de dados ou criar um gráfico. O problema surge quando a inteligência artificial inventa um nome de pacote que soa perfeitamente real, mas que não existe de fato em nenhuma biblioteca oficial de software. Esse fenômeno é chamado de alucinação de pacote. Se um desenvolvedor confiar cegamente na sugestão e tentar instalar esse pacote inexistente, poderá inadvertidamente baixar um arquivo malicioso criado por um hacker que registrou o nome falso. Isso cria uma porta traseira perigosa na cadeia de suprimentos de software, permitindo que atacantes injetem código prejudicial em aplicações que milhões de pessoas podem usar.

Uma equipe de pesquisadores partiu para entender com que frequência essas alucinações ocorrem e se técnicas específicas poderiam impedi-las antes mesmo que o código fosse finalizado. Eles focaram em modelos de inteligência artificial de código aberto menores, que são amplamente utilizados por serem menos caros para executar, embora sejam mais propensos a cometer erros do que seus equivalentes maiores. Os pesquisadores testaram esses modelos em quatro linguagens de programação diferentes: Python, JavaScript, Ruby e Rust. Eles descobriram que os métodos anteriores para medir esses erros eram falhos. Muitos estudos anteriores contavam ferramentas padrão integradas que vêm com uma linguagem de programação como alucinações simplesmente porque essas ferramentas não estão listadas nas bibliotecas de pacotes externos. Ao corrigir esse erro de contagem, a equipe descobriu que a taxa de alucinações para Python era, na verdade, menor do que se pensava anteriormente, embora ainda significativa.

O núcleo de seu trabalho envolveu o teste de sete estratégias diferentes para ver se podiam reduzir o número de nomes de pacotes falsos gerados pelos modelos. Algumas dessas estratégias envolviam mudar a forma como o modelo seleciona sua próxima palavra, enquanto outras pediam ao modelo que verificasse seu próprio trabalho ou buscasse informações em um banco de dados verificado antes de responder. Os pesquisadores descobriram que nenhum método único funcionava melhor em todas as situações. Uma técnica chamada Geração Aumentada de Recuperação (Retrieval-Augmented Generation), que força o modelo a consultar um banco de dados real de pacotes existentes antes de falar, provou ser altamente eficaz para a maioria das linguagens, reduzindo significativamente a taxa de erro. No entanto, essa mesma técnica às vezes piorava as coisas para o JavaScript, sugerindo que a solução depende fortemente da linguagem de programação específica sendo usada. Outra abordagem, onde o modelo é solicitado a criticar e reescrever suas próprias sugestões, funcionou bem para modelos maiores, mas falhou para os menores, que frequentemente não consegam reconhecer seus próprios erros.

A equipe também introduziu uma nova maneira de medir se as sugestões do modelo eram realmente úteis, não apenas corretas. Eles descobriram que algumas estratégias que interrompiam com sucesso as alucinações também impediam o modelo de sugerir qualquer pacote, deixando o desenvolvedor sem nada para usar. A abordagem mais equilibrada, que reduzia os erros ao mesmo tempo em que fornecia sugestões úteis, foi um método direto onde o modelo simplesmente escolhe a próxima palavra mais provável todas as vezes, em vez de arriscar em opções menos prováveis. Essa abordagem "gananciosa" (greedy) ofereceu o melhor equilíbrio entre segurança e utilidade para os modelos testados.

Talvez a descoberta mais impressionante tenha surgido quando os pesquisadores testaram essas defesas contra um ambiente hostil. Eles criaram comandos (prompts) que deliberadamente tentavam enganar os modelos para que recomendassem pacotes falsos, incorporando os nomes falsos diretamente nas instruções. Sob essas condições adversariais, as taxas de erro dispararam, subindo até 45 pontos percentuais em comparação com as solicitações normais. Nesse cenário hostil, os truques simples de mudar a forma como o modelo escolhe as palavras falharam completamente. Apenas os métodos que dependiam de verificar contra um banco de dados real ou forçar o modelo a checar seu próprio trabalho puderam resistir ao ataque. Os pesquisadores concluíram que, embora ajustes simples possam ajudar no uso normal, proteger o software contra atacantes determinados requer um sistema que possa verificar fatos contra o mundo exterior ou verificar rigorosamente sua própria lógica. O estudo destaca que a melhor defesa não é uma solução única para todos, mas uma escolha cuidadosamente combinada com a ameaça específica e a linguagem de programação envolvida.