Skip to main content
Security guideReviewed

Web cache deception: when a shared cache keeps one person's private page

A cache in front of your site stores copies of responses so it can answer the next visitor without asking your server.

Web cache deception is the case where it stores the wrong one: a signed-in person's private page, kept under an address the cache took for a public file and handed to the next request, session or no session. This guide explains how a shared cache decides what to store, why one URL can mean two things to two layers, and the four controls that stop it. It comes with a response-cache matrix, four path-confusion fixtures and a lab you can run on your own computer.

Response-cache matrix, path-confusion fixtures and lab

Part 1 is a matrix with six route types, from a public static file to an error page: who may see each, the Cache-Control and Vary to send, whether a shared cache may store it, the cache status to expect and what an anonymous request must get back, with the source named where a value rests on one. Part 2 gives four path-confusion fixtures.

How to use it

Parts 3 and 4 are an illustration you can run with Node.js and no installs: an invented origin behind a cache written for this page, each in a careless and a careful version, with every output copied from one recorded run on Node.js 26.0.0. Parts 5 and 6 are browser checks and a regression test for your own application.

web-cache-deception.txt

Introduction17 lines

RESPONSE-CACHE MATRIX, PATH-CONFUSION FIXTURES AND LAB ILLUSTRATION ONLY. Parts 1, 2, 5 and 6 are for your own application. Parts 3 and 4 are a lab: an invented origin, Lab Ledger, and a small shared cache written for this page, held in memory and run on one computer. Nothing in the lab is a client's system or a client's result. It shows the pattern, not how any real CDN, proxy or framework decides what to store, and its cache is not an implementation of RFC 9111. The one account, lab-member, its password invented-lab-password-not-real and the private marker were made up for this page and are no product's default. Use what the lab teaches only on systems you own or are authorised in writing to test, signed in as your own test account. WHAT THE LAB NEEDS Node.js. Apart from each other, the eight files import only node:assert/strict, node:crypto, node:http and node:test, and the lab installs no packages. The run in Part 4 was recorded on macOS with Node.js 26.0.0, the only version and the only system it was run on. Test timings, the port and the process id differ from run to run. WHAT THE LAB DOES NOT DO Both servers listen on 127.0.0.1, on ports the system picks, and no request leaves your computer. Nothing is written to disk: sessions and stored responses are held in memory and are gone when a script ends. The run scripts and the test start their own servers and stop them before they finish. Only serve.mjs keeps running, until you stop it. The session cookie's value is random and is never printed. There is no browser in the lab: its anonymous visitor is a second request that the script sends with no cookie. WHAT IS HERE Part 1 The response-cache matrix: six route types to fill in for your own application Part 2 The four path-confusion fixtures, and how to build them for your own routes Part 3 The lab files: eight files Part 4 The recorded run: nine commands and what each printed Part 5 Browser checks on your own application Part 6 The same regression test on your own application

What web cache deception is

Web cache deception is a private response ending up in a shared cache.

A signed-in person's browser requests an address. Your server reads that address as their account page and answers with it. The cache in front of your server reads the same address as a public file, such as a stylesheet or an image, and keeps a copy. From then on, a request for that address is answered from the copy, whoever sends it and whether or not they are signed in.

No password was guessed and no access check failed. Two layers read one URL two ways, and the layer that stores things believed the wrong reading.

The attack was described by Omer Gil in a post dated 27 February 2017, Web Cache Deception Attack. His example is a request for a page address with a file name added to it, home.php/non-existent.css. He writes that, depending on its technology and configuration, the server returns the content of home.php for that URL, with the same caching headers and the same content type as the page itself, and that a proxy set to cache static files while disregarding their caching headers identifies that the file has a css extension and caches it.

He gives two conditions for the vulnerability to exist: web cache functionality that is set to cache files by their extensions, disregarding any caching header, and a web server that returns the content of home.php when a page such as home.php/non-existent.css is accessed.

In the same post Gil reports that PayPal was vulnerable, and that the vulnerability is now fixed and was publicly disclosed. The information he lists as open to being leaked includes users' first and last names, account balance, the last four credit card digits, email address and home address.

That is his account of one service in 2017. The post's list of his talks includes Black Hat USA 2017, under the same title.

