Voltar a todos os artigos

Como encontrar falhas de lógica de negócio com o teu agente de código, e provar cada uma

Um método para encontrar falhas de lógica de negócio com o teu agente de código: mapear cada endpoint, escrever as regras e provar cada falha num teste.

Nesta página
  1. O que é uma falha de lógica de negócio?
  2. Porque é que os scanners não as veem e um agente de código as consegue encontrar?
  3. Como encontrar falhas de lógica de negócio em quatro passos
  4. Passo 1: mapeia cada ponto de entrada
  5. Passo 2: escreve o que o código garante
  6. Passo 3: revê cada ponto de entrada, papel a papel
  7. Passo 4: prova cada falha com um teste
  8. Seis falhas de lógica de negócio a procurar primeiro
  9. Onde é que o agente se engana?
  10. Quando é que se deve correr?
  11. Onde é que o CybeDefend entra?
  12. Perguntas frequentes
  13. As ferramentas SAST encontram falhas de lógica de negócio?
  14. Um agente de código com IA consegue encontrar vulnerabilidades IDOR?
  15. Qual é um exemplo de vulnerabilidade de lógica de negócio?
  16. Como se testam as vulnerabilidades de lógica de negócio?
  17. Qual é a diferença entre IDOR e BOLA?
  18. É seguro deixar um agente de código testar vulnerabilidades?
  19. Como se previnem as vulnerabilidades de lógica de negócio?
  20. O CybeDefend é open source?

O mapa de revisão de um agente de código: seis pontos de entrada, o seu controlo, uma falha provada por um teste e duas pistas

Uma falha de lógica de negócio é código que faz exatamente o que lhe pediram e mesmo assim deixa alguém fazer o que o negócio proíbe: ler a fatura de outro cliente, aprovar a sua própria despesa, usar duas vezes o mesmo cupão. Nada no código parece errado, por isso os scanners passam ao lado, como mostrámos no nosso guia sobre as falhas de lógica de negócio no código gerado por IA.

O teu agente de código consegue encontrá-las, porque sabe ler o que o código deveria fazer. Também consegue inventar falhas que não existem. Este guia dá-te um método que só fica com o que um teste prova: mapear cada ponto de entrada, escrever o que o código garante, rever cada ponto de entrada papel a papel e transformar cada suspeita num teste que falha. Aplicamo-lo a um caso real: uma fatura que qualquer utilizador com sessão iniciada consegue ler.

Mapeia cada ponto de entradaEscreve o que o código garanteRevê cada ponto de entrada, papel a papelProva cada falha com um teste que falha
O método em quatro passos. Só o último produz um finding.

O que é uma falha de lógica de negócio?

Uma falha de lógica de negócio é a distância entre o que a aplicação permite e o que o negócio queria permitir. A Web Security Academy da PortSwigger descreve-as como defeitos de conceção e de implementação que deixam um atacante provocar um comportamento que ninguém tinha previsto, e acrescenta que nascem muitas vezes de pressupostos errados sobre a forma como os utilizadores vão usar a aplicação.

A primeira família é o controlo de acesso. A CWE-639, Authorization Bypass Through User-Controlled Key, descreve um sistema cuja autorização não impede um utilizador de aceder aos dados de outro trocando o identificador no pedido; o MITRE dá Insecure Direct Object Reference, ou IDOR, como nome alternativo. O controlo de acesso quebrado continua em primeiro lugar no OWASP Top 10 2025. Depois vêm os fluxos que se podem saltar ou repetir, os montantes que o cliente escolhe, os limites que ninguém conta e dois pedidos que disputam o mesmo saldo.

O guia de testes da OWASP, o Web Security Testing Guide, dedica um capítulo inteiro ao tema, com dez testes: validação de dados, pedidos forjados, verificações de integridade, tempos dos processos, limites ao número de utilizações de uma função, contorno de fluxos de trabalho, defesas contra utilização abusiva, dois sobre envio de ficheiros e a funcionalidade de pagamento.

Porque é que os scanners não as veem e um agente de código as consegue encontrar?

