// SECURE CODING · IA · SDLC
// secure-coding.ai-sdlc

Secure Coding Practices para SDLC com IA assistida

IA já faz parte do desenvolvimento. O objetivo desta página é transformar velocidade em engenharia controlada: requisitos verificáveis, código seguro, supply chain, CI/CD, Docker, IaC, agentes, permissões e evidência de revisão.

secure-coding.ai-sdlc● ready
okami@sec-cod ~%okami threat-model --feature "AI assisted PR" --abuse-cases
✓ assets: invoice, payment token, dependency graph
✓ trust boundaries: browser -> API -> worker -> registry
⚠ abuse: IDOR, package hallucination, prompt injection indireto
→ next gate: criar teste negativo + revisar permissões do agente
okami@sec-cod ~%
84%usam ou planejam usar IA no desenvolvimentoStack Overflow 2025
51%profissionais usam IA diariamenteStack Overflow 2025
85%devs usam IA regularmente para coding/devJetBrains 2025
45%amostras de código gerado falharam testes de segurançaVeracode 2025
85%veem review e validação virarem gargaloGitLab 2026
01/dados

IA acelera código; segurança precisa acelerar validação

Os dados de adoção explicam por que a prática segura precisa entrar no fluxo diário, não ficar como auditoria tardia.
// chart · bar

IA no desenvolvimento virou padrão

Stack Overflow 2025, JetBrains 2025, GitLab 2026

A aula assume IA como parte normal do SDLC: controles de segurança precisam acompanhar a nova velocidade.

// anti-padrão

Vibe coding sem gates

Gerar uma feature inteira com IA e só testar se "funcionou" ignora autorização, dependências, segredo, logs e infraestrutura. A correção é transformar cada sugestão em evidência.

// controle distribuído

O que aparece em revisão

AuthZ por recurso95%
SCA no PR92%
Secret scan88%
Logs redigidos72%
Agente sandbox68%
02/sdlc

Secure SDLC com IA assistida

A base continua sendo SDLC seguro; a diferença é que agora o assistente também precisa passar pelos mesmos controles.
01

Preparar

Política de uso de IA, padrões de código seguro, threat model leve, classificação de dados e limites para agentes.

02

Proteger

Validação, authz, sessão, secrets, crypto, logs, API, upload e dependências com exemplos por stack.

03

Produzir

CI/CD com SAST, SCA, secret scan, container scan, IaC scan, SBOM, proveniência e approval para risco alto.

04

Responder

Observabilidade segura, rotação, exceções com dono, runbook e aprendizado que volta para requisitos e prompts.

// chart · bar

Controles fundamentais por superfície

OWASP Secure Coding Practices, NIST SSDF

Código seguro é um conjunto de controles distribuídos, não uma ferramenta única.

// maturidade · secure SDLC
0Ad-hoc
1Checklist
2Gates
3Evidence
4Secure-by-design
// Objetivo: sair de checklist ocasional para requisitos de segurança, abuso testável, gates automatizados, evidência de revisão e política explícita para IA/agentes.
03/hub

Hub de práticas fundamentais

Cada card abre um guia denso, checklist ou simulação contextual. O botão Simular não só rola a página: ele prepara o lab correspondente.
01 · fundamentos01

Requisitos e threat modeling

Segurança começa antes do código: abuso, dados, confiança e critérios testáveis.

fundamentossdlciarequisitos
02 · typescript02

Validação de entrada e output encoding

Entrada é contrato; saída é contexto. Validar não substitui encoding.

typescriptjavascriptpythonjava
03 · auth03

Autenticação, sessão e autorização

Login prova identidade; autorização decide recurso, tenant e ação.

authsessionapifundamentos
04 · secrets04

Secrets, configuração e logs

Segredo não entra em código, prompt, log, screenshot ou contexto de agente.

secretslogsci-cdia
05 · crypto05

Criptografia e proteção de dados