A research team later measured how far the problem reached. Cached and Confused: Web Cache Deception in the Wild, by Seyed Ali Mirheidari, Sajjad Arshad, Kaan Onarlioglu, Bruno Crispo, Engin Kirda and William Robertson, appeared in the proceedings of the 29th USENIX Security Symposium in August 2020.

It describes web cache deception as an attack in which an attacker tricks a caching proxy into erroneously storing private information and subsequently gains unauthorised access to that cached data. In a crawl the paper dates to 20 to 27 April 2018, its authors found 16 of 295 sites drawn from the Alexa Top 5K, or 5.4%, to contain web cache deception vulnerabilities, and 14 of the 16 leaked personal information of various kinds, including names, usernames, email addresses and phone numbers.

The 295 were the sites that offered sign-in through Google OAuth, which the authors used to create test accounts at scale, so the figure describes that sample.

The paper's diagnosis is the reason this guide treats the cache and the origin together. At its core, the authors write, web cache deception results from path confusion between an origin server and a web cache: different interpretations of a requested URL at these two points lead to a disagreement on the cacheability of a given object.

They add that this does not imply that the origin server and the web cache are each incorrectly configured, and that it is their hazardous interactions as a system that lead to the vulnerability.

Its mirror image, a harmful response stored and served to other visitors, is web cache poisoning, which has a guide of its own.

The two requests in a cache deception attack, and who sends them

In the published accounts, the first request comes from the signed-in person's browser and the second from someone else. Gil writes that the page is cached, and so publicly accessible, once a logged-on user accesses the address, and that the attacker then accesses the page on his own. He adds that websites usually do not require authentication for their public static files, so the cached file needs none either.

Everything on this page keeps both requests in your own hands. The first is sent with your own test account and the second with no session, against your own application or the lab, and the stored copy is your test account's page.

What a shared cache is and why sites use one

A cache is a store of responses.

RFC 9111, the HTTP caching standard published in June 2022, describes it as a local store of response messages together with the subsystem that controls their storage, retrieval and deletion, and says a cache stores cacheable responses in order to reduce the response time and network bandwidth consumption on future equivalent requests.

It separates two kinds. A shared cache stores responses for reuse by more than one user, and the RFC says shared caches are usually, but not always, deployed as part of an intermediary.

The other kind, a private cache, is dedicated to a single user, and the RFC says such caches are often deployed as a component of a user agent, which for a website is the browser.

The shared caches this page is about sit between your visitors and your server: a content delivery network (CDN), or a reverse proxy with its cache turned on. The 2020 USENIX paper describes CDNs as deploying massively distributed networks of shared caching proxies, so that as many requests as possible are served from the caches closest to clients and the origin servers are offloaded. For the site owner that means pages that arrive sooner and a server that answers fewer requests.

One sentence from the same paper explains why a mistake here is a privacy problem. Cached objects, it says, must not contain private or otherwise sensitive information, as application-level access control is not enforced at cache servers. Your sign-in check runs on your server.

A request the cache answers from its store is not passed on to your server, so the check does not run. Whatever is in the cache is available to anyone who can name its address.

A cache also needs a rule for which stored copy answers which request. RFC 9111 section 2 calls that the cache key and says it is composed from, at a minimum, the request method and the target URI.

A session cookie is not part of that minimum. Unless a product or a rule adds it, a signed-in request and an anonymous request for the same address are the same request to the cache.

How a cache decides what to store

Whether a response may be stored is decided twice: once by the HTTP standard, which sets the outer limits, and once by the product in front of your site, which has defaults and rules of its own.

