Agentes de programação como o Copilot, o Claude Code, o Cursor, o Devin e o Codex já abrem pull requests por iniciativa própria. Uma pessoa continua a revê-los, e essa pessoa lê o diff: a lógica, os testes, os nomes. Vale a pena fazer essa revisão, mas não é aí que surge a maior parte do risco da cadeia de fornecimento.

As alterações que mais podem prejudicar a sua equipa são as que um diff mostra pior. Uma edição de uma linha num manifesto pode trazer um pacote de que ninguém ouviu falar. Uma alteração ao lockfile estende-se por centenas de linhas que ninguém lê. Um script de instalação nem sequer aparece no diff, e o mesmo acontece com um ficheiro que o build descarrega durante o build. Este artigo aborda as verificações que uma equipa pode colocar entre o pull request de um agente e um lançamento, e o que cada uma deteta.

O diff é o sítio errado para procurar o risco da cadeia de fornecimento

A revisão de código foi pensada para código que uma pessoa escreveu e consegue explicar. Com um agente, o autor não lhe consegue dizer porque escolheu um pacote, e o revisor sente-se tentado a aprovar uma alteração que compila e passa nos seus testes. Há quatro tipos de alteração que merecem mais atenção do que recebem:

  • Dependências novas ou alteradas. A linha do manifesto é curta; o que ela traz não é.
  • Alterações em massa no lockfile. Centenas de versões resolvidas e hashes, normalmente recolhidos por predefinição na interface de revisão.
  • O que o build faz, não o que o repositório contém. Scripts de instalação, scripts de build que descarregam ficheiros, imagens base, curl num passo de um workflow.
  • Ficheiros de workflow. Uma alteração em .github/workflows/ altera o que é executado com os seus segredos.

Nenhuma destas situações exige que o agente esteja comprometido. Um modelo que escreve código plausível também escreve nomes de pacotes plausíveis, e um nome plausível é tudo o que um atacante precisa.

Dependências novas: verifique se o pacote é real

Os modelos de linguagem por vezes sugerem pacotes que não existem. Um estudo apresentado na USENIX Security 2025 gerou 576 000 amostras de código com 16 modelos e concluiu que pelo menos 5,2 % dos pacotes sugeridos por modelos comerciais, e 21,7 % dos sugeridos por modelos open source, não existiam, com 205 474 nomes inventados únicos. Registar esses nomes e esperar chama-se slopsquatting. É typosquatting sem o erro de digitação, e um agente que instala pacotes por iniciativa própria elimina a pessoa que poderia ter reparado.

Antes de fazer o merge de um pull request que adiciona uma dependência, verifique:

  • Se existe e é aquela que pretendia. Compare o nome, carácter a carácter, com o do projeto que o agente estava a tentar usar.
  • A sua antiguidade. Um pacote ou uma versão publicados há poucos dias merecem desconfiança. A definição minimumReleaseAge do pnpm recusa versões publicadas há menos de um determinado número de minutos, incluindo as transitivas.
  • Quem está por trás. Um repositório de código-fonte associado, um histórico de versões e mais do que um maintainer não provam que é seguro, mas a sua ausência é um sinal de alerta.
  • Se precisava mesmo dele. Os agentes adicionam pacotes para coisas que a biblioteca padrão ou uma dependência existente já fazem. Ter menos dependências é o controlo mais barato que existe.

A dependency review action do GitHub é executada em pull requests, lista as alterações de dependências e pode fazer falhar a verificação perante vulnerabilidades conhecidas ou licenças não permitidas. Não sabe nada de um pacote publicado ontem sem qualquer aviso de segurança, pelo que complementa as verificações acima em vez de as substituir.

Alterações ao lockfile: leia-as e saiba o que deixam de fora

Um lockfile fixa as versões exatas e os hashes de integridade que o seu gestor de pacotes resolveu. No pull request de um agente, é o registo mais preciso do que mudou, por isso torne-o visível: expanda-o na revisão e faça falhar o build quando o lockfile e o manifesto não coincidem (npm ci, pnpm install --frozen-lockfile).

