Hi people,
Cache testing can feel confusing because the response in front of you may not come from the application you are testing. It may come from a delivery layer that made its own decision earlier.
In this case, the origin understood the authentication boundary. The cache did not.
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.

The private baseline
I started with a controlled account page containing a unique harmless marker. While authenticated, I requested the page and confirmed that the response belonged to my account. The origin included a private cache directive, which looked encouraging.
Next, I repeated the request without a session. The direct application path refused it. That was the expected control: an anonymous visitor should not receive the account page.
I saved only the minimum comparison needed for the test: the response status, the controlled marker, and whether authentication was present. Keeping the evidence small made the boundary easier to explain without carrying unrelated account content into the write-up.
Authenticated request -> 200 -> marker: OWNER-ALPHA
Anonymous origin request -> 401 -> no account content
If I had tested only the origin behavior, I would have concluded that the page was protected. But the public route also passed through a shared delivery layer, so I changed clients and tested the complete path.
A fresh client saw too much
I opened a clean client with no cookies, no local storage, and no earlier connection to the controlled account. Then I requested the same public URL through the normal edge path.
The response was 200, and the body contained my unique account marker. It was not a generic shell or a login page. The private response previously created for the authenticated session had crossed into an unauthenticated request.
I repeated the comparison carefully because cache findings are easy to overstate. The marker made the response easy to identify, and the clean client made the missing session clear. The important proof was the body, not simply a cache-looking header.
Two layers made two different decisions
This was not a simple missing-login check. The application did perform the check when it handled the anonymous request directly. The failure appeared because another layer could answer before the origin had a chance to enforce that decision.
A response marked private expresses an intent, but every cache in the path must honor that intent. Cache keys must also separate representations whenever cookies, authorization headers, tenant context, language, or other request state changes the body.
One dangerous pattern is letting an authenticated response populate a key that an unauthenticated request can later match. Another is stripping the very request state that should have divided the cache entries. I could observe the boundary failure, but I could not see the private configuration that caused it, so I did not guess at the exact internal rule.
Keeping the claim bounded
The evidence showed content from my controlled account returned to my clean unauthenticated client. I did not test real customer accounts, and I did not claim that every account page or every edge location behaved the same way.
I also avoided treating a single cache header as proof. Headers can be inconsistent, diagnostic, or rewritten. The controlled marker crossing the session boundary was the finding.
That framing made the report stronger. It described exactly what an independent retest could reproduce without turning one controlled response into a claim about the entire customer base.
Open-source workflow companion: Param Miner
For a cache-boundary test, I would add Param Miner to the workflow. The Burp extension looks for hidden headers, cookies, and parameters by comparing responses, and its documentation calls out web cache poisoning as a core use case. After establishing authenticated and anonymous baselines, I would run it only against the approved route and watch for inputs that change how the delivery layer groups responses. A discovered input is a clue, not proof. The proof still needs a unique harmless marker from my controlled response appearing in a clean client. This is a current workflow recommendation, not a claim that Param Miner was used in the original private submission. Rate-limit it and keep the test isolated to controlled content.
The takeaway
For private responses, the origin and the delivery layer are one security boundary. Authentication at the application is not enough if an intermediary can replay the resulting body to someone else.
A useful retest needs at least three controls: an authenticated request with a unique marker, an anonymous request that reaches the origin, and a fresh anonymous request through the ordinary cached path. The last request must never receive the marker.
The defensive goal is not simply adding more Cache-Control text. Private responses should be uncacheable by shared systems or keyed on every relevant identity dimension, and authenticated pages should fail closed when those guarantees are uncertain.
That is all for this write-up. Whenever a private page looks protected, I now ask a second question: protected by which layer?
For another state-boundary story, read When two browsers inherited one cart, or browse the complete Bug Bounty Archive.
Test the path that actually serves the response.
Explore web application penetration testing for authentication, caching, and data-exposure review, or continue through the archive.
Research topics: web cache / private responses / data exposure / authentication boundaries