Start with the standard. The rules below are from RFC 9111 as it read on 14 November 2026, each with its section number and its requirement word.

  • The conditions for storing, section 3. A cache MUST NOT store a response to a request unless every condition on a list holds: the cache understands the request method; the response status code is final; if the status code is 206 or 304, or the must-understand directive is present, the cache understands the status code; the no-store directive is not present in the response; if the cache is shared, the private directive is either not present or allows a shared cache to store a modified response; if the cache is shared, the Authorization header field is not present in the request, or a response directive is present that explicitly allows shared caching; and the response contains at least one of seven things. The seven are a public directive, a private directive if the cache is not shared, an Expires header field, a max-age directive, an s-maxage directive if the cache is shared, a cache extension that allows it to be cached, or a status code that is defined as heuristically cacheable. The section notes that a cache extension can override any of the requirements listed.
  • no-store, section 5.2.2.5. The directive indicates that a cache MUST NOT store any part of either the immediate request or the response, and MUST NOT use the response to satisfy any other request. It applies to both private and shared caches.
  • private, section 5.2.2.7. The unqualified directive indicates that a shared cache MUST NOT store the response, the response being intended for a single user. It also indicates that a private cache MAY store the response, subject to the constraints in section 3, even if the response would not otherwise be heuristically cacheable by a private cache.
  • public, section 5.2.2.9. The directive indicates that a cache MAY store the response even if it would otherwise be prohibited, subject to the constraints in section 3. The RFC's example is that public permits a shared cache to reuse a response to a request containing an Authorization header field.
  • s-maxage, section 5.2.2.10. For a shared cache, the maximum age it specifies overrides the maximum age given by max-age or the Expires header field. A shared cache MUST NOT reuse a stale response with s-maxage to satisfy another request until it has been successfully validated by the origin. The directive also permits a shared cache to reuse a response to a request containing an Authorization header field, subject to those requirements on maximum age and revalidation.
  • must-revalidate, section 5.2.2.2. Once the response has become stale, a cache MUST NOT reuse it to satisfy another request until it has been successfully validated by the origin. The directive also permits a shared cache to reuse a response to a request containing an Authorization header field, subject to that requirement on revalidation.
  • Requests that carry an Authorization header, section 3.5. A shared cache MUST NOT use a cached response to a request with an Authorization header field to satisfy any subsequent request unless the response contains a Cache-Control field with a response directive that allows it to be stored by a shared cache, and the cache conforms to the requirements of that directive for that response. The section names the directives in the specification that have such an effect: must-revalidate, public and s-maxage.
  • Heuristic freshness, section 4.2.2. When the origin gives no explicit expiration time, a cache MAY assign a heuristic one. Heuristics can only be used on responses without explicit freshness whose status codes are defined as heuristically cacheable, and on responses without explicit freshness that have been marked as explicitly cacheable, for example with a public directive. RFC 9110 section 15.1 lists 200, 203, 204, 206, 300, 301, 308, 404, 405, 410, 414 and 501 among the status codes that are heuristically cacheable in that specification, unless the method definition or explicit cache controls indicate otherwise.

What the standard says about cookies, and what it does not

Section 3 has a condition for a request that carried an Authorization header field. It has no condition for a request that carried a Cookie header field. Outside its list of references, the word cookie appears in RFC 9111 in one passage, the note in section 7.3: the Set-Cookie response header field does not inhibit caching, a cacheable response with a Set-Cookie header field can be, and often is, used to satisfy subsequent requests to caches, and servers that wish to control caching of these responses are encouraged to emit appropriate Cache-Control response header fields.

The same section warns that implementation and deployment flaws, often led to by the misunderstanding of cache operation, might lead to the caching of sensitive information that is thought to be private.

Put those together for a web application that signs its visitors in with a session cookie. This is this page's reading, not a sentence from the RFC: a 200 response to a GET request, sent with no Cache-Control header, is not ruled out by anything on section 3's list merely because the request carried a session cookie. The standard leaves it to the origin to say that the response is private.

Vary decides which copy is reused, not whether one is kept

Vary is the origin's way to tell a cache that a response depends on more than the address. RFC 9110 section 12.5.5 says a Vary field that lists header names informs cache recipients that they MUST NOT use the response to satisfy a later request unless the later request has the same values for the listed header fields as the original request, or reuse of the response has been validated by the origin server.

RFC 9111 section 4.1 gives the cache's side: it MUST NOT use a stored response without revalidation unless all the presented request header fields nominated by the Vary value match those in the original request, and a header field that is absent from one request can only match if it is also absent from the other.

Both rules are about reuse, and Vary does not appear among section 3's conditions for storing. On this page's reading, a response that names Cookie in Vary can therefore still be kept by a shared cache, and Vary is a second signal on a personal response, not the control.

RFC 9110 adds that an origin server SHOULD generate Vary on a cacheable response when it wishes that response to be selectively reused, and that there is no need to send the Authorization field name in Vary.

How Cloudflare, CloudFront and nginx decide, in their own documentation

A product's defaults are not the standard's, and they differ from each other.

Each statement below comes from that product's own documentation as it read on 14 November 2026. It describes that product only, and a rule that you or your host added can change it.

Cloudflare: a list of file extensions, then the origin's headers

