Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as workflow author
-
DeliveryCreate custom Python tool
-
ExploitUse introspection to recover __import__
-
ExecutionImport os/subprocess past sandbox
-
PersistExecute host commands as service user
-
ImpactExfiltrate DB credentials and encryption keys
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V15 - Secure Coding and Architecture Protection mechanism completeness
|
| Exploitation Conditions | Exploitation requires an authenticated Heym account with permission to author or edit custom Python tools/workflows (CVSS PR:L) on a version before 0.0.21; the attacker must be able to submit and execute Python code through the tool executor feature. No user interaction from a victim is needed (UI:N) and the vector is network-reachable (AV:N) via the normal workflow interface. Limiting factors: the attacker cannot be fully anonymous - they need valid author-level credentials - so instances that restrict Python-tool authoring to trusted operators are not exposed to arbitrary users; impact is also gated to whatever secrets and privileges the backend service user holds, so a hardened, least-privilege service account reduces the payoff. Value of the exploit further depends on sensitive material (DB credentials, encryption keys) actually being present in the backend process environment. |
| Impact | Signals are mixed and point to a real-but-not-mass-exploitation profile. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N with VC:H/VI:H/VA:H, base 8.7) and SSVC 'Technical Impact: total' confirm severe consequences - full host command execution and credential theft - but require authenticated access (PR:L, a workflow author account), which sharply narrows the attacker population. SSVC 'Automatable: no' and the very low EPSS (0.04%, 14th percentile) indicate this is not being sprayed at scale; it is a post-authentication privilege/containment breach rather than a drive-by internet exploit. A public POC exists per SSVC, raising practical exploitability for anyone who already has author access, but there is no KEV listing and no evidence of active exploitation. Net: high priority for any organization running Heym that grants Python-tool authoring to semi-trusted users, but lower urgency where workflow authoring is restricted to fully trusted operators. No major data conflicts - the network vector is consistent with a web-based workflow platform, and the PR:L requirement is consistent with the 'authenticated workflow authors' language in the description. |
| Exploit ScenarioDerived | An attacker who has (or phishes/registers) a workflow-author account in a Heym instance creates a custom Python tool whose code walks the interpreter's object graph to recover __import__, then imports os and subprocess. Running that workflow yields arbitrary shell command execution as the backend service user and lets the attacker read environment variables containing database credentials and encryption keys, pivoting to the database and stored secrets. A public POC for this introspection technique already exists per the SSVC assessment, lowering the skill required. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 23, 2026
Sandbox escape in Heym's custom Python tool executor (versions before 0.0.21) allows authenticated workflow authors to break out of the restricted execution environment using Python object-graph introspection, recover the unrestricted __import__ function, and load blocked modules such as os and subprocess. Once free of the sandbox, an attacker executes arbitrary host commands as the backend service user and reads inherited environment variables holding database credentials and encryption keys. Publicly available exploit code exists (SSVC 'poc'), though the EPSS probability is very low at 0.04% and it is not listed in CISA KEV.
RemediationAI
Vendor-released patch: upgrade to Heym 0.0.21 or later, which hardens the Python tool sandbox via PR #94 (commit 32b7e809d987d9b018ec8daa2cdaf48f627f26f1); see https://github.com/heymrun/heym/releases/tag/v0.0.21. Until you can upgrade, restrict who can author or edit custom Python tools and workflows to a small set of fully trusted operators, since exploitation requires an authenticated author account - this reduces functionality for less-trusted users but directly removes the attacker population. Additionally, minimize secrets inherited by the backend service process: move database credentials and encryption keys out of the service's environment variables into a scoped secrets manager or per-request injection so a sandbox escape yields fewer usable secrets, at the cost of some configuration overhead. If feasible, run the tool executor under a dedicated low-privilege service account with a locked-down filesystem and network egress rules to limit what recovered os/subprocess access can reach. Note that v0.0.21 also bundles unrelated security fixes for stored upload path containment (PR #92) and subworkflow access checks (PR #93), so upgrading addresses multiple issues at once.
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 exposes a feature that lets workflow authors write custom Python 'tools' that run inside a restricted interpreter sandbox. The vulnerability is a classic Python sandbox-escape pattern: even when dangerous builtins like __import__ are removed from the namespace, an attacker can walk the object graph - for example via ().__class__.__bases__[0].__subclasses__() or accessing __globals__/__builtins__ on reachable functions - to re-obtain the real __import__ and pull in os and subprocess. This maps to CWE-693 (Protection Mechanism Failure): the sandbox is the intended protection control, and introspection primitives defeat it rather than exploiting a memory-safety bug. The single affected package per CPE is cpe:2.3:a:heymrun:heym, a workflow/automation tool where user-authored Python is a core capability, so the blast radius is the backend service process and every secret exposed to its environment.
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
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable workflow feature (AV:N/AC:L) but requires an authenticated author account (PR:L); sandbox escape yields full host command execution and secret theft (C:H/I:H/A:H), same authority so S:U.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Heym before 0.0.21 contains a sandbox escape vulnerability in the custom Python tool executor that allows authenticated workflow authors to bypass sandbox restrictions by using object-graph introspection primitives. Attackers can use Python introspection techniques to recover the unrestricted __import__ function, import blocked modules such as os and subprocess, and access inherited backend environment variables containing database credentials and encryption keys to execute arbitrary host commands as the backend service user.
Executive ViewAI
Heym's Python tool executor (versions before 0.0.21) contains a sandbox escape that allows authenticated workflow authors to execute arbitrary commands as the backend service user, gaining access to inherited database credentials and encryption keys. This creates direct risk of data breach and infrastructure compromise for any organization using vulnerable versions.
Apply vendor patch.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
Authenticated users with workflow create/edit rights on self-hosted Heym deployments prior to 0.0.40 can escape the appl
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
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-29869
GHSA-vhhj-j98h-xx8p
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB