Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain physical access to serial interface
-
DeliverySend TELEGRAM_LEN-byte crafted telegram
-
ExploitOff-by-one NUL write past stack buffer
-
ExecutionCorrupt adjacent stack control data
-
ImpactRedirect execution to attacker-controlled code
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Off-by-one prevention
|
| Exploitation Conditions | Exploitation requires physical control of the serial communication line directly connected to the MOOS-enabled system. The attacker must be able to transmit a raw serial telegram of exactly TELEGRAM_LEN bytes to the CMOOSSerialPort::GetTelegram() or GetTelegramOrAccumulate() code paths. No authentication is required on the serial interface, but the AV:P (Physical) attack vector confirmed by the CVSS 4.0 vector means remote network-based exploitation is not possible without an intermediate serial-to-network bridge explicitly exposing the port. Stack protection mechanisms present on modern Linux deployments (stack canaries, ASLR, NX) further condition whether the single-byte overwrite yields reliable code execution or instead triggers a process crash. The flaw affects all core-moos deployments through 10.4.0 that use the CMOOSSerialPort class; deployments that do not instantiate serial port communication are not exposed. |
| Impact | The CVSS 4.0 vector AV:P/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:H assigns a Physical attack vector, which is the dominant risk-limiting factor - exploitation requires direct control of the serial communication line interfacing with the target hardware, restricting the attacker population to physically proximate actors, insiders, or supply-chain adversaries. Once serial-line access is secured, complexity is low and no authentication is required. Integrity and availability impacts are rated High, consistent with a one-byte stack overwrite that could corrupt saved control data and enable code execution; however, actual exploitability is further conditioned on stack layout, compiler mitigations (stack canaries, ASLR), and the target platform's ABI. The physical access barrier means a standard remotely-managed network perimeter provides no meaningful exposure, though autonomous platforms operating in field conditions with accessible hardware interfaces present a more realistic attack surface. No EPSS data was provided and this CVE is absent from CISA KEV, indicating no known active exploitation. No public proof-of-concept has been identified. |
| Exploit ScenarioDerived | An attacker with physical access to the serial line on a MOOS-enabled autonomous marine or robotic platform sends a crafted telegram exactly TELEGRAM_LEN bytes long. The GetTelegram() loop allows nRead to reach TELEGRAM_LEN, after which the NUL-terminator write at pData[TELEGRAM_LEN] overwrites the adjacent stack byte - potentially corrupting a stack canary, saved return address, or frame pointer. Depending on the host platform's stack layout and mitigations, a carefully constructed telegram sequence could redirect execution to attacker-supplied shellcode or return-oriented programming gadgets. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 03, 2026
Stack corruption with potential code execution in MOOS core-moos through version 10.4.0 arises from an off-by-one error in CMOOSSerialPort::GetTelegram(), where a NUL terminator is written one byte past the end of a fixed-size stack buffer. An attacker who controls the serial communication line connected to a MOOS-enabled platform can send a full-length telegram to trigger the overwrite, corrupting adjacent stack memory and potentially redirecting execution. A vendor patch is available via GitHub PR #73 and commit befb04df; no public exploit has been identified at time of analysis.
RemediationAI
Apply the upstream fix from GitHub PR #73 (https://github.com/themoos/core-moos/pull/73) or incorporate commit befb04df2039d0080715ea35f56268092db4ec0f directly into local builds. The patch corrects the loop termination condition in both GetTelegram() and GetTelegramOrAccumulate() from nRead<TELEGRAM_LEN to nRead<TELEGRAM_LEN-1, and adds a safeguard to discard full-buffer accumulations lacking a terminator. No specific patched release tag was confirmed from available data; users should verify the upstream repository for a subsequent tagged release. As a compensating control where patching is not immediately feasible, physically securing access to serial ports on MOOS-enabled platforms eliminates the primary attack vector entirely. On platforms where serial interfaces are remotely accessible via adapters or terminal servers, disabling or restricting those bridges reduces exposure. Enabling operating-system stack-protection mechanisms (stack canaries, ASLR) on the host reduces the likelihood that the one-byte overwrite translates to reliable code execution.
Affected VersionsENISA
Affected Packages
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
MOOS (Mission Oriented Operating Suite) core-moos is a publish-subscribe middleware framework for autonomous robotic systems, widely used in marine autonomous underwater and surface vehicles. The vulnerable code resides in CMOOSSerialPort::GetTelegram() and CMOOSSerialPort::GetTelegramOrAccumulate() in Core/libMOOS/Utils/MOOSSerialPort.cpp (around line 595). Both functions use a while loop bounded by nRead<TELEGRAM_LEN to fill a fixed stack buffer, then write a NUL terminator at pData[nRead] after the loop exits. Because the loop can allow nRead to reach exactly TELEGRAM_LEN on a maximum-length telegram, the subsequent NUL write lands at pData[TELEGRAM_LEN] - one byte beyond the declared buffer (CWE-193, Off-by-One Error). The fix in PR #73 changes both bounds to nRead<TELEGRAM_LEN-1, reserving one slot for the terminator, and additionally discards accumulated partial telegrams that fill the buffer without a terminator. The affected CPE is cpe:2.3:a:themoos:core-moos:*:*:*:*:*:*:*:*.
Know when Core Moos 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
CVSS:4.0/AV:P/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:H/SC:N/SI:N/SA:N
Physical serial-line control required (AV:P); no privileges or user interaction needed; one-byte stack overwrite yields high integrity and availability impact with no confidentiality breach.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
MOOS core-moos through 10.4.0 contains a buffer overflow vulnerability in CMOOSSerialPort::GetTelegram() that writes a NUL terminator one byte past the serial telegram stack buffer. Attackers controlling the serial line can send a full-length telegram to trigger the off-by-one write, corrupting the stack and potentially enabling code execution.
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
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.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Remote code execution risk in MOOS core-moos through 10.4.0 arises from a pre-authentication heap overflow in MOOSCommPk
Unauthenticated variable write in MOOS core-moos through 10.4.0 lets any client that can reach the optional MOOSDB HTTP
Unauthenticated full compromise of the MOOSDB message bus in MOOS core-moos through 10.4.0, where the wire protocol perf
Unauthenticated buffer over-read in MOOS core-moos through 10.4.0 allows any attacker with TCP access to the MOOSDB port
MOOSDB in core-moos through 10.4.0 accepts wire-supplied source identifiers verbatim instead of enforcing the authentica
Uncontrolled memory allocation in MOOS core-moos through 10.4.0 exposes MOOSDB servers to pre-authentication denial of s
Unauthenticated denial-of-service in MOOS core-moos through 10.4.0 allows remote attackers to crash the central MOOSDB p
Resource exhaustion in the MOOSDB HTTP server component of MOOS core-moos through 10.4.0 allows unauthenticated remote a
Denial-of-service in MOOS core-moos through 10.4.0 allows any unauthenticated network peer to permanently freeze the MOO
Remote process termination in MOOS core-moos through 10.4.0 allows any multicast-reachable attacker to forcibly shut dow
Stored cross-site scripting in MOOS core-moos through 10.4.0 allows any MOOS publisher to inject script payloads into th
EUVD-2026-70788
GHSA-793h-4m99-4gx3
NVD
CVE.org
EPSS
Exploit-DB