/

CVE-2026-35052

Severity:

CRITICAL RISK

(9.8)

Remote Code Execution via Web Application State

CVE-2026-35052

Analyzed

Vulnerability type

Category:

Remote Code Execution via Web Application State

CWE:

CWE-79

Impact:

Remote Code Execution on the D-Tale Server

Severity:

CRITICAL RISK

(9.8)

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 remote code execution flaw in D-Tale, when hosted publicly with redis or shelf as the storage backend, can allow attackers to execute arbitrary code on the server through the web interface.

The issue becomes critical when untrusted users can reach the D-Tale instance over the network and influence the persisted state used by the application logic.

Affected context

This vulnerability affects D-Tale deployments that:

  • Are exposed on public or semi-public networks (e.g., internet-facing or shared internal environments), and
  • Use redis or a shelf-based storage layer for maintaining D-Tale state or configuration, and
  • Do not have strong access controls or network restrictions around the D-Tale interface.

In such contexts, data persisted from user interactions can later be interpreted in a way that leads to code execution in the Flask back end.

Exploit preconditions

  • Attack surface: The HTTP(S) endpoints exposed by the D-Tale Flask application.
  • Required access: Ability to send requests to the D-Tale instance (e.g., access to the public URL or reachable internal endpoint).
  • Trigger point: Interactions that cause D-Tale to read and act upon state stored in redis or shelf (such as loading sessions, configurations, or transformations).
  • Why exploitation is possible: User-controlled state written into the storage backend is not sufficiently constrained, validated, or isolated from server-side execution paths, enabling crafted input to be interpreted in a way that triggers arbitrary code execution.

Why this happens

At a high level, the bug stems from treating client-controlled or weakly trusted state as if it were safe to drive server-side behavior.

When D-Tale persists user-influenced information into redis or shelf and later reloads it, the application appears to couple this state too closely with execution logic, effectively allowing dangerous values to influence how code is executed.

This aligns conceptually with CWE-79 (Improper Neutralization of Input During Web Page Generation) in that user-controllable data is not adequately neutralized or separated from executable contexts, but instead of just causing script injection in a browser, the tainted state ultimately enables execution on the server.

Potential impact

  • Attackers may execute arbitrary Python code or system commands in the context of the D-Tale server process.
  • Full compromise of the host running D-Tale, depending on the process privileges and OS hardening.
  • Unauthorized access to sensitive data processed or stored by the application (e.g., Pandas data structures, environment variables, credentials).
  • Use of the compromised server as a pivot point to attack other internal services or infrastructure.
  • Service disruption or data corruption through malicious operations triggered via the D-Tale instance.

General mitigation guidance

Effective mitigation generally focuses on reducing trust in user-controlled state and constraining how it influences execution:

  • Treat all data coming from clients and persisted in redis or shelf as untrusted; avoid patterns where persisted values directly control code paths, imports, or evaluation of expressions.
  • Introduce strict schema validation and type checking on any configuration or state that can be written via the web interface before it is saved and before it is applied.
  • Prefer safe, non-evaluating patterns for applying user choices (e.g., using whitelists of allowed operations and parameters instead of interpreting arbitrary strings or expressions).
  • Run the D-Tale process with least privilege (e.g., non-root users, restricted filesystem and network permissions) to limit the blast radius if a flaw is present.
  • Avoid exposing D-Tale directly to the internet; place it behind authentication, VPNs, or reverse proxies with strong access controls whenever possible.

How teams detect issues like this

Organizations can approach detection from both code-centric and operational angles:

  • Static analysis and code review:
  • Look for flows where request parameters or values read from redis/shelf directly influence dynamic execution constructs (e.g., dynamic imports, eval-like behavior, reflection, or unsafe template rendering).
  • Flag code paths that deserialize or interpret stored state from redis/shelf without applying schema validation, whitelisting, or sanitization.
  • Review the integration between the Flask handlers and the storage layer for any pattern that mixes user input with control logic rather than treating it as pure data.
  • Runtime and logging:
  • Monitor logs for anomalous requests to D-Tale endpoints, especially parameters that look like code fragments or unexpected expressions.
  • Enable application-level logging around state load/save operations for redis/shelf so that unusual or malformed payloads can be detected and investigated.
  • Security policy enforcement:
  • Apply configuration scanning and CI checks to detect risky patterns (e.g., broad dynamic execution based on externalized state).
  • Use automated review tools or SAST products capable of tracking tainted data from HTTP requests through storage layers into execution sinks.

Sources

SourceLink
github.comgithub.com/man-group/dtale/security/advisories/GHSA-436g-fhfc-9g5w

Frequently asked

questions

Yes, when D-Tale is hosted publicly and reachable by untrusted users, an attacker who can interact with the web interface may be able to craft requests that lead to remote code execution on the server.

Exploitation primarily requires network access to the D-Tale instance. If the instance is exposed without strong authentication or is shared among multiple users, any user with access could potentially attempt to exploit the flaw.

The safest pattern is to ensure that any state or configuration derived from user input remains data-only and cannot directly control code execution; use strict validation, whitelisted operations, and avoid dynamic evaluation or interpretation of user-controlled values, especially those persisted in redis or shelf.

Prevent similar issues by designing application logic so that user input and stored state are never treated as executable instructions, enforcing clear separation between data and code, applying input validation and encoding, subjecting dangerous operations to explicit whitelisting, and regularly performing security-focused code reviews and automated analysis on components that bridge user input, storage layers, and execution paths.

Find out what's already
exploitable in your codebase.