Back to Intelligence

ZDI-26-1026: Open Robotics RViz PointField Out-of-Bounds Read DoS — Detection and Hardening Guide for Unpatched Robotics Workstations

SA
Security Arsenal Team
November 20, 2026
13 min read

Introduction

The Zero Day Initiative has published ZDI-26-1026, an unpatched out-of-bounds read vulnerability in the XYZPCTransformer component of Open Robotics RViz, the de facto standard 3D visualization tool for the Robot Operating System (ROS) ecosystem. The flaw allows network-adjacent attackers to trigger a denial-of-service condition on affected RViz installations — and critically, no authentication is required. ZDI has assigned this vulnerability a CVSS score of 6.5 (AV:A/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H)-class rating: adjacent network, low complexity, no privileges, no user interaction, pure availability impact.

If you think "it's just a DoS in a visualization tool, who cares" — reconsider. RViz sits in the operational path of autonomous vehicle development, warehouse robotics fleets, industrial manipulation cells, and research platforms. Operators rely on RViz for real-time situational awareness of robot state and sensor data. An attacker who can reliably crash the operator's visualization layer during a critical maneuver — or use it as a foothold probe against a poorly segmented robotics VLAN — has a meaningful impact on physical operations. And because this bug is a memory-safety flaw in a message parser, it is also a signal: the same code paths that read out of bounds today may yield a more severe primitive tomorrow.

There is no vendor patch at time of publication. This post covers what defenders need to do now: understand the attack surface, hunt for exploitation attempts, segment the exposure, and harden ROS workstations until a fix ships.

Technical Analysis

Affected Component and Products

  • Product: Open Robotics RViz (ROS 1 rviz and ROS 2 rviz2 packages)
  • Affected component: XYZPCTransformer — the transformer responsible for converting sensor_msgs/PointCloud2 message fields (X/Y/Z point fields) into renderable geometry for the PointCloud display plugin
  • Platforms: Linux (primary), macOS, Windows — anywhere RViz runs; the dominant deployment is Ubuntu-based robotics workstations and field laptops
  • Attack vector: Adjacent network. An attacker on the same network segment (or a segment routable to the ROS graph — remember, ROS 1 has no authentication on the topic bus by default) can publish a crafted PointCloud2 message that a subscribed RViz instance will parse
  • CVSS: 6.5 (ZDI assessment); availability impact only (DoS via crash)
  • Exploitation status: Unpatched zero-day disclosure. No confirmed in-the-wild exploitation, no CISA KEV entry as of this writing. ZDI published this after the coordinated disclosure window — which historically means a working PoC exists within the research community even if none is public. Treat exploitability as imminent, not theoretical.

How the Vulnerability Works

XYZPCTransformer parses the PointField descriptors embedded in incoming sensor_msgs/PointCloud2 messages. These descriptors define the layout of each point: field names, byte offsets, datatypes (e.g., FLOAT32, UINT32), and element counts. The root cause is an out-of-bounds read in this parsing path: the transformer trusts field metadata (offset/count/datatype declarations) from the wire and reads past the actual allocated buffer backing the point cloud data when the declared geometry does not match the real message payload size.

From a defender's perspective, the attack chain is:

  1. Attacker gains adjacency — same VLAN, compromised IoT device on the robotics segment, rogue Wi-Fi node, or a supply-chain-adjacent lab network. In ROS 1 environments, adjacency to the ROS master (TCP port 11311) plus topic registration is sufficient. In ROS 2, default DDS multicast discovery means any node on the segment can publish.
  2. Attacker publishes a malformed PointCloud2 message to a topic the target RViz instance subscribes to (e.g., /points, /points2, /lidar_points, camera depth topics) — or spoofs a publisher name RViz is configured to consume.
  3. RViz's PointCloud display invokes XYZPCTransformer, which reads out of bounds using attacker-controlled field offsets. The read hits an unmapped page (or corrupts control flow), and the rviz/rviz2 process segfaults — a full crash of the visualization process.
  4. Result: operator workstation visualization is dead. In environments where RViz is embedded in larger operator control stations, the blast radius can extend to the supervising application.

The honest technical caveat: this is an out-of-bounds read scored as DoS-only. Crash-only today. But OOB reads in C++ message parsers are routinely re-examined once public attention lands — read primitives adjacent to type-confused parsing have been escalated to information disclosure or worse in comparable codebases. Plan for patch verification accordingly.

Detection & Response