Os scanners procuram padrões, e uma falha de lógica de negócio é quase sempre uma linha que falta. Uma injeção tem forma: uma entrada que chega a uma consulta. Um controlo de proprietário em falta não tem nenhuma. O MITRE (CWE-840) nota que estes erros são difíceis de encontrar de forma automática porque passam por uma utilização legítima das funções da aplicação, e a PortSwigger diz o mesmo dos scanners de vulnerabilidades.

#1

A posição do Broken Access Control (controlo de acesso quebrado) no OWASP Top 10 2025.

4 em 10

Riscos do OWASP API Security Top 10 2023 sobre quem pode chegar a que objeto, campo, função ou fluxo de negócio: API1, API3, API5 e API6.

4 em 2 007

Regras da comunidade do Opengrep que visam as CWE da autorização em falta ou incorreta, na contagem que fizemos para o nosso guia OWASP. Uma das quatro é sobre Docker.

Um agente de código trabalha de outra forma. Lê a rota, o handler, o modelo de dados, os testes e o handler ao lado, e consegue dizer o que o código deveria fazer. Os agentes já o oferecem: o comando /security-review do Claude Code procura, entre outros padrões, falhas de autenticação e de autorização, e a GitHub Action de revisão de segurança da Anthropic inclui os IDOR e as race conditions entre o que procura. O nosso artigo sobre agentes de IA que reveem pull requests cobre esse passo de revisão.

Scanner de padrões (SAST)
Agente de código, com prova
O que lê
A forma do código, uma regra de cada vez
A rota, o handler, o modelo de dados, os testes e o handler ao lado
Uma injeção
Encontra: uma entrada que chega a uma consulta tem forma
Também encontra, mas os scanners já a cobrem
Um controlo de proprietário em falta
Raramente: não há padrão a reconhecer
Encontra-o comparando handlers sobre os mesmos dados
Um passo que se pode saltar
Raramente: cada linha está certa por si só
Encontra-o face à garantia escrita no passo 2
Os alertas errados
Falsos positivos, afinados regra a regra
Suspeitas, que só ficam se um teste falhar
O que obténs
Um alerta com o id de uma regra
Uma falha com o teste que a prova

O problema é o ruído. Essa mesma GitHub Action acrescenta um passo à parte para filtrar falsos positivos, porque um modelo a quem perguntas «isto é seguro?» responde com suspeitas, umas certas e outras não, e cada uma errada custa tempo a um programador para a pôr de lado. É o mesmo problema de triagem dos scanners, de que falámos em porque é que o teu scanner reporta 1.200 vulnerabilidades e só 12 são reais. O método abaixo faz com que seja o próprio agente a fazer essa verificação, com um teste.

Como encontrar falhas de lógica de negócio em quatro passos

Cada passo alimenta o seguinte: o mapa dá as linhas, as garantias dão as regras, a revisão dá as pistas e os testes transformam as pistas em findings.

Passo 1: mapeia cada ponto de entrada

Começa por uma lista, não por um juízo. Um agente a quem pedes «encontra problemas de segurança» lê alguns ficheiros e para; um agente que tem de preencher uma tabela tem de prestar contas de cada linha.

Lista cada ponto de entrada deste repositório: rotas HTTP, resolvers GraphQL, webhooks, consumidores de filas, tarefas agendadas e comandos de CLI. Uma linha por cada um: o ponto de entrada, quem o pode chamar, o que lê ou altera, e o ficheiro e a linha que fazem esse controlo, ou «nenhum». Lê tu os ficheiros de rotas, não só o ficheiro OpenAPI. Não julgues nada para já.

O resultado é parecido com isto:

Ponto de entradaQuem o pode chamarLê ou alteraO controlo (ficheiro:linha)Veredicto
GET /invoices/:idum membro da organização da faturalê a faturanenhum encontrado, routes/invoices.ts:12
DELETE /invoices/:idum membro da organização da faturaapaga a faturafiltro orgId, routes/invoices.ts:19
POST /orders/:id/shipa organização da encomenda, depois de pagaenvia a encomendafiltro orgId, sem controlo do pagamento, routes/orders.ts:31
POST /coupons/applyqualquer membro, uma vez por contabaixa o totalrestrição de unicidade, coupons.ts:41
GET /v1/exportsum administrador da organizaçãolê todos os clientespapel verificado, sem filtro orgId, routes/v1/exports.ts:9
POST /webhooks/paymento fornecedor de pagamentosmarca uma encomenda como pagaassinatura verificada, webhooks.ts:8

