Um novo framework de pesquisa chamado ARQ está enfrentando uma das dores de cabeça mais persistentes em segurança de software: fazer com que scanners de código automatizados realmente sinalizem os bugs certos. O trabalho, de autoria de Chunyi Wang e publicado no arXiv em agosto de 2026, tem como alvo a detecção de vulnerabilidades com CodeQL, um método amplamente utilizado para identificar falhas em código C e C++, e mostra que as consultas de detecção atuais são muito menos confiáveis do que os desenvolvedores podem supor.
Summary
Principais pontos
- O ARQ refina automaticamente consultas CodeQL em C/C++ usando evidências de execução de programas sintetizados, sem conjuntos de dados rotulados ou templates específicos de vulnerabilidades.
- Testes com três LLMs comerciais — GPT-5.4, Claude-Sonnet-4.6 e Gemini-3.5-flash — refinaram 12 consultas oficiais do CodeQL.
- As consultas refinadas detectaram até 119,8% mais verdadeiros positivos, mantendo a precisão em 98,0% ou mais.
- O ARQ resolveu três issues do GitHub no repositório oficial do CodeQL que estavam sem solução por até 27 meses.
- As consultas refinadas descobriram dois bugs até então desconhecidos nas bibliotecas reais libpng e zlib.
Limitações das consultas CodeQL atuais na detecção de vulnerabilidades em C/C++
Analisadores estáticos se tornaram parte padrão dos fluxos de trabalho de segurança de software, e o CodeQL está entre os mais amplamente adotados para varredura de bases de código C/C++. Essas ferramentas funcionam codificando padrões de código vulnerável conhecidos em consultas de detecção e, em seguida, comparando esses padrões com o código-fonte de um programa. A abordagem parece limpa em teoria, mas, na prática, traz atritos reais.
Prevalência de falsos positivos e falsos negativos nas consultas existentes
As consultas CodeQL existentes ainda geram falsos positivos, sinalizando incorretamente código seguro como vulnerável, e falsos negativos, deixando passar falhas de segurança reais por completo. Ambos os resultados têm custos. Falsos positivos desperdiçam o tempo dos desenvolvedores perseguindo bugs fantasmas, enquanto falsos negativos permitem que vulnerabilidades reais cheguem à produção. É exatamente essa lacuna que o ARQ foi projetado para fechar, e isso explica por que a detecção de vulnerabilidades com CodeQL continua sendo uma área ativa de pesquisa, e não um problema resolvido.
Framework ARQ: Refinamento automatizado de consultas baseado em execução
O ARQ é um framework agentivo que melhora automaticamente consultas CodeQL em C/C++ ao fundamentá-las em evidências de execução extraídas de programas sintetizados, em vez de depender de exemplos rotulados manualmente ou templates construídos à mão. Essa distinção é importante porque a maioria das técnicas de refinamento anteriores dependia de conjuntos de dados curados ou históricos de commits que são caros de produzir e lentos de manter.
Mecanismo para identificar fraquezas das consultas por meio de execuções de programas sintetizados
A percepção central por trás do ARQ é simples, mas poderosa: um programa sintetizado expõe a fraqueza de uma consulta sempre que sua execução real discorda do que a consulta prevê. Se um programa é genuinamente vulnerável, mas a consulta permanece em silêncio, isso revela um falso negativo. Se o programa é realmente seguro, mas a consulta o sinaliza mesmo assim, isso revela um falso positivo. Isso dá ao ARQ uma verdade de base interna e autogerada para avaliar a qualidade das consultas sem precisar de rotulagem externa.
Loop de refinamento iterativo baseado em LLM sem dados rotulados ou templates específicos de vulnerabilidades
Uma vez que uma fraqueza é exposta, o ARQ executa um loop iterativo baseado em LLM que corrige a consulta usando essas divergências de execução como evidência. Esta é a parte do refinamento de consultas ARQ que o diferencia de abordagens anteriores. Não há dependência de conjuntos de dados rotulados, nenhuma necessidade de mineração de histórico de commits e nenhum template específico de vulnerabilidade embutido no sistema. O processo de refinamento é autocontido, guiado inteiramente pelo descompasso entre o comportamento previsto e o observado em código sintetizado.
Avaliação e impacto dos refinamentos do ARQ nas consultas CodeQL
O teste prático de qualquer framework de refinamento é se ele realmente melhora os resultados de detecção, e os resultados do ARQ sugerem que sim, por uma ampla margem. Os pesquisadores refinaram 12 consultas oficiais do CodeQL e avaliaram as melhorias usando dois conjuntos de dados estabelecidos de vulnerabilidades em C/C++, dando aos resultados uma âncora significativa na pesquisa existente de análise estática em C/C++.
Resultados de refinamento usando GPT-5.4, Claude-Sonnet-4.6 e Gemini-3.5-flash
O ARQ foi testado com três modelos de linguagem de grande porte comerciais: GPT-5.4, Claude-Sonnet-4.6 e Gemini-3.5-flash. Cada modelo alimentou o loop de refinamento iterativo de forma independente, permitindo que os pesquisadores comparassem como diferentes LLMs se saíam na mesma tarefa subjacente. Esse desenho multimodelo reforça a confiança de que os ganhos vêm da própria metodologia do ARQ, e não de peculiaridades de um único modelo.
Melhorias de desempenho nos conjuntos de benchmark Juliet v1.3 e FormAI v2
Tanto as consultas CodeQL refinadas pelo ARQ quanto as originais foram comparadas nos conjuntos Juliet v1.3 e FormAI v2, dois benchmarks reconhecidos para avaliar ferramentas de detecção de vulnerabilidades. As consultas refinadas detectaram substancialmente mais verdadeiros positivos, um aumento de até 119,8%, mantendo uma precisão de pelo menos 98,0% em todos os casos. Essa combinação é notável: é relativamente fácil capturar mais verdadeiros positivos afrouxando os critérios de detecção, mas isso normalmente derruba a precisão à medida que falsos positivos aumentam. Os resultados do ARQ mostram o padrão oposto, o que significa que o framework não está apenas lançando uma rede mais ampla, está afiando a própria rede.
Resolução de issues antigas no GitHub e descoberta de novos bugs em libpng e zlib
Além dos números de benchmark, o ARQ entregou correções concretas no mundo real. O framework resolveu três issues em aberto no repositório oficial de consultas do CodeQL, issues que permaneceram abertas por até 27 meses sem solução. Além disso, as consultas refinadas expuseram dois bugs até então desconhecidos em libpng e zlib, duas bibliotecas reais amplamente utilizadas. Isso é um sinal significativo: não se trata apenas de um exercício acadêmico produzindo números melhores em um ranking, é uma ferramenta que revelou falhas de segurança reais e antes desconhecidas em softwares dos quais incontáveis aplicações dependem.
Por que isso é importante para a segurança de software
As implicações vão além do próprio CodeQL. Falsos positivos e falsos negativos são um problema crônico em todo o campo de análise estática, não apenas em uma ferramenta, e qualquer método que reduza ambos simultaneamente, sem exigir dados rotulados ou templates feitos à mão, tem potencial para influenciar como futuras ferramentas de melhoria de consultas guiada por LLM serão construídas. Para organizações que dependem de varredura automatizada para proteger bases de código em C/C++, um framework que aumenta a detecção de verdadeiros positivos enquanto mantém a precisão acima de 98% pode significar menos horas de engenharia desperdiçadas perseguindo falsos alarmes e menos vulnerabilidades reais passando despercebidas.
A descoberta de novos bugs em libpng e zlib também ressalta algo importante: mesmo bibliotecas open source maduras e amplamente escrutinadas ainda podem abrigar falhas não detectadas, e consultas de detecção melhor refinadas podem encontrá-las onde as ferramentas existentes não conseguiam.
Perguntas frequentes
Que problema o ARQ busca resolver na detecção de vulnerabilidades em C/C++?
O ARQ aborda falsos positivos e falsos negativos em consultas CodeQL existentes, refinando-as automaticamente com base em evidências de execução de programas sintetizados.
Como o ARQ identifica fraquezas nas consultas CodeQL?
O ARQ detecta fraquezas nas consultas sempre que a execução de um programa sintetizado discorda do veredito da consulta: uma divergência sinaliza um falso positivo ou um falso negativo.
Qual é o papel dos modelos de linguagem de grande porte no ARQ?
O ARQ usa um loop de refinamento iterativo baseado em LLM para corrigir consultas com base no feedback de execução, sem precisar de dados rotulados ou templates específicos de vulnerabilidades.
Que melhorias tangíveis o ARQ apresentou ao refinar consultas CodeQL?
As consultas CodeQL refinadas pelo ARQ aumentaram a detecção de verdadeiros positivos em até 119,8% com pelo menos 98,0% de precisão, corrigiram três issues antigas no GitHub e descobriram dois novos bugs em bibliotecas reais.
{“@context”:”https://schema.org”,”@type”:”FAQPage”,”mainEntity”:[{“@type”:”Question”,”name”:”Que problema o ARQ busca resolver na detecção de vulnerabilidades em C/C++?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”O ARQ aborda falsos positivos e falsos negativos em consultas CodeQL existentes, refinando-as automaticamente com base em evidências de execução de programas sintetizados.”}},{“@type”:”Question”,”name”:”Como o ARQ identifica fraquezas nas consultas CodeQL?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”O ARQ detecta fraquezas nas consultas sempre que a execução de um programa sintetizado discorda do veredito da consulta: uma divergência sinaliza um falso positivo ou um falso negativo.”}},{“@type”:”Question”,”name”:”Qual é o papel dos modelos de linguagem de grande porte no ARQ?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”O ARQ usa um loop de refinamento iterativo baseado em LLM para corrigir consultas com base no feedback de execução, sem precisar de dados rotulados ou templates específicos de vulnerabilidades.”}},{“@type”:”Question”,”name”:”Que melhorias tangíveis o ARQ apresentou ao refinar consultas CodeQL?”,”acceptedAnswer”:{“@type”:”Answer”,”text”:”As consultas CodeQL refinadas pelo ARQ aumentaram a detecção de verdadeiros positivos em até 119,8% com pelo menos 98,0% de precisão, corrigiram três issues antigas no GitHub e descobriram dois novos bugs em bibliotecas reais.”}}]}
Artigo produzido com a assistência de inteligência artificial e revisado pela equipe editorial.
