O número que ninguém esperava ver num changelog

Junho de 2026 entrou para a história do Chrome. Em apenas duas releases (versões 149 e 150), o time de segurança do Google corrigiu 1.072 vulnerabilidades. Para colocar em perspectiva: nas 23 versões anteriores, lançadas ao longo de dois anos, o total acumulado era 1.036. Ou seja, um único mês superou dois anos inteiros de trabalho.

O responsável por esse salto absurdo não foi um exército de engenheiros recém-contratados. Foi um agente de IA baseado no Gemini, rodando 24 horas por dia contra o codebase do Chromium. E o que ele encontrou lá dentro assustou até os veteranos do projeto.

CVE-2026-3545: o bug que dormiu 13 anos

Entre as 1.072 falhas corrigidas, uma merece destaque especial. A CVE-2026-3545 recebeu nota 9.8 no CVSS (praticamente o máximo) e ficou escondida no Chrome por mais de 13 anos. Treze. Anos.

A vulnerabilidade estava no componente de navegação do browser. Com uma página HTML especialmente criada, um atacante conseguiria escapar do sandbox do Chrome e ler arquivos locais do computador da vítima. Em termos práticos: aquele sandbox que todo mundo confia como barreira de segurança? Um HTML malicioso bastava para furá-lo.

A falha foi classificada como “insufficient data validation in Navigation” e corrigida no Chrome 145, em maio de 2026. Mas o ponto aqui não é que ela foi corrigida. É que nenhum humano, em 13 anos de code reviews, auditorias e pentests, sequer percebeu que ela existia.

Como o Gemini virou caçador de bugs

O Google não simplesmente jogou o Gemini no código e disse “acha bugs”. A abordagem foi mais sofisticada: eles construíram o que chamam de “agent harness”, uma espécie de arnês que conecta o modelo de linguagem ao codebase do Chromium com contexto real.

Esse agente foi treinado com:

• O histórico completo de CVEs já reportados no Chrome
• Todo o Git history do projeto Chromium
• Arquivos SECURITY.md escritos pelos próprios desenvolvedores
• Um “agente crítico” que questiona os achados do modelo principal para reduzir falsos positivos

O fluxo funciona assim: o Gemini varre seções do código, compara padrões com vulnerabilidades conhecidas, identifica trechos suspeitos e gera um relatório. Um segundo agente (o crítico) avalia se o achado faz sentido ou é alarme falso. Só depois disso o bug vai para triagem humana.

Eu acho particularmente elegante a decisão de usar um modelo contra o próprio modelo. É como ter um dev sênior revisando o PR do júnior, só que ambos são IAs e o sênior foi treinado especificamente para ser cético.

Os 4 pilares do pipeline automatizado

O Google dividiu o pipeline de segurança em quatro estágios, todos turbinados por IA:

Descoberta

O agente Gemini varre o codebase continuamente, não apenas o código novo. Isso é crucial porque a maioria das ferramentas tradicionais (SAST, fuzzing) foca em código recém-commitado. O Gemini vai além: ele analisa features antigas que ninguém toca há anos, exatamente onde bugs como o CVE-2026-3545 se escondem.

Triagem

Aqui entra o trabalho mais tedioso da segurança: filtrar spam, descartar duplicatas, reproduzir provas de conceito, atribuir severidade e rotear o relatório para o dev certo. O Google estima que essa automação economiza centenas de horas de trabalho por mês.

Para quem já trabalhou com bug bounty ou triagem de vulnerabilidades, sabe que esse é o gargalo real. Não é achar o bug, é processar a avalanche de relatórios (muitos deles lixo) que chegam todo dia.

Correção

O Gemini não só encontra o problema como sugere patches. Não estamos falando de “insira um if aqui”. O modelo gera diffs contextuais que levam em conta a arquitetura do Chromium, os padrões de código do projeto e possíveis regressões.

Os engenheiros ainda revisam tudo antes do merge, claro. Mas a diferença entre receber um relatório dizendo “tem um bug na linha 4.523 do navigation.cc” e receber um patch pronto com explicação é brutal em termos de velocidade.

Deploy

