CVE-2024-50282

Quoted from the kernel CNA's own scoring file, word for word. A highlighted metric carries the most severe value CVSS v3.1 defines for it, which is what pushes the score up. source

AV:LAttack vector, local

Exploitation requires opening the local debugfs node /sys/kernel/debug/dri/N/amdgpu_gprwave and issuing an ioctl plus read() against it. There is no network-facing path to this code.

AC:LAttack complexity, low

The overflow is fully deterministic — the attacker directly supplies the unvalidated `size` argument to read(), and `wave_read_regs()` writes exactly `size>>2` words into the fixed 4096-byte buffer with no race or unpredictable precondition. No specific memory layout is needed to trigger it.

PR:LPrivileges required, low

In the vulnerable kernels the node was mode 0444 and all debugfs directories default to 0755, so an unprivileged local user reaches it on any system that mounts debugfs with kernel-default permissions or relaxes it for GPU tooling (Android, embedded/automotive images, ROCm/umr-enabled compute hosts); the companion stable fix "Regular users shouldn't have read access" confirms regular users had it. No capability check exists on the path itself.

UI:NUser interaction, none

The attacker performs open/ioctl/read entirely on its own; no victim action or interaction is required at any point.

S:UScope, unchanged

The corruption is confined to the kernel slab of the same system and security authority; no VM, IOMMU, or sandbox boundary is crossed.

C:HConfidentiality impact, high

The drain loop copies `size` bytes from the 4096-byte buffer to userspace, directly disclosing tens of kilobytes of adjacent kernel heap — defeating KASLR and leaking credentials, keys, and other slab contents, and this leak occurs even where the vgpr/sgpr callback is absent.

I:HIntegrity impact, high

The heap buffer overflow writes an attacker-chosen number of bytes past the kmalloc-4k allocation with GPU wave-register data that a co-operating render-node shader can populate, giving a controlled slab overwrite of adjacent kernel objects — a standard primitive for control-flow hijack and privilege escalation.

A:HAvailability impact, high

Overwriting many kilobytes of adjacent slab objects reliably corrupts kernel structures and produces an oops or panic, and the attacker can repeat it at will.