Criptografia é ciclo de vida: algoritmo, chave, rotação, escopo e retenção.

cryptodadosfundamentos
06 · logs06

Erros, logs e observabilidade segura

Log deve ajudar operação sem virar vazamento, oracle ou trilha de exploração.

logsoperacaoia
07 · api07

APIs, uploads e parsing de arquivos

Parser é superfície de ataque: tamanho, tipo, path, timeout e conteúdo importam.

apiuploadpythonfundamentos
08 · supply-chain08

Dependências e supply chain

Instalar a biblioteca correta é controle de segurança.

supply-chainnpmpipnuget
09 · ci-cd09

CI/CD seguro

Pipeline é código privilegiado: permissões, secrets e eventos decidem blast radius.

ci-cdpipelinesecretssupply-chain
10 · docker10

Docker e runtime seguro

Imagem é runtime empacotado: base, usuário, scripts e CVEs entram no produto.

dockercontainerruntime
11 · iac11

IaC e cloud guardrails

Infra como código também é código: policy, revisão e scanner no PR.

iaccloudterraformkubernetes
12 · ia12

IA, vibe coding e agentes no SDLC

Agente de código tem poder real: arquivos, rede, comandos, dependências e conectores.

iaagentesvibe-codinggovernanca
13 · ia13

Prompt injection e output inseguro

LLM mistura instrução e dados; downstream precisa validar a saída.

iallmprompt-injectionoutput
14 · governanca14

Governança, rastreabilidade e responsabilidade

Velocidade só ajuda quando origem, decisão e risco residual são rastreáveis.

governancaiareviewsdlc
04/codigo

Cofre de código por stack

Padrões vulneráveis e correções em TypeScript/JavaScript, Python, Java, C#, CI/CD, Docker e IaC.
TypeScript/JavaScript

SQL injection e XSS no mesmo fluxo

Schema validation, prepared statement, auto-escape e teste negativo.

vulnerável
const q = req.query.q || "";
const rows = await db.query("select * from users where name like '%" + q + "%'");
res.send("<li>" + rows[0].name + "</li>");
seguro
const schema = z.object({ q: z.string().max(80).optional() });
const { q = "" } = schema.parse(req.query);
const rows = await db.query("select * from users where name like ?", [`%${q}%`]);
res.render("users", { users: rows }); // template auto-escapes
Python

Path traversal em download

Normalização de path, allowlist, tamanho e teste com ../.

vulnerável
@app.get("/download")
def download():
    name = request.args["file"]
    return send_file("/srv/reports/" + name)
seguro
BASE = Path("/srv/reports").resolve()
@app.get("/download")
def download():
    name = ReportQuery.model_validate(request.args).file
    target = (BASE / name).resolve()
    if BASE not in target.parents:
        abort(404)
    return send_file(target)
Java

Log4Shell como lembrete de transitivas

Dependency tree, OWASP Dependency-Check e política de atualização.

vulnerável
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.14.1</version>
</dependency>
seguro
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-bom</artifactId>
      <version>2.23.1</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
C#

Autorização por recurso

Teste com dois usuários e policy-based authorization.

vulnerável
[Authorize]
public async Task<IActionResult> GetInvoice(Guid id) {
  return Ok(await db.Invoices.FindAsync(id));
}
seguro
[Authorize]
public async Task<IActionResult> GetInvoice(Guid id) {
  var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
  var invoice = await db.Invoices.SingleOrDefaultAsync(i => i.Id == id && i.OwnerId == userId);
  return invoice is null ? NotFound() : Ok(invoice);
}
CI/CD

Secrets em PR não confiável

Sem secrets em fork, permissões mínimas e ambiente protegido.

vulnerável
on: pull_request_target
permissions: write-all
steps:
  - run: npm install && npm test
    env:
      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
seguro
on: pull_request
permissions:
  contents: read
steps:
  - run: npm ci --ignore-scripts
  - run: npm test