Cloudflare's page on default cache behaviour says Cloudflare only caches based on file extension and not by MIME type, and that the Cloudflare CDN does not cache HTML or JSON by default. 3 min read

Cloudflare's Cache Deception Armor

Cloudflare has a feature for this attack by name. 1 min read

Amazon CloudFront: a default time, and a minimum TTL to check

CloudFront's developer guide starts from time, not file type. 1 min read

nginx: nothing until a cache is configured, then the response headers

nginx stores nothing until it is told to: the documented default of its proxy_cache directive is off. 1 min read

The origin's framework writes the header the cache reads

The framework behind the cache matters as much as the cache. 1 min read

What the comparison tells you

Three products, three starting points: a list of file extensions, a default time when the origin sets none, and nothing at all until a cache zone is configured. 1 min read

Path confusion caching: why one URL means two things

A URL looks like one fixed thing, and the standards say otherwise.

RFC 3986, the URI standard, says in section 3.3 that apart from dot-segments a path segment is considered opaque by the generic syntax, and that applications often use the reserved characters allowed in a segment to delimit subcomponents of their own.

RFC 9110 says HTTP does not require the use of a specific method for determining whether two URIs are equivalent, and gives the example that a cache key might be compared as a simple string, after syntax-based normalisation, or after scheme-based normalisation.

On this page's reading, the layer that routes a request and the layer that stores the response are each left free to read the address their own way.

Path confusion is the name the 2020 USENIX paper gives to the result. Martin Doyhenard's research for PortSwigger, Gotta cache 'em all: bending the rules of web cache exploitation, published on 8 August 2024, puts the mechanism in one sentence: if the cache and the application server's parsers are different, it may be possible to use a discrepancy to change the meaning of the URL.

The USENIX authors set out the two properties such an address needs. The web server must interpret it as a request for a non-cacheable page with private information, and it should trigger a successful response; and an intermediate web cache must interpret the same URL as a request for a static object matching the caching rules in effect.

The four cases below are the fixtures in the lab on this page. In each, the lab's careless origin answers with the account page and its careless cache stores the answer. They illustrate four kinds of disagreement, and they are not a list of every kind.

A file name appended to a private path

The address is /account/photo.css. 1 min read

A path parameter delimiter

The address is /account;photo.css. 1 min read

An encoded delimiter

The address is /account%3Fphoto.css, where %3F is a percent-encoded question mark. 1 min read

A normalised dot-segment

The address is /static/..%2Faccount, where %2F is a percent-encoded slash. 1 min read

Four controls: the origin first, the cache second

Four controls close the gap, two at each layer.

They are listed in the order to apply them.

  • The origin marks every personal response so that no shared cache may store it. This page's advice is Cache-Control: private, no-store on each one.
  • The origin refuses paths it does not define. A request for /account/photo.css gets a 404 or a redirect, not the account page.
  • The cache decides from the origin's headers and the response's content type, not from a file extension or a folder name in the URL alone.
  • Both layers read a URL the same way.

Where the list comes from

Each control has a source. 1 min read

Cache-Control: no-store and private, and what each means for a shared cache

Both directives keep a response out of a shared cache, by different definitions. private is addressed to shared caches: RFC 9111 section 5.2.2.7 says the unqualified directive indicates that a shared cache MUST NOT store the response, and that a private cache MAY, subject to the constraints in section 3. no-store is addressed to every cache: a cache MUST NOT store any part of the request or the response, and the RFC says the directive applies to both private and shared caches. 2 min read

Refuse paths the application does not define

The origin's other half of the fix is routing. 1 min read

Make the cache decide from headers and content type

A rule that stores everything ending in .css asks the URL a question only the response can answer. 1 min read

Have both layers read the URL the same way

The last control removes the disagreement itself. 1 min read

Why the origin comes first

It is tempting to stop at the cache: turn on the product's protection and leave the application alone. 2 min read

Cache deception testing: every route type, both requests

Testing for web cache deception is two requests and a comparison.

Send a request for an address with a signed-in test account. Send the same address again with no session. If the second response contains anything that belongs to the test account, the route fails, whatever the headers said.

The headers and the cache status explain a result, and they do not replace the second request: the USENIX authors found that the presence of cache headers was an unreliable indicator of whether a resource is cached.