Duas coisas a procurar:

  • Uma origem alterada. Um pacote que antes era resolvido a partir do seu registo interno e agora é resolvido a partir do público é o padrão por trás da confusão de dependências. Associe os pacotes internos ao seu registo através de um scope, para que o registo público nunca seja consultado.
  • Saltos transitivos. Uma pequena atualização direta pode mover dezenas de pacotes transitivos. São as versões que ninguém escolheu.

Ainda assim, um lockfile só regista o que o gestor de pacotes resolveu. Não diz nada sobre o que um script de instalação descarrega, o que um script de build de Rust obtém, que imagem base um Dockerfile usa ou o que um passo de um workflow descarrega com curl. São dependências ocultas, e chegam ao produto na mesma.

Os scripts de instalação são executados antes de alguém ter revisto o que quer que seja

Eis a parte incómoda: a CI é executada sobre o pull request. Assim que o branch do agente é compilado, as suas novas dependências são instaladas, e os respetivos scripts preinstall e postinstall são executados com acesso a tudo o que o job consegue alcançar. A revisão acontece depois.

O comprometimento do Nx em agosto de 2025 mostrou onde isto pode chegar. Versões maliciosas do Nx no npm traziam um script postinstall que, segundo o postmortem dos maintainers, tentava usar ferramentas de IA locais como o Claude e o Gemini para procurar ficheiros sensíveis na máquina.

Formas de reduzir o risco:

  • Não execute scripts de ciclo de vida por predefinição. O pnpm trata os scripts de build das dependências como não revistos até que os autorize; com o npm, --ignore-scripts desativa-os.
  • Retenha a CI nos pull requests de agentes até alguém os ver. O cloud agent do Copilot do GitHub faz isto por predefinição: os workflows não são acionados até que um utilizador com acesso de escrita aprove a execução.
  • Mantenha os segredos fora dos jobs de pull requests. Um job de testes raramente precisa de um token de publicação. Consulte Segredos do GitHub Actions: como vazam e como os proteger.

Compare o que o build obteve com o último lançamento

A verificação mais forte nem sequer olha para o pull request. Olha para o que o build fez: que pacotes e ficheiros o job efetivamente obteve, e de onde. Uma SBOM registada durante o build regista isso enquanto o build decorre, pelo que inclui as dependências ocultas que um lockfile deixa de fora.

Compare-a com a SBOM do seu último lançamento e as perguntas tornam-se concretas:

  • Que componentes são novos e quais mudaram de versão?
  • Algum pacote passou a vir de outra origem?
  • O build descarregou alguma coisa de um host que nunca tinha contactado?

Tudo o que é novo deve ter uma linha na descrição do pull request que o explique. Um componente que ninguém consegue explicar é o motivo para parar. Para conhecer as formas de produzir uma SBOM em CI, consulte como gerar uma SBOM no GitHub Actions.

Os ficheiros de workflow precisam de um responsável próprio

Um agente que edita um workflow pode alterar o que é executado com os seus tokens e segredos. Trate .github/workflows/ como código sensível do ponto de vista da segurança, com revisores próprios. A referência de utilização segura do GitHub sugere colocar o diretório sob CODEOWNERS:

/.github/workflows/ @your-org/platform-security

Nessas alterações, procure:

  • Permissões mais amplas. Um novo contents: write ou id-token: write deve ter uma razão. Consulte permissões de GITHUB_TOKEN.
  • Novos triggers. pull_request_target é executado com um token de leitura e escrita e com os segredos do repositório, mesmo para pull requests vindos de forks.
  • Actions não fixadas. Uma nova action referenciada por etiqueta em vez de por SHA de commit completo pode mudar sem que dê por isso.
  • Segredos em sítios novos. Um segredo passado a um passo que antes não precisava dele.

Limite o que o build consegue alcançar