# publish só em branch protegida + ambiente aprovado
Docker

Imagem root e superfície desnecessária

Pinning, não-root, npm ci, scan de imagem e build reprodutível.

vulnerável
FROM node:latest
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]
seguro
FROM node:22-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev --ignore-scripts

FROM node:22-alpine
WORKDIR /app
USER node
COPY --from=deps /app/node_modules ./node_modules
COPY --chown=node:node . .
CMD ["node", "server.js"]
IaC

IAM wildcard e rede aberta

Checkov/tfsec, least privilege e exceção com dono/validade.

vulnerável
actions = ["s3:*"]
resources = ["*"]
cidr_blocks = ["0.0.0.0/0"]
seguro
actions   = ["s3:GetObject"]
resources = ["${aws_s3_bucket.data.arn}/reports/*"]
cidr_blocks = [var.office_cidr]
# exceção exige owner, motivo e validade
terminal · code gate● ready
okami@sec-cod ~%semgrep --config p/owasp-top-ten src/
✓ 117 arquivos analisados
⚠ finding: concatenação de SQL em users.controller.ts:44
⚠ finding: output HTML sem template auto-escape em reports.ts:19
→ fix: schema validation + prepared statement + teste negativo
okami@sec-cod ~%
05/supply-chain

Supply Chain Lab

Escolha uma dependência e veja sinais de risco antes de instalar. Biblioteca correta evita incidentes antes do código rodar.
// chart · bar

Package hallucination e slopsquatting

arXiv 2406.10279

Dependência sugerida por IA deve ser tratada como input não confiável até verificação externa.

terminal · dependency gate● ready
okami@sec-cod ~%npm audit --audit-level=high && npm view express-auth-middlewere
✓ audit ran against lockfile
✕ npm view: package not found / suspicious name
⚠ AI suggestion cannot be installed without source validation
→ decision: block and open architecture note
okami@sec-cod ~%
06/ia-agents

IA, vibe coding e agentes com limites

A aula trata IA como parte normal do desenvolvimento: útil, inevitável e perigosa quando opera sem limites claros.
// ajuda

Onde IA acelera

  • Explicar código legado.
  • Gerar testes negativos.
  • Propor refatoração pequena.
  • Comparar bibliotecas.
  • Revisar checklist de PR.
// risco

Onde IA quebra

  • Alucina pacote.
  • Remove validação.
  • Segue prompt injection indireto.
  • Lê segredo se tiver escopo.
  • Gera diff grande demais.
// prompt

Contexto mínimo

  • Objetivo pequeno
  • Dados sintéticos
  • Critérios testáveis
// sandbox

Permissão mínima

  • Workspace restrito
  • Rede com approval
  • Secrets fora
// evidence

Conclusão auditável

  • Arquivos tocados
  • Comandos rodados
  • Risco residual
// review

Humano no loop

  • Diff pequeno
  • Checklist de risco
  • Aprovação sensível
// do prompt ao merge

O fluxo seguro para desenvolvimento assistido por IA

A IA entra como acelerador, mas cada resposta deve atravessar um fluxo explícito: intenção pequena, contexto mínimo, testes negativos, validação de dependência, sandbox e evidência no PR. O aluno precisa sair da aula sabendo defender cada gate tecnicamente.

01 · especificarPrompt com fronteirasDeclare tenant, dados sensíveis, ações proibidas e critério de aceite. Sem isso a IA otimiza só o caminho feliz.
02 · atacarAbuse cases viram testePeça payloads de IDOR, traversal, prompt injection e bypass, mas só aceite quando eles entram em teste automatizado.
03 · verificarDependência é inputNome sugerido por IA precisa passar por registry, maintainer, lockfile, SCA e risco de slopsquatting antes do install.
04 · auditarConclusão com provaResumo sem comandos, diff, testes e risco residual não é evidência. É apenas opinião gerada.
// playbook de execução