Pede o número de linhas antes de começar a revisão. Se o router declara 41 rotas e a tabela tem 30 linhas, o agente saltou ficheiros. Os pontos de entrada sem URL também contam: um webhook que marca uma encomenda como paga é um deles, e a tarefa noturna que exporta todos os clientes também.

Passo 2: escreve o que o código garante

Uma falha é uma regra partida, por isso escreve primeiro as regras. Pede ao agente que as ponha por baixo da tabela, em frases simples, tiradas do README, do modelo de dados, dos testes existentes e do próprio código:

  • um membro só vê as faturas da sua própria organização;
  • só o proprietário de um espaço de trabalho o pode apagar;
  • uma encomenda é paga antes de ser enviada, e paga uma única vez;
  • um reembolso nunca ultrapassa o pagamento;
  • um link de reposição serve uma vez, para uma conta, durante uma hora.

Quando nada está escrito, é o código que faz bem que dá a regra. Se o handler de remoção verifica a organização, o de leitura também devia verificar. Esta lista é também a que entregas a um revisor humano: é curta, e qualquer pessoa da equipa pode dizer «essa regra está errada» antes de se escrever um único teste.

Passo 3: revê cada ponto de entrada, papel a papel

Agora o agente revê cada linha contra cada regra, e fá-lo para cada papel da aplicação, não só para o papel para o qual a rota foi escrita:

  • sem conta;
  • um membro, e um membro de outra organização;
  • um administrador de outra organização;
  • um membro removido, ou cujo papel foi rebaixado;
  • uma chave de API ou uma conta de serviço.

Dois hábitos encontram falhas mais depressa do que os outros. O primeiro é comparar irmãos: dois handlers sobre os mesmos dados com controlos diferentes. A remoção verifica o proprietário e a leitura não; a rota web verifica o papel e a rota de API não; a versão 2 de um endpoint verifica e a versão 1 continua a ser servida. O segundo é a varredura: assim que o agente encontra um controlo em falta, procura o mesmo erro em todas as outras linhas antes de avançar, porque a mão que o esqueceu uma vez costuma esquecê-lo duas.

Dois handlers sobre a mesma fatura: a leitura procura-a só pelo id, a remoção filtra também pela organização do utilizador. O filtro em falta é uma pista até um teste o provar.

Cada linha recebe um veredicto: ok, com a linha que a protege, ou pista, com quem pode fazer o quê a quem. «O Bob consegue ler as faturas da Alice» é uma pista. «Possível problema de autorização» não é.

Passo 4: prova cada falha com um teste

Uma pista passa a finding quando um teste a mostra. Esta é a falha da tabela, numa API Express:

// routes/invoices.ts
router.get('/invoices/:id', requireAuth, async (req, res) => {
  const invoice = await db.invoice.findUnique({ where: { id: req.params.id } });
  if (!invoice) return res.status(404).end();
  res.json(invoice);
});

router.delete('/invoices/:id', requireAuth, async (req, res) => {
  const invoice = await db.invoice.findFirst({
    where: { id: req.params.id, orgId: req.user.orgId },
  });
  if (!invoice) return res.status(404).end();
  await db.invoice.delete({ where: { id: invoice.id } });
  res.status(204).end();
});

requireAuth verifica que há um utilizador com sessão, não a que organização pertence. A remoção filtra por orgId; a leitura não. Qualquer membro de qualquer organização consegue ler qualquer fatura trocando o identificador no URL.

A prova é um teste na suite do próprio repositório, com as suas próprias fixtures:

// tests/security/invoices.security.test.ts
// Correr as provas sem a marca: PROOF_RAW=1 npx vitest run tests/security
import { it, expect } from 'vitest';
import request from 'supertest';
import { buildApp } from '../../src/app';
import { seed, loginAs } from '../helpers';

