Skip to main content

Heym EUVDEUVD-2026-98740

| CVE-2026-55376 HIGH
OS Command Injection (CWE-78)
2026-10-13 GitHub_M
8.8
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate or self-register to portal
  2. Delivery
    Create workflow with custom Python tool
  3. Exploit
    Reach OS/process attrs via allowed stdlib modules
  4. Execution
    Blacklist sandbox check passes, exec() runs code
  5. Impact
    Execute 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

heym < 0.0.40

Affected Packages

euvd heym fix: 0.0.40

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

Vendor (GitHub_M) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

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).

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Oct 13, 2026 - 16:18 EUVD
CVE Published
Oct 13, 2026 - 15:12 cve.org
HIGH 8.8

DescriptionCVE.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.

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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.4%
Top 72% exploitable
Prevalence
Rare
pre-1.0 niche self-hosted agentic-automation project, tiny production footprint
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

More in Heym

View all
CVE-2026-100864 HIGH
8.7 Sep 27

Sandbox escape in the heym workflow platform before 0.0.91 allows an authenticated user who can author or edit workflow

CVE-2026-100865 HIGH
8.7 Sep 27

Python eval()-based remote code execution in Heym (heymrun/heym) before 0.0.53 lets an authenticated user who can edit a

CVE-2026-45227 HIGH
8.7 May 12

Sandbox escape in Heym's custom Python tool executor (versions before 0.0.21) allows authenticated workflow authors to b

CVE-2026-101050 HIGH
8.3 Sep 27

Heym deployments prior to 0.0.53 leave their Telegram webhook endpoints without verification of the X-Telegram-Bot-Api-S

CVE-2026-101049 HIGH
8.3 Sep 27

Forged Slack webhook events can trigger Heym workflows with the owner's credentials because Heym before 0.0.53 skips Sla

CVE-2026-100858 HIGH
7.6 Sep 27

Non-blind server-side request forgery in heym (heymrun) before 0.0.109 lets any registered user redirect backend HTTP re

CVE-2026-45226 HIGH
7.6 May 12

Authorization bypass in Heym's workflow execution engine (versions before 0.0.21) allows any authenticated user to run w

CVE-2026-45225 HIGH
7.2 May 12

Arbitrary file write (and read/delete) in Heym before 0.0.21 lets an authenticated user escape the intended upload stora

CVE-2026-100859 HIGH
7.1 Sep 27

Credential exfiltration in Heym before version 0.0.106 allows an authenticated collaborator who has been granted shared

CVE-2026-100862 MEDIUM
6.9 Sep 27

Cleartext storage and over-exposure of multiple capability secrets in Heym, a workflow automation platform, affects all

CVE-2026-100860 MEDIUM
6.8 Sep 27

heym before 0.0.105 fails to enforce credential authorization in its Redis workflow node, letting an authenticated workf

CVE-2026-100863 MEDIUM
5.3 Sep 27

Server-side request forgery in Heym 0.0.90 and earlier lets a caller-controlled workflow input steer an outbound HTTP fe

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy