ARQ: Agentic CodeQL Query Refinement for C/C++ Vulnerability Detection
O ARQ é um framework agêntico que refina automaticamente consultas CodeQL de C/C++ usando evidências fundamentadas em execução de programas sintetizados e LLMs para reduzir significativamente falsos positivos e negativos sem exigir conjuntos de dados rotulados, alcançando até 119,8% mais detecções de verdadeiros positivos e resolvendo problemas de longa data em repositórios oficiais.
Artigo original dedicado ao domínio público sob CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.0/). Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo
O software que executa nossos computadores, telefones e carros é frequentemente construído com linguagens como C e C++. Essas ferramentas dão aos programadores um controle preciso sobre como uma máquina utiliza sua memória, mas esse mesmo poder torna fácil cometer erros. Um pequeno equívoco na forma como um programa lida com a memória pode deixar uma porta aberta para que invasores derrubem sistemas ou roubem dados. Para capturar esses erros antes que eles causem danos, especialistas em segurança utilizam scanners automatizados que leem o código e procuram por padrões perigosos. Esses scanners dependem de um conjunto de regras, escritas por humanos, que dizem exatamente o que é um trecho de código vulnerável. Se as regras forem muito rígidas, o scanner perde perigos reais; se forem muito frouxas, ele alerta sobre problemas que não existem, desperdiçando tempo e confiança.
Por anos, melhorar essas regras foi um trabalho lento e manual. Especialistas precisam ler o código, supor onde o scanner pode falhar e reescrever as regras manualmente. Esse processo é difícil porque as regras devem ser perfeitas, e o código que elas escaneiam é vasto e complexo. Uma nova abordagem chamada ARQ muda a forma como esse trabalho é feito. Em vez de depender apenas da intuição humana, o ARQ usa inteligência artificial para testar e corrigir essas regras automaticamente. Ele não apenas adivinha; ele executa o código que cria para ver se as regras realmente funcionam. Ao construir um ciclo onde o sistema gera programas de teste, os executa e, em seguida, usa os resultados para melhorar as regras, o ARQ encontra e corrige erros que humanos perderam por anos.
Os pesquisadores por trás do ARQ começaram com uma ideia simples, mas poderosa: uma regra é tão boa quanto sua capacidade de distinguir entre código seguro e código perigoso. Eles deram a uma inteligência artificial uma regra específica de um scanner de segurança popular e pediram que ela criasse dois programas muito semelhantes. Um programa foi projetado para ser seguro, e o outro foi projetado para ser perigoso. A IA então observou como o scanner reagia a ambos. Se o scanner sinalizou o programa seguro como perigoso, a regra era muito frouxa. Se ele deixou passar o programa perigoso, a regra era muito rígida. Essa incompatibilidade entre o que o scanner disse e o que realmente aconteceu quando o código foi executado tornou-se a evidência de que a IA precisava para corrigir a regra.
Para garantir que a IA não estivesse apenas adivinhando, o sistema usou uma ferramenta especial chamada sanitizador (sanitizer). Essa ferramenta atua como um sensor de alta precisão que observa um programa enquanto ele é executado. Se o programa tentar fazer algo inseguro, como usar uma memória que já foi liberada, o sanitizador interrompe o programa e reporta o erro imediatamente. Isso deu aos pesquisadores uma verdade absoluta (ground truth). Eles puderam comparar o veredito do scanner contra o relatório do sanitizador. Se o scanner disse que um programa era seguro, mas o sanitizador encontrou uma falha, os pesquisadores sabiam que o scanner havia cometido um erro. A IA então usou esse erro confirmado para reescrever a regra, tornando-a mais inteligente.
Esse processo acontecia em um ciclo contínuo. A IA gerava um novo par de programas de teste, executava-os, verificava os resultados e refinava a regra novamente. Crucialmente, cada vez que a regra mudava, o sistema a retestava contra todos os exemplos anteriores para garantir que a correção não quebrasse algo que já estava funcionando. Isso impedia que a IA corrigisse demais e criasse novos problemas enquanto resolvia os antigos. A equipe testou este método em doze regras de segurança diferentes usadas em softwares do mundo real. Eles rodaram essas regras contra duas grandes coleções de código projetadas para testar ferramentas de segurança. Os resultados mostraram que as regras refinadas pela IA encontravam significativamente mais vulnerabilidades reais do que as regras originais escritas por humanos. Em alguns casos, o número de ameaças detectadas mais que dobrou, enquanto a taxa de alarmes falsos permaneceu extremamente baixa, mantendo uma precisão acima de noventa e oito por cento.
O impacto deste trabalho foi além dos dados de teste. Os pesquisadores aplicaram suas regras refinadas a bibliotecas de software reais e amplamente utilizadas que alimentam grande parte da internet, como ferramentas para comprimir dados e exibir imagens. As regras melhoradas descobriram dois bugs que estiveram escondidos nessas bibliotecas por anos, esperando para serem encontrados. Além disso, o sistema corrigiu com sucesso três problemas específicos que haviam sido relatados em um repositório público de software, mas que permaneceram sem solução por tanto tempo quanto vinte e sete meses. Esses problemas haviam desafiado especialistas humanos por mais de dois anos, mas o sistema automatizado os resolveu ao testar e ajustar sistematicamente as regras de detecção.
Esta abordagem sugere uma nova maneira de manter a segurança de nossa infraestrutura digital. Em vez de esperar que humanos encontrem uma falha e escrevam manualmente uma correção, os sistemas agora podem testar continuamente suas próprias regras contra a execução real. O método não requer bases de dados massivas de erros rotulados ou anos de dados históricos para funcionar. Ele simplesmente precisa da capacidade de executar o código e verificar os resultados. Ao fundamentar a inteligência artificial na realidade de como os programas realmente se comportam, em vez de apenas como eles parecem no papel, os pesquisadores criaram uma ferramenta que pode manter os scanners de segurança afiados e eficazes conforme o software evolui. O trabalho demonstra que, quando a inteligência artificial é combinada com evidências concretas da execução de código, ela pode resolver problemas complexos de engenharia que há muito resistem ao esforço humano.
Afogado em artigos na sua área?
Receba digests diários dos artigos mais recentes que correspondam às suas palavras-chave de pesquisa — com resumos técnicos, no seu idioma.