IDOR Exploitation in Multi-Step SaaS Workflows

Later workflow steps often skip ownership checks.

· 8 min read
Cover illustration for “IDOR Exploitation in Multi-Step SaaS Workflows”
Exploitation Techniques · November 13, 2026 · 8 min read · 1,907 words

IDOR exploitation in multi-step SaaS workflows is an authorization problem that often hides after the first successful ownership check. Later steps trust what came before and skip checking who may use the object now. Finding that gap requires following the full workflow with different users and tenants.

What IDOR actually is and why authorization is the missing piece

An insecure direct object reference, or IDOR, occurs when a server accepts an object reference without checking whether the user who sent it may access that object. Exposing an identifier is not itself the flaw. The OWASP IDOR Prevention Cheat Sheet lists three parts of the flaw: an object, a reference to it, and a missing object-level authorization check. With that check in place, the reference is harmless.

Authentication and authorization answer different questions about a request. A valid session cookie proves that the request came from Alice, but it does not prove that the requested invoice belongs to Alice. Frameworks can handle authentication but leave ownership rules to application code, because only that code knows which users may touch which records. OWASP calls the same flaw Broken Object Level Authorization, or BOLA, in its API guidance. The missing relationship between identity and object is the root cause, regardless of the name.

Where object references hide across a SaaS application's surface

A URL such as /api/invoices/98432 is only the most visible place an object reference appears. Query strings can pick an account through ?account=88231, while request bodies and hidden form fields can pick an order. Hidden does not mean trusted by the server. Custom headers such as X-Account-Id and X-User-ID, as well as account cookies, are also inputs whose ownership claims need verification. Treating them as infrastructure does not change that.

GraphQL arguments pick objects through queries and mutations, while frames sent over a persistent connection can pick a subscription channel. JWT claims identify a subject or provide other attributes, but trusting a claim does not replace checking that subject’s right to the requested resource. Nor are references limited to numbers. File names, order codes, email addresses, encoded values, and UUIDs can all point to objects that need protection.

These references run through account management, billing, file operations, exports, and tenant settings. An invoice download and an SSO configuration change thus have the same authorization problem, though the harm each can cause differs. Testing only URL paths leaves most of that surface unexplored. Newly shipped features get less testing, so it is especially easy to miss new paths that take an object reference.

How multi-step workflows create authorization gaps that isolated endpoint tests cannot see

A workflow creates a gap when an early ownership check becomes an unwritten promise that every later object belongs to the same user. That promise holds during ordinary use. It fails when someone introduces a foreign identifier between stages, because a check on one request cannot authorize an unrelated reference supplied later. Second-order IDOR separates acceptance from use even further, with an identifier accepted and stored at one step, then consumed later without authorization.

Consider a cart workflow that starts at POST /cart/add, where ownership may be checked. Next, POST /cart/checkout processes the cart while assuming it still belongs to the original user. Finally, GET /orders/{order_id} retrieves an order, but an omitted ownership check lets it return another user’s order. The first check did not protect the last step. A test that uses only the tester’s own order may return a valid response and show nothing about foreign references passed in along the way.

The same trust in an earlier check can carry over when users resume pending requests, poll jobs, download exports, or follow document relationships that create standing access grants. Cross-tenant workflows add an organization boundary to the problem. A user in tenant A can change organizationId in a PUT body and write into tenant B’s configuration if the server validates the JWT but never binds the requested organization to that identity.

Why UUIDs and non-guessable identifiers do not close the gap

Langflow’s CVE-2026-55255 shows why UUIDs cannot replace ownership checks. Its flow IDs were UUIDs, but GET /api/v1/flows/ disclosed flow identifiers, including other users’ flows in multi-tenant deployments. An authenticated attacker could fetch the listing and then supply a victim’s UUID to execute that workflow. No guessing was needed to obtain the reference. CISA added the vulnerability to its Known Exploited Vulnerabilities catalog on July 7, 2026, with a federal remediation deadline of July 10, 2026.

Langflow checked ownership when resolving a human-readable endpoint name but not when resolving a raw UUID. Randomness could not repair that branch in the code.

A separate SaaS page-builder case followed the same structural pattern. Its delete endpoint lacked authorization despite using random, non-guessable IDs, and its build, preview, and publish flows exposed those values in Burp Suite HTTP history. The attacker’s discovery path was the application itself. Whenever an earlier step discloses the reference that a later step consumes, making that reference harder to guess leaves the consuming endpoint unprotected. Obscurity is not authorization.

What happens when a workflow IDOR is chained with other vulnerabilities

The Langflow attack chain continued beyond unauthorized workflow execution. Prompt injection using “leak api keys” led to extraction of LLM provider credentials, cloud credentials, and database credentials. The exposed UUID made the victim’s workflow reachable, the authorization failure allowed execution, and the prompt injection turned that execution into credential compromise.

