Gestão de vulnerabilidades com IA

Os modelos avançados de IA mudaram a velocidade e a escala com que as equipes de segurança e os invasores encontram vulnerabilidades. A IA pode encontrar vulnerabilidades em minutos, e os invasores podem explorar essas vulnerabilidades mais rápido do que nunca.

No Google, transformamos o gerenciamento de vulnerabilidades usando a IA, como demonstrado nos projetos Naptime e Bigsleep. Usamos a IA para verificar, identificar e corrigir vulnerabilidades na nossa própria infraestrutura. Também trabalhamos com parceiros do setor, como mantenedores de código aberto, fornecedores de chips e fabricantes de hardware, para encontrar e corrigir bugs com IA antes que eles possam ser explorados.

Este documento descreve como encontrar e corrigir vulnerabilidades nos seus aplicativos adotando tecnologias de IA que ajudam você a fazer o seguinte:

  • Desenvolver um programa de defesa contra ameaças de IA.
  • Verifique vulnerabilidades externas.
  • Priorize recursos e problemas.
  • Corrija vulnerabilidades críticas.
  • Monitore usando playbooks de resposta ativa.

Criar um programa de defesa contra ameaças com IA

As ameaças de IA diferem das convencionais em tempo e escala. Os processos manuais de desenvolvimento, teste e implantação de correções para seus aplicativos não são mais suficientes. Em vez disso, implemente novas estratégias que incluam gerenciamento automatizado de patches, monitoramento contínuo, integração mais estreita com pipelines de desenvolvimento e modernização de software.

Para mudar a abordagem da sua organização em relação à gestão de vulnerabilidades, considere os princípios a seguir:

  • A gestão de vulnerabilidades precisa incluir opções de IA e agênticas.
  • Todo o software precisa receber patches.
  • Os controles precisam descobrir e governar continuamente a IA sombra, integrações internas não autorizadas de APIs, extensões de navegador e ferramentas locais gerenciadas por desenvolvedores.
  • A definição de risco crítico da sua organização precisa reconhecer que os modelos podem explorar caminhos de ataque, não apenas vulnerabilidades únicas.
  • Sua organização precisa ser capaz de tomar medidas corretivas em minutos.

Para criar um programa de defesa contra ameaças de IA, você precisa do apoio de executivos e de parceiros de colaboração nas equipes de desenvolvimento, operações, segurança e negócios. Como parte do seu plano inicial, faça o seguinte:

  • Estabeleça governança e propriedade claras, incluindo um comitê, funções e processo de tomada de decisões definidos.
  • Defina resultados e métricas principais (como adesão ao SLA, volume de exceções e cobertura de recursos) para acompanhar o progresso e informar a liderança executiva.
  • Crie políticas, SLAs e processos de exceção.

O diagrama a seguir mostra as fases para criar um programa eficaz de defesa contra ameaças de IA. Cada fase é descrita nas seções restantes deste documento.

Fases do programa de defesa contra ameaças de IA.

Para ajudar você a criar e implementar um programa de defesa contra ameaças, entre em contato com a consultoria de cibersegurança da Mandiant.

Fase 1: preparação

Antes de implantar verificadores de vulnerabilidade de IA em toda a base de código, avalie o risco para seus recursos. Priorize os tipos de verificações e recursos que você precisa verificar usando a IA para não sobrecarregar seu pipeline de triagem.

Verificar exposições externas

Os ativos mais vulneráveis a ameaças de IA são aqueles voltados à Internet, como:

  • VMs do Compute Engine
  • Cloud Run functions
  • Clusters do Google Kubernetes Engine (GKE)
  • buckets públicos do Cloud Storage;

Para manter uma lista abrangente desses recursos ao longo do tempo, ative a descoberta contínua usando um produto como o Wiz Red Agent. A descoberta contínua é um processo automatizado e constante que verifica os recursos em tempo real à medida que são criados ou alterados. O Wiz Red Agent pode verificar proativamente sua rede voltada para a Internet para encontrar aplicativos da Web ativos, APIs expostas publicamente, software criado sob medida e até mesmo aplicativos codificados por vibração.

Depois de encontrar um recurso, o Wiz Red Agent pode simular ataques reais para encontrar vulnerabilidades e criar cadeias de ataque. Quando o Wiz Red Agent encontra uma vulnerabilidade, ele envia os dados para o Wiz Security Graph. Com o gráfico de segurança da Wiz, é possível ver a quais recursos internos o recurso voltado à Internet está se conectando. Assim, você pode mapear o possível impacto de uma violação externa.