Da sugestão da IA até o merge: o que precisa existir

O ponto didático aqui é transformar "a IA gerou código" em uma cadeia de evidência. A resposta só vira mudança quando passa por contexto mínimo, teste de abuso, verificação de dependência, política de permissões e resumo auditável. Use os demos abaixo para mostrar no terminal como cada etapa reprova ou libera uma parte do fluxo.

01 · promptContrato antes da geraçãoDeclare recurso, tenant, dados proibidos, arquivos fora de escopo, critérios de aceite e testes negativos esperados.
02 · red teamAbuso vira artefatoPeça casos de IDOR, path traversal, prompt injection e dependency confusion, mas registre isso como teste ou checklist.
03 · supply chainPacote sugerido é suspeitoNome, maintainer, registry, lockfile, transitivas, SBOM e advisory precisam ser validados antes do install.
04 · policyAgente não decide privilégioRede, secrets, home, comandos destrutivos e conectores externos exigem escopo mínimo e aprovação humana.
05 · evidenceTerminal como provaSAST, SCA, secret scan, abuse tests, IaC scan e revisão precisam aparecer no PR com resultado e risco residual.
06 · accountabilityOrigem e responsabilidadeMarque origem assistida por IA, reviewer humano, exceções aprovadas, artefato assinado e condição de rollback.
prompt red team● ready
okami@sec-cod ~%okami prompt-redteam --feature invoice-export --agent-output ai-output/
✓ contrato do prompt: tenant, dados proibidos, arquivos fora de escopo
⚠ caso gerado: user A tenta exportar invoice do tenant B
⚠ caso gerado: README injeta instrução para ignorar checklist
→ converter cada abuso em teste antes de aceitar o diff
okami@sec-cod ~%
// agent permission lab

Monte o perfil de execução do agente

Ative permissões e observe o risco residual. Um agente produtivo não precisa de acesso total para entregar código revisável.