Run these checks only on an application you own or are authorised in writing to test, signed in as a test account that holds invented data. A check that finds the problem has placed a copy of that account's page in a shared cache, where it stays until it expires or is purged. Keep that copy harmless and easy to find:

  • Use staging where it sits behind the same CDN or proxy configuration as production.
  • Use a test account whose pages hold nothing real, and put a marker word of your own in its profile so you can search responses for it.
  • For the path-confusion addresses, use a file name nobody else would request, different on every attempt, so the only stored copy sits at an address only you know.
  • Send the second request yourself, from a private browser window or a command-line client with no cookies. Nobody else needs to open anything.
  • Purge each test address when you finish, then request it once more to confirm the copy has gone.
  • Check your host's and your CDN's testing terms before you start.

Cover every kind of route

Test more than the account page. 1 min read

Reading the cache status

A cache can report what it did with a request in a response header. 1 min read

The browser checks, in short

You need a browser, a test account and the address of one route from each row of the matrix. 1 min read

Where the OWASP testing guide covers it

The OWASP Web Security Testing Guide has a test for this in its latest edition, the one its site says represents the latest contributions and may frequently change: Path Confusion, with the id WSTG-CONF-13. 1 min read

The lab: an invented origin behind a cache written for this page

The lab on this page is an illustration.

It is an invented origin, Lab Ledger, with a sign-in, an account page, an API route, a statement download and a stylesheet, and in front of it a small shared cache written for this page that keeps what it stores in memory. It shows the pattern this guide describes.

It does not show how any real CDN, proxy or framework decides anything, and its cache is not an implementation of RFC 9111: it has no clock, so nothing expires, and it does no validation and no Vary matching.

Each side has a careless and a careful version. The careless origin answers the account page for any path that resembles /account once decoded and trimmed, and sends no Cache-Control header. The careful origin answers only the exact paths it defines and marks every personal response private, no-store. The careless cache stores any GET response whose path ends in one of four file extensions or starts with /static/, without reading the response.

The careful cache stores a 200 response only when the origin said public, not when it said private or no-store, not when the response has a Vary header, and, when the path ends in one of the lab's four static file extensions, only when the content type is the one the lab lists for that extension; a path with no such ending gets no content-type check. Requiring public makes it stricter than the standard.

Apart from each other, the eight files import only node:assert/strict, node:crypto, node:http and node:test, and the lab installs no packages. Both servers listen on 127.0.0.1 and ask for port 0. The Node.js documentation says the HTTP server's listen() is identical to the one in its net module, where port 0 makes the operating system assign an arbitrary unused port.

The one account, lab-member, has an invented password that is no product's default, and the private marker is a line of text made up for this page.

The run recorded in the asset was made on Node.js 26.0.0 on macOS, the only version and the only system it was run on. The Node.js documentation lists the node:test module as stable since v20.0.0.

The fixture script signs in as the test account, requests each of the four addresses through the cache, then requests the same address with no cookie. Across the four pairings of origin and cache it printed these results.

  • Careless origin, careless cache: the anonymous request received the private marker in 4 of 4 fixtures. Each signed-in response was stored, three because the address ended in .css and one because it started with /static/, and each request with no cookie was a HIT.
  • Careless origin, careful cache: 0 of 4. The origin still answered all four with the account page. The cache did not store them, and the requests with no cookie were redirected to the sign-in page.
  • Careful origin, careless cache: 0 of 4. The origin answered 404 with no-store, and the careless cache stored the 404 pages anyway, so the requests with no cookie were HITs on an error page with nothing private in it.
  • Careful origin, careful cache: 0 of 4, and nothing stored.

The matrix script, and the leak the fixtures do not show

A second script runs the same two requests over the lab's own six route types, one for each row of the matrix. It found a leak that needs no path confusion: under the careless cache, the statement download was stored and served to the request with no cookie, private marker included, with either origin.

Under the careful pair, the stylesheet and the home page were HITs on the second request and the three personal routes were not stored.

The regression test

The test file runs ten checks against one pairing. Seven are that a request with no cookie receives no private marker: the four fixtures and the three personal routes. One is that the origin answers 404 to every fixture address.

One is that every response carrying the marker says private, no-store. The last is that the public stylesheet is still served from the cache on the second request, so that a fix which simply turned caching off would not pass.

Seven of the ten failed on the careless pair. Three failed with only the cache made careful, one failed with only the origin made careful, and all ten passed on the careful pair. The Node.js documentation says that if any tests fail, the process exit code is set to 1.

