Skip to main content

OpenTelemetry OBI CVE-2026-45683

| EUVDEUVD-2026-33956 LOW
Buffer Under-read (CWE-127)
2026-05-18 https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation GHSA-fjq3-ffvr-vm46
3.8
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. Recon
    Obtain local session on OBI host
  2. Delivery
    Confirm Java TLS instrumentation is active
  3. Exploit
    Identify readable kernel virtual address to target
  4. Install
    Issue ioctl(0, JAVA_TLS_MAGIC, kernel_addr) from local process
  5. C2
    OBI kprobe reads kernel memory via bpf_probe_read
  6. Execute
    Kernel bytes emitted to OBI telemetry via bpf_ringbuf_output
  7. Impact
    Extract disclosed memory from telemetry pipeline

Vulnerability Assessment

Weakness
CWE
Exploitation Conditions

Java TLS instrumentation must be explicitly enabled in the OBI deployment - this is not a default-on feature in all configurations, so defenders should verify their OBI config before assessing exposure. The attacker must hold a local authenticated session on the OBI host (CVSS PR:L confirms authenticated local access is required; unauthenticated remote exploitation is not possible). The host must be running OBI version less than 0.9.0 with the do_vfs_ioctl kprobe loaded. Any local process can issue ioctl syscalls without elevated privilege, satisfying that step. For kernel bytes to be disclosed, the supplied kernel address must reference readable kernel memory and the first few bytes must satisfy enough of the Java TLS structure (operation byte valid, length field greater than zero) to pass early BPF checks - the PoC notes partial satisfaction may be sufficient. Exploitation is further constrained by telemetry access: the disclosed bytes are emitted into the OBI telemetry ring buffer rather than returned directly to the calling process, so the attacker needs visibility into the OBI telemetry pipeline (or a cooperating observer) to recover the exfiltrated content.

Impact

CVSS 3.8 (AV:L/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:N) reflects a local, low-complexity, low-privilege attack with Scope:Changed - meaning the impact crosses from the attacker's user-space process into the kernel memory domain and the privileged OBI telemetry pipeline. The Scope:Changed designation is materially significant: even though raw CVSS severity is low, the attacker gains a read primitive against kernel memory, which may contain credentials, encryption keys, or process secrets. EPSS data is absent from available intelligence, so quantitative exploitation probability cannot be assessed. No CISA KEV listing exists, but the presence of a working PoC in the published security advisory substantially lowers the exploitation bar for any local attacker. In security-sensitive or multi-tenant environments - precisely where eBPF observability tooling like OBI is commonly deployed - the ability to exfiltrate kernel memory into an observable telemetry stream represents a disproportionate risk relative to the base CVSS score. For standard single-tenant deployments where local access is tightly controlled, real-world risk is lower. The CVSS attack complexity of Low and no user interaction requirement mean that once the conditions are met, exploitation is straightforward and repeatable.

Exploit ScenarioDerived

A developer or service account with a standard local shell session on an OBI-instrumented host compiles the PoC (published verbatim in GHSA-fjq3-ffvr-vm46) and runs it, issuing ioctl(0, 0x0b10b1, 0xffff888000000000) - the Java TLS magic command with a crafted kernel virtual address. The OBI kprobe intercepts the call in do_vfs_ioctl and uses bpf_probe_read to copy bytes from that kernel address into its buffer, then emits the result through bpf_ringbuf_output into the OBI telemetry pipeline. The attacker then reads the disclosed kernel bytes from the telemetry stream, potentially recovering secrets or memory layout information resident in the kernel at that address.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.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

Kernel memory disclosure in OpenTelemetry eBPF Instrumentation (OBI) versions prior to 0.9.0 allows a local authenticated process to exfiltrate arbitrary kernel memory into the OBI telemetry pipeline by supplying a crafted kernel-space pointer to the Java TLS ioctl kprobe. The BPF probe hooks do_vfs_ioctl and incorrectly uses bpf_probe_read - which can dereference any memory address, kernel or user - instead of the boundary-enforcing bpf_probe_read_user, causing the kernel bytes to be emitted via bpf_ringbuf_output into downstream telemetry. Publicly available exploit code exists (PoC published in the GitHub security advisory); no confirmed active exploitation (CISA KEV) has been identified at time of analysis.

RemediationAI

The primary fix is upgrading OBI to version 0.9.0 or later, which corrects the use of bpf_probe_read to bpf_probe_read_user and is expected to add strict length validation on the ioctl-supplied pointer. The vendor advisory is published at https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation/security/advisories/GHSA-fjq3-ffvr-vm46. If immediate upgrade is not feasible, the most effective compensating control is to disable Java TLS instrumentation in the OBI configuration, which prevents the vulnerable kprobe from loading entirely and eliminates the attack surface; the trade-off is loss of TLS-layer telemetry visibility for Java processes. Restricting which local users can run processes on OBI-instrumented hosts reduces the pool of potential attackers but does not eliminate the vulnerability. There is no network-layer workaround because exploitation is local; revoking BPF-related capabilities (CAP_BPF, CAP_SYS_ADMIN) from untrusted processes is generally advisable hygiene but does not apply to OBI itself, which requires those capabilities to function.

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