Por exemplo, suponha que um desenvolvedor crie um ambiente de teste para um novo chatbot. O desenvolvedor quer testar como o chatbot interage com dados em tempo real e implanta um protótipo usando o Cloud Run. Para simplificar os testes, o desenvolvedor permite invocações não autenticadas, o que torna o protótipo público. O desenvolvedor conecta um bucket temporário do Cloud Storage que contém um instantâneo de dados reais do usuário ao protótipo. No entanto, o desenvolvedor esquece de excluir o ambiente de teste.

Neste exemplo, o Wiz Red Agent pode encontrar o novo subdomínio *.run.app e sinalizar o recurso como voltado para a Internet usando a capacidade de descoberta contínua. O Wiz Red Agent pode interagir com o protótipo de chatbot para determinar que ele está conectado a um endpoint de API. O Wiz Red Agent simula vários ataques, como um ataque de injeção de comandos, para determinar vulnerabilidades. Como o desenvolvedor não configurou a segurança adequada, o Wiz Red Agent encontra uma vulnerabilidade e determina que ela pode se mover lateralmente para o bucket do Cloud Storage. O Wiz Red Agent envia os dados ao Wiz Security Graph, que sinaliza essa vulnerabilidade como uma prioridade crítica. Seus processos podem desligar esse protótipo em minutos.

Priorizar recursos para verificação detalhada de código

A verificação de código avançada rastreia o fluxo de dados e o código-fonte para encontrar erros estruturais e backdoors de segurança enquanto os desenvolvedores ainda estão escrevendo o software. No entanto, a verificação profunda de código é um processo demorado e que consome muitos recursos para implementar em todo o código.

Para priorizar quais bases de código exigem uma verificação completa, crie um inventário de todos os repositórios por plataforma ou ambiente, como SaaS ou auto-hospedado. Considere o seguinte:

  • A acessibilidade do seu código-fonte ou binários (se eles estão disponíveis publicamente ou são internos). Se os seus binários estiverem disponíveis publicamente, não haverá proteção real contra engenharia reversa com tecnologia de LLM.
  • A linguagem de programação (se o código está em uma linguagem segura em termos de memória, como Go, Rust, Java ou Python).
  • Os privilégios necessários para a execução do código.
  • A sensibilidade dos recursos que o código precisa acessar.

Implemente a verificação de código avançada para o código de maior risco: aquele que é acessível publicamente, usa linguagens com segurança de memória comprometida, exige privilégios altos para ser executado e precisa acessar dados altamente sensíveis.

Além disso, determine se você pode tomar outras medidas de mitigação para ajudar a proteger seu código. Considere o seguinte:

  • Antes de verificar componentes legados ou subutilizados, avalie se eles podem ser desativados ou descontinuados completamente, eliminando o ônus de manutenção e segurança. Em alguns casos, é possível migrar para alternativas com uma superfície de ataque menor.
  • Revise o estado do patch. Se o patch estiver atrasado, priorize o upgrade dessas dependências para versões modernas compatíveis.
  • Como uma estratégia de priorização de longo prazo, identifique componentes críticos escritos em linguagens sem segurança de memória e procure alternativas com segurança de memória. Se não houver alternativas mais seguras, considere colocá-las em um roteiro para reescritas em linguagens que protegem a memória para reduzir as vulnerabilidades. A curto prazo, considere o sandbox como uma mitigação de riscos, como o GKE Sandbox.

Para ajudar a priorizar recursos, use os recursos do Wiz, como:

  • Catálogo de serviços do Wiz e inventário do Wiz para determinar os riscos de exposição e impacto associados aos seus recursos.

    O inventário do Wiz descobre automaticamente recursos como máquinas virtuais, bancos de dados e repositórios de código. O inventário do Wiz pode determinar se um recurso é acessível publicamente, processa entradas de usuários não confiáveis ou tráfego de API externa e o ambiente em que o recurso está sendo executado. O catálogo de serviços da Wiz pode agrupar esses recursos em serviços comerciais (por exemplo, o sistema de faturamento ou o portal do cliente) que você pode atribuir como proprietário. Esses grupos ajudam a identificar quais ativos são sistemas comerciais críticos, quais sistemas têm acesso a dados sensíveis e quem é responsável pelo aplicativo.

  • Wiz Security Graph e Wiz Workload Scanner para identificar os repositórios de código-fonte usados em um ambiente de produção ativo.

    O Wiz Workload Scanner analisa seu ambiente para determinar se o código está sendo executado nele e rastreia a linhagem do software. O grafo de segurança do Wiz descobre combinações tóxicas para determinar se um possível problema é de alto risco. Use essas informações para priorizar a verificação profunda de código em caminhos de ataque de alto risco e possíveis vulnerabilidades de movimentação lateral.

  • O pipeline de código para nuvem do Wiz mapeia a linhagem de um recurso em produção.

    O pipeline de código para nuvem da Wiz pode priorizar o código ativo e acessível em produção, determinar o repositório de origem das vulnerabilidades e proteger as configurações de infraestrutura como código (IaC). Com o pipeline Code-to-Cloud do Wiz, é possível vincular seu repositório de código ao uso real.

