Skip to main content

Astron Agent EUVDEUVD-2026-95992

| CVE-2026-108263 CRITICAL
Eval Injection (CWE-95)
2026-10-09 GitHub_M
9.9
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Authenticate as low-privilege tenant
  2. Delivery
    Submit workflow Code node to /workflow/v1/run
  3. Exploit
    Escape via unrestricted Python builtins (LocalExecutor)
  4. Execution
    Execute code as root in core-workflow container
  5. Persist
    Reuse shared DB/service credentials
  6. Impact
    Read or modify other tenants' data

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Eval input sanitization
MITRE ATT&CK

1 technique 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

Exploitation requires that CODE_EXEC_TYPE is left at its pre-1.1.2 default (not explicitly set), which causes code_node.py to select LocalExecutor - the vulnerable, sandbox-free path; this is the shipped default so most unmodified deployments qualify. The attacker must hold a valid low-privilege tenant account (PR:L) and be able to create/run a workflow containing a Code node, reachable via /console-api/workflow/code/run or /workflow/v1/run. Limiting factors: authentication to a tenant is mandatory (not anonymous), and deployments that explicitly set CODE_EXEC_TYPE to 'disabled' or the isolated LangChain/Pyodide sandbox, or that have upgraded to 1.1.2, are not exposed.

Impact

This is a genuine high-priority issue, not a CVSS-inflation artifact. The provided CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, 9.9) is internally consistent with the description: a network-reachable workflow endpoint (/console-api/workflow/code/run and /workflow/v1/run), low attack complexity, only low-privilege tenant authentication required (PR:L), no user interaction, and a scope change (S:C) because code runs as root inside the shared core-workflow container and reaches other tenants' data and shared services via shared DB/service credentials. The scope change plus full CIA 'High' impact is well-justified by the described tenant-isolation break. EPSS score was NOT provided, so exploitation probability cannot be quantified. KEV status is not listed (treat as not in KEV). No public exploit code is referenced - the GitHub artifacts are the fix (PRs #1650/#1651, two commits, release v1.1.2 and the GHSA advisory), NOT a POC. The key risk amplifier is that the vulnerable LocalExecutor is the DEFAULT path when CODE_EXEC_TYPE is unchanged, so typical deployments are exposed out of the box; the only mitigating signal is that authentication (a tenant account) is required, making this authenticated rather than fully anonymous RCE.

Exploit ScenarioDerived

An attacker who holds any low-privilege tenant account on an Astron Agent instance (prior to 1.1.2, default config) builds a workflow containing a Code node and submits malicious Python via /console-api/workflow/code/run or /workflow/v1/run. Because LocalExecutor exposes full Python builtins with no sandbox, the code runs as root in the core-workflow container, from which the attacker uses shared service/database credentials to bypass tenant checks and read or alter other tenants' data. No public POC is referenced, but the attack requires no special exploitation skill given low attack complexity.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
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 09, 2026

Authenticated low-privilege tenant users of iFlytek Astron Agent prior to 1.1.2 can run arbitrary Python as root inside the core-workflow container by submitting a workflow Code node, because the shipped default configuration routes dynamic code execution to an unsandboxed LocalExecutor that exposes the full set of Python builtins. From that foothold the attacker can read shared service and database credentials and use them to bypass application-level tenant checks, read or modify other tenants' data, and disrupt shared services (CVSS 9.9, scope-changed, CWE-95). Exploitation requires a valid tenant account plus the ability to create or run a workflow containing a Code node; no public exploit identified at time of analysis, and the vendor-released patch is version 1.1.2.

RemediationAI

