Blog/Vulnerabilities

Broken Access Control: The Flaw Scanners Are Worst At Finding

Why the most common application weakness is also the hardest to scan for, how authentication bypasses reach CVSS 10.0, and how to test for it properly.

CyberWatch AILast reviewed 21 November 2026 · 7 min read
A row of metal filing cabinets with some drawers partly open

A customer logs into a billing portal and views their invoice at /invoice/80412. Out of curiosity they try /invoice/80411. Another company's invoice loads: their address, their order history, their account manager's name.

Nothing was hacked. No payload was injected, no credential was stolen, no software crashed. The request was perfectly formed and the user was properly logged in. The application simply never asked whether this logged-in person was entitled to invoice 80411.

That is broken access control, and OWASP ranked it first in the 2021 Top 10 with figures worth sitting with: 94% of applications in the dataset were tested for some form of it, the average incidence rate was 3.81%, and it had the most occurrences of any category, over 318,000. It is the most common application weakness and the one automated tools are least able to find.

Authentication is not authorization

These two words are routinely treated as one idea, and separating them explains why this flaw class is so persistent.

Authentication establishes identity. A password, a passkey, a one-time code, a certificate. The industry has invested heavily here and the controls are mature.

Authorization establishes entitlement. Given that we know who you are, may you read this record, call this endpoint, change this setting? There is no central mechanism for this, because the answer depends entirely on what the application does. It has to be written, by hand, at every point where it matters.

The consequence is uncomfortable: every authentication improvement you make leaves broken access control exactly as it was. Rolling out phishing-resistant multi-factor authentication is valuable and does nothing about an authorization check that was never written. Our guide on passkeys and phishing resistance covers the authentication half; this is the other one.

The forms it takes

OWASP enumerates the common failures, and they fall into four recognizable shapes.

Object-level failures

The application accepts an identifier from the user and fetches the matching record without verifying ownership. OWASP describes it as "permitting viewing or editing someone else's account, by providing its unique identifier (insecure direct object references)." MITRE tracks the pattern as CWE-639, authorization bypass through a user-controlled key.

The invoice example above is this. So is a document identifier in an API path, a user identifier in a profile update, a message identifier in a messaging feature. These are the most common findings in real applications because every single endpoint that takes an identifier needs its own check, and missing one is easy.

A note on a popular non-fix: replacing sequential identifiers with random ones. This is worth doing, because it stops casual enumeration and keeps your record counts out of public view. It is not an access control. A random identifier is still a bearer token for the record, and identifiers leak through referrer headers, logs, shared links, support tickets and exports. Use unguessable identifiers and also check ownership.

Function-level failures

The user can invoke an operation reserved for a higher role. OWASP's examples include "accessing API with missing access controls for POST, PUT and DELETE" and "force browsing to authenticated pages as an unauthenticated user or to privileged pages as a standard user."

The classic version of this is an application where the administration screen is protected by not appearing in the menu. The server has no opinion about who requests it. Another frequent version is a read endpoint that checks permissions properly while the corresponding write endpoint, added later, does not.

Metadata and state manipulation

The decision is made from something the user can change. OWASP lists "metadata manipulation, such as replaying or tampering with a JSON Web Token (JWT) access control token, or a cookie or hidden field manipulated to elevate privileges," along with CORS misconfiguration permitting API access from untrusted origins.

A role stored in a cookie and trusted on return is the archetype. A token whose signature is not actually verified is the modern equivalent, and it has appeared in production more often than anyone would like.

Missing or bypassable authentication on a critical function

The most severe variant, and the one that produces the headline advisories. Here the broken check is the front door.

CVE-2023-22515 in Atlassian Confluence is the case to study. The CVE record contains Atlassian's own description: the company "has been made aware of an issue reported by a handful of customers where external attackers may have exploited a previously unknown vulnerability in publicly accessible Confluence Data Center and Server instances to create unauthorized Confluence administrator accounts and access Confluence instances." Atlassian scored it 10.0 and noted that Atlassian Cloud sites were not affected. CISA's catalog entry names it a broken access control vulnerability, added in October 2023, and records known use in ransomware campaigns.

The same shape recurs across products. CISA describes CVE-2022-1388 in F5 BIG-IP as a missing authentication in a critical function that can allow remote code execution, and CVE-2024-1709 in ConnectWise ScreenConnect as an authentication bypass allowing an attacker with network access to the management interface to create a new administrator-level account. In the current exploited catalog, missing authentication for a critical function and improper access control together account for dozens of entries. This is not an obscure corner of the catalog.

Why your scanner is quiet about it

A vulnerability scanner works by sending input and recognizing a response that indicates a flaw: an error message revealing a stack trace, a time delay indicating injected SQL, a reflected payload. Broken access control produces none of that. The request is well-formed, the response is a normal HTTP 200, and the data returned is real.

To flag it, a tool would need to know that account A should not be able to see record 80411. That is business logic, and it is not in the application's responses, its configuration, or its source code in any machine-readable form. This is why access control findings come from penetration tests and bug bounty reports rather than from scan output, and why a clean scan report says very little about this class. Our vulnerability management guide makes the general version of this point about what scanning does and does not cover.

Testing for it in a way that works