A pipeline step that treats a non-zero exit code as a failure then stops. Part 6 of the asset describes how to point the same checks at your own application.

Neighbouring guides, and where a Clever Ops test fits

Two more guides sit beside this one.

The cookie security guide covers the attributes of the session cookie itself, which decide where a browser sends it and not what a cache does with the response. The security misconfiguration guide covers settings that drift between what was tested and what is running, and a cache rule changed in a dashboard is a setting of that kind.

Clever Ops tests websites, custom web applications and their APIs. A web application and API penetration test is run from test accounts in every role the scope names, and for a Next.js application caching is one of the areas in the route-by-route matrix described in the Next.js guide.

Whatever the stack, tell us at the scoping call which CDN or reverse proxy sits in front of the application, who controls its settings, and whether a staging copy runs behind the same cache configuration.

Cache tests run on staging, or with a cache key unique to the test on production, so that test responses are not stored where real visitors are served from.

Each finding comes with evidence, a fix and the criteria the retest will use. A report is evidence for your decisions, not a certificate, and it is not monitoring: a cache rule added the week after the test is outside what it can speak to.

If Clever Ops built or hosts your application, the work is a security review rather than an independent test, and the report says who built it and who hosts it.

Frequently asked questions

It is a shared cache, such as a CDN, storing one signed-in person's private page because it took the address for a public file. The next request for that address gets the stored copy, with or without a session. Omer Gil described the attack in February 2017, and a 2020 USENIX Security paper traces it to path confusion: the origin server and the cache interpreting the same URL differently.

There are two requests. First, a signed-in person's browser requests an address such as /account/photo.css. The origin answers it with the account page, and the cache stores the response because the address looks like a stylesheet. Second, a request for the same address arrives with no session, and the cache answers it from the stored copy. In the checks on this page you send both requests yourself, using your own test account.

It tells every cache that follows the HTTP standard not to store the response: RFC 9111 says a cache MUST NOT store any part of it. Whether your cache follows it depends on the product and its rules. Cloudflare's documentation says no-store and private prevent caching in either of its Origin Cache Control modes. CloudFront's says that with a minimum TTL above 0 it uses that minimum even if those directives are present, and adds two sub-points: if the origin is reachable, CloudFront gets the object from the origin and returns it to the viewer, and if the origin is unreachable and the minimum or maximum TTL is greater than 0, it will serve the object it got from the origin previously. nginx's proxy_ignore_headers directive can disable processing of Cache-Control. Send the header, then confirm with a request that has no session.

It is two components reading one URL differently. The latest edition of the OWASP testing guide describes it as routers, proxies, caches, web application firewalls (WAFs) and the application itself disagreeing on what a given URL path identifies, because of path normalisation, trailing slashes, case sensitivity or encoding differences. This page uses four examples: a file name appended to a private path, a semicolon parameter, an encoded question mark, and an encoded slash with a dot-segment.

In the person's own browser, the standard allows it: RFC 9111 section 5.2.2.7 says the unqualified private directive indicates that a shared cache MUST NOT store the response and that a private cache MAY, subject to the constraints in section 3. Whether you want that is a separate decision, and ASVS 5.0 requirement 14.3.2 asks for Cache-Control: no-store so that sensitive data is not cached in browsers. In a shared cache, a response that differs by signed-in person has no place.

Use a test account that holds invented data, on staging if it sits behind the same cache configuration. Request the route signed in, then request the same address with no session, and check that nothing from the test account comes back. For path-confusion addresses, use a file name nobody else would request, so that any stored copy is at an address only you know, and purge it afterwards. Test only a site you own or are authorised in writing to test.

Not under the HTTP standard. RFC 9111's conditions for storing a response include one for requests that carry an Authorization header and none for requests that carry a cookie, and the RFC notes that a Set-Cookie header on the response does not inhibit caching. Products add rules of their own, so read your product's documentation and mark personal responses private, no-store.

One layer is then checking. In the lab on this page, a careful cache in front of a careless origin stopped all four fixtures, yet the origin still answered each with the account page and no caching header, and three of the regression test's ten checks still failed. Cloudflare's documentation says a Cache-Control header from the origin or an Edge Cache TTL rule may override its Cache Deception Armor. Fix the origin first, then keep the cache's check on.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.