Skip to main content

OpenTelemetry OBI CVE-2026-45679

| EUVDEUVD-2026-33953 MEDIUM
Improper Output Neutralization for Logs (CWE-117)
2026-05-18 https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation GHSA-8rrq-wcg8-cv5q
6.5
CVSS 3.1 · Vendor: https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation
View

Attack ChainAIDerived

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

  1. Access
    Send Redis command with embedded sensitive value
  2. Delivery
    Redis returns error echoing command fragment
  3. Exploit
    OBI eBPF hook captures raw RESP error reply
  4. Execution
    getRedisError stores unfiltered text in DBError.Description
  5. Persist
    span.go exports description as OTLP span status message
  6. Impact
    Sensitive value reaches telemetry backend or SIEM

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A09:2025 - Security Logging & Alerting Failures
ASVS 5.0
V16 - Security Logging and Error Handling Log output neutralization
Exploitation Conditions

OBI must be deployed and actively tracing Redis traffic via its eBPF instrumentation - this is the default operating mode for any Redis-connected application instrumented with OBI, requiring no special configuration flag to be enabled. Redis errors must contain sensitive or attacker-influenced text; this occurs naturally in two scenarios: (1) authentication errors where Redis echoes back user context (e.g., ERR invalid password for user bob secret=TOPSECRET), and (2) invalid command errors where Redis reflects the unrecognized command name back in the error reply, allowing a caller who can send any Redis command to embed arbitrary text in the error. No authentication to OBI, the Redis instance, or the telemetry backend is required for the exfiltration path to activate - the CVSS vector PR:N confirms unauthenticated network access is sufficient. Exploitation is bounded by two factors: the attacker must have sufficient network access to trigger Redis errors (directly or by influencing application requests), and the sensitive data must actually appear in Redis error text rather than only in successful command payloads. Deployments where Redis errors never contain sensitive values and where telemetry backends are strictly access-controlled face reduced practical risk.

Impact

The CVSS 6.5 score (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N) reflects network-accessible, zero-authentication exploitation with low complexity. The C:L component captures the indirect confidentiality impact: sensitive values are not directly returned to the attacker from the Redis server, but are exfiltrated into telemetry pipelines that operators or downstream consumers may access - the blast radius depends entirely on who can read the OTLP backend. The I:L component captures the telemetry injection risk: untrusted text inserted into span status messages can corrupt SIEM queries, alert logic, or dashboard visualizations that rely on structured telemetry. No EPSS score was provided in the available data, so exploitation probability cannot be quantitatively compared. The vulnerability is not listed in CISA KEV, indicating no confirmed widespread active exploitation at time of analysis. However, the existence of a detailed PoC in the public advisory (with exact reproduction steps) meaningfully lowers the barrier to exploitation. Real-world priority is highest in environments that: (1) use OBI to trace Redis traffic, (2) store or forward OTLP spans containing sensitive Redis command context, and (3) expose telemetry backends beyond a tightly controlled trust boundary. In air-gapped or single-tenant observability stacks with restricted telemetry access, practical impact is lower despite the medium CVSS.

Exploit ScenarioDerived

A publicly available PoC is included in the GHSA advisory. An unauthenticated caller with network access to a Redis instance monitored by OBI sends a command containing a sensitive value (e.g., redis-cli -p 6379 'NOTACMD my-secret-token-123'); Redis returns an error echoing the invalid command fragment. OBI's eBPF hook captures the RESP error reply, getRedisError stores the raw text without sanitization, and the value is emitted as the OTLP span status message in the next export cycle. The sensitive token then appears in any connected telemetry backend - Jaeger, Zipkin, Grafana Tempo, or a centralized SIEM - accessible to operators or exposed via a misconfigured observability endpoint, without the attacker needing any direct access to those systems.

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

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

Alert me

AnalysisAIv1 – May 18, 2026