The vulnerability resides in the eBPF-based instrumentation layer of OBI, specifically in bpf/generictracer/java_tls.c. The BPF kprobe hooks the kernel function do_vfs_ioctl, filters on fd == 0 and the Java TLS magic command (0x0b10b1), and then dereferences the third ioctl argument as a structured buffer containing an operation byte, connection metadata (connection_info_t), a payload length (u32), and a payload buffer pointer. All field reads use the generic bpf_probe_read helper rather than bpf_probe_read_user. CWE-127 (Buffer Under-read) reflects the root cause: bpf_probe_read can legally dereference kernel virtual addresses, whereas bpf_probe_read_user enforces that reads target only user-space memory. The computed payload pointer is passed to handle_buf_with_connection in k_tracer_defs.h, which again applies bpf_probe_read and tail-calls into protocol logic; the HTTP path ultimately emits the bytes via bpf_ringbuf_output in protocol_http.h, placing kernel-resident bytes into the OBI telemetry ring buffer. The affected package is go.opentelemetry.io/obi (CPE: pkg:go/go.opentelemetry.io_obi), all versions before 0.9.0.

Know when Java 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 3.8 LOW
AV:L/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:N

Primary rating from Vendor (https://github.com/open-telemetry/opentelemetry-ebpf-instrumentation) · only source for this CVE.

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

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
Low
Integrity
None
Availability
None

DescriptionCVE.org

Summary

The Java TLS ioctl probe reads user-controlled ioctl pointers with bpf_probe_read instead of bpf_probe_read_user. An instrumented local process can therefore point OBI at kernel memory and cause that memory to be copied into telemetry.

Details

The vulnerable path is in bpf/generictracer/java_tls.c. The kprobe hooks do_vfs_ioctl, filters on fd == 0 and the Java TLS magic command, and then treats the third ioctl argument as a structured buffer. It reads fields from that pointer using bpf_probe_read, including:

  • the operation byte from arg
  • connection metadata from arg + 1
  • the payload length from arg + 1 + sizeof(connection_info_t)

If len > 0, it computes buf = arg + 1 + sizeof(connection_info_t) + sizeof(u32) and passes that pointer into handle_buf_with_connection.

The next stage, bpf/generictracer/k_tracer_defs.h, uses bpf_probe_read(args->small_buf, MIN_HTTP2_SIZE, (void *)args->u_buf); on the supplied pointer and tail-calls deeper protocol logic. The HTTP protocol path then reads from u_buf and emits the bytes through bpf_ringbuf_output in bpf/generictracer/protocol_http.h.

Because the ioctl pointer originates in user space, the probe should be using bpf_probe_read_user with strict length validation. Using bpf_probe_read instead makes it possible for an instrumented process to supply a kernel pointer and exfiltrate kernel-resident bytes into telemetry.

PoC

A complete lab reproduction requires:

  1. a vulnerable build of OBI with Java TLS instrumentation enabled
  2. a host capable of loading the BPF program
  3. a local process that issues the Java TLS magic ioctl with an attacker-controlled pointer

Suggested reproduction steps:

bash
git checkout v0.0.0-rc.1+build
make build
sudo ./bin/obi

Then run a local helper that issues the matching ioctl command against fd=0 and supplies a crafted pointer.

c
// save as /tmp/ioctl_kernel_ptr.c
#include <stdio.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <unistd.h>

#define JAVA_TLS_MAGIC 0x0b10b1

int main(void) {
  void *ptr = (void *)0xffff888000000000ULL;
  long rc = ioctl(0, JAVA_TLS_MAGIC, ptr);
  printf("ioctl rc=%ld\n", rc);
  return 0;
}

Compile and run:

bash
cc -O2 -o /tmp/ioctl_kernel_ptr /tmp/ioctl_kernel_ptr.c
/tmp/ioctl_kernel_ptr

On a vulnerable system, if the supplied pointer references readable kernel memory and the bytes satisfy the expected Java TLS structure enough to pass the early checks, OBI can read from that address and emit the resulting bytes into telemetry. The remaining local prerequisite is a host session with sufficient BPF capability to load and inspect the probe; the compile side of the reproduction is already satisfied here.

Impact

This is a local kernel memory disclosure primitive reachable from unprivileged instrumented processes. It affects deployments that enable Java TLS support. Successful exploitation can expose kernel memory contents to the privileged OBI agent and then to downstream telemetry systems.

Threat Intelligence Overview

EPSS Score
0.0%
Top 98% exploitable
Threat Intel
1
1 source
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 LOW
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.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
Low

Priority Score

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

View all
CVE-2012-4681 CRITICAL POC
9.8 Aug 28

Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m

CVE-2015-7450 CRITICAL POC
9.8 Jan 02

Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti

CVE-2013-2465 CRITICAL POC
9.8 Jun 18

Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent

CVE-2011-3544 CRITICAL POC
9.8 Oct 19

Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug

CVE-2010-1871 HIGH POC
8.8 Aug 05

JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to

CVE-2012-1723 CRITICAL POC
9.8 Jun 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up

CVE-2013-0422 CRITICAL POC
9.8 Jan 10

Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using

CVE-2012-0507 CRITICAL POC
9.8 Jun 07

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up

CVE-2015-4852 CRITICAL POC
9.8 Nov 18

The WLS Security component in Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, and 12.2.1.0 allows remote attackers

CVE-2012-5076 CRITICAL POC
9.8 Oct 16

Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow

CVE-2017-3066 CRITICAL POC
9.8 Apr 27

Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla

CVE-2012-0391 CRITICAL POC
9.8 Jan 08

The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during

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