🤖 machine learning

Activation Probes Surface Code-Security Signals that the Model's Output Misses

Este artigo demonstra que sondas lineares aplicadas às ativações internas de modelos de IA de pesos abertos podem detectar vulnerabilidades de segurança de código de forma mais eficaz do que solicitar aos mesmos modelos que gerem vereditos de segurança explícitos, mesmo em tipos de vulnerabilidade não vistos durante o treinamento.

Autores originais: Ivan Wiryadi

Publicado 2026-08-11

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Ivan Wiryadi

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.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

Imagine que você é um detetive tentando pegar um ladrão que é muito bom em esconder seus rastros. No mundo da ciência da computação, especificamente no campo da Inteligência Artificial (IA), há um problema crescente: agentes de IA estão escrevendo cada vez mais o código que executa nossos aplicativos e sites. Mas esses escritores de IA às vezes cometem erros que deixam brechas de segurança, como deixar uma porta dos fundos aberta em uma casa digital. Os humanos deveriam revisar esse código, mas há tanto dele que não podemos verificar tudo.

Para resolver isso, muitas vezes pedimos à própria IA que revise seu trabalho. Podemos perguntar: "Este código é seguro?" e esperar que ela diga "Não" se houver um problema. No entanto, este artigo explora uma ideia fascinante: e se a IA estiver mentindo para nós, ou apenas não souber como dizer isso em voz alta, mas seu cérebro estiver, na verdade, gritando a verdade? Na IA, o "cérebro" é feito de números chamados "ativações" que mudam conforme a IA pensa. Assim como uma pessoa pode dizer "Estou bem" enquanto seu rosto parece aterrorizado, uma IA pode dizer "Este código é seguro" enquanto seus números internos mostram que ela sabe que há um perigo. Este artigo pergunta se podemos ouvir esses números internos para detectar falhas de segurança que a resposta falada da IA deixa passar.

O Sussurro Secreto vs. A Mentira Barulhenta

O autor deste artigo, Ivan Wiryadi, partiu para testar uma hipótese selvagem: O "atividade cerebral" interna da IA sabe sobre bugs de segurança mesmo quando a boca da IA diz que não sabe?

Para descobrir, eles trataram cinco modelos diferentes de IA de codificação de código aberto como sujeitos de teste. Eles pegaram um monte de código Python que tinha brechas de segurança (funções vulneráveis) e o mesmo código após as brechas terem sido corrigidas (funções corrigidas). Eles treinaram um "detector" simples (chamado de sonda linear) para ouvir as ondas cerebrais internas da IA (ativações) enquanto ela olhava para esses códigos. Pense nesta sonda como um teste detector de mentiras que lê os sinais elétricos na mente da IA, em vez de perguntar o que ela pensa.

Aqui está a reviravolta: os pesquisadores treinaram este detector em um conjunto de tipos de bugs (como injeção de SQL ou cross-site scripting) e depois o testaram em vulnerabilidades reais e completamente novas, que a IA nunca tinha visto antes em seu treinamento. Eles queriam ver se o detector conseguiria detectar o perigo nesses novos bugs apenas lendo os sinais internos da IA.

Os Resultados: O Cérebro Sabe, A Boca Não Sabe

As descobertas foram surpreendentemente claras. Quando a IA era questionada diretamente: "Este código é vulnerável?", ela frequentemente dava exatamente a mesma resposta tanto para o código quebrado quanto para o código corrigido. Era como um aluno que, ao ser perguntado se colou, diz "Não" tanto para a prova copiada quanto para a prova honesta. O veredito falado da IA era inútil para distinguir a diferença.

No entanto, quando os pesquisadores observaram as ativações internas da IA usando sua sonda, a história mudou. A sonda conseguia distinguir consistentemente entre o código quebrado e o código corrigido.

A Pontuação: Em 147 vulnerabilidades do mundo real que foram corrigidas alterando apenas uma função, a sonda classificou corretamente o código vulnerável como "mais arriscado" do que o código corrigido de 61% a 67% das vezes em todos os cinco modelos.
A Comparação: Isso superou as próprias respostas faladas da IA todas as vezes. Mesmo quando os pesquisadores tentaram enganar a IA para que ela pensasse mais profundamente, pedindo que ela explicasse seu raciocínio passo a passo (uma técnica chamada "Cadeia de Pensamento" ou Chain of Thought), a IA ainda falhou em distinguir o código ruim do código bom em sua saída escrita.
A Significância: O artigo observa que, embora 61–67% não seja uma pontuação perfeita (não é 100%), é estatisticamente significativa. É melhor do que um palpite aleatório (que seria 50%) e prova que existe um "sinal de segurança" dentro do modelo que a própria saída do modelo esconde.

O Que Isso Significa (e o Que Não Significa)