Because RViz is a Linux GUI application with no native security telemetry, detection hinges on three observables: process crash artifacts (segfaults in syslog/journald, core dumps), anomalous publishers on ROS point-cloud topics, and network connections from unexpected hosts to the ROS graph. The detections below are tuned to fire on exploitation of this specific flaw and the behaviors an attacker must exhibit to reach it.

SIGMA

YAML
---
title: RViz Process Crash Segfault via Malformed PointCloud2
description: Detects segfault/crash of the rviz or rviz2 process, consistent with exploitation of ZDI-26-1026 (XYZPCTransformer PointField out-of-bounds read DoS). RViz rarely crashes in stable operation; a segfault correlated with active point cloud subscriptions is a strong exploitation indicator.
author: Security Arsenal
date: 2026/04/06
status: experimental
references:
  - http://www.zerodayinitiative.com/advisories/ZDI-26-1026/
logsource:
  product: linux
  service: syslog
detection:
  selection_segfault:
    Message|contains:
      - 'segfault'
  selection_proc:
    Message|contains:
      - 'rviz'
      - 'rviz2'
  condition: selection_segfault and selection_proc
falsepositives:
  - Known instability of RViz under heavy point cloud load with buggy GPU drivers
  - Development workstations with custom rviz plugins under active development
level: high
---
title: RViz Crash Loop Repeated Process Restart
description: Detects repeated rapid restarts of rviz/rviz2, indicating a persistent denial-of-service condition where an attacker repeatedly publishes malformed PointCloud2 messages (ZDI-26-1026) causing cyclical crashes after supervisor/auto-restart relaunches the process.
author: Security Arsenal
date: 2026/04/06
status: experimental
references:
  - http://www.zerodayinitiative.com/advisories/ZDI-26-1026/
logsource:
  category: process_creation
  product: linux
detection:
  selection:
    Image|endswith:
      - '/rviz'
      - '/rviz2'
  condition: selection
timeframe: 5m
level: medium
falsepositives:
  - Operators manually relaunching RViz during debugging
  - Launch scripts that restart RViz on display configuration changes
---
title: Core Dump Artifact Created for RViz Process
description: Detects creation of core dump files for the rviz binary via systemd-coredump or apport, capturing post-crash forensic evidence after suspected ZDI-26-1026 exploitation. Preserve these dumps for analysis.
author: Security Arsenal
date: 2026/04/06
status: experimental
references:
  - http://www.zerodayinitiative.com/advisories/ZDI-26-1026/
logsource:
  product: linux
  service: syslog
detection:
  selection_core:
    Message|contains:
      - 'coredump'
      - 'core dump'
      - 'apport'
  selection_rviz:
    Message|contains:
      - 'rviz'
  condition: selection_core and selection_rviz
falsepositives:
  - Routine crash reporting on development systems
level: medium

KQL — Microsoft Sentinel / Defender

RViz hosts typically report via Syslog/CEF into Sentinel. The first query hunts kernel segfault records for the rviz process; the second pivots to network telemetry to identify new or unexpected remote publishers communicating with ROS infrastructure — the prerequisite adjacency for this attack.

KQL — Microsoft Sentinel / Defender
// Hunt: RViz segfaults consistent with ZDI-26-1026 PointField OOB read DoS
Syslog
| where TimeGenerated > ago(24h)
| where ProcessName =~ "kernel"
| where SyslogMessage has_cs "segfault" and SyslogMessage has "rviz"
| extend CrashedProcess = extract(@"segfault at [0-9a-fx]+ ip [0-9a-fx]+ sp [0-9a-fx]+ error [0-9]+ in ([a-zA-Z0-9_./-]+)", 1, SyslogMessage)
| project TimeGenerated, Computer, SyslogMessage, CrashedProcess
| sort by TimeGenerated desc
KQL — Microsoft Sentinel / Defender
// Hunt: RViz crash frequency — detect DoS crash loops (multiple segfaults in 10-min window)
Syslog
| where TimeGenerated > ago(7d)
| where SyslogMessage has_cs "segfault" and SyslogMessage has "rviz"
| summarize CrashCount = count() by Computer, bin(TimeGenerated, 10m)
| where CrashCount >= 3
| sort by CrashCount desc
KQL — Microsoft Sentinel / Defender
// Hunt: New remote hosts connecting to ROS master (11311) or DDS discovery (7400-7500/udp)
// Baseline your robotics segment first; flag connections from hosts outside known robot/operator sets.
DeviceNetworkEvents
| where TimeGenerated > ago(24h)
| where RemotePort in (11311) or (RemotePort between (7400 .. 7500) and Protocol =~ "Udp")
| where DeviceName has "rviz" or InitiatingProcessFileName has "rviz"
| summarize Connections = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated)
    by RemoteIP, RemotePort, DeviceName, InitiatingProcessFileName