Qualquer uma das verificações acima pode falhar. Um pacote malicioso acabado de publicar não tem qualquer aviso de segurança, tem um nome convincente e um diff limpo. O que precisa é de uma ligação de rede: para obter a sua segunda fase ou para enviar os seus segredos para algum lado.

Uma política de egress permite que o build chegue aos registos e hosts de que precisa, e a mais nada. Não depende de conhecer o ataque, por isso funciona logo da primeira vez que um ataque novo é executado no seu pipeline.

Mantenha uma pessoa no circuito de aprovação

Os agentes não devem poder aprovar o seu próprio trabalho, e a pessoa que o pediu também não. O cloud agent do Copilot do GitHub impede que o utilizador que lhe pediu para criar um pull request o aprove, e as proteções de branch e as verificações obrigatórias existentes continuam a aplicar-se.

Garanta o mesmo para todos os agentes com rulesets no branch predefinido:

  • Exija um pull request e pelo menos uma aprovação.
  • Exija a revisão dos code owners, para que as alterações a workflows e dependências cheguem às pessoas certas.
  • Descarte as aprovações desatualizadas quando novos commits alteram o diff, já que os agentes continuam a fazer push depois da revisão.
  • Exija verificações de estado, incluindo as verificações de dependências e de SBOM acima.

Algumas ferramentas antecipam o controlo. O AI CodeOps, por exemplo, só abre um pull request depois de o conjunto de testes ter passado nessa versão exata, de uma revisão do diff por IA não ter encontrado problemas e de uma pessoa o ter aprovado.

Controle o lançamento, não apenas o merge

Um controlo no merge vê uma alteração. Um controlo no lançamento vê tudo o que mudou desde o último lançamento, incluindo dependências que estavam bem quando foi feito o merge e nas quais entretanto foram encontradas vulnerabilidades. Antes de lançar:

  • Volte a verificar os componentes do lançamento face aos avisos de segurança atuais, e bloqueie perante vulnerabilidades críticas conhecidas e versões maliciosas conhecidas.
  • Verifique as licenças de tudo o que é novo desde o último lançamento.
  • Guarde o registo do que o build do lançamento obteve, para poder responder mais tarde à pergunta «fomos afetados?». Consulte Estamos afetados? Como avaliar um novo CVE nos seus builds.

O papel do CRACI

O CRACI não revê o código que um agente escreve. Também não deteta pacotes maliciosos novos, por isso avalie as dependências novas com as verificações acima. O que cobre é o build.

O CRACI executa os seus jobs de GitHub Actions em runners próprios, cerca de duas vezes mais rápidos do que os runners alojados no GitHub. Altera runs-on para craci, e as execuções continuam a aparecer no GitHub. Durante a execução de cada job, o CRACI regista cada pacote que o job efetivamente obteve, incluindo pacotes restaurados de caches de CI e dependências ocultas, como código descarregado por hooks de instalação do npm: um gravador, não um scanner. A SBOM de cada job inclui um estado de completude que assinala o que o CRACI não conseguiu ver, e é exportada em CycloneDX ou SPDX, para que possa comparar o build de um pull request com o seu último lançamento. Uma comparação de lançamentos integrada está no roadmap.

No runner, uma política de egress decide que hosts um job pode alcançar. É validada antes de o job começar, falha em modo fechado e pode ser configurada para negar por predefinição, pelo que uma dependência maliciosa no pull request de um agente não consegue chegar a um host de que o build não precisa, mesmo que ninguém tenha visto o ataque antes. As violações da política geram alertas. Os policy gates podem bloquear um build com base nas conclusões, incluindo builds que contenham um CVE específico, e as regras de política de licenças podem bloquear um build devido a uma licença. Depois do lançamento, o CRACI continua a reavaliar as SBOM que monitoriza face a novos avisos de segurança, e o histórico de builds mostra que builds continham uma dependência vulnerável.

Marque uma demo para ver o registo de um dos seus builds.