Fase 2: verificação e priorização

Depois de criar seu programa e priorizar os recursos com base no risco, use a IA para encontrar e triar as vulnerabilidades no seu ambiente.

Concluir a verificação avançada da sua base de código

Ao concluir a verificação completa de código, você usa o raciocínio avançado de IA para encontrar falhas complexas, associar as falhas a vulnerabilidades na nuvem e reduzir os falsos positivos. Conclua os seguintes tipos de verificações:

  • Verificações de valor de referência: verifique continuamente o código no seu IDE e pipeline de CI/CD para encontrar erros de programação comuns, segredos codificados e dependências vulneráveis.
  • Verificações de IA avançadas: analise bases de código altamente críticas com lógica de negócios complexa e identifique vulnerabilidades encadeadas ou de dia zero que a SAST pode perder.

Para concluir uma verificação de baseline, use o Wiz Code para verificar segredos, encontrar erros de configuração de IaC, concluir testes estáticos de segurança de aplicativos (SAST) e identificar riscos de segurança em softwares de terceiros usando análise de composição de software (SCA).

O Wiz Code ajuda a aplicar suas políticas de segurança avaliando o código no plano de ação de CI/CD e bloqueando builds que não atendem aos seus padrões. O Wiz Code pode verificar seu inventário para determinar quais vulnerabilidades podem ser acessadas na produção. Quando o Wiz Code encontra uma vulnerabilidade, o Wiz Green Agent analisa automaticamente o código ao redor e cria um patch para resolver o problema. Se o problema for encontrado no ambiente de desenvolvimento integrado (IDE) do desenvolvedor, o Green Agent poderá refatorar o código antes que o desenvolvedor faça o commit da mudança no pipeline. Se um problema for encontrado no pipeline de CI/CD, o Wiz Green Agent poderá criar automaticamente uma solicitação de envio no GitHub ou GitLab com o patch de código.

Para concluir uma verificação detalhada de IA, implante o CodeMender (prévia) com a Gemini Enterprise Agent Platform. O CodeMender (desenvolvido pelo Google DeepMind) é um agente de engenharia de IA autônomo e altamente especializado, focado em raciocínio, depuração e correção de código em profundidade. O CodeMender age como um engenheiro de software sênior autônomo que extrai código para um sandbox, executa vários testes e corrige a lógica principal. As execuções de teste podem incluir análise dinâmica, teste de fuzzing e teste de compilação automatizada. O CodeMender pode priorizar bugs de forma autônoma com base no impacto estrutural, corrigir problemas e refatorar o código usando um método iterativo.

Triagem e planejamento da correção

Depois de compilar uma lista de vulnerabilidades, é possível encaminhar as descobertas do Wiz Code e do CodeMender para mecanismos como o Wiz SAST Triage AI Engine (em inglês) para melhorar as descobertas e ajudar a determinar se os vetores de ataque são exploráveis. O Wiz Security Graph também pode ajudar a enriquecer o contexto usando o pipeline de código para nuvem. O Wiz Red Agent pode testar o site ativo e validar o caminho de ataque.

Depois de concluir o trabalho de triagem, considere as seguintes recomendações para ajustar os agentes de IA e remover falsos positivos:

  • Peça aos engenheiros sênior para analisar uma pequena amostra aleatória de descobertas para identificar padrões, esclarecer limites de confiança e refinar seus processos de IA.
  • Crie habilidades de IA com base no seu guia de denúncia de vulnerabilidades, que define o que sua organização considera uma vulnerabilidade real, e não um falso positivo ou um bug não relacionado à segurança.
  • Use um agente de IA para planejar e escrever casos de teste e executá-los em um ambiente de sandbox.
  • Execute seus agentes de IA com base em novas descobertas de amostras e ajuste seus comandos e habilidades de IA até que correspondam às suas decisões humanas.

