Assistentes de codificação por IA escrevem uma grande parte do código que as equipes entregam. Relatório de Segurança de Código GenAI 2026 da Veracode estima que a IA seja responsável por cerca de metade de todo o código enviado em equipes que adotaram essas ferramentas. Essa velocidade é valiosa, mas os assistentes são criados para produzir código funcional, não código seguro, e nenhum deles conhece seus padrões internos de segurança. Este guia apresenta um fluxo de trabalho prático para proteger o código gerado por IA: como criar prompts, realizar varreduras, validar dependências, revisar as alterações de maior risco, definir políticas e automatizar a aplicação para que a segurança acompanhe o ritmo do desenvolvimento feito por máquinas.
Quais são os riscos de segurança do código gerado por IA?
O código gerado por IA tende a falhar de quatro maneiras reconhecíveis:
- Pacotes alucinados. Os modelos às vezes fazem referência a bibliotecas que não existem. Atacantes podem registrar esses nomes e preenchê-los com código malicioso.
- Segredos codificados (hardcoded). Exemplos de código geralmente trazem credenciais de exemplo, e chaves reais acabam sendo enviadas junto com eles.
- Padrões de codificação inseguros. Falhas de injeção, como cross-site scripting e injeção de log, aparecem porque o modelo não consegue ver como dados não confiáveis fluem por toda a aplicação.
- Falhas de design e lógica. Autorização quebrada, dados expostos em strings de consulta e limites de taxa ausentes podem compilar perfeitamente e ainda passar em uma varredura básica.
A pesquisa é consistente. Relatório de Segurança de Código GenAI 2026 da Veracode testou mais de 100 modelos em quatro snapshots. As taxas de aprovação de sintaxe atingiram 99,9%, mas a taxa média de aprovação de segurança permaneceu em torno de 56%. Em cerca de 44% das tarefas, os modelos introduziram uma vulnerabilidade detectável do OWASP Top 10. Os resultados variaram amplamente de acordo com o tipo de falha: os modelos lidaram bem com injeção de SQL (taxa de aprovação de 83%), mas tiveram um desempenho ruim em cross-site scripting (15%) e injeção de log (12%).
Os segredos seguem o mesmo padrão. O relatório State of Secrets Sprawl 2026 da GitGuardian, conforme coberto pela SC Media, descobriu que commits públicos coautoria dos pelo Claude Code vazaram segredos em 3,2% dos casos, cerca do dobro da linha de base de 1,5% em todos os commits públicos do GitHub. Também descobriu mais de 24.000 segredos expostos em arquivos de configuração MCP públicos.
Sobre dependências, um Estudo da USENIX Security 2025 com 16 LLMs geradoras de código e 576.000 amostras de código constatou taxas médias de alucinação de pacotes de pelo menos 5,2% para modelos comerciais e 21,7% para modelos de código aberto, com 205.474 nomes de pacotes alucinados exclusivos.
A boa notícia é que esses riscos seguem padrões previsíveis. Você pode gerenciar riscos previsíveis com um fluxo de trabalho repetível, que é o que o restante deste guia aborda.
Oriente a IA com Prompts Focados em Segurança
Prompts vagos tendem a produzir código com lacunas de segurança. Os testes da Veracode deliberadamente não forneceram aos modelos nenhuma orientação específica de segurança, pois os desenvolvedores geralmente se concentram na funcionalidade e nem sempre sabem quando uma solicitação tem implicações de segurança. Nessas condições, os modelos escolheram uma implementação insegura em quase metade das tarefas. Declarar os requisitos de segurança logo no início elimina parte dessa lacuna.
Um prompt mais forte nomeia os controles que você espera, não apenas o recurso:
- Fraco: "Crie um endpoint de API que exclua um usuário."
- Mais forte: "Crie um endpoint de API que exclua um usuário. Exija autenticação por token bearer no cabeçalho Authorization, não na string de consulta. Passe o ID do usuário no corpo da solicitação e verifique se o autor da chamada está autorizado a excluir aquele usuário específico. Valide todas as entradas, use consultas parametrizadas, limite a taxa de solicitações do endpoint e não codifique credenciais fixas."
A versão mais forte visa exatamente as falhas que o Salt Code sinaliza em sua própria demonstração: autorização de nível de objeto quebrada (OWASP API1), tokens de autenticação na string de consulta (API2) e IDs de usuário vazando por meio de URLs (API3).
Mantenha uma biblioteca compartilhada de prompts de codificação segura validados para que toda a equipe comece a partir da mesma base. Mesmo assim, a disciplina com prompts depende de cada desenvolvedor se lembrar de cada requisito em cada solicitação. É por isso que as etapas posteriores e a aplicação automatizada são importantes.
Analise cada alteração com ferramentas de segurança automatizadas
Execute três tipos de verificações automatizadas em cada alteração sugerida pela IA, não apenas antes de um lançamento:
- Teste estático de segurança de aplicativos (SAST) para detectar padrões de código inseguros, como falhas de injeção.
- Análise de composição de software (SCA) para sinalizar pacotes de terceiros vulneráveis ou suspeitos.
- Detecção de segredos para impedir credenciais antes que sejam enviadas. A recomendação da própria GitGuardian é verificar alterações de código em busca de segredos antes de realizar o commit.
Coloque essas verificações em dois pontos. Na IDE, elas fornecem feedback instantâneo aos desenvolvedores enquanto o código ainda está fresco. No CI, elas atuam como um bloqueio que impede um merge quando uma verificação falha.
A verificação tem um limite que vale a pena mencionar. Como Salt Code aponta, as ferramentas de SAST e DAST detectam problemas a jusante, após o código ser enviado, revisado e colocado na fila para implantação, de modo que cada correção se torna uma reescrita. Os dados da Veracode também mostram por que os scanners sozinhos não são suficientes para algumas classes de falhas: detectar cross-site scripting e injeção de log exige rastrear como a entrada do usuário flui entre arquivos e funções, o que um modelo que gera uma única função não consegue ver. Ajuste seus scanners para os padrões que as ferramentas de IA produzem e combine-os com a prevenção no início do fluxo de trabalho.
Verifique cada dependência antes que ela entre na sua base de código
Ferramentas de codificação por IA às vezes sugerem pacotes que não existem. O Estudo da USENIX Security 2025 descreve isso como uma nova forma de ataque de confusão de pacotes: um invasor registra o nome alucinado em um repositório público como PyPI ou npm, publica código malicioso sob esse nome e espera que um desenvolvedor execute o comando de instalação sugerido pela IA. Os pesquisadores descobriram que o problema era persistente e sistêmico em todos os modelos.
Antes de instalar qualquer pacote sugerido por uma ferramenta de IA, confirme três coisas:
- Ele é real. Verifique se o pacote existe no repositório oficial com o nome exato e fique atento a grafias semelhantes de bibliotecas populares.
- Ele é mantido ativamente. Observe o histórico de lançamentos, a atividade do mantenedor e o volume de downloads. Um pacote novo, sem histórico, merece ser examinado.
- Ele está livre de vulnerabilidades conhecidas. Execute-o através da sua ferramenta de análise de composição de software antes que ele chegue a um arquivo de bloqueio (lockfile).
Em seguida, mantenha uma lista de materiais de software (SBOM). Um SBOM é uma lista dos componentes de código aberto e de terceiros em seu código, com suas versões, licenças e status de patch, conforme o Programa de Segurança da Informação e Privacidade do CMS explica. Gerá-lo no CI fornece um registro contínuo de cada componente que uma ferramenta de IA introduziu, para que você possa responder rapidamente quando uma nova vulnerabilidade for divulgada.
Reserve a revisão humana para alterações de alto risco
Ferramentas automatizadas não conseguem detectar todas as falhas de lógica de negócios, e revisores não conseguem ler cada linha gerada por IA na velocidade da máquina. Concentre a revisão humana onde um erro custa mais caro:
- Autenticação e autorização. O controle de acesso merece a atenção mais rigorosa. O relatório da Gartner How to Secure Custom-Built AI Agents constata que problemas de controle de acesso causarão a maioria das falhas de segurança em agentes.
- Criptografia. Escolha de algoritmos, gerenciamento de chaves e geração de números aleatórios.
- Tratamento de dados sensíveis. Qualquer coisa que envolva PII, dados de pagamento ou dados de saúde, incluindo onde esses dados são registrados.
- Novos endpoints externos, ferramentas de agentes e servidores MCP. Cada nova integração de API ou MCP expande sua superfície de ataque. A Gartner também observa que a maioria dos servidores MCP publicados carece de sanitização de conteúdo, tornando os servidores MCP públicos um vetor de ataque significativo e subestimado.
Separe a pessoa que solicitou uma alteração arriscada da pessoa que a aprova. Um desenvolvedor que iterou com um assistente de IA até o código funcionar é o menos propenso a identificar o que o assistente fez de errado.
A revisão também não termina no merge. Como Nick Rago, da Salt, explica em Sua transformação de IA precisa de proteção em tempo de execução para todo o ecossistema de agentes, um único prompt pode viajar de um agente através de um LLM e servidores MCP até as APIs que operam seu negócio. Um invasor que descobre uma ferramenta exposta pode ignorar o agente completamente e chamar a API por trás dele. O código que seus assistentes de IA escrevem torna-se parte desse caminho, portanto, valide-o em tempo de execução, assim como na revisão.
Estabeleça uma Política de Governança Leve para Ferramentas de Programação com IA
Escreva uma política curta e prática em vez de um longo documento de conformidade. Uma política que as pessoas conseguem ler em cinco minutos é uma política que as pessoas seguem. Salt Code define a alternativa claramente: quando as políticas vivem em PDFs, wikis e no conhecimento informal, a IA que constrói seu software não leu nenhuma delas.
No mínimo, a política deve declarar:
- Onde as ferramentas de IA são permitidas. Quais assistentes são aprovados, para quais repositórios e se algum código (como módulos criptográficos ou de pagamento) é proibido.
- O que deve ser escaneado. As verificações de SAST, SCA e segredos que toda alteração assistida por IA deve passar, e onde elas são executadas.
- O que precisa de revisão humana. As categorias de alto risco da seção anterior.
- Quem é responsável pelas exceções. Um responsável nomeado que pode aprovar um desvio e registrar o motivo.
Identifique commits gerados por IA para que as equipes possam rastrear um problema até a origem da criação do código. Os metadados de commit foram o que tornou possível as descobertas do Claude Code pelo GitGuardian: os pesquisadores só conseguiram comparar as taxas de vazamento porque esses commits continham uma tag de coautor. Essa mesma identificação permite que sua equipe avalie se o código assistido por IA está se tornando mais seguro ao longo do tempo.
Automatize a aplicação de políticas com uma plataforma de governança de código de IA
Cada etapa acima só funciona se os desenvolvedores se lembrarem de segui-la, em cada prompt, sob a pressão de prazos. Uma plataforma de governança dedicada aplica essas etapas automaticamente. Ao avaliar uma, procure por:
- Prevenção no momento da geração. As políticas devem moldar o código enquanto a IA o escreve, não apenas sinalizar problemas após o commit.
- Cobertura em todos os seus assistentes. Os desenvolvedores usam várias ferramentas; um modelo de política deve governar todas elas.
- Aplicação em pipeline e em tempo de execução. Verificações em CI/CD que bloqueiam violações antes da produção, além do monitoramento de como APIs, servidores MCP e agentes realmente se comportam após a implantação.
- Priorização baseada em exposição real. Resultados classificados pelo que é alcançável e explorável, para que as equipes corrijam primeiro o que é importante.
- Trilhas de auditoria claras. Registros de quais políticas foram aplicadas a qual código, para conformidade e resposta a incidentes.
Salt Code foi criado para este fluxo de trabalho. Seu objetivo é tornar o código gerado por IA compatível assim que é criado, e não depois do fato. O Salt Code conecta o Salt Posture Governance Engine às ferramentas que os desenvolvedores já usam e aplica a governança desde o prompt até a produção:
- Descubra cada API, servidor MCP e integração de agente de IA em repositórios de código e ambientes de nuvem.
- Aplique durante a geração de código traduzindo políticas de segurança em regras que orientam assistentes de codificação de IA em tempo real.
- Governe no pipeline validando políticas em CI/CD e pull requests, bloqueando violações antes da produção.
- Valide em tempo de execução monitorando APIs, integrações MCP e agentes em busca de violações de política, lacunas de postura e atividades anômalas.
- Remedeie e melhore enviando os resultados do tempo de execução de volta para os fluxos de trabalho dos desenvolvedores e para os próprios assistentes de IA.
O Salt Code vem com mais de 140 políticas pré-configuradas, cobrindo estruturas desde o OWASP API Security Top 10 até o MCP Security Top 10, além de suas próprias regras personalizadas. Ele funciona com Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, Codex, Gemini CLI, JetBrains e qualquer assistente de codificação de IA que suporte a configuração de servidor MCP.
As equipes que desejam começar imediatamente podem usar a versão gratuita do Salt Code. Ela é instalada em cerca de 60 segundos, adiciona 40 políticas de segurança abrangendo segurança de API, segurança de MCP, segurança de LLM e conformidade com OpenAPI, e fica ativa a partir do próximo prompt. Segundo a Salt, ela injeta contexto de segurança na janela de contexto do agente, para que seu código nunca saia da sua máquina. O plano corporativo adiciona pacotes de políticas personalizados, gerenciamento em toda a organização, relatórios de segurança no momento do prompt e SSO/SCIM.
Para ver em ação, assista ao webinar sob demanda Proteja o código escrito por IA antes de colocá-lo em produção: Salt Code, que inclui uma demonstração ao vivo do Salt Code aplicando políticas em assistentes de codificação de IA em tempo real.
Perguntas Frequentes
Como solicitar que a IA escreva um código mais seguro?
Declare os requisitos de segurança no prompt em vez de pedir apenas a funcionalidade. Solicite explicitamente validação de entrada, consultas parametrizadas, verificações de autenticação e autorização, manuseio seguro de tokens e IDs, e a ausência de segredos codificados (hardcoded). Mantenha uma biblioteca compartilhada de prompts validados para que toda a equipe comece a partir da mesma base e utilize uma ferramenta que injete políticas de segurança automaticamente, para que a proteção não dependa da memória humana.
Ainda é necessária a revisão humana do código gerado por IA?
Sim, mas de forma direcionada. A Veracode descobriu que até mesmo o modelo com melhor desempenho em seus testes de 2026 falhou em cerca de uma a cada três tarefas de segurança. Concentre a revisão humana em autenticação e autorização, criptografia, manuseio de dados sensíveis e novos endpoints, ferramentas de agente ou servidores MCP, e deixe que a automação cuide do restante.
Quais ferramentas ajudam a proteger o código gerado por IA?
Um conjunto em camadas: análise estática (SAST) para padrões inseguros, análise de composição de software (SCA) para pacotes vulneráveis ou inexistentes, detecção de segredos antes do commit, geração de SBOM para rastreamento de componentes e uma plataforma de governança de código de IA, como o Salt Code, que aplica políticas dentro do próprio assistente de codificação.
Como evitar que segredos apareçam no código gerado por IA?
Nunca cole credenciais reais em prompts ou exemplos de código. Referencie segredos a partir de um cofre ou gerenciador de segredos, execute a detecção de segredos na IDE e como uma verificação de pré-commit e CI, e audite arquivos de configuração MCP, que a GitGuardian identificou como uma fonte crescente de vazamento de credenciais. Se um segredo vazar, faça a rotação dele imediatamente em vez de apenas excluí-lo do commit mais recente.
O código gerado por IA deve passar por um processo de revisão separado do código escrito por humanos?
Ele deve atender ao mesmo padrão de segurança, com verificações adicionais adaptadas às formas como a IA falha: verificação de pacotes, varredura de segredos e uma revisão mais rigorosa de categorias de alto risco. Marcar commits assistidos por IA torna isso prático, pois permite direcionar essas alterações para as verificações corretas e medir os resultados ao longo do tempo.
.jpg)