OpenTelemetry eBPF Instrumentation (OBI) versions prior to 0.9.0 forwards raw Redis error replies verbatim into OTLP span status messages, enabling both information disclosure and telemetry injection against any deployment tracing Redis traffic. The getRedisError function in pkg/ebpf/common/redis_detect_transform.go applies only CRLF trimming before storing error text directly into request.DBError.Description, which span.go then exports as the span status message for every non-zero-status Redis span. A publicly available proof-of-concept demonstrates that caller-supplied values embedded in Redis error replies - including authentication credentials, tokens, and PII - are automatically propagated into OTLP collectors, dashboards, and log aggregators without requiring any special attacker position beyond the ability to trigger Redis errors. No public exploit identified at time of analysis beyond the included PoC; not in CISA KEV.

RemediationAI

Upgrade go.opentelemetry.io/obi to version 0.9.0 or later, which is the vendor-confirmed fixed release per the upstream advisory at https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation/security/advisories/GHSA-8rrq-wcg8-cv5q. For deployments that cannot upgrade immediately, three compensating controls are available with noted trade-offs: First, disable Redis tracing in OBI's instrumentation configuration to prevent error capture entirely - this eliminates the exposure but removes Redis observability coverage. Second, deploy an OpenTelemetry Collector pipeline with the redaction processor configured to scrub or hash span status message fields before forwarding to storage backends - this preserves span structure while preventing sensitive text from reaching long-term storage, but requires collector infrastructure and introduces a processing step that may miss novel patterns. Third, restrict access to OTLP receivers, tracing backends, and dashboards to trusted operators only, reducing the population that can observe exfiltrated data - this is a containment measure, not a remediation, and does not prevent the data from entering the pipeline. Apply the upstream patch as soon as operationally feasible; the compensating controls above should be treated as temporary.

Affected VersionsENISA

opentelemetry-ebpf-instrumentation < 0.9.0

Affected Packages

go go.opentelemetry.io/obi fix: 0.9.0
euvd opentelemetry_ebpf_instrumentation fix: 0.9.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 2 packages in go, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

OBI (go.opentelemetry.io/obi) is an eBPF-based auto-instrumentation agent for OpenTelemetry that intercepts application traffic at the kernel level - including the Redis Serialization Protocol (RESP) - without requiring code changes. When OBI observes a Redis error reply, the function getRedisError in pkg/ebpf/common/redis_detect_transform.go (lines 60-74) trims the raw kernel buffer and assigns it to request.DBError.Description. The function in pkg/app/request/span.go (lines 347-352) then unconditionally uses that description as the exported OTLP span status message for any Redis span whose status is non-zero. The root cause maps to CWE-117 (Improper Output Neutralization for Logs): the software writes externally influenced data - specifically Redis error text, which can echo back caller-supplied command fragments or reveal server-side authentication details - to an output channel (telemetry) without sanitization. Redis itself often reflects portions of invalid commands in its error replies (e.g., ERR unknown command 'NOTACMD', with args beginning with: my-secret-token-123), meaning attacker-controlled input can reliably flow into OBI-captured spans. The affected package is identified by CPE pkg:go/go.opentelemetry.io_obi, all versions below 0.9.0.

Know when Redis 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 (https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation) PRIMARY 6.5 MEDIUM
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N
SUSE MEDIUM

Primary rating from Vendor (https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation).

CVSS VectorVendor: https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
Low
Availability
None

DescriptionCVE.org

Summary

OBI exports raw Redis error text as the span status message. Because Redis error replies can contain attacker-controlled or sensitive values, this behavior can exfiltrate tokens, PII, or other confidential input into telemetry backends and inject untrusted text into downstream analysis systems.

Details

In pkg/ebpf/common/redis_detect_transform.go, getRedisError trims the raw error buffer and stores it directly in request.DBError.Description.

Later, pkg/appolly/app/request/span.go returns that description as the exported status message for Redis spans whenever the span status is non-zero.

There is no opt-in control or sanitization beyond CRLF trimming. As a result, raw Redis error text becomes part of OTLP-exported status metadata by default.