Other SaaS chains depend on what the reachable step permits. If it accepts field updates, IDOR combined with mass assignment can let an attacker change another user’s object and may let them elevate a role. If it accepts a webhook target or callback URL, a destination that the attacker controls can let them use server-side request forgery against internal services. If it stores content in another user’s object, cross-site scripting can execute when the victim views that content and lead to admin session theft. These are possible chains.

An authorization failure shared across tenants can expose their equivalent objects. A horizontal flaw, such as Alice reading Bob’s invoice, can become vertical privilege escalation or cross-tenant access, depending on what later steps let the user do. Approval and deletion steps need testing for that reason, since using them without authorization changes state.

Why automated scanners cannot find multi-step workflow IDOR on their own

To establish the central contradiction in an IDOR finding, a scanner needs an object belonging to user A and a request from user B that should not be allowed to use it. The tool must follow the steps in the right order, keep the identifiers it gets, and replay them under a different identity at the step being tested.

Static analysis faces a related limit because there is no single code signature for every missing ownership relationship. A valid rule may depend on a user, organization, role, or intended document relationship. Traffic alone does not show how those business rules work. Code, API documentation, and application behavior provide the context needed to judge whether access is wrong.

Some vulnerable endpoints are also absent from a simple crawl. A job-status or export-download endpoint may only become reachable after earlier steps produce its identifier. GraphQL creates another coverage gap when one resolver checks ownership but a sibling returning the same type does not. Automated tools are still useful for well-defined vulnerability classes with known signatures, but it takes more than isolated probes to prove these workflow flaws. The mismatch is between the test model and the vulnerability.

How to test multi-step workflows for IDOR correctly

To cover that gap, testers should map each workflow from entry to completion before replaying requests. Record every step, the identifiers it consumes, and whether its design expects an independent ownership check or inherited authorization. Then set up independent authenticated sessions in a proxy such as Burp Suite. The setup needs accounts at the same privilege level, at different privilege levels, and in separate tenants so that horizontal, vertical, and cross-tenant boundaries can all be tested.

At each stage, replay the request with session B’s authentication and an object reference obtained through session A. Vary the step where the foreign reference is passed in. Include the main submission endpoint, job-status polls, export downloads, webhook callbacks, approval triggers, and subscription or follow relationships. A successful response alone is not proof, since the returned object or completed action must actually cross the intended boundary.

For async workflows, complete the sequence as A to obtain the job ID, export ID, or callback token, then attempt retrieval as B. Test human-readable names and raw UUIDs separately wherever both point to the same object, because their lookup branches may apply different rules. Test each GraphQL resolver independently for the same reason. The finding must end with a working exploit showing B accessing or modifying A’s object.

How to fix multi-step workflow IDOR at the code level

Engineering teams should close the gap at every server-side step that consumes an object reference. Scope the lookup to the authenticated session’s user or organization, according to the application’s access rules. The client’s ownership claim is not trusted evidence. Nor does a successful check on an earlier request authorize the next object supplied.

The vulnerable lookup is invoice = db.invoices.find(id = request.path.id). The scoped version is invoice = db.invoices.find(id = request.path.id, owner_id = session.user_id). A foreign ID then returns a 404. For actions whose identity must come from the session, the server should derive it there instead of accepting a user_id field from the request body.

Store the owner when creating a job or export, then independently check that owner when another request retrieves it. Bind callback tokens to the creating session’s identity at issuance and verify that binding when they are consumed. Possession of the token alone must not stand in for ownership.

Apply authorization consistently to both named and UUID lookup paths. Random identifiers remain useful alongside ownership checks as a secondary control that reduces guessability. After remediation, retest the whole sequence. Fixing the retrieval endpoint does not establish that a related status, callback, or action endpoint is also protected.

Why point-in-time testing misses workflow IDOR and what a continuous approach catches instead

A successful retest establishes something about the workflow that exists at that time. It cannot cover a later export stage, approval step, or callback endpoint that has not yet shipped. Each addition can inherit the same unsafe assumption. A prior finding may be closed while a new endpoint quietly reopens the vulnerability class.

Testing once a year is therefore a poor fit for a SaaS team that ships multiple releases per week. New object-consuming steps can reach production between engagements without their authorization model being reviewed. Scanning and review of each pull request should work alongside periodic penetration testing to check that each new step has a server-side ownership check before it ships. That review does not remove the need for human testing of the complete sequence, because the presence of a check alone does not prove that it enforces the right relationship.

The evidence must cover remediation as well as discovery. For SOC 2, HIPAA, and ISO 27001, access-control findings need a record showing that remediation happened and was verified. A workflow flaw introduced and exploited between annual tests exposes a gap in that documented control environment. A continuous approach pairs review of changes with a certified human reviewer who follows the workflow against source code and API documentation, proves findings with working exploits, and retests the fixes.

Sources

  1. Langflow Authorization Bypass Added to CISA’s KEV Catalog

More in Exploitation Techniques