Skip to main content

MOOS core-moos EUVDEUVD-2026-70788

| CVE-2026-85454 MEDIUM
Off-by-one Error (CWE-193)
2026-09-03 VulnCheck GHSA-793h-4m99-4gx3
5.2
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Gain physical access to serial interface
  2. Delivery
    Send TELEGRAM_LEN-byte crafted telegram
  3. Exploit
    Off-by-one NUL write past stack buffer
  4. Execution
    Corrupt adjacent stack control data
  5. Impact
    Redirect 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

core-moos 0 ≤10.4.0

Affected Packages

euvd core_moos 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

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

Vendor (VulnCheck) PRIMARY 5.2 MEDIUM
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
vuln.today AI 6.1 MEDIUM

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.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

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

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

EPSS Score
0.2%
Top 88% exploitable
Prevalence
Rare
niche robotics middleware, primarily marine AUV and ASV deployments
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.2%
Patch available Yes
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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
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.

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

CVE-2026-85440 CRITICAL
9.3 Sep 03

Remote code execution risk in MOOS core-moos through 10.4.0 arises from a pre-authentication heap overflow in MOOSCommPk

CVE-2026-85428 CRITICAL
9.3 Sep 03

Unauthenticated variable write in MOOS core-moos through 10.4.0 lets any client that can reach the optional MOOSDB HTTP

CVE-2026-85424 CRITICAL
9.3 Sep 03

Unauthenticated full compromise of the MOOSDB message bus in MOOS core-moos through 10.4.0, where the wire protocol perf

CVE-2026-85455 HIGH
8.8 Sep 03

Unauthenticated buffer over-read in MOOS core-moos through 10.4.0 allows any attacker with TCP access to the MOOSDB port

CVE-2026-85432 HIGH
8.8 Sep 03

MOOSDB in core-moos through 10.4.0 accepts wire-supplied source identifiers verbatim instead of enforcing the authentica

CVE-2026-85442 HIGH
8.7 Sep 03

Uncontrolled memory allocation in MOOS core-moos through 10.4.0 exposes MOOSDB servers to pre-authentication denial of s

CVE-2026-85441 HIGH
8.7 Sep 03

Unauthenticated denial-of-service in MOOS core-moos through 10.4.0 allows remote attackers to crash the central MOOSDB p

CVE-2026-85450 HIGH
8.7 Sep 03

Resource exhaustion in the MOOSDB HTTP server component of MOOS core-moos through 10.4.0 allows unauthenticated remote a

CVE-2026-85443 HIGH
8.7 Sep 03

Denial-of-service in MOOS core-moos through 10.4.0 allows any unauthenticated network peer to permanently freeze the MOO

CVE-2026-85451 HIGH
7.1 Sep 03

Remote process termination in MOOS core-moos through 10.4.0 allows any multicast-reachable attacker to forcibly shut dow

CVE-2026-85453 MEDIUM
5.3 Sep 03

Stored cross-site scripting in MOOS core-moos through 10.4.0 allows any MOOS publisher to inject script payloads into th

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