Skip to main content

NASA Trick EUVDEUVD-2026-68148

| CVE-2026-82478 MEDIUM
Stack-based Buffer Overflow (CWE-121)
2026-08-30 VulDB GHSA-fq2p-334f-fcrf
6.9
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Identify exposed JSONVariableServer TCP port
  2. Delivery
    Connect without authentication
  3. Exploit
    Send crafted oversized JSON payload
  4. Execution
    Trigger unbounded sscanf stack overflow
  5. Persist
    Overwrite return address
  6. Impact
    Execute arbitrary code or crash simulation process

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Stack buffer bounds checking
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

The NASA Trick JSONVariableServer component must be active and its TCP port must be reachable by the attacker - this is an optional subsystem that must be explicitly enabled in the simulation configuration, but is a commonly used feature for external variable monitoring. Per the CVSS 4.0 vector (PR:N, AV:N, AC:L), no authentication, special configuration beyond enabling the feature, or user interaction is required once the TCP port is accessible. Exploitation is constrained by: (1) the requirement that the JSONVariableServer feature specifically must be running and network-reachable; (2) the research/lab deployment context of NASA Trick, which is rarely exposed to untrusted networks; (3) platform memory protections (ASLR, stack canaries, NX) that may degrade reliable code execution to denial-of-service.

Impact

The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) characterizes this as a network-reachable, zero-prerequisite, low-complexity attack - a genuinely dangerous profile. The score of 6.9 reflects constrained impact metrics (VC:L/VI:L/VA:L), indicating the scoring does not assume reliable code execution, consistent with a stack overflow whose practical exploitability may be limited by platform mitigations such as ASLR and stack canaries. No KEV listing is present, meaning exploitation has not been confirmed by CISA. No confirmed public exploit code exists at time of analysis, though the detailed Notion writeup at the linked reference suggests a thorough technical disclosure exists that could accelerate weaponization. EPSS data was not provided, leaving probabilistic exploitation risk unquantified. The vendor's non-response to disclosure is a significant risk amplifier: there is no coordinated patch forthcoming, and users of the open-source project must rely on community-driven fixes or self-apply compensating controls. Real-world blast radius is moderated by deployment context - NASA Trick is almost exclusively used in research, aerospace, and simulation lab environments that are typically network-restricted or air-gapped, substantially reducing realistic attack surface compared to internet-facing enterprise software.

Exploit ScenarioDerived

A remote attacker with network access to the simulation host sends a specially crafted JSON request over TCP to the JSONVariableServer listener, triggering the unbounded sscanf call in parse_request with a payload that overflows the fixed-size stack buffer. On systems lacking stack canaries or ASLR, this can overwrite the saved return address and redirect execution to attacker-controlled code; on hardened systems the likely outcome is a crash that terminates the simulation process. The Notion writeup title referencing the specific sscanf sink suggests a detailed technical disclosure is available that could guide exploit development.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAI

Stack-based buffer overflow in NASA Trick 19.6.0's JSONVariableServer component exposes the simulation framework to remote exploitation via crafted TCP requests, with no patch available and no vendor response to disclosure. The vulnerability resides in JSONVariableServerThread::parse_request, where user-supplied network data is processed through an unbounded sscanf call without bounds checking on a stack-allocated buffer. Unauthenticated remote attackers reaching the TCP socket can trigger this overflow, potentially crashing the simulation process or achieving code execution on the host.

RemediationAI

No vendor-released patch has been identified at time of analysis; the NASA Trick project did not respond to disclosure. The primary compensating control is to restrict network access to the JSONVariableServer TCP port using host-based firewall rules or network segmentation, allowing only trusted simulation client hosts to connect - this eliminates the remote attack vector without code changes but does not fix the underlying flaw. If the JSONVariableServer feature is not required by the simulation deployment, disabling it entirely in the Trick configuration removes the vulnerable component from the attack surface with no functional trade-off for those workflows. Operators should monitor the simulation server port for unexpected connection attempts as an anomaly detection measure. The Notion writeup linked in the references (https://app.notion.com/p/Stack-based-Buffer-Overflow-in-NASA-Trick-JSONVariableServer-via-Unbounded-sscanf-on-Network-Receive-39cbd773e51180e1917cd717b90b8bc8) may contain additional technical detail or community patch references.

Affected VersionsENISA

Trick 19.6.0

Affected Packages

euvd trick no fix

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

NASA Trick is an open-source simulation framework developed by NASA, widely used in aerospace, spacecraft, and vehicle dynamics research. Its JSONVariableServer component provides a TCP socket-based interface allowing external clients to query and manipulate simulation variables using JSON-formatted messages. The affected function JSONVariableServerThread::parse_request in trick_source/sim_services/JSONVariableServer/JSONVariableServerThread.cpp reads raw network data and processes it with what the Notion writeup title describes as an unbounded sscanf call - a classic CWE-121 (Stack-based Buffer Overflow) root cause where a fixed-size stack buffer is overwritten by attacker-controlled input of arbitrary length. CWE-121 flaws in network-facing parsers are well-understood and historically exploitable when platform memory protections are absent or bypassable. The CPE cpe:2.3:a:nasa:trick:*:*:*:*:*:*:*:* uses a wildcard, suggesting the vulnerability class may not be exclusive to version 19.6.0.

Know when Trick 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 (VulDB) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N
vuln.today AI 7.3 HIGH

Network-reachable TCP service requires no authentication; stack overflow enables partial memory corruption, denial of service, and potential code execution.

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

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

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

DescriptionCVE.org

A vulnerability was determined in NASA Trick 19.6.0. This issue affects the function JSONVariableServerThread::parse_request of the file trick_source/sim_services/JSONVariableServer/JSONVariableServerThread.cpp of the component TCP Socket Handler. This manipulation causes stack-based buffer overflow. The attack is possible to be carried out remotely. The vendor was contacted early about this disclosure but did not respond in any way.

Threat Intelligence Overview

EPSS Score
0.3%
Top 74% exploitable
Prevalence
Rare
specialized aerospace simulation framework, limited research and government lab use
Social Media
2
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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

A stack-based buffer overflow occurs when a program writes more data to a buffer located on the stack than it was allocated to hold.

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