Skip to main content
Mallory
LowExploited in the wildCISA KEVPublic exploitVulnerability

CVE-2023-26083: Kernel address disclosure in Arm Mali GPU Kernel Driver

Published Apr 6, 2023 · Updated 28 days ago
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 daysNo mention activity in the last 30 days.
CVSS3.3Low · v3.1
EPSS1.2%69th percentile
CISA KEVYesAdded Apr 7, 2023
In the wildActivePer CISA KEV
Vendor
ARM Holdings
IdentifiersCVE-2023-26083CWE-200

CVE-2023-26083 is an information disclosure vulnerability in the Arm Mali GPU Kernel Driver affecting Midgard r6p0–r32p0, Bifrost r0p0–r42p0, Valhall r19p0–r42p0, and Avalon r41p0–r42p0. The driver's timeline-stream facility serializes kernel object pointers into diagnostic events readable by unprivileged processes. Functions including __kbase_tlstream_tl_kbase_kcpuqueue_enqueue_fence_wait record raw queue and fence pointers without sanitization, exposing sensitive kernel metadata through valid GPU operations. The vulnerability has been exploited in targeted attacks.

Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Analyst brief

Impact, mitigation & remediation

What it means and what to do now: patch path, interim mitigations, and the assume-compromise checklist.

Impact

What an attacker gets, and what they’ve been doing with it.

Local unprivileged processes can obtain kernel object addresses, weakening kernel address-space randomization and improving the reliability of exploitation of separate memory-corruption vulnerabilities. Disclosed objects can include GPU contexts, KCPU command queues, and DMA fences, depending on the driver configuration. The disclosure alone does not establish arbitrary kernel read/write, code execution, or root access, but it has supported exploit chains used in targeted Android spyware attacks.

Mitigation

If you can’t patch tonight, do this now.

Prevent unprivileged processes from acquiring or reading Mali timeline streams. Where supported, disable unprivileged global profiling and ensure timeline permission checks deny unauthorized access. Merely adding permission checks is insufficient if the driver configuration continues to permit unprivileged profiling.

Remediation

Patch, then assume compromise.

Upgrade Bifrost, Valhall, and Avalon/Arm 5th Gen GPU architecture kernel drivers to r43p0 or a later vendor-supported fixed release. For Midgard, obtain an applicable vendor fix; a fixed release is not specified here. On Android devices, install device-vendor security updates incorporating the complete fix. The tested Pixel 6 Pro and Pixel 8 configurations required the December 2023 security update. Verify that unprivileged timeline access is actually disabled: earlier permission checks could remain ineffective when development-build defaults enabled unprivileged profiling.

Public exploits

Exploits

3 exploits validated by Mallory's analysis.