// Falha esperada até à correção: a suite continua verde.
const proof = process.env.PROOF_RAW ? it : it.fails;

proof('um membro não lê a fatura de outra organização', async () => {
  const { alice, otherOrgInvoice } = await seed(); // outra organização
  const res = await request(buildApp())
    .get(`/invoices/${otherOrgInvoice.id}`)
    .set('Cookie', await loginAs(alice));

  expect(res.status).not.toBe(200);
  expect(JSON.stringify(res.body)).not.toContain(otherOrgInvoice.customerEmail);
});

Três regras fazem dele uma prova e não um palpite:

  1. Chama o handler real. Nem cópia da lógica, nem mock do controlo que está a ser testado. Só se substitui o que está fora do código: a base de dados, o relógio, um SDK de pagamentos.
  2. Falha pela razão que diz. Corre-o sem a marca e lê a mensagem: tem de ser a tua asserção, não um erro de import nem uma fixture em falta. Ao fim de duas tentativas sem uma falha limpa, a pista continua a ser uma pista.
  3. Verifica a regra, não a correção. «Os dados da outra organização não voltam» mantém-se quer a correção responda 403, quer 404. Um teste que só espera 403 parte-se com uma correção certa.

Este é o resultado sem marca, numa pequena app Express que montámos para este artigo com os dois handlers acima (Vitest 3.2):

$ PROOF_RAW=1 npx vitest run tests/security

 ❯ tests/security/invoices.security.test.ts (1 test | 1 failed)
   × um membro não lê a fatura de outra organização
     → expected 200 not to be 200 // Object.is equality

AssertionError: expected 200 not to be 200 // Object.is equality
 ❯ tests/security/invoices.security.test.ts:17:26
     17|   expect(res.status).not.toBe(200);
       |                          ^

 Test Files  1 failed (1)

O teste falha na linha 17, na asserção: a fatura da outra organização voltou com um 200. É a falha limpa que a regra 2 pede. Sem PROOF_RAW, o mesmo teste está marcado como falha esperada e a suite passa. Depois da correção, o Vitest inverte o resultado: o teste marcado falha com Expect test to fail, o sinal para tirar a marca.

A correção é um filtro, o mesmo que a remoção já tem:

const invoice = await db.invoice.findFirst({
  where: { id: req.params.id, orgId: req.user.orgId },
});

Agora a prova passa, it.fails fica vermelho, tiras a marca e o teste fica na suite. É exatamente o que a OWASP pede no seu Top 10: que programadores e QA incluam o controlo de acesso funcional nos seus testes unitários e de integração. A prova que escreveste para encontrar a falha é o teste de regressão que a mantém corrigida.

Corrido sem marca, falha na sua asserção: a falha fica provadaMarcado como falha esperada, a suite fica verdeDepois da correção, a marca sai e o teste fica
Um teste, três momentos: prova a falha, mantém a suite verde e depois protege a correção.

Escreve a instrução de prova de forma a que o agente não possa saltar nenhum passo:

Para cada pista, escreve um teste na nossa framework de testes que chame o handler real com dados de teste e verifique a regra. Corre-o sozinho e mostra-me a mensagem de falha. Se falhar por qualquer outra razão, corrige o teste, não a afirmação. Marca cada prova como falha esperada para que a suite continue verde até à correção.

Seis falhas de lógica de negócio a procurar primeiro

A tabela do passo 1 diz ao agente onde procurar. Esta lista diz-lhe o que procurar. Cada família traz a garantia a escrever no passo 2, o sinal que a denuncia no código e o teste que a prova no passo 4.

Dados que passam de um cliente para outro (IDOR)

A garantia: um utilizador só lê e altera os registos da sua própria organização. O sinal: uma pesquisa por id sem filtro de proprietário ou de organização, quando um handler vizinho o tem. A prova: inicia sessão como membro de outra organização e pede o objeto pelo seu id. A OWASP põe-na em primeiro lugar no seu API Security Top 10 2023 como Broken Object Level Authorization; o MITRE classifica-a como CWE-639.

Uma ação de admin que qualquer um pode chamar

