DAST

5 Reasons Your DAST and SAST Scans Miss BOLA & BFLA

Picture of Shikha Patra
Shikha Patra
Product Marketing Manager
• ⏱︎ 10 min read

TL;DR

  • DAST and SAST miss BOLA and BFLA because both flaws depend on identity and ownership context that scanners lack.
  • Reason 1: Scanners have no data on who owns which object.
  • Reason 2: Scanners have no policy on which role may call which function.
  • Reason 3: Valid, authenticated requests look normal to a scanner.
  • Reason 4: Multi-step workflow abuse passes per-request tests.
  • Reason 5: AI agents create call paths no test suite enumerates.
  • The fix: Keep your scanners and add a logic layer. AppSentinels maps authorization logic with the Business Logic Graph, tests it continuously, and enforces it at runtime.

Every API security evaluation reaches the same objection: “We already run SAST and DAST.”

The objection is fair. Static Application Security Testing (SAST) reads source code before release. Dynamic Application Security Testing (DAST) probes a running application from the outside. Both belong in continuous integration and continuous delivery (CI/CD) pipelines.

Both also struggle with the two API flaws that matter most. The Open Worldwide Application Security Project (OWASP) ranks Broken Object Level Authorization (BOLA) first and Broken Function Level Authorization (BFLA) fifth in the OWASP API Top 10. Both sit at the heart of business logic security, which governs what each identity may do.

A green scan dashboard looks like assurance. Authorization is a different question than code safety. Scanners ask whether code or inputs are unsafe. Authorization asks whether this caller should reach this object or call this function.

This post gives five reasons scanners miss these flaws, then outlines a layered fix.

What do SAST and DAST actually see?

SAST sees source code patterns. DAST sees how a running application responds to crafted inputs. Neither holds a model of who owns which data or which role may call which function.

ControlWhere it runsWhat it seesWhat it cannot see
SASTBuild stageCode patterns, unsafe functions, hardcoded secretsRuntime data ownership, callers, role-to-function rules
DASTTest or stagingResponses to crafted inputs from a few test usersCross-user object relationships, role intent, endpoints outside the spec
Authorization logic layerTest and productionObjects, owners, roles, functions, and identitiesCode-level defects that SAST already covers

The table shows a division of labor. Each layer covers a different failure mode. The five reasons below explain why the first two rows leave a gap.

Reason 1: Why can’t scanners see who owns an object?

BOLA occurs when an API accepts an object identifier and never verifies that the caller owns that object. Detection takes at least two identities, a map of who owns what, and tests that swap identifiers across users. Scanners rarely hold any of these.

Consider a request for /orders/1042. The call is authenticated and well-formed. Whether it is a flaw depends on who owns order 1042. A scanner running as one user sees a 200 response and moves on.

Static analysis fares no better, because data ownership lives in databases and business rules. Even with the best API frameworks, most teams must still write the ownership check by hand.

Reason 2: Why can’t scanners tell which role may call a function?

BFLA occurs when a regular user can call a privileged function, such as refund approval or account deletion. The endpoint works exactly as coded. The open question is who may call it, and scanners hold no policy to answer that.

That policy lives in product specifications and in developers’ heads. It rarely exists in a machine-readable form. A scanner cannot test a rule nobody gave it.

Undocumented endpoints make this worse. Zombie APIs and unmanaged APIs never enter scanner scope, so hidden admin functions go untested.

Reason 3: Why do valid, authenticated requests look safe to a scanner?

Scanners flag malformed or malicious inputs. An attacker using a legitimate session sends neither. The Lovable incident shows how a valid request can expose another user’s data when ownership checks are weak. A researcher classified the flaw as BOLA, and Computing used the same label.

In April 2026, an independent researcher publicly reported a flaw in Lovable, an AI app-building platform. Per the researcher, five API calls were enough to reach another user’s profile, public projects, and source code. Database credentials then surfaced in that code. The researcher said the exposure covered projects created before November 2025.

It was reported that the researcher filed the issue through HackerOne on 3 March 2026. That was 48 days before the public dispute. Lovable first stated that it “did not suffer a data breach” and called public code visibility intentional. It later apologized. It said a February backend permissions change had accidentally re-enabled chat access on public projects, and it revoked that access.

Computing added a telling detail. After the fix, the researcher retested. A new project returned a 403 response. An older project still returned 200 with full access. AppSentinels covered the incident in its own analysis of the Lovable breach.

Two lessons matter for scanner-first programs.

  • The calls looked ordinary. Per the researcher’s description, these were standard API requests against object identifiers. A tool hunting for unsafe code patterns has nothing to flag.
  • Intent was disputed. The company first called the exposure intentional, then called it a mistake. No scanner can infer authorization intent from code. Teams must model it explicitly before they can test it.

Reason 4: Why does multi-step workflow abuse pass per-request tests?

Many business logic abuses need no single malformed request. The sequence is the attack. Per-request testing judges calls in isolation and never evaluates their order.

An attacker skips a payment confirmation step. Another replays a coupon call. A third reorders calls to reach a state the designers never planned. Each request is valid alone.