View more in app →
CVE-2023-26083The repository contains one standalone C proof of concept, mali_tlstream_leak.c (9,230 bytes), a README with vulnerability details and example output (10,565 bytes), and an MIT LICENSE (1,064 bytes). It is not part of an exploit framework. Repository URL, revision, and archive size were not supplied; the empty metadata fields and zero archive size represent unavailable information. The program opens /dev/mali0, performs KBASE_IOCTL_VERSION_CHECK, sets context creation flags to zero rather than requesting BASE_CONTEXT_CREATE_FLAG_MONITOR, and calls KBASE_IOCTL_TLSTREAM_ACQUIRE using ioctl type 0x80 and command number 18. The claimed vulnerability is insufficient authorization for access to the timeline stream. After a two-second delay, it reads timeline data, prints up to 512 bytes as hexadecimal, and decodes object-summary packets. Event formats cover GPU, context, logical processing unit, address-space, and atom objects, including pointers, timestamps, identifiers, and attributes. Pointers whose upper 32 bits equal 0xffffff80 or 0xffffffc0 are marked as kernel addresses. It does not actively trigger the reset or other operations named in its event enumeration; those names describe parsed events. This is an information-disclosure exploit, not merely a version detector. Disclosed addresses can help defeat address-space secrecy or support a separate exploitation chain, but the program does not calculate a kernel image base or implement privilege escalation. No shellcode, command payload, network communication, persistence, or exfiltration destination is present. The README attributes the issue to CVE-2023-26083 and reports testing on a Samsung Galaxy J7 Prime running Android 8.1.0, kernel 3.18, with an April 2020 security patch level. Those claims and the sample output are not independently verified by this static analysis. There are notable implementation limitations. The read loop permits eight 4,096-byte reads into a 16,384-byte stack buffer without checking remaining capacity, potentially overflowing the buffer after four full reads. Packet family, class, and type values directly index small string arrays without bounds checks. Parsing assumes specific event layouts and native byte order, handles only object-summary packets, and uses a narrow kernel-pointer heuristic. Reads are blocking and have no timeout, so the two-second sleep does not guarantee bounded execution. The source also uses __u16 and __u32 without explicitly including their defining Linux types header, which may cause compilation failures depending on the toolchain. These defects affect reliability but do not indicate an intentionally fake exploit.noverisp3 · Disclosed May 28, 2026 · c · localPoCCVE-2023-26083This repository is a small standalone proof-of-concept for CVE-2023-26083 affecting the Arm Mali GPU Kernel Driver. The repo contains three files: an MIT LICENSE, a detailed README, and one C source file (mali_tlstream_leak.c) that implements the exploit. There is no framework integration, no remote component, and no post-exploitation payload beyond information disclosure. The exploit is a local kernel information-leak PoC. It targets the Mali timeline stream interface exposed through /dev/mali0. In main(), the program opens the device, performs KBASE_IOCTL_VERSION_CHECK, sets create_flags to BASE_CONTEXT_CREATE_FLAG_NONE via KBASE_IOCTL_SET_FLAGS, and then calls KBASE_IOCTL_TLSTREAM_ACQUIRE. The vulnerability is that timeline stream acquisition should require monitor privileges (BASE_CONTEXT_CREATE_FLAG_MONITOR), but the driver fails to enforce that check. If successful, the ioctl returns a timeline-stream file descriptor that the unprivileged process can read. After acquiring the stream, the code sleeps briefly, reads multiple packets from the returned descriptor, prints a raw hex dump, and parses timeline packets. The parser understands several Mali timeline message types such as NEW_CTX, NEW_GPU, NEW_LPU, NEW_ATOM, NEW_AS, and relationship/configuration events. It extracts pointer-sized fields from packet payloads and heuristically flags values in kernel address ranges (for example addresses beginning with 0xffffff80 or 0xffffffc0) as leaked kernel pointers. This demonstrates disclosure of internal driver object addresses including kbase_context, GPU, LPU, address-space, and atom-related objects. Operationally, the exploit provides unauthorized access to sensitive kernel memory layout information and can help defeat KASLR. By itself it does not execute code, overwrite memory, or elevate privileges, so it is best classified as a PoC information disclosure exploit rather than a weaponized chain. The README also documents build instructions for Android/Linux ARM targets and explains that the PoC was tested on a Samsung Galaxy J7 Prime running Android 8.1.0 with a 3.18 kernel.Noverisp3 · Disclosed May 28, 2026 · c · markdown · localPoCCVE-2023-26083-Mali-InfoLeak-PoCStandalone local proof-of-concept for CVE-2023-26083 affecting the Arm Mali GPU Kernel Driver. The repository is minimal: LICENSE, README.md, and a single C source file implementing the exploit. The code opens /dev/mali0, performs KBASE_IOCTL_VERSION_CHECK, sets create_flags to BASE_CONTEXT_CREATE_FLAG_NONE via KBASE_IOCTL_SET_FLAGS, then calls KBASE_IOCTL_TLSTREAM_ACQUIRE despite lacking monitor privileges. If the target driver is vulnerable, the ioctl returns a timeline stream fd that the program reads from and parses. The parser decodes tlstream packet headers and selected object/event message formats, then prints embedded pointer fields and marks likely kernel addresses when they match expected high address patterns (for example 0xffffff80 / 0xffffffc0 upper bits on tested 64-bit targets). Exposed objects include NEW_CTX, NEW_GPU, NEW_LPU, NEW_AS, and related linkage/configuration records. This makes the exploit useful for KASLR bypass and kernel-driver state disclosure, but it does not itself perform privilege escalation or arbitrary code execution. There are no network callbacks, remote C2 endpoints, or external services involved. The only fingerprintable target surface in the code is the local device node /dev/mali0 and the associated Mali ioctls. Overall, this is a genuine local information-disclosure exploit PoC with clear research intent and limited operationalization.Noverisp3 · Disclosed May 28, 2026 · c · markdown · localPoC
Exposure surface

