Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate or self-register to portal
-
DeliveryCreate workflow with custom Python tool
-
ExploitReach OS/process attrs via allowed stdlib modules
-
ExecutionBlacklist sandbox check passes, exec() runs code
-
ImpactExecute commands/file ops as backend user
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK
2 techniques across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires an authenticated account on a Heym instance prior to 0.0.40 with permission to create or edit a workflow that contains an Agent custom Python tool; the attacker's tool code must reference operating-system/process/filesystem functionality through public attributes of standard-library modules that are on the allowlist, so that it survives _safe_import() and _validate_code_safety() before being run via exec(). Reachability is broadened when self-registration is enabled (an attacker can obtain the needed low-privilege account), but merely triggering a workflow from the portal is insufficient - the attacker must control the tool's Python source. Exploitation is limited by: needing workflow create/edit rights, needing the account itself (closed instances with only trusted users reduce exposure), and being fully mitigated by upgrading to 0.0.40 where tool code runs in a hardened Docker sandbox (default 'auto' mode fails closed if Docker is absent). |
| Impact | This is a genuine high-priority issue in the context of any multi-user deployment, but the real-world blast radius is constrained by product footprint rather than by exploit difficulty. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 8.8) is internally consistent with the description: exploitation is network-reachable through the workflow editor, low-complexity (a deterministic blacklist bypass using public attributes of allowed standard-library modules), and requires only a low-privileged authenticated account (PR:L) that can create or edit a workflow containing an Agent custom Python tool - no user interaction. The outcome is full code/command execution as the backend application user, justifying C:H/I:H/A:H. No EPSS score, CISA KEV listing, or public proof-of-concept was provided in the input, so there is no public exploit identified at time of analysis and no evidence of active exploitation; the probability of opportunistic mass exploitation is therefore low, driven mainly by the product's small deployment base rather than by any mitigating technical factor. The description's note that 'self-registration affects reachability, but portal triggering alone does not grant code control' is an important nuance: if self-registration is enabled, the PR:L barrier is effectively lowered to anyone who can register, pushing real risk higher for internet-exposed instances; conversely, on a closed instance with trusted users only, the practical risk is lower. Net assessment: technically a reliable authenticated-to-RCE sandbox escape that should be patched promptly where deployed, but not a widespread internet-scale threat given the niche product. |
| Exploit ScenarioDerived | An authenticated low-privileged user (or, where self-registration is enabled, an attacker who simply signs up) opens the workflow editor and defines an Agent custom Python tool whose code reaches operating-system, process, or filesystem capabilities via public attributes of allowed standard-library modules, slipping past the blacklist checks in _safe_import() and _validate_code_safety(). When the tool runs, the backend executes it with exec(), giving the attacker arbitrary command and file operations as the backend application user. No public exploit code was identified in the provided data, but the blacklist bypass is low-complexity and deterministic over the network. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
Authenticated users with workflow create/edit rights on self-hosted Heym deployments prior to 0.0.40 can escape the application's blacklist-based Python sandbox and execute arbitrary commands and file operations as the backend service account. The flaw lives in backend/app/services/python_tool_executor.py, where the allowlisted standard-library modules still expose OS, process, and filesystem primitives through public attributes, so tool source that passes _safe_import() and _validate_code_safety() is ultimately run through exec() with full application privileges (CVSS 8.8, CWE-78). Exploitation requires a low-privilege authenticated account (PR:L) with permission to create or edit a workflow containing an Agent custom Python tool; enabling self-registration makes that account trivially obtainable, though merely triggering a workflow from the portal does not grant code control. There is no public exploit identified at time of analysis and no confirmed active exploitation (not in CISA KEV), but the fix in 0.0.40 is available and the assessed risk is high for any multi-user deployment.
RemediationAI
Upgrade Heym to 0.0.40 or later, which is the exact version that introduces the hardened execution model for user Python tools; the release is at https://github.com/heymrun/heym/releases/tag/v0.0.40 and the code change is commit b36d795c6ea841b8f1b511a0952e274487ee4ef3, with details in advisory GHSA-wcgw-9hfw-f6f2. After upgrading, verify that the HEYM_PYTHON_TOOL_SANDBOX setting resolves to the Docker backend (either the default 'auto' mode with Docker present, or an explicit 'docker' value) - in 'auto' mode the call fails closed and raises if Docker is unavailable, so absence of Docker will break tool execution rather than run untrusted code, and selecting 'subprocess' deliberately re-enables the non-security-boundary best-effort mode and should be avoided on any shared deployment. Where upgrade is not immediately possible, compensating controls are to disable the Agent custom Python tool capability entirely or restrict workflow create/edit permissions to fully trusted operators only (this removes the attacker prerequisite of PR:L but also removes self-service automation for legitimate users), and to turn off self-registration so that an outside party cannot obtain the low-privilege account needed to reach the feature (trade-off: new users must be provisioned manually). Because the executor runs with the backend application user's privileges, additionally confine that service account - least-privilege filesystem permissions, no access to secrets or host mounts, and no Docker socket exposure - so that any residual escape has minimal lateral impact. Monitor for unexpected subprocess or filesystem activity originating from the backend process as a detection measure while remediation is pending.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Heym is a self-hosted platform for building and running agentic systems and business-process automations, implemented as a Python backend that lets users author 'custom Python tools' attached to agent workflows. The vulnerable design is a classic blacklist-based in-process sandbox in backend/app/services/python_tool_executor.py: it maintained BLACKLIST_BUILTINS (exec, eval, __import__, open, getattr, etc.), FORBIDDEN_CODE_FRAGMENTS (dunder/introspection strings such as '__', f_globals, gi_frame), and BLACKLIST_MODULES (os, sys, subprocess, socket, ctypes, importlib and similar), then relied on an AST walker (_validate_code_safety) plus a wrapper import hook (_safe_import) before handing the code to exec(). Because the check is denylist-based and only inspects names, attribute prefixes starting with underscore, and literal strings, any non-blacklisted standard-library module that transitively exposes operating-system, process-spawning, or filesystem functionality through public (non-underscore) attributes survives validation - the CWE-78 command-injection class - and the tool then runs with the backend application user's privileges. The upstream fix (commit b36d795c6ea841b8f1b511a0952e274487ee4ef3, released in v0.0.40) abandons blacklisting as the security boundary and introduces two execution backends selected by the HEYM_PYTHON_TOOL_SANDBOX environment variable: a hardened, throwaway Docker container (no network, read-only root filesystem, non-root user, all Linux capabilities dropped, no-new-privileges, strict CPU/memory/PID limits, no Docker socket) that receives the JSON payload over stdin and returns results on stdout, and a local subprocess mode explicitly documented as best-effort and not a security boundary. The default 'auto' mode requires Docker and fails closed if Docker is unavailable rather than silently falling back to unisolated execution. The CPE entry cpe:2.3:a:heymrun:heym:*:*:*:*:*:*:*:* reflects that all released versions before 0.0.40 are in scope.
Know when Heym gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Network-reachable workflow editor (AV:N), deterministic blacklist bypass (AC:L), requires a low-privileged workflow-editing account (PR:L), no user interaction, yielding full command execution as the backend user (C/I/A:H).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Heym builds and runs agentic systems and business-process automations on self-hosted infrastructure. Prior to 0.0.40, an authenticated user who can create or edit a workflow with an Agent custom Python tool can bypass the blacklist-based sandbox in backend/app/services/python_tool_executor.py because allowed standard-library modules expose operating-system, process, and filesystem capabilities through public attributes that pass _safe_import() and _validate_code_safety(). The runner then executes the supplied tool with exec(), permitting commands and file operations as the backend application user; self-registration affects reachability, but portal triggering alone does not grant code control. This issue is fixed in 0.0.40.
Articles & Coverage 1
Technical POC Analysis
CWE-78 (OS command injection) as assigned to CVE-2026-55376, with the advisory also recording CWE-94 (code injection) and naming CWE-693 (protection mechanism failure) as its suggested primary class.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Self-hosted Heym deployments running versions below 0.0.40 carry a sandbox-escape weakness that allows any authenticated user holding workflow create/edit rights to execute arbitrary commands and file operations as the backend service account. Because Heym supports self-registration, a low-privilege or self-created account can be enough to pivot from an ordinary workflow author into full control of the server hosting the application, putting any data, integration secrets, or downstream systems reachable from that host at risk. Leadership should care because remediation is currently limited to configuration hardening rather than a vendor fix, and every self-hosted instance that allows open registration is effectively a standing exposure.
No vendor-released patch identified at time of analysis. Interim mitigations: disable self-registration and close any untrusted account path; restrict workflow create/edit rights to a minimal trusted set of administrators; run the Heym backend service under a dedicated low-privilege account in an isolated container or host with no sensitive mounts; block outbound egress from the backend to only required endpoints; remove unnecessary Agent custom Python tools; monitor and alert on process creation and filesystem writes by the backend service; and deploy the fixed 0.0.40-or-later release as soon as it is obtainable.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
Sandbox escape in the heym workflow platform before 0.0.91 allows an authenticated user who can author or edit workflow
Python eval()-based remote code execution in Heym (heymrun/heym) before 0.0.53 lets an authenticated user who can edit a
Sandbox escape in Heym's custom Python tool executor (versions before 0.0.21) allows authenticated workflow authors to b
Heym deployments prior to 0.0.53 leave their Telegram webhook endpoints without verification of the X-Telegram-Bot-Api-S
Forged Slack webhook events can trigger Heym workflows with the owner's credentials because Heym before 0.0.53 skips Sla
Non-blind server-side request forgery in heym (heymrun) before 0.0.109 lets any registered user redirect backend HTTP re
Authorization bypass in Heym's workflow execution engine (versions before 0.0.21) allows any authenticated user to run w
Arbitrary file write (and read/delete) in Heym before 0.0.21 lets an authenticated user escape the intended upload stora
Credential exfiltration in Heym before version 0.0.106 allows an authenticated collaborator who has been granted shared
Cleartext storage and over-exposure of multiple capability secrets in Heym, a workflow automation platform, affects all
heym before 0.0.105 fails to enforce credential authorization in its Redis workflow node, letting an authenticated workf
Server-side request forgery in Heym 0.0.90 and earlier lets a caller-controlled workflow input steer an outbound HTTP fe
EUVD-2026-98740
NVD
CVE.org
EPSS
GitHub
Exploit-DB