O artigo descarta explicitamente a ideia de que simplesmente pedir à IA para ser um revisor de segurança seja suficiente. O autor mostra que, mesmo com truques avançados de prompting, os vereditos escritos de "Sim/Não" da IA são frequentemente errados ou iguais, tornando-os não confiáveis para detectar diferenças sutis entre o código quebrado e o corrigido.

O artigo sugere que o estado interno da IA carrega um "sinal de segurança de código" que está sendo ignoramente no momento. O autor é cuidadoso ao não chamar isso de um problema resolvido ou de uma solução mágica. Eles descrevem isso como um efeito "modesto, mas consistente" que se mantém em diferentes tipos de modelos de IA. Eles também observam que isso foi testado em código Python e tipos específicos de bugs, portanto, ainda não sabemos se funciona perfeitamente para todas as linguagens de programação ou para todo tipo de falha de segurança.

A Conclusão

Em termos simples, este artigo descobriu que agentes de codificação de IA podem estar nos "mentindo" quando dizem que seu código é seguro, mas suas "ondas cerebrais" internas estão dizendo a verdade. Ao ouvir esses sinais internos em vez de apenas ler a saída da IA, podemos construir melhores redes de segurança para a enorme quantidade de código que a IA está escrevendo agora. É um pouco como perceber que, embora um suspeito possa dizer "Eu não fiz isso", seu batimento cardíaco está acelerado de uma forma que conta uma história diferente. O autor espera que, no futuro, possamos usar esses sinais de "batimento cardíaco" para sinalizar automaticamente códigos perigosos antes que eles cheguem a um revisor humano.

Resumo Técnico: Sondas de Ativação Revelam Sinais de Segurança em Código que o Output do Modelo Omissos

Declaração do Problema

Agentes de codificação de IA (ex: Claude Code, Cursor, OpenAI Codex) estão cada vez mais escrevendo código de produção, com auditorias empíricas indicando que 24–29% dos trechos de Python e JavaScript gerados por IA contêm fraquezas de segurança. A revisão de segurança humana não consegue escalar para acompanhar a taxa de geração de código, tornando necessária a triagem automatizada. No entanto, as verificações automatizadas atuais são insuficientes: analisadores estáticos sofrem com altas taxas de falsos positivos, e o uso de prompting em Large Language Models (LLMs) para obter vereditos binários de segurança não é robusto. Reescritas triviais de código podem inverter os vereditos do LLM, e os modelos frequentemente emitem respostas "SIM/NÃO" idênticas tanto para pares de código vulnerável quanto para o código corrigido, tornando seu output declarado inútil para distinguir o risco.

Além disso, os agentes de codificação mais utilizados são de pesos fechados (closed-weight), impedindo que as equipes de implantação inspecionem seus estados internos. As equipes podem, em vez disso, implantar modelos de pesos abertos (open-weight) como revisores, mas o prompting padrão desses revisores falha em detectar vulnerabilidades que os próprios estados ocultos do modelo podem codificar.

Metodologia

O autor investiga se sondas lineares aplicadas às ativações do fluxo residual de LLMs de código de pesos abertos podem recuperar sinais de segurança que os outputs induzidos por prompting dos modelos omitem.

Modelos e Dados

Modelos Revisores: Cinco LLMs de código de pesos abertos de quatro famílias de arquitetura foram avaliados: Qwen2.5-Coder (7B, 14B), DeepSeek-Coder (33B), Devstral-Small e Llama-3.1 (8B).
Dados de Treinamento (SVEN-Python): As sondas foram treinadas em funções Python pareadas (vulneráveis e corrigidas) do conjunto de dados SVEN, cobrindo quatro CWEs (Common Weakness Enumerations) específicas: 022, 078, 079 e 089.
Dados de Avaliação (PATCHEVAL): As sondas foram testadas zero-shot em 234 vulnerabilidades reais de Python (CVEs) do benchmark PATCHEVAL. Crucialmente, as CVEs usadas para avaliação continham tipos de CWE não vistos durante o treinamento (sem sobreposição com as quatro CWEs de treinamento).
Divisão de Dados: Para evitar vazamento de dados (data leakage), as divisões foram agrupadas por projeto/repositório, garantindo que nenhum código de um repositório específico aparecesse tanto no treinamento quanto na avaliação.

Ajuste da Sonda (Probe Fitting)

Arquitetura: Uma única sonda linear foi ajustada por modelo.
Entrada: As ativações foram extraídas da entrada da normalização de camada (layers[L].input_layernorm) usando nnsight.
Otimização: O autor realizou varreduras (sweeps) através de camadas, estratégias de agrupamento de tokens (média, máximo, último, sliding-window-max) e forças de regularização L2. A configuração que maximizou o AUC de 5-fold GroupKFold foi selecionada.
Tarefa: A sonda aprende a distinguir entre uma função vulnerável e sua contraparte corrigida baseando-se apenas nas ativações do estado oculto.

