Cache Poisoning in Chi with Api Keys

Cache poisoning in the context of using API keys with a service like Cloudflare Workers (Chi) occurs when an attacker manipulates cache behavior so that sensitive or unauthorized data is served to other users. This typically arises when API keys are included in request URLs or headers that are not considered part of the cache key, causing responses intended for one client to be reused for another.

Chi (Workers) allows developers to define custom cache keys. If the cache key omits the Authorization header or API key query parameters, a request like /resource?api_key=ATTACKER_KEY might be stored and later served to users with different keys. Because Workers caches at the edge, improperly scoped caching can inadvertently link authenticated responses to public cache entries, leading to data leakage across tenants.

In practice, this misconfiguration maps to the BOLA/IDOR category in middleBrick’s checks, where insecure direct object references enable one user to access another’s data. middleBrick’s 12 security checks run in parallel and would flag such cache-related authorization gaps, providing severity and remediation guidance. Because Workers often serve static or semi-static content, the risk is compounded when responses contain PII or tokens that should remain scoped to a single API key context.

An illustrative scenario: an endpoint /user/profile uses an API key passed as a query parameter but does not include that parameter in the cache key. Worker A requests /user/profile?api_key=KEY_A and receives a cached response. If Worker B then requests /user/profile?api_key=KEY_B, the edge cache may incorrectly return the cached response meant for KEY_A, exposing KEY_A’s associated data to KEY_B’s context. middleBrick’s OpenAPI/Swagger analysis, with full $ref resolution, can detect mismatches between declared authentication and caching behavior by cross-referencing spec definitions with runtime findings.

LLM/AI Security checks in middleBrick do not directly mitigate cache poisoning, but they help identify risks like system prompt leakage or unsafe endpoint exposure that can coexist with misconfigured caching. For example, if an LLM endpoint is unauthenticated or improperly scoped, it might amplify the impact of cache poisoning by returning model outputs that should have been isolated per API key. middleBrick’s unique active prompt injection testing ensures that endpoints are inspected beyond basic caching concerns, covering authorization and data exposure vectors.

Remediation guidance centers on ensuring cache keys incorporate authorization context. In Workers, this means explicitly including headers or query parameters that contain the API key in the cache key configuration. Developers should avoid caching responses that contain user-specific data unless the cache key uniquely identifies the requester. middleBrick’s per-category breakdowns and prioritized findings help teams quickly locate and fix these issues, aligning with frameworks like OWASP API Top 10 and GDPR data protection expectations.

To remediate cache poisoning when using API keys in Chi (Workers), ensure that the cache key explicitly includes the API key or a derived, safe representation of it. Below are concrete code examples demonstrating secure practices.

Example 1: Include API key in cache key via headers

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event))
})

async function handleRequest(event) {
  const apiKey = event.request.headers.get('X-API-Key')
  const cacheKey = new Request(event.request, {
    headers: new Headers({
      'X-Cache-Key': apiKey
    })
  })
  const cache = caches.default
  let response = await cache.match(cacheKey)
  if (!response) {
    response = await fetch(event.request)
    event.waitUntil(cache.put(cacheKey, response.clone()))
  }
  return response
}

This approach adds a custom header used solely for cache differentiation, ensuring that responses are segregated by API key. Note that the actual API key is not logged or exposed in responses; it is only used to construct the cache key.

Example 2: Use a hash of the API key for cache key safety

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event))
})

async function handleRequest(event) {
  const apiKey = event.request.headers.get('Authorization')?.replace('Bearer ', '')
  const hashedKey = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(apiKey || ''))
  const keyHex = Array.from(new Uint8Array(hashedKey)).map(b => b.toString(16).padStart(2, '0')).join('')
  const cacheKey = new Request(event.request, {
    url: event.request.url,
    headers: new Headers({
      'X-Cache-Scope': keyHex
    })
  })
  const cache = caches.default
  let response = await cache.match(cacheKey)
  if (!response) {
    response = await fetch(event.request)
    event.waitUntil(cache.put(cacheKey, response.clone()))
  }
  return response
}

Hashing prevents potential leakage of the raw key in cache metadata and ensures consistent key derivation. This pattern is especially useful when API keys appear in query parameters and should not be stored plainly.

Example 3: Conditional cache bypass for authenticated requests

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event))
})

async function handleRequest(event) {
  const url = new URL(event.request.url)
  const apiKey = url.searchParams.get('api_key')
  if (apiKey) {
    // Bypass cache entirely for requests with API keys to avoid cross-user contamination
    return fetch(event.request)
  }
  const cache = caches.default
  let response = await cache.match(event.request)
  if (!response) {
    response = await fetch(event.request)
    event.waitUntil(cache.put(event.request, response.clone()))
  }
  return response
}

This approach disables caching for any request containing an API key, which is a conservative but effective mitigation when precise cache scoping is complex. It aligns with security guidance from assessments available through middleBrick’s CLI tool (middlebrick scan <url>) and its GitHub Action for CI/CD pipeline gates.

For teams using the Pro plan, continuous monitoring can detect regressions in cache behavior, and the MCP Server integration allows scanning API configurations directly from development environments. Always validate that cache keys incorporate authorization context and that responses containing sensitive data are not shared across API key scopes.