| sort by FirstSeen desc
KQL — Microsoft Sentinel / Defender
// Hunt: CommonSecurityLog (firewall/router CEF) — unexpected traffic to ROS master port on robotics VLAN
CommonSecurityLog
| where TimeGenerated > ago(24h)
| where DestinationPort == 11311
| where DeviceAction =~ "Permitted" or DeviceAction =~ "Allow"
| summarize Hits = count(), FirstSeen = min(TimeGenerated) by SourceIP, DestinationIP, DestinationPort
| sort by FirstSeen desc

Velociraptor VQL

Deploy this as a hunt across robotics workstations to identify rviz processes, their live network connections (who is talking to them right now), and recent core dump artifacts for collection.

VQL — Velociraptor
-- ZDI-26-1026 Hunt: RViz processes, their network peers, and crash artifacts
-- Identifies running rviz instances and the remote hosts connected to them
LET rviz_procs = SELECT Pid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)rviz' OR Exe =~ '(?i)/rviz'

SELECT Pid, Name, Exe, Username, CreateTime,
       Connections.Rport AS RemotePort,
       Connections.Raddr AS RemoteAddr,
       Connections.Status AS ConnStatus
FROM rviz_procs
JOIN (
  SELECT Pid, Rport, Raddr, Status
  FROM netstat()
) AS Connections
ON rviz_procs.Pid = Connections.Pid
VQL — Velociraptor
-- ZDI-26-1026 Forensics: collect recent core dumps for rviz (systemd-coredump + /var/crash + /var/lib/apport)
SELECT FullPath, Size, Mtime, Atime
FROM glob(globs=[
  '/var/lib/systemd/coredump/*rviz*',
  '/var/crash/*rviz*',
  '/var/lib/apport/coredump/*rviz*',
  '/core*'
])
WHERE Mtime > now() - 86400 * 7
ORDER BY Mtime DESC

Immediate Triage and Response Steps

  1. Preserve crash evidence before anything else. Core dumps (/var/lib/systemd/coredump/, /var/crash/) contain the malformed message context at crash time. Copy them off-box — they are your ground truth for confirming ZDI-26-1026 exploitation vs. garden-variety instability.
  2. Identify the publisher. Pull rostopic info <topic> / ros2 topic info history from ROS logs (~/.ros/log/, journald on the host) to determine which node published to the point cloud topic at crash time, and from which IP.
  3. Isolate the source host at the switch/NAC level. A foreign publisher on your ROS graph is an incident, not an anomaly — even if the outcome was "only" a crash.
  4. Check lateral movement. A host with adjacency to your robotics VLAN that is publishing malformed DDS/TCPROS traffic should be assumed to have enumerated the entire graph (rosnode list, DDS discovery is trivially passive). Review what other services that host touched.

Remediation

There is no upstream patch available as of this advisory's publication. Defenders must compensate. Prioritized actions:

1. Segment and gate the ROS graph (highest impact)

The vulnerability requires network adjacency. Remove the adjacency:

  • Place robotics/ROS infrastructure on a dedicated, access-controlled VLAN with explicit ACLs. Only authorized robot platforms, operator workstations, and the ROS master should be reachable.
  • For ROS 1: restrict access to the ROS master (TCP 11311) via host firewall; only trusted nodes should be able to register publishers. Better: tunnel ROS through rosauth/VPN overlays or migrate to ROS 2 with security enabled.
  • For ROS 2: enable SROS2 (DDS Security). Enforce participant authentication and encrypt topic traffic with governance/permissions documents so that unauthenticated participants cannot publish to point cloud topics. This directly breaks the attack path.
  • Disable DDS multicast discovery across segment boundaries; use unicast discovery with explicit peer lists.

2. Apply host-level network controls on RViz workstations

The following Bash script audits RViz presence, applies defensive iptables rules restricting ROS-plane traffic to known peers, enables core dump capture for forensics, and sets a crash watchdog. Adjust $TRUSTED_ROS_NET to your environment before running.

Bash / Shell
#!/usr/bin/env bash
# ZDI-26-1026 compensating controls for RViz hosts (unpatched)
set -euo pipefail

TRUSTED_ROS_NET="10.50.0.0/24"   # <-- CHANGE: your authorized robotics segment
LOG=/var/log/zdi_26_1026_hardening.log

echo "[$(date -u)] Starting ZDI-26-1026 compensating controls" | tee -a "$LOG"