O Google também está trabalhando em “dynamic patching”: a capacidade de aplicar correções de segurança sem reiniciar o browser. Hoje, quando o Chrome recebe um update de segurança, ele precisa ser reiniciado. Com dynamic patching, a correção seria injetada em runtime.

Isso ainda está em desenvolvimento, mas a combinação de descoberta automatizada + patches gerados por IA + deploy sem restart criaria um ciclo de segurança praticamente em tempo real.

Os números em contexto

O Chrome 151, lançado em julho, trouxe mais 370 correções. No ano de 2026, o total já passa de 1.800 vulnerabilidades corrigidas. Para comparação, o ano inteiro de 2025 teve cerca de 900.

A Microsoft também está no jogo

O Google não está sozinho nessa corrida. A Microsoft, no Patch Tuesday de junho de 2026, corrigiu 570 falhas de segurança em seus produtos, também citando ferramentas internas de IA como catalisador. A Apple, por sua vez, corrigiu 482 bugs ao longo de 2026, mais ou menos no ritmo de 2025.

Ranking de patches de segurança (2026, até julho):
1. Google Chrome      → 1.800+
2. Microsoft (total)  → 1.200+ (estimativa)
3. Apple (todos)      → 482

Fica claro que as empresas que adotaram IA para segurança estão corrigindo bugs num ritmo muito superior. A questão que surge é: esses bugs sempre estiveram lá, ou a IA está criando uma ilusão de insegurança?

Mais bugs ou mais visibilidade?

Essa é a pergunta que a comunidade de segurança está fazendo. Especialistas alertam há pelo menos dois anos que ferramentas de IA inevitavelmente revelariam vulnerabilidades em escala antes inimaginável. E é exatamente isso que está acontecendo.

Não é que o Chrome ficou mais inseguro. É que ele sempre teve esses bugs, só não tinha olhos suficientes para achá-los. O codebase do Chromium tem mais de 40 milhões de linhas de código. Nenhum time humano, por maior que seja, consegue auditar tudo. A IA consegue.

Isso traz um paradoxo interessante: quanto mais bugs você corrige, mais inseguro o produto parece no papel. O Chrome 150 corrigiu 500+ falhas, e a manchete vira “Chrome tinha 500 vulnerabilidades”. Mas a realidade é o oposto: o Chrome nunca esteve tão seguro, justamente porque essas falhas foram encontradas antes de serem exploradas.

É a mesma lógica de fazer exame de sangue todo mês. Você vai “descobrir” mais problemas do que quem nunca vai ao médico. Mas quem está mais saudável?

O que isso significa para outros projetos

Se o Google conseguiu esse resultado com o Chromium, imagine o potencial para outros projetos gigantes:

O Linux kernel tem mais de 30 milhões de linhas de código e um histórico de bugs dormindo por décadas (lembra do bug que o Claude encontrou depois de 23 anos?). Um agent harness similar varrendo o kernel poderia encontrar centenas de vulnerabilidades críticas.

O Firefox, com um codebase consideravelmente menor, já anunciou que está experimentando ferramentas de IA para segurança, mas ainda não publicou resultados comparáveis.

Projetos open source menores, que não têm budget para equipes de segurança dedicadas, são os que mais se beneficiariam. A Anthropic já fez algo parecido quando soltou IA em 1.000 projetos open source e encontrou 6.202 bugs críticos. A tendência é que esse tipo de auditoria automatizada se torne padrão.

O custo escondido

Tem um lado que ninguém está comentando: o custo computacional. Rodar o Gemini continuamente contra 40 milhões de linhas de código não é barato. O Google tem GPUs e TPUs sobrando, então para eles é viável. Mas para uma startup que quer adotar a mesma abordagem no seu codebase?

As ferramentas ainda não estão democratizadas. O Google fala em “agent harness” mas não liberou o código. A Anthropic liberou parcialmente seu framework de auditoria, e existem iniciativas open source como o Needle, mas nenhuma chega perto do nível de sofisticação do que o Google construiu internamente.

Por enquanto, a vantagem competitiva em segurança está com quem tem mais GPU e melhores modelos. E isso concentra poder nas mãos das mesmas big techs de sempre.

Fuzzing + LLM: a combinação que muda o jogo