Vendor-released patch: v1.1.2 - upgrade immediately per https://github.com/iflytek/astron-agent/releases/tag/v1.1.2, which incorporates the config-hardening changes in PRs 1650 and 1651 and commits 848daba03e5e045435863815be7ab6dfbcefc18f and ebf074a431e96da0ad9e0a56409d3d2da15eae36, and additionally review the advisory at https://github.com/iflytek/astron-agent/security/advisories/GHSA-mh3w-4q3f-2fg5. If immediate upgrade is not possible, explicitly set CODE_EXEC_TYPE as a process environment variable rather than relying on the mounted workflow config: setting CODE_EXEC_TYPE=disabled fully disables Code node execution (strongest mitigation, but breaks any workflow that legitimately depends on Code nodes), or set it to the isolated 'langchain' (Pyodide) or 'e2b' sandbox to retain functionality with documented restrictions; an explicit process-level value, including 'disabled', takes precedence and is not overridden by the legacy-default migration. Because the exploit path yields root in the core-workflow container with shared database and service credentials, reduce blast radius by running that container as a non-root user, splitting or rotating the shared credentials and enforcing per-tenant database/service accounts, and restricting which roles may author or run workflows containing Code nodes - accepting that these are compensating controls, not substitutes for upgrading, and that they may break existing workflows or integrations until the patch is applied.

Affected VersionsENISA

astron-agent < 1.1.2

Affected Packages

euvd astron_agent fix: 1.1.2

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

The flaw is a CWE-95 improper-neutralization-of-directives-in-dynamically-evaluated-code issue (effectively eval/exec injection) in Astron Agent's workflow code-node engine. In core/workflow/engine/nodes/code/code_node.py the executor class is chosen from the CODE_EXEC_TYPE setting; when that variable is left untouched (the pre-1.1.2 shipped default) LocalExecutor is selected, which passes complete Python builtins into the dynamic execution context instead of applying the documented sandbox restrictions used by the isolated LangChain/Pyodide executor. The two reachable entry points are the workflow code-run endpoints /console-api/workflow/code/run and /workflow/v1/run, and the resulting code runs with the core-workflow container's privileges, i.e. as root in most deployments. Because the container also holds shared service and database credentials, the compromise is not confined to the requesting tenant - hence the scope change (S:C) in the assessed vector - and it enables cross-tenant data access and disruption of shared services. The upstream fix reworks config loading in core/workflow/configs/__init__.py so that genuinely legacy, unmodified 'CODE_EXEC_TYPE=disabled' templates are migrated to the built-in isolated LangChain/Pyodide sandbox (adding CODE_EXEC_MEMORY_LIMIT_MB and a legacy-header fingerprint check), while an explicit process-level CODE_EXEC_TYPE - including 'disabled' - always wins and remains fail-closed.

Know when Astron Agent 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 9.9 CRITICAL
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 9.9 CRITICAL

Network endpoint with low complexity and only low-privilege tenant auth (PR:L); root execution reaching other tenants and shared services justifies S:C with full C/I/A High.

3.1 AV:N/AC:L/PR:L/UI:N/S:C/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:H/SI:H/SA:H

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

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

Lifecycle Timeline

2
Patch available
Oct 09, 2026 - 22:17 EUVD
CVE Published
Oct 09, 2026 - 20:47 cve.org
CRITICAL 9.9

DescriptionCVE.org

Astron Agent is an agentic workflow platform for building and running AI agents. Prior to 1.1.2, the default workflow code-node path through /console-api/workflow/code/run and /workflow/v1/run selects LocalExecutor in core/workflow/engine/nodes/code/code_node.py when CODE_EXEC_TYPE is not explicitly changed. LocalExecutor supplies complete Python builtins to dynamic code execution without the documented sandbox restrictions. An authenticated low-privilege tenant can execute code as root in the core-workflow container and use shared service and database credentials to bypass application-level tenant checks, read or modify other tenants' data, and disrupt shared services. This issue is fixed in version 1.1.2.

Technical POC Analysis

The primary defect is CWE-95: untrusted code is passed to Python exec() without neutralization or a real sandbox.

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

A critical flaw in iFlytek's Astron Agent platform (versions prior to 1.1.2) lets an ordinary customer tenant account run code as root inside a shared workflow container, from which the platform's tenant isolation controls can be bypassed. In practice, one customer - or one compromised low-privilege user account - could read or alter other tenants' data and obtain shared service and database credentials, directly undermining the isolation guarantee the platform is sold on. Leadership should treat this as a customer-trust, data-confidentiality and contractual/regulatory exposure rather than a routine infrastructure defect.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 64% exploitable
Prevalence
Low
niche open-source iflytek AI-agent platform, limited production footprint
Social Media
5
Sightings
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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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

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

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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