Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconObtain local session on OBI host
-
DeliveryConfirm Java TLS instrumentation is active
-
ExploitIdentify readable kernel virtual address to target
-
InstallIssue ioctl(0, JAVA_TLS_MAGIC, kernel_addr) from local process
-
C2OBI kprobe reads kernel memory via bpf_probe_read
-
ExecuteKernel bytes emitted to OBI telemetry via bpf_ringbuf_output
-
ImpactExtract 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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:
- a vulnerable build of OBI with Java TLS instrumentation enabled
- a host capable of loading the BPF program
- a local process that issues the Java TLS magic ioctl with an attacker-controlled pointer
Suggested reproduction steps:
git checkout v0.0.0-rc.1+build
make build
sudo ./bin/obiThen run a local helper that issues the matching ioctl command against fd=0 and supplies a crafted pointer.
// 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:
cc -O2 -o /tmp/ioctl_kernel_ptr /tmp/ioctl_kernel_ptr.c
/tmp/ioctl_kernel_ptrOn 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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Oracle Java SE 7 Update 6 and earlier contains multiple sandbox bypass vulnerabilities via the ClassFinder and forName m
Remote code execution in IBM Sterling B2B Integrator, Sterling Integrator, and Tivoli Common Reporting allows unauthenti
Java Runtime Environment sandbox bypass via incorrect image channel verification in 2D component allows remote unauthent
Oracle Java SE JDK/JRE 7 and 6 Update 27 and earlier allows remote code execution with complete system compromise throug
JBoss Seam 2 in Red Hat JBoss EAP 4.3.0 fails to sanitize JBoss Expression Language inputs, allowing remote attackers to
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 update 4 and earlier, 6 up
Multiple vulnerabilities in Oracle Java 7 before Update 11 allow remote attackers to execute arbitrary code by (1) using
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 2 and earlier, 6 Up
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
Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE 7 Update 7 and earlier allow
Remote unauthenticated attackers can execute arbitrary code on Adobe ColdFusion servers through Java deserialization fla
The ExceptionDelegator component in Apache Struts before 2.2.3.1 interprets parameter values as OGNL expressions during
EUVD-2026-33956
GHSA-fjq3-ffvr-vm46
NVD
CVE.org
EPSS
Exploit-DB