Vale destacar que o Google não abandonou ferramentas tradicionais. O Gemini trabalha em conjunto com o OSS-Fuzz, o fuzzer open source do Google que já encontrou mais de 10.000 vulnerabilidades desde 2016.

A diferença é que o fuzzing clássico gera inputs aleatórios e espera que algo quebre. O LLM adiciona inteligência: ele entende o que o código deveria fazer, identifica padrões de vulnerabilidade conhecidos e gera inputs direcionados. É fuzzing com propósito em vez de fuzzing às cegas.

# Fuzzing tradicional (simplificado)
for i in range(1000000):
    input = generate_random_bytes()
    result = target_function(input)
    if result.crashed:
        report_bug(input)

# Fuzzing guiado por LLM (conceitual)
context = analyze_code_semantics(target_function)
known_vulns = get_similar_cve_patterns(context)
for pattern in known_vulns:
    inputs = llm.generate_targeted_inputs(pattern, context)
    for input in inputs:
        result = target_function(input)
        if result.crashed:
            report_with_context(input, pattern, context)

A segunda abordagem encontra bugs mais rápido porque não depende de sorte. Ela sabe onde procurar.

Dynamic patching: o futuro sem restart

Um detalhe que passou despercebido na maioria das análises é a menção ao dynamic patching. O Google está desenvolvendo a capacidade de aplicar correções de segurança no Chrome sem que o usuário precise reiniciar o browser.

Hoje, quando aparece aquela setinha de “Reiniciar para atualizar” no Chrome, muita gente ignora por dias. Isso significa que, mesmo com o patch disponível, milhões de usuários continuam vulneráveis até decidirem reiniciar.

Com dynamic patching, a correção seria aplicada em background, em runtime, sem interrupção. É tecnicamente complexo (você está modificando código em execução), mas o impacto na segurança real seria enorme.

O Firefox já experimentou algo similar com o “hot patching” no Gecko, mas nunca levou adiante. Se o Google conseguir implementar isso em produção, a janela de exposição entre “bug descoberto” e “usuário protegido” cai de dias para minutos.

Lições para quem mantém código legado

Se você trabalha em uma empresa com um codebase de mais de 5 anos, a história do Chrome tem lições diretas.

Primeiro: code review humano não escala. O CVE-2026-3545 passou por milhares de reviews ao longo de 13 anos. Ninguém pegou. Não porque os engenheiros do Google são incompetentes (longe disso), mas porque o volume de código simplesmente excede a capacidade de atenção humana.

Segundo: bugs de segurança não ficam mais seguros com o tempo. Pelo contrário. Quanto mais tempo um bug fica no código, mais provável que alguém mal-intencionado o encontre antes de você. A diferença é que agora a IA pode encontrar primeiro, se você usar as ferramentas certas.

Terceiro: a barreira de entrada está caindo. Você não precisa do budget do Google para começar. Ferramentas como o Semgrep com regras customizadas, o CodeQL do GitHub (gratuito para open source) e até prompts bem escritos no Claude ou GPT contra trechos críticos do seu código já conseguem pegar classes inteiras de vulnerabilidades.

Um exercício prático: pegue a função mais antiga do seu projeto, aquela que ninguém toca há 3 anos, e peça para uma IA analisar possíveis falhas de segurança. Aposto que você vai se surpreender.

O que esperar dos próximos meses

O ritmo não vai diminuir. O Chrome 152, previsto para agosto de 2026, provavelmente vai seguir com centenas de correções. O Google praticamente admitiu que ainda tem um backlog enorme de vulnerabilidades identificadas pela IA que estão sendo processadas.

Para desenvolvedores web, a mensagem é simples: mantenha seu Chrome atualizado. Com a quantidade de sandbox escapes e falhas de validação sendo corrigidas, rodar uma versão desatualizada nunca foi tão arriscado.

Para engenheiros de segurança, o recado é outro: as ferramentas de auditoria baseadas em IA não são mais experimentais. Elas estão em produção, encontrando bugs reais em escala industrial. Quem não adotar vai ficar para trás, simples assim.

E para quem acha que IA só serve para gerar código e chatbots? Bom, 1.072 bugs em 30 dias é um argumento difícil de ignorar.

Fonte de inspiração: Google Security Blog | TechCrunch | SecurityWeek