The method is unglamorous, repeatable and effective.

  1. Create at least three test accounts: two unprivileged users in different tenants or customer records, and one privileged user.
  2. Exercise the application as each one and capture the requests made, including the API calls the front end issues rather than only the pages a person visits.
  3. Replay every captured request under the other identities, and with no session at all. The correct result is a refusal. Anything that returns data is a finding.
  4. Test every verb, not just GET. A properly protected read and an unprotected delete on the same resource is a common pattern.
  5. Turn the results into automated regression tests. Access control breaks when code changes, and a test suite that asserts "user B cannot read user A's invoice" catches the regression on the day it is introduced.

Step five is where the lasting value is. Access control failures are not usually introduced by a careless developer writing a bad check. They are introduced by somebody adding a new endpoint and not knowing that a check was required.

Designing it out

OWASP's prevention guidance begins with a sentence that rules out whole categories of mistake: access control "is only effective in trusted server-side code or server-less API, where the attacker cannot modify the access control check or metadata." Everything else follows from that.

  • Deny by default, for everything except genuinely public resources. A new endpoint should be inaccessible until someone decides who may use it, rather than open until someone remembers to close it.
  • Implement the mechanism once and reuse it. Scattered per-endpoint checks are where the gaps appear. A single enforcement point that every request passes through is both easier to review and harder to forget.
  • Enforce record ownership in the data model. OWASP's phrasing is worth adopting: access controls should enforce record ownership "rather than accepting that the user can create, read, update, or delete any record." A query scoped to the current user's records by construction cannot return someone else's.
  • Invalidate sessions server-side on logout, and keep stateless tokens short-lived so the window for a stolen one is small. Our explainer on session and token theft covers why that window matters so much.
  • Log access control failures and alert on repeated ones. A single denied request is noise. Fifty from one account in a minute is someone enumerating.
  • Rate limit API and controller access, which limits the damage automated tooling can do before anyone notices.
  • Turn off directory listing and make sure metadata such as .git directories and backup files are not sitting in the web root.

Access control failures are often reported by customers, not tools. If someone tells you they can see another account's data, treat it as a confirmed finding and investigate before asking for proof. For checking a suspicious message or link instead, use CyberWatch AI Scan.

The short version

Broken access control is the application failing to check entitlement rather than identity. It appears as object-level failures where an identifier fetches a record nobody verified you own, as function-level failures where a privileged operation is reachable, as trusting metadata the user controls, and at its most severe as a missing or bypassable authentication check on an internet-facing product.

Automated scanning does not find it, because the malicious request is indistinguishable from a legitimate one without knowing the business rules. What finds it is authenticated testing from multiple accounts, and what prevents it is denying by default, enforcing ownership in the data model, and having one authorization mechanism rather than a check at every call site. For the sideways-movement version of the same problem, see our explainer on privilege escalation.

Frequently asked questions

What is broken access control?

A failure to enforce what a user is allowed to do. The user is who they claim to be; the application simply does not check whether that identity is permitted to see or change the thing they asked for. OWASP ranked it first in the 2021 Top 10.

What is an IDOR?

An insecure direct object reference: the application uses an identifier supplied by the user to fetch a record, without checking that the user owns it. Changing a number in a URL or an API call returns someone else's data. MITRE tracks the pattern as CWE-639.

What is the difference between authentication and authorization?

Authentication establishes who you are. Authorization establishes what you may do. Broken access control is an authorization failure, which is why it survives strong passwords, multi-factor authentication and single sign-on untouched.

Why don't vulnerability scanners find these?

Because the request looks valid. There is no malformed input, no injected payload and no error. Detecting the flaw requires knowing what this specific user should be allowed to do, which is business logic the scanner has no access to.

What is force browsing?

Requesting a URL directly rather than navigating to it, to reach a page the interface did not offer you. If an administrative page is protected only by not being linked in the menu, force browsing reaches it.

Does hiding the admin link help at all?

No. Removing a link from a menu changes nothing about what the server will serve. Access control that lives only in the user interface is not access control, and OWASP states that it is only effective in trusted server-side code.

Why do these flaws reach the highest severity scores?

When the broken check is the authentication check itself on an internet-facing product, an unauthenticated stranger can create an administrator account. Atlassian scored CVE-2023-22515 in Confluence at 10.0 on that basis, and CISA records it as exploited and used in ransomware campaigns.

How do we test for it?

With authenticated testing from multiple accounts. Capture the requests one user's session makes, replay them with a different user's session and with no session, and confirm the responses are refusals. This catches what scanners cannot, and it can be automated as a regression test.

Sources

  1. A01:2021 Broken Access Control, OWASP
  2. CWE-284: Improper Access Control, MITRE
  3. CWE-639: Authorization Bypass Through User-Controlled Key, MITRE
  4. CVE-2023-22515, CVE Program
  5. Known Exploited Vulnerabilities Catalog, US Cybersecurity and Infrastructure Security Agency
  6. CVSS v4.0 Specification Document, FIRST
  7. CWE-306: Missing Authentication for Critical Function, MITRE
  8. Authorization Cheat Sheet, OWASP
Share this article
LinkedIn WhatsApp X
For organizations

Your people get these messages at work too.

CyberWatch AI sends your staff realistic practice attacks, trains the gaps it finds, and shows management exactly where the organization stands.