Se provar que uma vulnerabilidade é explorável levar mais tempo do que implementar uma correção de baixo risco, pule o processo de reprodução e vá para a etapa de correção.

Fase 3: correção

Para corrigir problemas, implemente fluxos de trabalho de alta velocidade que possam verificar, corrigir e validar vulnerabilidades de forma autônoma em grande escala no ambiente de desenvolvimento integrado (IDE) do desenvolvedor, no repositório de código e no ambiente de produção.

O Wiz Green Agent pode criar automaticamente um plano de correção com base nos dados disponíveis. Ele aciona os fluxos de trabalho do Wiz para alertar as equipes de SecOps usando o sistema de tíquetes e enviar o plano de correção ao CodeMender. O CodeMender cria o patch, testa a correção em uma sandbox segura para evitar regressões e cria a solicitação de envio para corrigir seu sistema. Em seguida, um desenvolvedor pode revisar a solicitação de envio e clicar para implantar a mudança.

Embora as práticas principais para atualizar dependências não sejam novas, manter um sistema de patch automatizado e saudável é uma necessidade crítica para lidar com o grande volume de patches gerados pela descoberta orientada por IA. Sua organização precisa estar preparada para ingerir atualizações rapidamente sem interromper os sistemas de produção.

Recomendamos as seguintes práticas para otimizar o processo de correção:

  • Estabeleça a visibilidade das dependências: mantenha um inventário contínuo das dependências de software.
  • Automatize seu build e o mecanismo de lançamento: depois que o trabalho de teste e qualificação for concluído, minimize as etapas manuais necessárias para lançar o código e iniciar os upgrades.
  • Estabeleça uma cadência de upgrade contínuo: manter as dependências atualizadas regularmente minimiza o delta de código quando um patch de segurança é lançado. Um delta menor significa menos risco de mudanças incompatíveis e tempos de implantação mais rápidos durante um patch de emergência.
  • Testar lançamentos com implantações canário: implemente implantações canário automatizadas e mecanismos de reversão robustos para upgrades de dependência. As implantações canário permitem testar patches em produção com impacto mínimo.

Modernizar seu software

A transição de um fluxo de trabalho de desenvolvimento convencional para um framework agêntico exige a orquestração de agentes de IA especializados focados em tarefas específicas, como criação de conteúdo, geração de testes e auditoria de segurança. Os exemplos a seguir descrevem como você pode introduzir agentes de IA no ciclo de vida de desenvolvimento de software:

  • Desenvolvimento: os desenvolvedores projetam e criam protótipos de aplicativos com comandos de linguagem natural na CLI ou no chat do ambiente de desenvolvimento integrado.
  • Criação: os processos de IA ajudam os desenvolvedores a gerar ou modificar códigos atuais com preenchimentos de código.
  • Testar e manter: desenvolvedores e equipes de controle de qualidade usam testes e refatoração automatizada com tecnologia de IA.
  • Revisão e implantação: os desenvolvedores usam revisões de código com tecnologia de IA e suporte para infraestrutura como código.
  • Solução de problemas: os desenvolvedores usam a análise de problemas com tecnologia de IA em ferramentas como o Firebase Crashlytics para falhas e erros.
  • Operar: desenvolvedores e engenheiros de software usam agentes de IA para entender e modificar aplicativos atuais.

Com a modernização de software, a segurança e a mitigação de dívidas técnicas são transferidas para a esquerda, para agentes autônomos projetados para fazer pequenas mudanças iterativas no ambiente. A modernização de software depende de servidores do Protocolo de Contexto de Modelo (MCP), que oferecem aos modelos acesso direto e em tempo real a ferramentas externas e dados ambientais ativos.

Para reduzir o risco de código não seguro no início do ciclo de vida do desenvolvimento de software, implante agentes independentes que possam analisar dependências durante o planejamento, gerar testes de unidade usando integrações de ferramentas e realizar revisões de código automatizadas diretamente no repositório de origem. Ao incorporar regras específicas do projeto, habilidades especializadas e hooks de comando deterministas diretamente no espaço de trabalho do desenvolvedor, os agentes de programação se tornam a principal linha de frente para a redução de riscos. Para forçar os agentes a seguir as etapas corretas, use scripts deterministas e invoque revisões por pares usando agentes separados e especializados. Os agentes especializados podem incluir um agente de verificação de segurança, um agente de depuração ou um agente de simulação de ataque automatizada.