PoC

Local request-layer testing recorded a status message containing ERR invalid password for user bob secret=TOPSECRET, which shows that unfiltered Redis error text reaches the exported status message.

Use a vulnerable build:

bash
git checkout v0.0.0-rc.1+build
make build

Start Redis and OBI:

bash
docker run --rm -p 6379:6379 redis:7
sudo ./bin/obi

Send a command that causes Redis to return an error containing caller-supplied text:

bash
redis-cli -p 6379 'NOTACMD my-secret-token-123'

Capture the exported span or inspect the local telemetry output. On a vulnerable build, the span status message contains the Redis error text, including the supplied command fragment. This demonstrates that raw Redis error text is exported into telemetry by default and that values embedded in that text, including data supplied unintentionally by a caller, can be carried into tracing systems.

Impact

This is an information disclosure and telemetry injection issue. It affects any deployment that traces Redis traffic and exports spans to collectors, logs, or dashboards. Sensitive values, tokens, or PII present in Redis error text can be exfiltrated into telemetry systems, and untrusted text can contaminate downstream analysis.

Threat Intelligence Overview

EPSS Score
0.0%
Top 92% exploitable
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High

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.0%
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact· derived
Medium

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

More in Redis

View all
CVE-2026-48172 CRITICAL POC
10.0 May 21

Privilege escalation to root in the LiteSpeed User-End cPanel Plugin (versions 2.3 through before 2.4.5) lets attackers

CVE-2025-49844 CRITICAL POC
9.9 Oct 03

UAF in Redis 8.2.1 via crafted Lua scripts by authenticated users. EPSS 12.4%. Patch available.

CVE-2022-0543 CRITICAL POC
10.0 Feb 18

It was discovered, that redis, a persistent key-value database, due to a packaging issue, is prone to a (Debian-specific

CVE-2018-11218 CRITICAL POC
9.8 Jun 17

Memory Corruption was discovered in the cmsgpack library in the Lua subsystem in Redis before 3.2.12, 4.x before 4.0.10,

CVE-2025-46817 HIGH POC
7.0 Oct 03

Redis is an open source, in-memory database that persists on disk. Versions 8.2.1 and below allow an authenticated user

CVE-2015-4335 CRITICAL POC
10.0 Jun 09

Redis before 2.8.21 and 3.x before 3.0.2 allows remote attackers to execute arbitrary Lua bytecode via the eval command.

CVE-2016-8339 CRITICAL POC
9.8 Oct 28

A buffer overflow in Redis 3.2.x prior to 3.2.4 causes arbitrary code execution when a crafted command is sent. Rated cr

CVE-2026-77602 CRITICAL POC
9.9 Sep 23

Authenticated remote code execution in OpenC3 COSMOS (Ruby gem 'openc3' versions 5.1.0 through 7.2.1) lets any logged-in

CVE-2026-27574 CRITICAL POC
9.9 Feb 21

Code injection in OneUptime monitoring via custom JS monitor using vm module. PoC and patch available.

CVE-2026-84372 CRITICAL POC
9.8 Sep 01

RESP protocol command injection in Predis, the popular PHP client for Redis and Valkey, affects versions 3.0.0-RC1 throu

CVE-2021-31649 CRITICAL POC
9.8 Jun 24

In applications using jfinal 4.9.08 and below, there is a deserialization vulnerability when using redis,may be vulnerab

CVE-2020-11981 CRITICAL POC
9.8 Jul 17

An issue was found in Apache Airflow versions 1.10.10 and below. Rated critical severity (CVSS 9.8), this vulnerability

Vendor StatusVendor

SUSE

Severity: Medium
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Fixed
SUSE Linux Enterprise High Performance Computing 15 SP7 Fixed
SUSE Linux Enterprise Module for Basesystem 15 SP7 Fixed
SUSE Linux Enterprise Server 15 SP7 Fixed
SUSE Linux Enterprise Server 16.0 Fixed

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