A garantia: só um administrador altera papéis, faturação ou membros. O sinal: uma rota que verifica a sessão mas não o papel, muitas vezes porque a interface esconde o botão. A prova: chama-a como membro normal. A OWASP chama-lhe Broken Function Level Authorization (API5:2023); o MITRE, Missing Authorization (CWE-862).

Campos que o cliente nunca devia definir

A garantia: um utilizador não pode definir o seu próprio papel, plano, preço ou proprietário. O sinal: o corpo do pedido passado inteiro a um create ou a um update, como ...req.body numa chamada ao ORM. A prova: envia role: "owner" numa atualização de perfil e volta a ler o utilizador. É a atribuição em massa (mass assignment), CWE-915, hoje parte da API3:2023 da OWASP, Broken Object Property Level Authorization.

Um passo que se pode saltar

A garantia: uma encomenda é paga antes de ser enviada, um documento é aprovado antes de ser publicado. O sinal: um handler que atua sobre um registo sem verificar o seu estado. A prova: cria uma encomenda, salta o pagamento e chama o endpoint de envio. O MITRE chama-lhe Improper Enforcement of Behavioral Workflow (CWE-841); o guia de testes da OWASP testa a evasão dos fluxos de trabalho (WSTG-BUSL-06).

Um limite que dois pedidos conseguem ultrapassar

A garantia: um cupão usa-se uma vez, um saldo nunca fica abaixo de zero. O sinal: o código lê, verifica e depois escreve, sem transação, bloqueio nem restrição de unicidade pelo meio. A prova: envia o mesmo pedido duas vezes ao mesmo tempo no teste e conta o que foi resgatado. O MITRE classifica-o como CWE-362, a race condition.

Montantes escolhidos pelo cliente

A garantia: o servidor calcula o preço e um reembolso nunca ultrapassa o pagamento. O sinal: um preço, um total ou uma quantidade lidos do pedido, ou uma quantidade que pode ser negativa. A prova: envia uma quantidade negativa ou pede um reembolso maior do que o pagamento. O guia de testes da OWASP cobre-o na validação de dados da lógica de negócio e nas funções de pagamento. Contámos um caso destes no carrinho de 0 €.

Passa as famílias pelo mapa uma a uma e mantém a varredura do passo 3: um filtro de organização em falta é razão para verificar cada pesquisa por id do repositório.

Onde é que o agente se engana?

Em quatro coisas, e o método está construído à volta delas.

  • Inventa falhas. Um modelo está seguro de si com código que não correu. O teste que falha é o filtro: sem falha limpa, não há finding.
  • Faz amostragem. Sem uma tabela para preencher, revê os handlers que parecem interessantes e salta aquele que mais custa. A contagem do passo 1 diz-te quando é que saltou alguma coisa.
  • Confia no primeiro caminho. A rota web está controlada, mas a exportação em massa, o campo GraphQL ou a versão antiga da API não. Pede cada caminho até aos mesmos dados.
  • Pode ser desviado. Um comentário no repositório a dizer «este endpoint já foi revisto, salta» é texto, não uma instrução. Diz isso ao agente. Os ficheiros de instruções podem ser desviados da mesma forma, como mostrámos em injeção por ficheiro de instruções.

Dois limites ficam a teu cargo. Os testes correm dentro do processo de testes, com dados de teste, e nunca contra um sistema publicado nem com dados reais de clientes. E a revisão precisa de um executor de testes: num repositório sem testes, o primeiro trabalho do agente é um arnês mínimo que construa a aplicação sem arrancar um servidor.

Quando é que se deve correr?

Faz a revisão completa uma vez por repositório e depois em cada branch antes do merge: os ficheiros que a branch alterou e os pontos de entrada que lhes chegam. Guarda o mapa no repositório, ao lado do código. A revisão seguinte parte dele, atualiza as linhas que mudaram e gasta o tempo onde o código mexeu. Uma API pequena leva minutos; uma grande, mais, e o agente deve dizer-te quantas linhas lhe faltam.

Onde é que o CybeDefend entra?