# 1. Confirm RViz presence and record version for patch tracking
if dpkg -l 2>/dev/null | grep -E 'ros-.*rviz' | tee -a "$LOG"; then
  echo "[!] RViz installed. Track upstream: https://github.com/ros2/rviz and http://www.zerodayinitiative.com/advisories/ZDI-26-1026/" | tee -a "$LOG"
else
  echo "[+] No rviz package found via dpkg; check source builds in /opt/ros" | tee -a "$LOG"
fi
ls /opt/ros/*/lib/rviz* 2>/dev/null | tee -a "$LOG" || true

# 2. Restrict ROS master (11311) and DDS discovery to the trusted robotics segment only
iptables -C INPUT -p tcp --dport 11311 -s "$TRUSTED_ROS_NET" -j ACCEPT 2>/dev/null || \
  iptables -A INPUT -p tcp --dport 11311 -s "$TRUSTED_ROS_NET" -j ACCEPT
iptables -C INPUT -p tcp --dport 11311 -j DROP 2>/dev/null || \
  iptables -A INPUT -p tcp --dport 11311 -j DROP
iptables -C INPUT -p udp --dport 7400:7500 -s "$TRUSTED_ROS_NET" -j ACCEPT 2>/dev/null || \
  iptables -A INPUT -p udp --dport 7400:7500 -s "$TRUSTED_ROS_NET" -j ACCEPT
iptables -C INPUT -p udp --dport 7400:7500 -j DROP 2>/dev/null || \
  iptables -A INPUT -p udp --dport 7400:7500 -j DROP
echo "[+] Firewall rules applied for ROS master and DDS discovery" | tee -a "$LOG"

# Persist rules (Ubuntu)
if command -v netfilter-persistent >/dev/null; then
  netfilter-persistent save
fi

# 3. Ensure core dumps are captured for forensic analysis of crashes
sysctl -w kernel.core_pattern="|/lib/systemd/systemd-coredump %P %u %g %s %t %c %e" | tee -a "$LOG"
ulimit -c unlimited
mkdir -p /var/crash
echo "[+] Core dump capture enabled (systemd-coredump)" | tee -a "$LOG"

# 4. Verify SROS2/DDS security artifacts if ROS 2 is present
if [ -d "$HOME/sros2_keystore" ] || [ -d "/etc/ros2/security" ]; then
  echo "[+] SROS2 keystore detected — verify enclaves govern point cloud topics" | tee -a "$LOG"
else
  echo "[!] WARNING: No SROS2 keystore found. ROS 2 topics are unauthenticated — see https://docs.ros.org/en/rolling/Tutorials/Advanced/Security/Introducing-ros2-security.html" | tee -a "$LOG"
fi

echo "[$(date -u)] Hardening complete. Re-run after upstream patch lands to verify." | tee -a "$LOG"

3. Reduce the blast radius operationally

  • Subscribe narrowly. Audit RViz configurations (.rviz files, launch files) and remove PointCloud/PointCloud2 displays from topics fed by untrusted or internet-exposed sensor bridges. Every subscribed point cloud topic on an unpatched host is an attack surface.
  • Do not bridge ROS to flat networks. Audit rosbridge, webviz, and any WebSocket-based visualization relays — these extend "network adjacent" far beyond your physical segment and would expose this parser to anyone who can reach the bridge.
  • Run RViz under a supervisor with restart limits (systemd Restart=on-failure with StartLimitBurst) so a crash loop does not silently disable operator awareness — and so restarts are logged, giving you the crash-loop detection signal above.

4. Track the patch and verify

  • Monitor the ZDI advisory: http://www.zerodayinitiative.com/advisories/ZDI-26-1026/
  • Track upstream fixes in the ros2/rviz and ros-visualization/rviz repositories, and your ROS distribution's package sync announcements (packages.ros.org).
  • When a patched build lands, upgrade via your normal apt ROS package flow, then verify the XYZPCTransformer field-validation fix is present (check the commit diff for bounds checks on PointField offset/count handling) before relaxing any compensating controls.

5. Treat this as a segmentation audit trigger

An unauthenticated, network-adjacent crash in a ROS message parser is a symptom of a larger architectural truth: the ROS data plane trusts everyone. Use this advisory as the forcing function to inventory every host with adjacency to your robotics segments, enable DDS Security where you run ROS 2, and firewall ROS 1 masters you cannot retire. The next advisory against this ecosystem may not stop at availability.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.

ZDI-26-1026: Open Robotics RViz PointField Out-of-Bounds Read DoS — Detection and Hardening Guide for Unpatched Robotics Workstations | Security Arsenal | Security Arsenal