Para ajudar na modernização de software, ferramentas como o Google Antigravity e o Gemini Code Assist podem funcionar como colaboradores independentes que capturam, testam e corrigem problemas antes da revisão humana ou da criação de pipelines centrais. O Google Antigravity oferece um gerenciador de agentes completo e uma experiência de IDE, e o Gemini Code Assist na CLI do Gemini oferece uma CLI de terminal para execução sem interface gráfica. Você pode usar várias habilidades do agente no Wiz e em outros produtos do Google para ajudar no seu processo de desenvolvimento. A Agent Platform inclui modelos, como o Gemini 3.5 Pro e o Flash, que oferecem raciocínio em várias etapas, janelas de contexto longo e execução de ferramentas integrada.

Para aumentar a velocidade de desenvolvimento, use agentes que possam planejar de forma incremental, testar continuamente e verificar pequenas mudanças localmente antes de fazer o commit. Esses agentes ajudam a garantir a estabilidade da base de código e fazem rollbacks quando os commits são pequenos e isolados.

Reforçar sua base de segurança

Antes de introduzir agentes no seu ambiente, verifique se você reforçou adequadamente sua infraestrutura e o pipeline de SDLC. Considere as seguintes ações para criar uma base segura:

  • Configure políticas e controles de acesso para ter visibilidade dos componentes de software, detectar vulnerabilidades e corrigir problemas antes de implantar o software em produção.
  • Use imagens de base reforçadas com VM protegida, computação confidencial e WizOS para proteger as camadas de aplicativo, SO e hardware.
  • Monitore estações de trabalho de desenvolvedores e executores de build de CI/CD usando o sensor de tempo de execução do Wiz para detectar ataques ativos de pipeline de CI/CD e fornecer contexto ativo na memória.
  • Encontre e corrija desvios do seu serviço de postura de segurança para manter um ambiente consistente com suas políticas de segurança.
  • Configure um gateway seguro para uso de código aberto e aplique suas políticas de segurança usando os conectores do Wiz Registry.
  • Isole os ambientes de desenvolvimento, preparo e produção usando segmentação de rede e regras de firewall rigorosas.
  • Armazene todos os registros de pipeline, implantação e acesso em um local de armazenamento centralizado e imutável para monitoramento contínuo e análise forense.
  • Trate o pipeline de CI/CD como uma infraestrutura imutável para evitar adulterações e desvios de configuração. A infraestrutura imutável também exige o uso de executores temporários e de curta duração que não permitem que um invasor ganhe uma posição permanente na sua infraestrutura.
  • Armazene todas as mudanças em aplicativos e clusters em repositórios de origem que permitem o controle de versão e a revisão antes da implantação.

Para mais práticas recomendadas, consulte Google Cloud plataforma mínima viável e segura.

Aumentar a proteção do seu SDLC

O framework de IA segura (SAIF) descreve os controles que você precisa implementar para garantir o uso seguro da IA no pipeline do ciclo de vida de desenvolvimento de software (SDLC, na sigla em inglês). Ao adicionar IA, considere o seguinte:

  • Os humanos precisam manter o controle para garantir a responsabilização e evitar que os agentes ajam de forma autônoma em situações críticas sem supervisão ou atribuição humana clara. Você precisa de identidades de agente distintas, mecanismos de consentimento do usuário e entradas seguras.
  • As permissões dos agentes precisam ser limitadas para garantir que eles só possam concluir a finalidade pretendida e não aumentar os privilégios de maneira inadequada. Você precisa configurar controles de acesso adequados, gerenciamento de credenciais com escopo e usar sandboxing para isolar os componentes de maneira adequada.
  • Todas as ações precisam ser observáveis para garantir transparência e auditabilidade, além de permitir decisões de segurança e compreensão do usuário.