Affected products & vendors

Products and vendors Mallory has correlated with this vulnerability. Open in Mallory to drill down to specific CPE configurations and version ranges.

VendorProductType
ARM Holdings5th Gen Gpu Architecture Kernel Driverapplication
ARM HoldingsBifrost Gpu Kernel Driverapplication
ARM HoldingsMidgard Gpu Kernel Driverapplication
ARM HoldingsValhall Gpu Kernel Driverapplication
FAQ

Frequently asked questions

Is CVE-2023-26083 exploited in the wild?
Yes. As of Oct 25, 2026, Mallory has reports of exploitation in the wild, and CISA added it to KEV on Apr 7, 2023.
Is there a public exploit for CVE-2023-26083?
Yes. Mallory tracks 3 public exploits or proofs of concept for CVE-2023-26083, the earliest disclosed May 28, 2026.
Is there a patch for CVE-2023-26083?
Upgrade Bifrost, Valhall, and Avalon/Arm 5th Gen GPU architecture kernel drivers to r43p0 or a later vendor-supported fixed release. For Midgard, obtain an applicable vendor fix; a fixed release is not specified here.
What products are affected by CVE-2023-26083?
ARM Holdings 5th Gen Gpu Architecture Kernel Driver, ARM Holdings Bifrost Gpu Kernel Driver, ARM Holdings Midgard Gpu Kernel Driver, and ARM Holdings Valhall Gpu Kernel Driver.
How severe is CVE-2023-26083?
CVE-2023-26083 has a CVSS v3.1 score of 3.3 (Low) and an EPSS score of 1.2% (69th percentile) as of Oct 25, 2026.
Activity feed

Recent activity

6 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.

View more in app →
grsecurityNews · Jan 1, 2026grsecurity - CONSTIFY: Fast Defenses for New ExploitsAn Android/Linux kernel vulnerability (CVE-2023-26083) providing a limited write primitive that can be leveraged to manipulate kernel structures (e.g., miscdevice ->fops / file_operations) to enable further privilege escalation via crafted function-pointer tables and type confusion in callbacks.Read more ↗developer armNews · Jan 1, 2026Mali GPU Driver Security Bulletin: 2021-2023 DisclosuresAn Arm Mali GPU Kernel Driver information disclosure vulnerability that exposes sensitive kernel metadata; Arm states there is evidence of limited, targeted exploitation.Read more ↗starlabs sgNews · Jun 5, 2025Solo: A Pixel 6 Pro Story (When one bug is all you need) | STAR LabsAn information disclosure vulnerability in the Mali GPU driver's Timeline Stream functionality that leaks kernel pointers to unprivileged userspace, aiding exploitation.Read more ↗8ksec blogNews · Feb 5, 2025CVE-2023-26083: Mali GPU Kernel Pointer Leak | 8kSecAn information disclosure vulnerability in the Arm Mali GPU kernel driver's timeline stream exposes raw kernel object addresses to unprivileged applications. The demonstrated proof of concept retrieves a kbase_kcpu_command_queue address through timeline events. Leaked addresses can assist exploitation of additional vulnerabilities by reducing uncertainty about kernel memory locations; this flaw alone does not establish arbitrary code execution or root access. The article states that restricting unprivileged access to the timeline facility fixed the issue, with the demonstrated Pixel 8 exposure addressed in the December 2023 security update despite an earlier reported March 2023 patch.Read more ↗
+1 more in the timeline. Sign up to see them
Do you run this?See affected versions in your environment and whether adversaries are exploiting this vulnerability against assets like yours.
Check your exposure
Mallory platform

The version that knows your environment.

This page is what’s public. Mallory adds the parts that aren’t: which of your assets are affected, which adversaries are exploiting it right now, and which detections to deploy tonight.
Exposure mappingQuery your assets running an affected version, and investigate the blast radius.
Threat actor evidence1Every report linking this CVE to a named adversary.
Associated malware2Malware families linked to this CVE, with evidence and IOCs.
Detection signatures2YARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activityCommunity discussion across Reddit, Mastodon, and other social sources.