Métricas de Avaliação

Taxa de Vitória Pareada (Paired Win-Rate): Para cada CVE, a sonda pontua a função vulnerável ( $\hat{p}_{vul}$ ) e a função corrigida ( $\hat{p}_{fix}$ ). A taxa de vitória é a fração de casos onde $\hat{p}_{vul} > \hat{p}_{fix}$ .
Comparadores: A sonda foi comparada contra o output induzido por prompting do mesmo modelo sob três condições:
1. No-shot: Consulta direta sem exemplos.
2. Few-shot: Consulta com exemplos de tipos de fraquezas retidos.
3. Chain-of-Thought (CoT): Consulta exigindo raciocínio passo a passo antes de um veredito.
Métodos de Leitura (Readout Methods): Os comparadores foram avaliados usando tanto a leitura de logit (probabilidade YES/NO renormalizada) quanto a leitura de token (literal da string "yes"/"no").

Principais Resultados

1. Sondas Detectam Sinais Omitidos pelo Prompting

Nas vulnerabilidades reais e não vistas (CVEs de função única), a sonda linear consistentemente classificou a função vulnerável com pontuação superior à sua correção, alcançando uma taxa de vitória pareada de 61–67% em todos os cinco modelos. Este desempenho é estatisticamente significativo ( $p < 0.05$ ) e consistentemente acima da linha de 50% de chance.

Em contraste, os outputs induzidos por prompting dos modelos tiveram um desempenho insatisfatório:

Leitura de Logit: A taxa de vitória da sonda foi maior que a leitura de logit dos modelos via prompting para cada modelo sob cada condição de prompt. No entanto, embora a sonda tenha superado significativamente o prompting no-shot em três dos cinco modelos e o few-shot em quatro, a vantagem sobre o prompting de Chain-of-Thought (CoT) lido via logits foi estreita e estatisticamente significativa para apenas um dos cinco modelos. Apesar dessa margem estreita, a taxa de vitória da sonda permaneceu maior que a do CoT para todos os modelos.
Leitura de Token: Ao ler o veredito escrito literal, os modelos falharam em distinguir os pares em 72–97% dos casos, atribuindo a mesma palavra tanto para a função vulnerável quanto para a corrigida.

2. Generalização para Tipos de Fraqueza Não Vistos

As sondas, treinadas apenas em quatro CWEs específicas, generalizaram com sucesso para 234 CVEs com tipos de fraqueza inteiramente diferentes. Isso sugere que as sondas capturam um "sinal de segurança de código" generalizável, em vez de memorizar padrões de vulnerabilidade específicos.

3. Estado Interno vs. Output Declarado

O estudo confirma uma lacuna entre a representação interna de um modelo e o texto gerado. Enquanto a resposta declarada do modelo (token) frequentemente colapsa para um empate, a probabilidade interna (logits) e a sonda de ativação retêm um sinal capaz de classificar o risco. A sonda efetivamente "superficializa" um sinal de segurança que o próprio mecanismo de output do modelo descarta.

4. Desempenho In-Distribution

Na distribuição de treinamento (SVEN-Python), as sondas alcançaram um AUC de 0.77–0.85 e precisão de 0.72–0.77 em um limiar de 0.5, superando significativamente os modelos via prompting (precisão ~0.50).

Significância e Alegações

O artigo alega que as ativações do modelo carregam um sinal de segurança de código que o prompting do mesmo modelo omite.

Revisão Escalável: Os achados sugerem um caminho para controles de segurança auto-hospedados, onde um modelo de pesos abertos atua como revisor. Ao ler os estados ocultos deste revisor via uma sonda linear, as equipes podem sinalizar mudanças que merecem re-revisão humana sem precisar de acesso aos internos do agente de codificação de pesos fechados que gerou o código.
Superioridade ao Prompting: A sonda supera as estratégias de prompting no-shot e few-shot do mesmo modelo em vulnerabilidades não vistas. Embora a sonda também supere o prompting de Chain-of-Thought (CoT) em termos de taxa de vitória, a vantagem sobre o CoT é estreita e nem sempre estatisticamente significativa. A lacuna clara permanece sobre o prompting no-shot e few-shot.
Modesto mas Robusto: O autor caracteriza o efeito como "modesto" (taxas de vitória na casa dos 60 baixos), mas consistente entre arquiteturas e tipos de fraqueza. Eles afirmam explicitamente que integrar a sonda em um hook pós-escrita de um agente de codificação e calibrá-la para limiares absolutos são passos futuros necessários para a implantação.

O trabalho estende pesquisas anteriores sobre sondas lineares para detecção de segurança e vulnerabilidade ao demonstrar a transferibilidade para tipos de fraqueza e CVEs do mundo real, e ao comparar diretamente o desempenho da sonda contra as capacidades de raciocínio via prompting do próprio modelo.