Líderes de pensamento
A IA está encontrando vulnerabilidades em velocidade vertiginosa. Corrigi-las é outra história.

Pontos-chaveA IA agora descobre zero-days mais rápido do que os defensores conseguem corrigi-los.
Ver mais
- A IA agora descobre zero-days mais rápido do que os defensores conseguem corrigi-los.
- Mais da metade dos patches gerados por IA falharam em corrigir a falha ou introduziram novas.
- Depender apenas de CVEs divulgados deixa os defensores reagindo aos prazos dos atacantes.
A cibersegurança enfrenta um novo problema e, ironicamente, ele é consequência da nossa capacidade de encontrar problemas mais rápido do que nunca.
Os modelos de IA de ponta estão ficando muito bons em descobrir e explorar vulnerabilidades de software. Isso significa que falhas que poderiam ter permanecido ocultas por anos estão sendo reveladas em uma velocidade que seria quase impossível de imaginar há poucos meses.
Mas o desafio é que o setor está ficando muito melhor em encontrar vulnerabilidades do que em corrigi-las. Veja a pesquisa da Anthropic mais recente. O modelo GLM-5.3, de pesos abertos, da Zhipu AI, desenvolveu com sucesso explorações funcionais de ponta a ponta em 50 das 410 tentativas no benchmark ExploitBench, enquanto o Claude Mythos Preview conseguiu fazê-lo em 56.
Essa é uma diferença extremamente pequena entre um modelo de ponta restrito e outro cujos pesos estão disponíveis abertamente. Recursos que antes exigiam pesquisadores de segurança altamente especializados estão se tornando acessíveis a um público muito mais amplo. Enquanto isso, o software que todos usamos não ficou subitamente menos vulnerável. Entramos em uma era em que encontrar uma vulnerabilidade de dia zero pode ser mais rápido do que o processo de corrigi-la.
As recentes vulnerabilidades do PHP2Shell são um exemplo emblemático. De acordo com a pesquisa da Wiz, da Calif e da equipe Codex Segurança da OpenAI, a IA de ponta ajudou um único pesquisador a descobrir falhas críticas no mecanismo do PHP em cerca de uma semana. Essas vulnerabilidades afetaram um ambiente de execução que sustenta uma parcela significativa da web, incluindo aplicativos desenvolvidos com WordPress, Drupal e Joomla.
Para as equipes de segurança, isso levanta uma questão urgente: o que acontece quando os invasores conseguem descobrir vulnerabilidades mais rápido do que os defensores conseguem corrigi-las?
O manual de gestão de vulnerabilidades não foi criado para isso
Durante anos, a gestão de vulnerabilidades seguiu um ritmo conhecido. Uma vulnerabilidade é descoberta, alguém a relata, um CVE é atribuído, uma correção é disponibilizada, os scanners a identificam, as equipes de segurança avaliam o risco, priorizam a correção e a implementam. Não é um processo perfeito, mas todo o ecossistema de segurança foi construído em torno dele.
O verdadeiro problema, porém, é que esse processo depende, em grande medida, de se conhecer a vulnerabilidade. Os scanners tradicionais são ótimos para indicar quais vulnerabilidades conhecidas existem no seu ambiente, mas e aquelas que ainda não foram divulgadas? Aquelas que não têm um CVE, um comunicado de segurança nem uma correção?
A divulgação do PHP2Shell mostra o quanto esse modelo nos deixa expostos. As duas vulnerabilidades críticas, CVE-2026-109618 e CVE-2026-109619, receberam classificação CVSS 9.2 e envolviam falhas de segurança de memória no próprio PHP. Pesquisadores demonstraram a execução remota de código e a divulgação de memória em aplicativos amplamente utilizados, incluindo WordPress, Drupal e Joomla. Até aplicativos com código seguro em todos os outros aspectos poderiam estar vulneráveis, pois a falha estava no ambiente de execução subjacente.
E a cronologia foi igualmente reveladora. Após um alerta público inicial, a equipe de segurança do PHP acelerou o cronograma de lançamento. Quando as correções foram disponibilizadas, já se observavam as primeiras tentativas de ataque.
Além disso, o PHP não foi o único problema daquele dia. Um ataque separado à cadeia de suprimentos de software comprometeu a versão 1.107.0 do LiteLLM, um gateway de código aberto popular para modelos de linguagem de grande porte. Os invasores inseriram um ladrão de informações e um trojan de acesso remoto no pacote Python publicado, enquanto o repositório de código-fonte do projeto permanecia limpo. Uma equipe que analisasse apenas o código-fonte não teria detectado de forma alguma a carga maliciosa.
Esses incidentes mostram como vulnerabilidades podem permanecer por anos profundamente ocultas em componentes de software confiáveis, enquanto código malicioso também pode entrar pelas dependências que as organizações instalam rotineiramente. Nenhum dos dois casos necessariamente tem origem no código do próprio aplicativo.
Isso também mostra como seu scanner pode indicar que está tudo em ordem, mesmo quando ainda há vulnerabilidades graves no software de que seus aplicativos dependem. Até recentemente, descobrir falhas ocultas em grande escala exigia muita experiência e recursos de pesquisa, mas a IA de ponta está mudando esse cenário.
Encontrar a falha é a parte fácil. E agora?
Há muito entusiasmo em torno da capacidade da IA de descobrir vulnerabilidades de dia zero. Com razão, pois o progresso é extraordinário. Mas acho que há exagero demais em torno de quantas vulnerabilidades a IA consegue encontrar e atenção de menos ao que acontece em seguida.
Encontrar uma vulnerabilidade não torna você mais seguro. Primeiro, é preciso comprovar que ela é real, pois as descobertas geradas por IA não são automaticamente válidas, e uma exploração aparentemente convincente nem sempre pode ser reproduzida. Depois, é preciso entender quais versões são afetadas, se a vulnerabilidade pode de fato ser explorada e que risco ela representa.
Em seguida, é preciso corrigi-la, e é aí que as coisas ficam particularmente interessantes. A pesquisa da 1Password analisou 6.080 correções geradas por IA e constatou que 53,9% não resolveram a vulnerabilidade original, introduziram uma nova falha de segurança ou fizeram as duas coisas.
Nesse estudo, mais da metade dos patches gerados apresentava um problema de segurança próprio. É claro que esses resultados refletem condições específicas de teste. Mas eles ilustram algo que todo engenheiro experiente sabe: escrever código que parece corrigir um problema e provar que de fato o corrige são duas coisas muito diferentes.
E, mesmo quando o patch está correto, o trabalho ainda não acabou. Ele vai comprometer alguma funcionalidade existente? Funciona com a versão mais antiga da biblioteca da qual seu aplicativo depende? É possível implantá-lo sem forçar uma atualização que introduza uma dúzia de outros problemas?
O que acontece quando é preciso implantá-lo em centenas de aplicativos, equipes e ambientes? Um patch que funciona em um ambiente de teste, mas nunca chega à produção, não protege ninguém. Essa é a grande lacuna que, na minha opinião, o setor de segurança precisa enfrentar.
Estamos acelerando a descoberta de vulnerabilidades em um ritmo vertiginoso, enquanto boa parte do trabalho necessário para transformar essas descobertas em proteção efetiva continua dolorosamente lenta. E essa lacuna está se tornando, por si só, um risco de segurança.
Então, como podemos realmente fechar essa lacuna?
Não acho que a resposta seja dizer às equipes de segurança, já sobrecarregadas, que trabalhem mais ou processem mais alertas. Precisamos repensar o que significa gerenciar vulnerabilidades de forma eficaz quando encontrar falhas deixa de ser o maior gargalo.
Eu começaria por estes quatro pontos.
1. Não trate o banco de dados de CVEs como o quadro completo
CVEs e scanners de vulnerabilidades são essenciais, mas registram o que sabemos — não tudo o que realmente existe. As equipes de segurança precisam começar a olhar além das vulnerabilidades divulgadas publicamente, combinando a varredura tradicional com pesquisa proativa, análise de código, inteligência sobre ameaças e um entendimento claro dos componentes de software dos quais suas organizações dependem.
Recursos como o catálogo de vulnerabilidades conhecidas e exploradas da CISA são valiosos para priorizar ameaças conhecidas, mas não podem informar sobre vulnerabilidades que ainda não foram divulgadas. O PHP2Shell mostrou que vulnerabilidades graves podem existir em softwares fundamentais durante anos antes de serem descobertas. Quando a IA de ponta consegue encontrar essas falhas em dias, depender exclusivamente de avisos publicados significa que os defensores estarão sempre reagindo no ritmo ditado por outra pessoa.
2. Reconheça que mais descobertas ≠ mais segurança
A IA pode gerar um volume enorme de possíveis descobertas, mas isso não significa que cada uma delas justifique interromper todo o trabalho de uma equipe de engenharia para investigá-la.
O verdadeiro valor está em saber quais vulnerabilidades são reais, exploráveis e relevantes para o seu ambiente. É possível reproduzir o problema? Quais versões são afetadas? Existe um caminho de ataque plausível? Qual é o impacto real para os negócios?
Sem esse contexto, as organizações correm o risco de priorizar vulnerabilidades apenas com base em pontuações de gravidade, sem considerar como os invasores poderiam de fato acessar sistemas e credenciais confidenciais.
3. Faça com que a correção possa ser implantada, e não apenas que esteja tecnicamente correta
Esse é um dos desafios mais subestimados na correção de vulnerabilidades. As empresas não operam em ambientes perfeitos, onde todas as dependências podem ser atualizadas para a versão mais recente da noite para o dia. Elas têm aplicativos legados, sistemas interconectados, requisitos de compatibilidade e versões de software que não podem simplesmente substituir.
Por isso, uma correção que exija que uma organização reconstrua metade da sua infraestrutura não é particularmente útil. Precisamos de maneiras melhores de adaptar patches de segurança a versões anteriores, preservar a compatibilidade, reduzir superfícies de ataque desnecessárias e distribuir atualizações pelas ferramentas e fluxos de trabalho que as equipes já usam.
As diretrizes da NIST para o gerenciamento de patches em empresas enfatizam a importância de identificar, priorizar, instalar e verificar atualizações. O desafio agora é tornar todo esse processo rápido o suficiente para acompanhar as descobertas impulsionadas pela IA, pois o melhor patch do mundo é inútil se ninguém puder implantá-lo.
4. Meça quanto tempo realmente leva para estar protegido
Se a IA descobrir hoje uma vulnerabilidade crítica, quanto tempo levará para validá-la, desenvolver um patch funcional, testá-lo e implantá-lo em produção?
A resposta ao PHP2Shell oferece uma referência útil. Na Echo, entregamos pacotes PHP corrigidos logo após a disponibilização dos patches upstream, e as imagens atualizadas para as versões compatíveis do PHP foram reconstruídas naquela mesma tarde.
As equipes de segurança devem medir todo o ciclo de correção, desde a descoberta e a validação até o desenvolvimento do patch, os testes de compatibilidade e a implantação. Elas devem saber com que rapidez conseguem reconstruir o software afetado, se conseguem identificar todos os aplicativos que usam uma dependência vulnerável e quanto trabalho manual é necessário para garantir a proteção.
À medida que a IA de ponta torna a descoberta de vulnerabilidades mais rápida e acessível, o intervalo entre a descoberta e a possível exploração continuará a diminuir. Não podemos presumir que os ciclos tradicionais de divulgação e aplicação de correções conseguirão acompanhar esse ritmo. A próxima era da gestão de vulnerabilidades será definida por quem conseguir transformar essas descobertas em correções confiáveis e prontas para implantação antes que os invasores tenham a oportunidade de agir.