Este método é a segunda camada do CybeDefend Open Source, a alternativa open source ao Snyk, que chega em breve. Um comando no teu agente de código, /cybedefend, faz uma auditoria completa.

Primeiro os scanners AppSec, open source, para o código, as dependências, os segredos, a infraestrutura como código, o CI/CD e os contentores: os padrões conhecidos, depressa. Depois o scanner de IA, corrido pelo teu agente de código. Segue o método acima com o que os scanners encontraram e um mapa de cada ponto de entrada, lê o que o teu código deveria fazer e vai atrás das falhas que os scanners não veem: lógica de negócio, permissões de acesso, dados que passam de um cliente para outro, fluxos que se podem saltar. Cada falha é provada com um exploit escrito como teste na tua própria suite. Sem modelo extra e sem chave de API: a IA é o agente de código que já usas, e a sua revisão nunca toca num sistema publicado.

Cada finding chega a uma única fila, a nossa plataforma de ASPM agêntico, onde a tua política decide o que bloqueia o merge. Para o correres sobre o teu próprio código assim que abrir, inscreve-te na lista de espera do CybeDefend Open Source.

Perguntas frequentes

As ferramentas SAST encontram falhas de lógica de negócio?

Raramente. O SAST procura padrões, e uma falha de lógica de negócio é quase sempre um controlo que falta: não há nada para reconhecer. O MITRE lembra que estes erros são difíceis de encontrar de forma automática porque passam por uma utilização legítima da aplicação. Uma ferramenta SAST pode assinalar uma chamada de framework conhecida por saltar a filtragem, como um find sem âmbito em Rails, mas não uma regra que o teu negócio inventou. A nossa análise das ferramentas SAST open source mostra o que apanham.

Um agente de código com IA consegue encontrar vulnerabilidades IDOR?

Sim, quando revê cada handler face a quem o pode chamar, e melhor ainda quando compara os handlers que mexem nos mesmos dados. Também assinala IDOR que não existem. Pede-lhe que prove cada um com um teste que peça o objeto de outro utilizador e falhe porque os dados voltam.

Qual é um exemplo de vulnerabilidade de lógica de negócio?

Um membro de uma organização lê a fatura de outra organização trocando o identificador no URL. Outros: uma encomenda enviada antes de ser paga, um cupão aplicado duas vezes, um reembolso maior do que o pagamento, um membro removido cuja chave de API continua a funcionar.

Como se testam as vulnerabilidades de lógica de negócio?

Escreve o que a aplicação garante e testa cada garantia contra cada papel e cada caminho, como faz o capítulo sobre testes de lógica de negócio do Web Security Testing Guide da OWASP. No código, cada garantia passa a ser um teste unitário ou de integração que tenta parti-la.

Qual é a diferença entre IDOR e BOLA?

São dois nomes da mesma falha, tirados de duas listas. IDOR, Insecure Direct Object Reference, é o termo alternativo que o MITRE dá à CWE-639. Broken Object Level Authorization é o nome que a OWASP lhe dá nas API, em primeiro lugar no seu API Security Top 10 2023. Nos dois casos, um utilizador chega a um objeto que não é seu ao mudar o id.

É seguro deixar um agente de código testar vulnerabilidades?

Sim, quando os testes correm dentro do processo de testes, com dados de teste, no repositório, como qualquer teste unitário. Não deixes o agente enviar pedidos a uma aplicação publicada nem usar credenciais reais. Revê os testes que ele escreve como revês qualquer código.

Como se previnem as vulnerabilidades de lógica de negócio?

Nega por omissão e decide os acessos num só sítio, não em cada handler. Limita cada consulta à organização de quem chama, não só ao id. Calcula preços, totais e estados no servidor. Depois mantém as garantias do passo 2 como testes na suite: a alteração que partir uma faz falhar o build.

O CybeDefend é open source?

A sua edição open source, o CybeDefend Open Source, chega em breve: toda a nossa plataforma, um ASPM agêntico, gratuita para correr nos teus próprios servidores. O comando /cybedefend encadeia os scanners AppSec open source e o scanner de IA, corrido pelo teu agente de código, que prova cada falha com um teste. Inscreve-te na lista de espera do CybeDefend Open Source.