/

CVE-2026-52780

Severity:

CRITICAL RISK

(9.6)

Cache Store Poisoning (CWE-20) in OpenProject RCE Risk

CVE-2026-52780

Deferred

Vulnerability type

Category:

Cache Poisoning

CWE:

CWE-20

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A cache store poisoning vulnerability in OpenProject allows crafted inputs to corrupt cached application state, ultimately enabling remote code execution under certain configurations.

When an attacker can influence cache keys or values, they may abuse improper input validation to inject executable data that is later interpreted by the application.

Affected context

This issue arises in OpenProject deployments that rely on an application-level cache store for performance and state management, where cache keys or values are derived from user-controllable data.

Environments that allow dynamic content or metadata to be cached without strict validation are more exposed, especially when cached data is later used in code evaluation, template rendering, or dynamic loading mechanisms.

Exploit preconditions

  • Attack surface: Web interface or API endpoints that influence cache entries (keys or values).
  • Required access: Ability to send crafted requests that cause data to be written to or updated in the cache store.
  • Trigger point: Subsequent application operations that read poisoned cache entries and treat them as trusted configuration, executable data, or dynamic templates.
  • Why exploitation is possible: Inputs used for cache population are insufficiently validated (CWE-20), allowing malicious data to persist and be interpreted in a context that can lead to code execution.

Why this happens

The core issue is improper input validation and trust of data written into the cache store (CWE-20).

User-controllable values or metadata are allowed into the cache without rigorous checks on type, structure, or content, creating a path where poisoned entries are later consumed by components that assume cache data is safe.

When those components perform dynamic evaluation, loading, or rendering based on cached content, the poisoned entries can be transformed from mere data into executable behavior, resulting in remote code execution.

Potential impact

  • Remote code execution with the permissions of the OpenProject application process
  • Compromise of project data, including tasks, documents, and user information
  • Privilege escalation within the application or underlying host environment
  • Lateral movement to other services that rely on the same infrastructure or credentials
  • Service disruption or defacement of the OpenProject instance

General mitigation guidance

Effective mitigation focuses on tightening validation and trust boundaries around all data that flows into the cache store.

Common patterns include:

  • Validating cache-related inputs for type, length, and allowed characters before caching
  • Separating untrusted user data from internal configuration or executable content in the cache
  • Avoiding any dynamic evaluation, code loading, or template execution directly from cached data
  • Applying least-privilege principles to the runtime environment so that, even if cache is misused, execution capabilities are constrained
  • Designing cache keys and values so they are derived from controlled, server-side data rather than raw client input

How teams detect issues like this

Detection generally involves looking for insecure cache usage and trust of cached content:

  • Static analysis rules that flag cache writes where keys or values are derived from unvalidated user input
  • Code review practices that scrutinize any use of cached data in dynamic evaluation, template rendering, or configuration loading
  • Runtime monitoring and logging for anomalous cache patterns, such as unexpected keys, oversized values, or unusual data types
  • Policy enforcement that requires explicit validation functions on all inputs that may be stored in caches, supported by automated tooling integrated into CI/CD pipelines

Sources

SourceLink
github.comgithub.com/opf/openproject/security/advisories/GHSA-qj96-f42f-6336

Frequently asked

questions

Exploitability depends on whether an attacker can control data that is written to the cache and whether that data is later used in a way that can trigger code execution. In exposed web deployments, this can often be done remotely through crafted requests.

An attacker typically needs the ability to interact with endpoints that influence cache entries. Depending on configuration, this may be possible as an unauthenticated user or might require at least basic application access.

The safest pattern is to enforce strict validation on all inputs used for cache keys or values and to ensure cached data is never directly interpreted as executable code, configuration, or templates without additional safety checks.

Adopt a design where caches only store strongly typed, validated server-side data; avoid mixing untrusted user input with executable or configuration content; and embed validation and cache usage checks into development guidelines, code review, and automated security testing.

Find out what's already
exploitable in your codebase.