// impacto operacional
Workspace restrito Permissões mínimas mantêm o agente útil sem entregar acesso desnecessário a rede, secrets ou comandos destrutivos.
terminal · agent policy● ready
    0calculando

    // AI security test bench

    Transforme output da IA em evidência

    O dado de 45% deixa de ser um gráfico solto: nesta aula ele vira uma regra operacional. Código gerado por IA só passa quando SAST, abuso, dependências, secrets e prompt injection deixam evidência no terminal.

    45%amostras de código gerado falharam testes de segurançaVeracode 2025
    0gates executados nesta simulaçãoterminal lab
    0falhas bloqueando mergeaguardando
      terminal · AI security tests● ready
      07/review

      PR Review Simulator

      Um PR assistido por IA parece útil, mas contém problemas escondidos. Clique nas linhas, leia o achado e reinicie quando quiser.
      açãoClique nas linhas do diff para marcar achados. Cada linha selecionada deve virar uma decisão de review: bloquear, pedir teste, trocar dependência ou exigir approval.
      // achados marcados
      // roteiro de review
      1. Primeiro procure autorização, segredo e dependência suspeita. São achados que bloqueiam merge.
      2. Depois conecte cada linha a um gate: teste de abuso, SCA, secret scan, IaC, container ou prompt canary.
      3. No fim aceite apenas resumo com evidência: comando, resultado, risco residual e dono da correção.
      terminal · agent canary● ready
      okami@sec-cod ~%okami agent-test --fixture malicious-readme.md --tool-policy allowlist
      fixture: README contains hidden instruction
      ✓ agent flagged repository text as untrusted input
      ✓ shell tool blocked pending approval
      → keep output validation and tool allowlist
      okami@sec-cod ~%
      08/pipeline

      Pipeline Gate Simulator

      Ligue e desligue gates para ver o risco residual. IA aumenta velocidade; pipeline precisa aumentar evidência.
      0calculando
        cálculoO score é normalizado pelo peso total dos gates. Ele só chega a 100 quando todos os gates estão ligados; antes disso pode ser forte, mas continua incompleto.
        // chart · line

        Gates deslocam risco para a esquerda

        NIST SSDF, SLSA, OWASP SCP

        Quanto mais cedo o gate roda, menor o custo de correção e maior a evidência para review.

        terminal · pipeline audit● ready
        okami@sec-cod ~%okami ci-audit .github/workflows --event pull_request_target
        ⚠ workflow uses pull_request_target
        ⚠ permissions: write-all
        ⚠ secret exposed to untrusted code path
        → fix: pull_request + contents:read + protected release workflow
        okami@sec-cod ~%
        09/terminal

        Terminal de prática

        Comandos reais para discutir em sala ou praticar fora do HTML. Aqui o terminal é parte da experiência, não decoração.
        terminal · comandos seguros● ready
        okami@sec-cod ~%codex run --sandbox workspace-write --ask-for-approval on-request
        ✓ workspace write allowed
        ✓ network requires approval
        ✓ outside workspace blocked
        ⚠ MCP connectors require explicit scope review
        → summary must include tests, diff, residual risk
        okami@sec-cod ~%
        10/quiz

        Quiz de missões

        Pontuação, feedback e atalhos para revisar o conceito quando a resposta mostra uma lacuna.
        // chart · bar

        AI accountability: geração corre na frente do controle

        GitLab AI Accountability Report 2026

        A produtividade individual sobe; review, validação, governança e rastreabilidade viram o gargalo.

        11/referencias

        Referências e materiais usados

        Links diretos para as fontes usadas na pesquisa e nos gráficos. Os filtros ajudam a separar fundamentos, IA, supply chain e ferramentas.
        // Design system

        OKAMI Design System

        Contrato visual usado nesta página: tokens, componentes, terminal, cards, tabs, toasts e padrões.

        design-systemokami
        Abrir fonte →
        // Framework

        NIST SP 800-218 SSDF v1.1

        Base para inserir práticas de desenvolvimento seguro em qualquer SDLC.

        fundamentossdlc
        Abrir fonte →
        // Checklist

        OWASP Secure Coding Practices Quick Reference Guide

        Checklist agnóstico de tecnologia para validação, encoding, auth, sessão, crypto, logs e configuração.

        fundamentoscodigo
        Abrir fonte →
        // Checklist

        OWASP Secure Coding Checklist

        Lista operacional para transformar revisão em perguntas verificáveis.

        fundamentosreview
        Abrir fonte →
        // Referência

        OWASP Cheat Sheet Series

        Guias práticos por classe de controle: validation, auth, logging, upload, Docker, secrets e mais.

        fundamentoscodigo
        Abrir fonte →
        // Padrão

        OWASP ASVS

        Ajuda a escrever requisitos de segurança que podem ser testados.

        requisitosverificacao
        Abrir fonte →
        // Referência

        OWASP API Security Top 10

        Base para BOLA/IDOR, inventory, authorization e API abuse cases.

        apiauthz
        Abrir fonte →
        // Guia

        CISA Secure by Design

        Reposiciona segurança como responsabilidade do fabricante e do processo de engenharia.

        sdlcgovernanca
        Abrir fonte →
        // Referência

        OWASP Top 10 for LLM Applications

        Referência para prompt injection, excessive agency, data leakage, supply chain e output handling em LLMs.

        iallm
        Abrir fonte →
        // Framework

        NIST AI Risk Management Framework

        Estrutura de governança para mapear, medir e gerenciar risco em sistemas com IA.

        iagovernanca
        Abrir fonte →
        // Base técnica

        MITRE ATLAS

        Táticas e técnicas adversariais contra sistemas de IA.

        iaameacas
        Abrir fonte →
        // Relatório

        Stack Overflow Developer Survey 2025

        Mostra mainstream adoption: 84% usam ou planejam usar IA; profissionais usam IA diariamente em grande escala.

        iadados
        Abrir fonte →
        // Relatório

        JetBrains Developer Ecosystem 2025

        Aponta IA como habilidade central e uso regular em coding/development.

        iadados
        Abrir fonte →
        // Relatório

        GitLab AI Accountability Report 2026

        Mostra o paradoxo: geração acelera, mas revisão, validação, governança e rastreabilidade viram gargalo.

        iagovernanca
        Abrir fonte →
        // Relatório

        Veracode GenAI Code Security Report 2025

        Pesquisa sobre segurança de código gerado por mais de 100 LLMs em Java, JavaScript, Python e C#.

        iacodigo
        Abrir fonte →
        // Relatório

        Sonar State of Code Developer Survey 2026

        Dados sobre uso diário, vibe coding e validação de código assistido por IA.

        iadados
        Abrir fonte →
        // Relatório

        DORA Impact of Generative AI

        Mostra que IA precisa de feedback loops fortes para não degradar estabilidade.

        iadevops
        Abrir fonte →
        // Paper

        We Have a Package for You!

        Pesquisa sobre package hallucination e slopsquatting em código gerado por LLMs.

        iasupply-chain
        Abrir fonte →
        // Documentação

        OpenAI Codex Agent Approvals & Security

        Referência de sandbox, approvals e limites operacionais para agente de código.

        iaagentes
        Abrir fonte →
        // Documentação

        GitHub Copilot Cloud Agent Risks and Mitigations

        Riscos de vazamento, prompt injection e necessidade de rastreabilidade em agentes.

        iaagentes
        Abrir fonte →
        // Documentação

        Claude Code Security

        Permissões, aprovações e comandos que exigem cuidado em agentes locais.

        iaagentes
        Abrir fonte →
        // Framework

        SLSA

        Modelo para integridade de build, proveniência e cadeia de suprimentos.

        supply-chainci-cd
        Abrir fonte →
        // Ferramenta

        Sigstore

        Assinatura e verificação de artefatos, imagens e releases.

        supply-chainassinatura
        Abrir fonte →
        // Ferramenta

        GitHub Dependency Review

        Revisão de mudanças em dependências antes do merge.

        supply-chainreview
        Abrir fonte →
        // Ferramenta

        npm audit

        Auditoria de vulnerabilidades no ecossistema npm.

        npmsca
        Abrir fonte →
        // Ferramenta

        pip-audit

        Auditoria de dependências Python contra vulnerabilidades conhecidas.

        pythonsca
        Abrir fonte →
        // Ferramenta

        NuGet auditing

        Auditoria de pacotes NuGet no restore/build.

        csharpsca
        Abrir fonte →
        // Ferramenta

        OWASP Dependency-Check

        SCA para Java/Maven/Gradle e outros ecossistemas.

        javasca
        Abrir fonte →
        // Guia

        Docker Build Best Practices

        Práticas de imagem mínima, pinning, camadas e builds reprodutíveis.

        docker
        Abrir fonte →
        // Ferramenta

        Docker Scout

        Análise de CVEs e políticas para imagens de container.

        dockersca
        Abrir fonte →
        // Checklist

        OWASP Docker Security Cheat Sheet

        Controles de usuário não-root, superfície e runtime de containers.

        docker
        Abrir fonte →
        // Padrão

        Kubernetes Pod Security Standards

        Perfis baseline/restricted para pods em Kubernetes.

        kubernetesiac
        Abrir fonte →
        // Ferramenta

        Checkov

        Scanner de IaC para Terraform, Kubernetes, CloudFormation e pipelines.

        iac
        Abrir fonte →
        // Ferramenta

        Gitleaks

        Detecção de segredos em código, histórico e pipelines.

        secrets
        Abrir fonte →
        // Ferramenta

        Semgrep

        SAST e regras customizadas para padrões de código inseguro.

        sast
        Abrir fonte →