Payment flows raise the stakes. AppSentinels outlines the controls in its guide to 7 API security requirements for payment transactions.

Reason 5: Why do AI agents create paths no test suite covers?

Agentic AI turns BOLA and BFLA into machine-speed risks. AI agents call APIs and Model Context Protocol (MCP) tools using non-human identities (NHI). They choose their call paths at runtime. A prompt injection can steer an agent’s valid credentials toward objects and functions outside its intended scope.

The traffic uses real credentials and well-formed calls. Pre-release test suites cannot enumerate paths an agent generates on the fly. The OWASP Top 10 for Agentic Applications reflects this shift.

A system prompt cannot enforce these limits. A Business Logic Graph can, because it models what each identity, human or machine, may reach and do.

Security teams now need an answer to one question. For every identity, what is it authorized to touch, and is it staying inside that boundary right now? Programs built for agentic AI security start there.

What do the five reasons have in common?

All five share one root cause: scanners test code and inputs, while authorization lives in business logic. Fixing it takes a model of intent that software can test and enforce. More scanning of the same kind will not supply that model.

What does a missed BOLA or BFLA cost?

A missed BOLA or BFLA can expose customer data, source code, and credentials in a single request path. Lovable showed how one authorization gap can reach the secrets stored inside exposed projects.

The cost drivers are consistent across incidents: data exposure, credential rotation, incident response effort, customer trust, and regulatory attention. Your own numbers depend on your data and your APIs. AppSentinels provides a framework in its CISO guide to the hidden cost of BOLA and BFLA vulnerabilities.

Should teams drop SAST and DAST?

No. Keep both. They catch injection flaws, misconfigurations, unsafe dependencies, and exposed secrets. Those risks remain real.

Treat scanners as necessary and incomplete. They cover the code and input layer. A second layer must cover authorization logic. Framing this as a replacement fight wastes budget and invites resistance from AppSec teams.

A web application firewall (WAF) or API gateway does not close the gap either. AppSentinels compares WAF or API gateway controls in a separate guide.

What does a layered approach look like?

A layered approach adds authorization logic coverage on top of existing scanners. Five practices make up the layer.

  • Model authorization intent. Map objects, owners, roles, and functions in a form software can test.
  • Test with real identities. Run BOLA and BFLA checks across multiple users and roles. Practice continuous red-teaming rather than annual tests.
  • Cover the right test types. Review the enterprise API testing capabilities your program needs.
  • Enforce at runtime. Block abuse of valid sessions using logic context, since signatures cannot spot it.
  • Cover agents and machine identities. Apply the same authorization checks to AI agents and MCP tool calls.

How does AppSentinels close the BOLA & BFLA gap?

AppSentinels closes the gap by turning authorization intent into something software can test and enforce. The Business Logic Graph maps objects, identities, roles, relationships, and functions across your APIs. Every capability below builds on it.

The result complements your scanners. SAST and DAST keep guarding code and inputs. AppSentinels guards the authorization logic they cannot see. It delivers this as one API security platform.

For agents and MCP, AppSentinels extends the same model through AI discovery and posture management, AI red-teaming, AI runtime protection, and MCP security.

What should buyers ask any vendor claiming BOLA & BFLA coverage?

Buyers should ask five questions that separate real authorization coverage from signature matching.

  1. Does it learn authorization logic? Signature matching cannot find ownership flaws.
  2. Can it test with multiple real identities and roles? Single-user testing misses BOLA.
  3. Does it cover agent and MCP traffic? Machine identities now carry much of the risk.
  4. Does it find APIs your scanners never saw? Unknown endpoints cannot be tested.
  5. Does it enforce in production? Reports without enforcement leave the window open.

Use the API Security Buyer’s Checklist for the full evaluation. To compare vendors, see the top 10 API security companies, the best agentic AI security platforms, and the top 10 MCP security companies.

Ready to see your BOLA & BFLA gaps? Book a demo to see your authorization gaps mapped against your current scanner coverage.

Frequently Asked Questions

Does AppSentinels replace SAST and DAST?

AppSentinels complements both. SAST and DAST keep catching code-level and input-level flaws. AppSentinels covers the authorization logic they cannot see.

How does AppSentinels detect BOLA and BFLA?

AppSentinels builds the Business Logic Graph, a model of objects, identities, roles, and functions across your APIs. It tests that model with multiple identities and flags requests that break ownership or role rules.

Can AppSentinels find APIs that DAST never tested?

Yes. AppSentinels discovers shadow, zombie, and unmanaged APIs, so endpoints outside your specifications enter testing and monitoring.

Does AppSentinels cover agentic AI and MCP traffic?

Yes. AppSentinels extends BOLA and BFLA protection to AI agents, non-human identities, and MCP tool calls. Agent actions face the same authorization checks as human users.

How does AppSentinels fit into an existing AppSec pipeline?

AppSentinels runs alongside your CI/CD scanners. It adds continuous testing before release and enforcement in production, with no need to remove current tools.

Related Content