Hi people,

I want to share a broken access control story that started with a perfectly reasonable response: 403 Forbidden. At first, I thought the application had handled the object boundary correctly. A second account could not open a draft owned by my first account.

The interesting part came when I stopped treating read and write as the same permission.

Publication note: This story is reconstructed from private research. The company, product, routes, identifiers, dates, and UI labels were removed or replaced. The examples are synthetic, and I am not claiming a deployed fix or completed retest.

A protected document that cannot be viewed but can still be changed through another path.
Original Swiss-modernist typographic illustration for this anonymized field note.

The first check looked safe

I began with two controlled accounts. Account A created a draft and added a harmless marker to it. Account B had no sharing invitation, no editor role, and no reason to see that object.

When I requested the draft as Account B, the server rejected the request. That was the expected result. It also gave me a useful baseline: the application itself agreed that Account B should not have access to this draft.

Account A -> open draft_42 -> allowed
Account B -> open draft_42 -> 403 access_denied

It would have been easy to stop there and write down "read authorization works." Instead, I looked at every action the interface could perform on the draft. Saving text and changing the order of sections used different requests from opening the draft.

The write told a different story

I kept Account B's authenticated session, reused the known draft reference, and submitted a harmless edit. The server accepted it. I tried the reorder action as a second path, and that was accepted too.

A success response was not enough for me. APIs sometimes return optimistic messages even when nothing changes. So I went back to Account A, opened the original draft, and found Account B's marker saved in the content. The new order was visible as well.

That was the moment the finding became real. The 403 was genuine, but it protected only the read path. The operations that changed the object did not enforce the same relationship.

Reconstructed flow using placeholder accounts and identifiers. It illustrates the evidence sequence, not an original product screen.

Why the owner's view mattered

When I test authorization, I try to separate the server's words from the server's state. A 200 can be misleading. A denied read followed by an independently observed stored change is much stronger evidence.

The owner check also ruled out a local interface trick. The unauthorized account did not merely change something in its own browser. The application persisted the change to the owner's object.

I repeated the idea through the second mutation path because authorization gaps often appear where features split into separate handlers. "Edit content" and "reorder content" may look like one feature to a user while reaching different policy checks on the server.

What I could actually claim

The evidence proved a loss of draft integrity: an unrelated controlled account could alter stored work owned by another account. It did not prove that the draft could be sent, signed, approved, or completed. I did not need to stretch the impact. The stored unauthorized change was already clear.

I also did not claim that identifiers were enumerable. I already knew the test object's reference from my controlled setup. The security failure was that knowing a reference became enough to change the object.

This distinction matters in bug bounty reports. A narrow claim supported by two-account evidence is far more useful than a dramatic claim built on assumptions.

Open-source workflow companion: Autorize

A practical open-source companion for this authorization pattern is the Caido Autorize plugin. It automatically tests whether lower-privilege users can reach resources they should not, making it useful for spotting the mismatch where an owner can perform an action and an unrelated account unexpectedly receives the same result. I would capture the owner's read and update requests, configure only my second controlled account as the alternate identity, and keep the test limited to a synthetic draft. The automated comparison is the lead, not the proof: after a suspicious write response, I would return to the owner's clean session and verify whether the harmless marker was actually stored. This is a workflow recommendation for authorized testing, not a claim that Autorize was used in the original private submission.

The takeaway

Read permission and write permission answer different questions. A secure object read does not automatically protect save, reorder, attach, publish, or background-processing actions.

The repair direction is simple to describe even if implementation takes work: every mutation must ask whether the current principal may perform this action on this object. Child objects must belong to the same authorized parent, and queued work should preserve the initiating identity instead of inheriting a worker's broad authority.

For a retest, I would check both sides. An unrelated account must be denied without any stored change, while a deliberately invited editor must still be able to work. That proves the policy is precise, not merely restrictive.

That is all for this write-up. The lesson I kept from it is short: when a read returns 403, do not assume the writes are protected too.

If you liked this story, read When two browsers inherited one cart next, or browse the complete Bug Bounty Archive.

Continue reading

Test every action, not only every screen.

Explore SaaS penetration testing for role and object authorization testing, or continue through the archive.

Research topics: broken access control / object authorization / draft integrity / bug bounty