Cache Poisoning in Rocket with Cockroachdb

Cache poisoning in a Rocket application that uses Cockroachdb as the backend data store occurs when an attacker causes cached responses to reflect attacker-controlled data or incorrect application state. Because Rocket does not include a built-in cache, developers often introduce caching at the database, query, or response layer, and misconfiguration can lead to poisoned entries that other users or endpoints subsequently read.

When using Cockroachdb, the risk surface involves how query results are cached, how cache keys are built, and how stale or malicious entries can persist across tenant boundaries or user contexts. For example, if a cache key is derived only from user-supplied parameters without including the authenticated user ID or tenant context, one user may retrieve another user’s cached data, effectively exposing or altering data through cache poisoning.

Consider a Rocket endpoint that caches user profile data using a key based solely on the profile ID:

// Risky: cache key does not include user context
#[get("/profile/<profile_id>")]
async fn get_profile(
    profile_id: i32,
    cache: &Cache<String, Profile>,
) -> Result<Json<Profile>, Status> {
    let key = format!("profile:{}", profile_id);
    if let Some(cached) = cache.get(&key) {
        return Ok(Json(cached));
    }
    let profile = fetch_profile_from_cockroachdb(profile_id).await?;
    cache.insert(key, profile.clone());
    Ok(Json(profile))
}

An attacker can supply a profile_id that belongs to another user. If the cache does not differentiate by user, subsequent requests for that key return the victim’s data — a cache poisoning and information disclosure issue. This is compounded if the Cockroachdb query layer does not enforce row-level security, allowing the cached result to be reused across different authorization contexts.

Another vector involves query parameters that influence Cockroachdb execution plans or result ordering without being included in the cache key. An attacker could supply crafted parameters that change the cached response shape, and later users receive poisoned or inconsistent data. For example, a leaderboard endpoint that caches based on query parameters but omits sorting rules or tenant identifiers can return incorrect rankings or data to unrelated users.

Because Rocket runs as an independent service and Cockroachdb provides strong consistency, the poisoning typically stems from application-level cache design rather than the database itself. However, Cockroachdb’s multi-region capabilities and distributed nature can increase persistence and replication scope, making improperly invalidated cache entries more difficult to contain across nodes.

To detect such issues, scans should verify that cache keys incorporate user or tenant identifiers, that queries enforce proper filtering, and that cached outputs are validated for unexpected PII or sensitive content. middleBrick’s LLM/AI Security checks can identify whether endpoints expose system prompts or data that should remain isolated, and its Authorization and BOLA/IDOR checks help uncover missing tenant context in cache lookups.

Remediation centers on ensuring cache keys include contextual identifiers and that database queries enforce strict tenant and ownership checks. The following Rocket + Cockroachdb example demonstrates a secure pattern where the cache key includes the user ID and tenant ID, and the Cockroachdb query uses parameterized statements with row-level conditions.

use rocket::State;
use cockroach_client::CockroachDB;
use rocket_cache::Cache;

struct AppState {
    db: CockroachDB,
    cache: Cache<String, Profile>,
}

#[get("/profile/<profile_id>")]
async fn get_profile(
    profile_id: i32,
    user: AuthUser, // authenticated user context
    state: &State<AppState>,
) -> Result<Json<Profile>, Status> {
    let cache_key = format!("tenant:{}/user:{}/profile:{}", user.tenant_id, user.id, profile_id);
    if let Some(cached) = state.cache.get(&cache_key) {
        return Ok(Json(cached));
    }

    let profile = state.db
        .fetch_one(
            "SELECT id, name, email, tenant_id FROM profiles WHERE id = $1 AND tenant_id = $2 AND user_id = $3",
            (&profile_id, &user.tenant_id, &user.id),
        )
        .await
        .map_err(|_| Status::NotFound)?;

    state.cache.insert(cache_key, profile.clone());
    Ok(Json(profile))
}

This approach ensures the cache is segregated by tenant, user, and profile, preventing cross-user cache poisoning. The Cockroachdb query explicitly filters by tenant_id and user_id, aligning with the cache key and preventing unauthorized data retrieval even if cache lookup fails.

For endpoints that accept query parameters influencing result sets, include those parameters in the cache key and validate them against allowed values before constructing Cockroachdb queries:

#[get("/leaderboard<region>?order=<order>")]
async fn leaderboard(
    region: String,
    order: Option<String>,
    state: &State<AppState>,
) -> Result<Json<Vec<Player>>, Status> {
    let order = order.unwrap_or_else(|| "score_desc".to_string());
    // Validate order to prevent injection via cache key
    let order_key = if ["score_desc", "score_asc", "name_asc"].contains(order.as_str()) {
        order.as_str()
    } else {
        "score_desc"
    };
    let cache_key = format!("leaderboard:region:{}:order:{}", region, order_key);
    if let Some(cached) = state.cache.get(&cache_key) {
        return Ok(Json(cached));
    }

    let players = state.db
        .fetch_all(
            "SELECT name, score FROM leaderboards WHERE region = $1 ORDER BY score $2 LIMIT 100",
            (®ion, &order_key.to_sql_order()),
        )
        .await
        .map_err(|_| Status::InternalServerError)?;

    state.cache.insert(cache_key, players.clone());
    Ok(Json(players))
}

In this example, the cache key includes region and validated order, ensuring poisoned ordering parameters cannot cause cross-context data mixing. Cockroachdb receives a parameterized order value that is mapped to a safe SQL fragment, avoiding injection through the cache layer.

Additional remediation steps include implementing cache invalidation on data updates and setting reasonable TTLs to limit the window of poisoned entries. middleBrick’s Pro plan supports continuous monitoring, which can help detect anomalous cache hit patterns or repeated authorization context misses across scans, while the GitHub Action can enforce security thresholds before deployment.