Ataques à cadeia de suprimentos podem comprometer um agente confiável para modificar um banco de dados crítico, adulterar código ou expor segredos de produção. Para mitigar, os pipelines de SDLC que usam IA dependem de práticas recomendadas de segurança, como:

  • Configurações de ambiente de desenvolvimento integrado e espaço de trabalho que controlam extensões do navegador, utilitários de CLI e plug-ins do ambiente de desenvolvimento integrado para evitar que assistentes de programação de IA não autorizados exfiltrem linhas de base de código proprietárias para endpoints de modelos externos não testados.
  • Controles de acesso rígidos para evitar modificações não autorizadas. Controles rigorosos de autenticação e do Identity and Access Management (IAM) ajudam a garantir que você conceda às contas de serviço do pipeline, incluindo as contas de agente, apenas as permissões mínimas obrigatórias, aplique a autenticação multifator a todos os usuários humanos e revise regularmente o acesso que usuários e agentes têm para garantir que ele permaneça atualizado.
  • Proteções de código-fonte e configuração para garantir que códigos maliciosos ou acidentais nunca cheguem à fase de build. Considere o seguinte:
    • Verifique se as ramificações e os pedidos de envio ou mesclagem são revisados por colegas autorizados, principalmente revisores humanos.
    • Não permita opções de bypass para mesclagem.
    • Verifique se todas as confirmações estão assinadas para verificar a autenticidade do código e evitar adulterações não autorizadas.
    • Restrinja a capacidade de fazer fork de código interno ou tornar repositórios privados públicos por acidente.
  • Gerenciamento dinâmico de secrets para evitar o comprometimento de credenciais. Para processar secrets de forma dinâmica, elimine senhas, chaves de API e tokens codificados no código-fonte e nos arquivos de configuração. As ferramentas automatizadas de verificação de secrets nos seus arquivos de configuração e IaC ajudam a encontrar secrets antes que os commits sejam aceitos. O Secret Manager permite injetar credenciais dinamicamente no ambiente de execução.
  • Automação da verificação de segurança no pipeline para detectar vulnerabilidades antecipadamente. Considere uma estratégia de teste que inclua SAST, SCA e DAST para encontrar vulnerabilidades durante o desenvolvimento, em bibliotecas de terceiros e ao executar aplicativos.
  • Pacotes de aplicativos protegidos para evitar adulterações. Use o controle de versão imutável para seus pacotes de build e verifique imagens e pacotes de contêiner antes de enviá-los ao registro de artefatos. Promova as mesmas imagens de contêiner em todos os ambientes, incluindo desenvolvimento, preparação e produção.

Fase 4: monitoramento

Como os ataques com agentes mudam rapidamente o cenário de ameaças, é necessário monitorar continuamente os processos e identificar oportunidades de automação. Você também precisa detectar e responder a ameaças criadas por vulnerabilidades no código, não importa onde ele esteja. Para monitorar ameaças com eficácia, é necessário garantir que os sensores estejam instalados, estabelecer métricas adequadas, concluir execuções de simulação e usar playbooks de resposta ativa ensaiados.

O Wiz Defend se integra ao Google Security Operations para melhorar seus fluxos de trabalho do SOC com alertas e contexto da plataforma Wiz. O Wiz Defend monitora o comportamento de tempo de execução, as configurações de nuvem, as identidades e as vulnerabilidades diretamente no ambiente de nuvem. O Wiz Defend organiza alertas em tempo real e processa evidências forenses em detecções de alta fidelidade e ameaças consolidadas. O Wiz Blue Agent pode investigar os dados para determinar se uma ameaça é real. Em seguida, o Wiz pode enviar alertas priorizados para o Google SecOps para outras atividades de resposta.

O Google SecOps pode ingerir telemetria de todo o seu ambiente para correlacionar eventos e coordenar playbooks de resposta. Essa telemetria inclui servidores locais, provedores de identidade SaaS, endpoints, firewalls e ambientes multicloud. O Google SecOps inclui um SOC de agentes que pode investigar alertas automaticamente para fornecer mais contexto. Os analistas podem fazer perguntas em linguagem natural, e o agente pode fornecer contexto técnico, telemetria e recomendações sobre como resolver problemas. O agente também pode automatizar a criação e o gerenciamento de regras de detecção de ameaças, identificar lacunas de detecção e gerar regras de detecção automaticamente para essas lacunas.

A inteligência contra ameaças com agentes pode usar dados da Mandiant e do VirusTotal para acelerar as investigações. A inteligência contra ameaças agênticas automatiza tarefas complexas e demoradas, como engenharia reversa de código, análise de malware e geração de resumos personalizados de ameaças, liberando as equipes de segurança para outros trabalhos importantes.

O diagrama a seguir mostra como as várias ferramentas de monitoramento funcionam juntas para adicionar contexto, concluir tarefas automatizadas e priorizar alertas.

Ferramentas de monitoramento de ameaças de IA.

A seguir