Skip to main content
Mallory
HighExploited in the wildCISA KEVPublic exploitVulnerability

CVE-2026-31431: Copy Fail

Published Apr 22, 2026 · Updated 3 days ago
Trending this weekNot trendingOutside this week’s top 100
Mention activity · 30 days14 mentions · peak 5 in a dayToday
CVSS7.8High · v3.1
EPSS98.1%100th percentile
CISA KEVYesAdded May 1, 2026
In the wildActivePer CISA KEV
Vendors
Amazon Web ServicesSuseArista NetworksDebian ProjectRed HatLinuxNixosOpensuse
IdentifiersCVE-2026-31431CWE-669 · Incorrect Resource Transfer…

Copy Fail (CVE-2026-31431) is a local privilege-escalation vulnerability in the Linux kernel's algif_aead authenticated-encryption interface, accessible through AF_ALG sockets. Incorrect in-place processing involving different source and destination mappings allows an unprivileged process to modify shared page-cache contents. Exploitation permits a controlled four-byte write into the cached contents of a readable file, including a setuid executable, enabling escalation to root without requiring permission to write the underlying file. The vulnerable behavior dates to 2017. Because containers share the host kernel and page cache, exploitation can also undermine container isolation under suitable conditions. The kernel fix restores out-of-place cryptographic processing while retaining direct copying of associated data.

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.

Successful exploitation can compromise host confidentiality, integrity, and availability through root privilege escalation. An attacker can alter protected executable contents in memory, access credentials and sensitive data, interfere with applications, and disable security controls. In containerized environments, page-cache corruption may affect binaries used by the host or privileged workloads, potentially enabling container escape and Kubernetes node takeover. Access to node secrets, cloud credentials, other workloads, and downstream resources depends on the compromised node's permissions and connectivity. Public exploits and exploitation in the wild have been reported.

Mitigation

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

If patching must be delayed, disable the algif_aead kernel module and prevent its reloading using the platform vendor's supported procedure. Where applicable, prevent initialization with the kernel argument initcall_blacklist=algif_aead_init. For container workloads, enforce a seccomp profile denying AF_ALG socket creation; Docker Engine 29.4.3 includes default security-profile changes that reduce exposure but do not replace the kernel fix. Restrict local shell access, arbitrary code execution, and deployment of untrusted workloads. Monitor affected systems while updates are deployed.

Remediation

Patch, then assume compromise.

Install the Linux distribution or appliance vendor's kernel update explicitly addressing CVE-2026-31431, reboot as required, and verify that the fixed kernel is running. For Kubernetes and cloud fleets, update node images and replace or roll affected nodes rather than only updating workload images. The upstream correction reverts algif_aead to out-of-place processing. Talos fixes are available in v1.12.7 and v1.13.0 or later; the upstream fix is included in Linux 6.18.22. Google Container-Optimized OS affected 6.12 kernel packages should be updated to 19216.220.180 or later. Use the applicable vendor advisory to select fixed builds because distributions backport patches and appliance releases differ.

Public exploits

Exploits

225 exploits validated by Mallory's analysis. Hidden: 147 rejected by Mallory's analysis as not a working exploit; 22 not yet analyzed, such as Exploit-DB entries; 1 not loaded here. Showing the 25 most capable, earliest first.

View more in app →
copy-fail-mcpThis repository is a Python FastMCP-based exploitation toolkit with a React/Vite web dashboard for CVE-2026-31431 ('Copy Fail'), presented as a Linux kernel local privilege escalation tester. It is not just a detector: it embeds and deploys a real Python exploit payload, supports remote execution over SSH, local script export, subnet scanning, and mitigation generation. The backend lives under src/copy_fail_mcp/ and is the operational core; the frontend under webapp/ provides a dashboard for target discovery, assessment, exploit execution, and safety/help content. Key backend structure: server.py exposes MCP tools such as cf_scan_network, cf_check_target, cf_run_exploit, cf_assess, cf_get_exploit_script, cf_exploit_local, and mitigation helpers. checker.py contains the embedded exploit payload as gzip+base64, decodes it at runtime, checks kernel/config state, and orchestrates exploit/mitigation actions. ssh_client.py handles async SSH connectivity with agent forwarding and username enumeration. scanner.py performs asynchronous TCP/22 scanning and SSH banner inspection to identify likely Linux hosts. transport.py provides stdio/HTTP MCP serving, defaulting to 127.0.0.1:10955/mcp. Exploit capability: the embedded Python payload uses AF_ALG sockets, authencesn, and splice() to obtain an arbitrary page-cache write primitive in 4-byte chunks. It includes an 'escalate' mode that reads /etc/passwd, creates /tmp/.passwd.bak, and rewrites the root entry in page cache to remove the password field, enabling 'su root' without a password. It also includes a generic 'write' mode for arbitrary file/offset/data page-cache corruption. The repository additionally documents /usr/bin/su corruption as the conceptual exploit path, but the actual embedded payload shown here directly targets /etc/passwd for escalation. Operationally, the tool can scan a /24 subnet for SSH hosts, connect to targets over SSH, upload or emit the exploit script, run assessment logic, and optionally apply mitigations by blacklisting algif_aead or adding initcall_blacklist=algif_aead_init. The webapp communicates with the backend over /mcp and proxies to http://127.0.0.1:10955. Test infrastructure under test/docker/ provides an SSH container for validating the deployment pipeline, though not the kernel exploit itself. Notable security observations: the repository includes a real test private key at test/docker/keys/id_test_rsa and a docker-compose test target exposed on localhost:10966. The project intentionally obfuscates the exploit payload with gzip+base64 to reduce AV signature hits. Overall, this is a weaponized exploit management interface around an embedded Python LPE payload, with both network discovery and exploitation workflow support.sandraschi · Disclosed May 2, 2026 · Framework: other · python · typescript · local · network · webWeaponizedCVE-2026-31431-Metasploit-exploitThis repository is a very small Metasploit exploit module package consisting of a README and a single Ruby module, copy_fail.rb. Because it is clearly a Metasploit module, the main exploit logic is concentrated in copy_fail.rb. The module is a post-exploitation local privilege escalation exploit targeting CVE-2026-31431, described as a Linux kernel AF_ALG/algif_aead page-cache overwrite flaw ('Copy Fail'). It is intended to be run after an attacker already has a shell or meterpreter session on a Linux host. The Ruby module defines a Metasploit Post module for Linux and supports shell and meterpreter sessions. It exposes two configurable options: TARGET_BINARY, defaulting to /usr/bin/su, and WRITABLE_DIR, defaulting to /tmp. In run(), it first exits if the session is already root, then checks for python3 on the target. If Python 3 is present, it dynamically writes an embedded Python helper script to WRITABLE_DIR/.cf_exp.py, executes it, and registers the file for cleanup. The embedded Python code is the actual exploitation payload. It opens the chosen setuid binary read-only, creates an AF_ALG socket using the AEAD type and algorithm string authencesn(sha256,aes), sets a key, accepts a connection, uses os.splice() to move file data into the AF_ALG socket path, then sends a crafted message intended to trigger a controlled 4-byte overwrite in page cache memory. Finally, it executes the target binary via os.system(). The overwrite value is hardcoded as 0x90909090, so this is not a generic payload framework but an operational exploit implementation with a fixed corruption primitive. Capabilities: local privilege escalation to root on vulnerable Linux kernels; staging and execution of a Python helper on the target; support for Metasploit cleanup; compatibility with existing shell or meterpreter sessions. There are no external C2 or network callback endpoints in the exploit logic. The only meaningful targetable observables are local file paths (/usr/bin/su, /usr/bin/sudo, /tmp/.cf_exp.py, /tmp) and the AF_ALG crypto socket binding string. Overall, this is a real exploit module rather than a detector or README-only repository.adityasingh108 · Disclosed May 16, 2026 · Framework: metasploit · ruby · markdown · localWeaponizedcopy-fail-CVE-2026-31431Small standalone local privilege-escalation repository for CVE-2026-31431 ('Copy Fail'). The repo contains only a README and one Python exploit script. The Python file is the main entry point and implements a compact exploit against the Linux kernel crypto API using an AF_ALG socket (family 38) bound to the AEAD algorithm string 'authencesn(hmac(sha256),cbc(aes))'. Inside helper function c(), it creates the socket, configures multiple socket options, accepts the operation socket, sends crafted ancillary data with sendmsg(), and uses os.splice() with a pipe to move data from an open descriptor for /usr/bin/su into the socket path in a way intended to corrupt or overwrite the target binary in 4-byte increments. A zlib-compressed payload blob is decompressed at runtime and iteratively written chunk-by-chunk across the target file. After patching completes, the script invokes 'su', implying the payload modifies the SUID binary so that executing it yields root or equivalent elevated access. There are no network callbacks, C2 endpoints, or remote targets; this is a purely local exploit. The README identifies tested Linux distributions and kernel builds: Ubuntu 24.04 LTS (6.17.0-1007-aws), Amazon Linux 2023 (6.18.8-9.213.amzn2023), RHEL 14.3 (6.12.0-124.45.1.el10_1), and SUSE 16 (6.12.0-160000.9-default). Overall, this is a concise operational PoC/exploit that weaponizes a kernel bug to tamper with a privileged executable and then leverage it for privilege escalation.theori-io · Disclosed Apr 29, 2026 · python · markdown · localOperationalCVE-2026-31431_pocSmall 2-file repository containing a README and a single Python exploit script named copyfail. The script is a local Linux privilege-escalation PoC for CVE-2026-31431. It imports os, zlib, and socket, defines a helper to decode hex, and a core function c(f,t,c) that creates an AF_ALG crypto socket, binds it to the AEAD algorithm string authencesn(hmac(sha256),cbc(aes)), applies several crafted setsockopt calls, accepts an operation socket, sends controlled data with ancillary messages, and uses os.splice with a file descriptor for /usr/bin/su to move file data through the socket path. A compressed embedded blob is decompressed and written in 4-byte chunks by repeatedly invoking the primitive, after which the script executes su. The overall purpose is to overwrite /usr/bin/su with attacker-controlled content and immediately run it, yielding a local root shell or equivalent elevated execution if the kernel is vulnerable. No external network infrastructure, URLs, or C2 endpoints are present; the notable observables are the local file target /usr/bin/su and the AF_ALG crypto interface parameters used to trigger the bug.mhdgning131 · Disclosed Apr 29, 2026 · python · markdown · localOperationalCVE-2026-31431This repository is a small standalone Go local privilege-escalation exploit for CVE-2026-31431, labeled "CopyFail." It contains only three files: a minimal README, go.mod, and a single Go source file implementing the exploit logic. The code is Linux-specific via a build tag and directly uses low-level syscalls rather than any external framework. The main exploit flow is in main.go. It opens /usr/bin/su, decompresses a hardcoded zlib-compressed hex blob into shellcode, and iterates over that shellcode in 4-byte chunks. For each chunk, the exploit() function creates an AF_ALG socket, binds it to the AEAD algorithm string "authencesn(hmac(sha256),cbc(aes))", sets crafted socket options and ancillary control messages, and uses sendmsg plus splice operations to drive a vulnerable kernel code path. The file descriptor for /usr/bin/su is spliced through a pipe into the AF_ALG connection, suggesting the exploit is abusing a kernel copy/write primitive to inject or overwrite data associated with the target binary or its execution path. After all chunks are processed, the program executes su interactively. There are no network callbacks, remote C2 endpoints, or external downloads. The only fingerprintable targets are local: /usr/bin/su, the AF_ALG socket family, and the specific crypto algorithm string used to reach the vulnerable path. The exploit is operational rather than a mere proof of concept because it includes a built-in payload (shellcode) and an end-to-end execution path, but it is not highly generalized: the target path and payload are hardcoded.Alfredooe · Disclosed Apr 29, 2026 · go · markdown · localOperationalcopy-fail-CVE-2026-31431This repository is a compact local privilege-escalation exploit for CVE-2026-31431 ('Copy Fail') on Linux. It contains only two files: a short README naming the vulnerability and listing tested distributions/kernel versions, and a single Python exploit script, copy_fail_exp.py. The Python script is heavily minimized/obfuscated but clearly implements an exploit rather than a detector. It imports os, zlib, and socket, defines a helper to decode hex, and a core function c(f,t,c) that creates an AF_ALG socket (family 38, type 5), binds it to the crypto transform string 'authencesn(hmac(sha256),cbc(aes))', sets multiple socket options at level 279, and uses sendmsg with ancillary data plus splice() from a file descriptor into the accepted socket. This strongly indicates abuse of a vulnerable Linux kernel crypto API path. The exploit opens /usr/bin/su read-only, decompresses an embedded blob into memory, and iterates over it in 4-byte chunks, repeatedly invoking the exploitation primitive with increasing offsets. That behavior suggests arbitrary or out-of-bounds write semantics against the target file, effectively patching or replacing /usr/bin/su. Before that loop, it also decompresses and executes another embedded command string via os.system(), then finally runs 'su'. The intended result is to make su usable for privilege escalation and then invoke it. There are no remote network targets, C2 endpoints, or external callback addresses in the exploit. The only notable fingerprintable targets are the local file path /usr/bin/su, the AF_ALG crypto socket interface, and the specific crypto algorithm string used to reach the vulnerable code path. Overall, this is a small, operational local Linux kernel exploit PoC with a built-in payload path aimed at obtaining root privileges on vulnerable systems.Theori-lO · Disclosed Apr 29, 2026 · python · markdown · localOperationalCopy-Fail-Exploit-CVE-2026-31431Repository contains a small standalone local privilege escalation proof-of-concept for the claimed Copy Fail vulnerability (CVE-2026-31431). Structure is minimal: a README with usage and mitigation notes, one C PoC, and one Python exploit. The exploit is not part of a known framework. The core behavior in both code files is local-only and targets the Linux kernel AF_ALG crypto interface using an AEAD socket bound to the algorithm string authencesn(hmac(sha256),cbc(aes)). Both variants interact with the SUID binary /usr/bin/su and then invoke su, indicating the intended outcome is root shell access. The Python version is the more complete exploit: it defines a helper function that creates an AF_ALG socket, sets socket options, accepts an operation socket, sends crafted ancillary data with sendmsg, and uses os.splice from the opened /usr/bin/su file descriptor into the AF_ALG socket. It iterates over a decompressed embedded blob in 4-byte chunks, suggesting staged corruption or overwrite of page-cache contents before executing su. The C version is much simpler and appears more demonstrative than robust, but still shows the same target indicators and final privilege-escalation step. Notable fingerprintable artifacts include the local file target /usr/bin/su, the AF_ALG/AEAD algorithm identifier authencesn(hmac(sha256),cbc(aes)), and documentation references to /proc/crypto and /etc/modprobe.d/disable-algif.conf. The README states the exploit requires a vulnerable Linux kernel, AF_ALG enabled, and algif_aead loaded, and explicitly describes the attack as page-cache-only and non-persistent. Overall, this is a local Linux kernel LPE repository with an operational Python exploit and a simpler C companion PoC.painoob · Disclosed Apr 29, 2026 · markdown · c · localOperationalcopyfail-goThis repository is a compact standalone Go implementation of a local Linux privilege-escalation exploit for CVE-2026-31431 ('copy-fail'). The repo is minimal: one substantive source file (main.go), a short README, Go module metadata, and release automation files for building a static Linux binary. There is no framework involvement; the exploit logic is entirely contained in main.go. The exploit is clearly operational rather than a detector. It uses Linux AF_ALG crypto sockets and splice-based page-cache manipulation to overwrite the cached contents of /usr/bin/su in 4-byte increments. The core function c() creates an AF_ALG socket, binds it to the AEAD algorithm string 'authencesn(hmac(sha256),cbc(aes))', configures key/auth parameters, accepts an operational socket via a raw accept syscall, sends crafted control messages, and then performs two splice operations: file-to-pipe and pipe-to-crypto-socket. Finally it reads from the socket to trigger the overwrite condition. The payload is embedded directly in the binary as a zlib-compressed hex string. Comments describe it as a 160-byte Linux ELF that performs setuid(0) and execve('/bin/sh'). The main routine decompresses this payload, opens /usr/bin/su read-only, repeatedly invokes the overwrite primitive across the payload length, and then executes 'su' with inherited stdin/stdout/stderr. If successful, this yields a root shell. Notable fingerprintable artifacts are limited because this is a local exploit: /usr/bin/su is the overwrite target, /bin/sh is the spawned shell, and the AF_ALG algorithm identifier is a distinctive kernel-facing observable. The only network-like strings are informational URLs in the README/help text and a commented GitHub reference to the original payload source. Overall, the repository's purpose is to provide a portable static Go binary for exploiting the Linux copy-fail LPE without requiring Python.badsectorlabs · Disclosed Apr 29, 2026 · go · yaml · localOperationalCopyFail-CVE-2026-31431Repository contains a single Python exploit script (copyfail.py) plus a short README. This is a real local privilege-escalation exploit for CVE-2026-31431 ('copy.fail'), not a scanner-only tool. The script abuses a Linux kernel AF_ALG + splice issue to overwrite the page cache of an existing setuid-root executable without modifying the on-disk file directly. It then executes that SUID binary so the injected cached payload runs as root. Structure and purpose: README.md documents requirements, supported architectures, and usage modes. copyfail.py is the full exploit implementation and main entry point. It includes helper logic for splice compatibility across Python versions, preflight/scan modes, target discovery, architecture detection, and embedded payload selection. Main exploit flow: the _c() function creates an AF_ALG socket, binds to the AEAD algorithm authencesn(hmac(sha256),cbc(aes)), sets key/auth parameters, sends crafted ancillary data, and uses splice twice (file->pipe, pipe->crypto socket) to trigger the vulnerable kernel behavior. The script iterates over the payload in 4-byte chunks, repeatedly corrupting the target file's page cache until the full ELF payload is staged. Finally, main() executes the chosen SUID binary with os.execv. Capabilities: local root escalation; preflight diagnostics via --check; filesystem enumeration of setuid-root binaries via --scan; automatic selection of a suitable SUID target from a hardcoded preference list; architecture-specific payload delivery for x86_64, i386/i686, armv6l/armv7l, and aarch64. The payload is operational and embedded, intended to spawn a root shell via setuid(0)+execve('/bin/sh'). No external C2 or remote network infrastructure is present. The only notable fingerprintable values are local target file paths, the AF_ALG algorithm string, and reference URLs in comments/documentation.ZephrFish · Disclosed Apr 30, 2026 · markdown · python · localOperationalCVE-2026-31431-CThis repository is a small standalone local privilege-escalation exploit consisting of a README and one C proof-of-concept source file. The code targets the claimed Linux kernel vulnerability CVE-2026-31431 by abusing AF_ALG AEAD sockets together with splice()-based zero-copy behavior to corrupt or rewrite data associated with a privileged executable. The main logic is in poc.c: main() decompresses an embedded zlib-compressed patch blob, opens /usr/bin/su, and iterates over the patch in 4-byte chunks. For each chunk, exploit_chunk() creates an AF_ALG socket, binds it to the AEAD algorithm string authencesn(hmac(sha256),cbc(aes)), sets socket options, crafts ancillary control messages (ALG_SET_OP, ALG_SET_IV, ALG_SET_AEAD_ASSOCLEN), sends a small payload, and then uses a pipe plus two splice() calls to move data between the target file descriptor and the AF_ALG operation socket. After attempting all chunk writes, the exploit executes system("su") to leverage the modified authentication path and obtain a root shell. There are no network callbacks, C2 endpoints, or remote targets; the attack vector is purely local. The exploit is operational rather than a mere detector because it contains a concrete payload and attempts privilege escalation automatically.b5null · Disclosed Apr 30, 2026 · markdown · c · localOperationalCopy-Fail-CVE-2026-31431-Statically-PoCThis repository is a Linux-only Go proof-of-concept exploit for CVE-2026-31431, ported from a public Python PoC into a small static binary. The structure is simple: cmd/copy-fail-poc/main_linux.go is the executable entry point; internal/poc/runner_linux.go contains the exploit logic; internal/poc/payload.go and payload_blobs.go manage embedded compressed payload ELFs for amd64, arm64, and 386; tests validate helper logic and payload format; and .github/workflows/release.yml builds and publishes static Linux binaries. Core exploit behavior is local, not network-based. Run() calls RunWithTarget() with a default target of /usr/bin/su. The code decompresses an architecture-matched embedded ELF payload, opens the target binary read-only, and iterates over the payload in 4-byte padded windows. For each chunk, trigger() creates an AF_ALG AEAD socket, binds to authencesn(hmac(sha256),cbc(aes)), sets a crafted key and auth size, sends AEAD control messages, and uses splice(2) through a pipe into the accepted AF_ALG socket. This is intended to exercise the vulnerable kernel path and patch the target file contents chunk-by-chunk. After patching, the program executes su, presumably to run the overwritten binary and obtain code execution. The payload is operational rather than a bare detection artifact: embedded ELF blobs are included directly in the repository, and tests confirm they are valid ELF files containing /bin/sh. That strongly suggests the payload is a shell-oriented native binary. There are no external C2 endpoints, hardcoded IPs, or remote services contacted by the exploit itself. Fingerprintable artifacts are primarily local file paths and kernel interface identifiers: /usr/bin/su, /bin/sh, AF_ALG, and the specific crypto algorithm string. Overall, this is a compact local privilege-escalation PoC targeting vulnerable Linux kernels by overwriting a privileged executable with an embedded payload and then invoking it.Percivalll · Disclosed Apr 30, 2026 · go · yaml · localOperationalCVE-2026-31431This repository is a minimal local Linux kernel exploit PoC for CVE-2026-31431. It contains only two files: a short Python exploit script and a minimal README. The Python file is the sole functional component. The exploit is not network-facing; it is a local attack that abuses the Linux AF_ALG crypto socket interface. The script creates a socket with numeric parameters corresponding to the kernel crypto API, binds it to the AEAD algorithm string "authencesn(hmac(sha256),cbc(aes))", applies several crafted setsockopt calls at level 279, accepts an operation socket, and sends attacker-controlled data with ancillary control messages. It then uses os.splice to move data from /usr/bin/su into the socket, likely to shape kernel heap/state while iterating over a decompressed embedded blob in 4-byte chunks. The embedded payload is stored as zlib-compressed hex data and decompressed at runtime. For each 4-byte chunk, the helper function c() is called with an incrementing offset, suggesting repeated triggering of the vulnerable code path with controlled parameters. There is no explicit reverse shell, command execution, or user creation logic in the script; instead, the exploit appears intended to achieve privilege escalation indirectly through kernel memory corruption or logic abuse. Repository structure is extremely small and purpose-built: README.md only labels the CVE, while CVE-2026-31431.py contains the full exploit logic. The code is operational as a PoC/exploit script, but not heavily weaponized: it has hardcoded target assumptions, no argument parsing, no reliability checks, and no post-exploitation automation.yiyihuohuo · Disclosed Apr 30, 2026 · python · markdown · localOperationalcve-2026-31431This repository is a minimal exploit/test repository consisting of a single GitHub Actions workflow and a README. The core logic is in `.github/workflows/test.yml`, which defines a manually triggered workflow (`workflow_dispatch`) running on `ubuntu-latest`. Its only substantive action is a shell command that downloads Python code from `https://copy.fail/exp`, executes it via `python3`, and then pipes `id` into `su` to verify whether root access was obtained. The success condition is a returned string starting with `uid=0`, indicating privilege escalation on the runner. The README documents the claimed target vulnerability, CVE-2026-31431, links to `https://copy.fail/`, and reports a successful test on an official GitHub-hosted Ubuntu runner. Structurally, this is not a full exploit framework or standalone local exploit implementation; instead, it is an operational wrapper that triggers a remotely hosted exploit payload inside a CI environment. The main capability is privilege escalation on a vulnerable GitHub Actions runner, making the attack surface primarily cloud/CI infrastructure with a local privilege-escalation outcome on the ephemeral Linux host.ruattd · Disclosed Apr 30, 2026 · yaml · markdown · cloud · localOperationalCVE-2026-31431This repository is a compact local privilege-escalation PoC for CVE-2026-31431 on Linux. It contains three files: a short README with usage notes, a primary C exploit (poc.c), and a shorter Python reimplementation (poc.py). Both code files target a local kernel/file-cache corruption condition by abusing the AF_ALG crypto socket interface together with splice/pipe operations to modify the page-cache contents of a readable SUID executable without directly writing to the file on disk. The main exploit logic is in poc.c. It defines an embedded x86_64 ELF payload as raw bytes. That payload is a minimal privileged launcher that executes /bin/sh. The helper function write4_to_page_cache() writes the payload into the target executable four bytes at a time. It creates an AF_ALG socket, binds to the AEAD algorithm string authencesn(hmac(sha256),cbc(aes)), configures key/auth parameters with setsockopt(), sends crafted ancillary data with sendmsg(), and then uses splice() to move bytes from the target file through a pipe into the crypto socket. This appears intended to corrupt the page cache for the target file at controlled offsets. In main(), the target defaults to /usr/bin/su but can be overridden by argv[1]. After all chunks are written, the exploit executes the target path with execl(), causing the modified in-memory image to run and yield a root shell. The Python file mirrors the same technique in a more compact form. It opens /usr/bin/su, reconstructs the same ELF payload from compressed hex, writes it into the target page cache in 4-byte chunks using AF_ALG sockets and os.splice(), then invokes su via os.system(). There are no external network callbacks, C2 endpoints, or remote targets. The only fingerprintable targets are local file paths and the Linux AF_ALG crypto interface/algorithm identifiers. Overall, this is a real exploit PoC rather than a detector: its purpose is to achieve local root by replacing the runtime image of a SUID binary with attacker-controlled ELF code.gubaiovo · Disclosed Apr 30, 2026 · c · python · localOperationalCVE-2026-31431-Advanced-ExploitRepository contains a single self-contained Python exploit (exploit.py) and a README describing CVE-2026-31431, a local Linux kernel page-cache overwrite vulnerability in the algif_aead/AF_ALG AEAD path. The exploit is not part of a larger framework. The Python script implements a local privilege-escalation and arbitrary cached-file overwrite tool. It uses AF_ALG sockets with the AEAD algorithm 'authencesn(hmac(sha256),cbc(aes))', sets a crafted authenc key blob, sends attacker-controlled AAD via sendmsg(), and uses splice() to feed readable target-file pages into the kernel crypto scatter-gather path. A recv() call then triggers the vulnerable decrypt flow, causing 4 attacker-controlled bytes to be written into the page cache at a chosen file offset before HMAC verification fails. The script expects that failure and ignores the resulting error. Observed structure from the available code: - exploit.py: main exploit implementation, including a ctypes-based fallback wrapper for libc splice() if os.splice is unavailable, AF_ALG constant definitions, ancillary control-message construction, the core _write_4bytes primitive, command handling for generic writes, and an escalation mode. - README.md: detailed vulnerability explanation, exploitation theory, constraints, examples, and recovery guidance. Capabilities: - Arbitrary 4-byte page-cache writes to any readable file at attacker-chosen offsets. - Multi-chunk writes by iterating the primitive over user-supplied data. - Verification by reading back cached content after overwrite. - Built-in 'escalate' mode targeting /etc/passwd to remove the root password from cached content and then exec 'su root'. - Generic 'write' mode allowing direct corruption of cached targets such as /etc/ld.so.preload, libc, SUID binaries, PAM modules, or sudo. This is a real local exploit, not a detector. It does not include a network component, C2, or remote callback behavior. Its purpose is to weaponize a kernel bug into a practical local privilege-escalation primitive by transiently altering how privileged processes perceive file contents through the page cache.Sndav · Disclosed Apr 30, 2026 · python · markdown · localOperationalCVE-2026-31431This repository is a compact local privilege escalation proof-of-concept for CVE-2026-31431 ('Copy Fail'), a Linux kernel logic flaw in the authencesn AEAD crypto template. The repo contains two exploit implementations: a minimal Python script (exp.py) and a more readable C version (exp.c), plus English/Chinese READMEs and a long-form advisory. The exploit is not a scanner or detector; it actively abuses AF_ALG AEAD decryption combined with splice() to obtain a deterministic 4-byte write primitive into the page cache of a readable file. Core exploit flow: both implementations open /usr/bin/su read-only, create an AF_ALG socket, bind it to the vulnerable algorithm string authencesn(hmac(sha256),cbc(aes)), configure key/authsize/options, send crafted AEAD metadata via sendmsg control messages, then splice bytes from the target file through a pipe into the AF_ALG operation socket. For each iteration, 4 attacker-controlled bytes are written into the target file's page cache. The loop walks over an embedded 160-byte x86-64 ELF payload in 4-byte chunks. After corruption is complete, the exploit invokes su, expecting execution of the modified in-memory setuid binary and a root shell. The Python version is highly compressed/obfuscated for brevity, using only os, socket, and zlib. It decompresses a hex-encoded payload blob at runtime and performs the same AF_ALG/splice sequence. The C version is clearer and documents each stage of the exploit, including the AF_ALG socket creation, bind, setsockopt calls, sendmsg ancillary data, pipe/splice chain, and final system("su") call. Notable endpoints/targets are local rather than network-based: /usr/bin/su is the hardcoded privilege-escalation target, /bin/sh is embedded in the payload, and the AF_ALG algorithm name authencesn(hmac(sha256),cbc(aes)) is the critical kernel attack surface selector. The advisory and READMEs also emphasize broader impact: any readable file's page cache may be targeted, and shared page cache makes this a potential container escape primitive on vulnerable Linux systems.luotian2 · Disclosed Apr 30, 2026 · c · python · local · containerOperationalCopyFail-CVE-2026-31431This repository is a compact local Linux privilege-escalation proof-of-concept/exploit for CVE-2026-31431. It contains only two files: a minimal README with compile/run instructions and a single C source file, exp.c, which implements the exploit logic. The exploit is not network-facing and does not contact external infrastructure. Instead, it abuses the Linux AF_ALG kernel crypto socket interface. In alg_setup(), it creates an AF_ALG socket, binds it to the AEAD algorithm string "authencesn(hmac(sha256),cbc(aes))", sets a crafted key and authentication size, and accepts an operation socket. In alg_sendmsg(), it sends specially structured ancillary data (ALG_SET_OP, ALG_SET_IV, ALG_SET_AEAD_ASSOCLEN) and 8 bytes of payload data, likely to place the kernel into the vulnerable state. The main exploitation loop opens /usr/bin/su and iterates over the embedded shellcode in 4-byte chunks. For each chunk, it sets up the AF_ALG socket, sends crafted crypto input, creates a pipe, splices data from /usr/bin/su into the pipe, then splices from the pipe into the AF_ALG socket. This splice-based pattern strongly suggests exploitation of a kernel copy/splice logic flaw to corrupt or overwrite the target SUID binary incrementally. After processing all chunks, it closes the file and invokes system("su"). The embedded payload is raw x86_64 ELF machine code. Its behavior is straightforward: call setuid(0), then execve("/bin/sh"), then exit. If the overwrite succeeds and /usr/bin/su is replaced or sufficiently corrupted into the attacker-controlled ELF, running su should yield a root shell. Repository structure and purpose: - README.md: very short usage instructions (compile with gcc, run ./exp). - exp.c: full exploit implementation, including helper wrappers for open/pipe/splice, AF_ALG setup and message crafting, embedded ELF payload bytes, and the main overwrite/execution routine. Overall, this is a real exploit rather than a detector. It is operational because it includes a hardcoded privilege-escalation payload and a complete exploitation path, but it is not part of a larger reusable framework.JnamerZ · Disclosed Apr 30, 2026 · c · markdown · localOperationalcopy-fail-CVE-2026-31431This repository is a minimal local Linux privilege-escalation proof-of-concept for CVE-2026-31431 ('copy-fail'). It contains only three files: an MIT LICENSE, a very short README with an external reference, and a single Python exploit script, copyfail.py. The exploit is not part of a known framework. The Python script is heavily compacted/obfuscated but straightforward in purpose. It imports os, zlib, and socket, defines a helper to decode hex, and implements a function that creates an AF_ALG crypto socket, binds it to the AEAD algorithm string 'authencesn(hmac(sha256),cbc(aes))', sets several socket options, accepts an operation socket, and uses sendmsg plus splice on a file descriptor. The script opens /usr/bin/su read-only, decompresses an embedded blob, and iterates over it in 4-byte chunks, invoking the crafted primitive repeatedly with increasing offsets. After the loop, it executes 'su'. Operationally, this indicates an exploit that abuses a vulnerable Linux kernel copy/splice path associated with AF_ALG to corrupt or alter data related to /usr/bin/su, likely to make the binary yield elevated privileges when executed. There are no remote network targets, C2 endpoints, or exfiltration logic. The only fingerprintable artifacts are the local target path (/usr/bin/su), the executed command (su), the AF_ALG crypto identifiers, and the README reference URL. Repository structure is extremely small and purpose-built: one exploit file and no supporting modules, build scripts, or detection logic. This is exploit code rather than a scanner or verifier, and its maturity is best classified as OPERATIONAL because it contains a concrete exploitation routine and payload flow, though it is hardcoded for a specific local target and environment.vishwanathakuthota · Disclosed Apr 30, 2026 · python · markdown · localOperationalCVE-2026-31431This repository is a minimal local proof-of-concept exploit for CVE-2026-31431. It contains one Python script, copyfun.py, and a short README. The script implements a page-cache/file-content poisoning primitive against a target file using the Linux AF_ALG crypto userspace interface. The core function, patch(target, offset, word), creates an AF_ALG socket, binds to the AEAD algorithm string "authencesn(hmac(sha256),cbc(aes))", sets key and authsize socket options, sends crafted control messages, and uses pipe()+splice() to move file data through the crypto socket in a way that triggers the vulnerability. Errors from recv() are ignored, suggesting the exploit expects the side effect rather than a clean cryptographic result. The higher-level copyfun(file, payload) helper opens the target file read-only, checks its size, truncates the payload if necessary, and iteratively patches the file in 4-byte chunks. The script ends with a hardcoded demonstration call: copyfun("/tmp/fun", b"asdfqwer"). There are no network callbacks, remote targets, persistence features, or shell payloads; this is a focused local exploit demonstration showing arbitrary cached byte replacement in an existing file on a vulnerable Linux kernel.desultory · Disclosed Apr 30, 2026 · python · markdown · localOperationalCVE-2026-31431-Linux-Copy-FailThis repository is a compact Rust local privilege escalation exploit for CVE-2026-31431 (“Copy-Fail”). It is not a framework module; the main exploit logic is entirely in src/main.rs, with build.sh used to compile static x86_64 and i686 binaries. The repository contains 7 files total: one Rust source file, one Bash build script, package metadata (Cargo.toml/Cargo.lock), a README, license, and .gitignore. Core capability: the exploit abuses the Linux kernel AF_ALG/algif_aead plus splice() bug to obtain an arbitrary 4-byte page-cache write primitive. The code repeatedly writes 4-byte chunks of attacker-controlled data into the page cache backing a target file descriptor. The chosen target is /usr/bin/su. After enough chunks are injected, the in-memory contents of su are replaced with either an embedded minimal ELF payload or a user-supplied payload file. The exploit then executes su via execvp("su"), causing the overwritten page-cache image to run with su’s privileges. Operational modes: - --test: creates /tmp/.cve_test, attempts to overwrite its first bytes with "HACK", and reports whether the host appears vulnerable. - --exploit: injects the built-in x86_64 ELF payload into /usr/bin/su. That payload performs setuid(0) and execve("/bin/bash", NULL, NULL), yielding a root shell. - --bin <file>: reads an external payload from disk and injects it into /usr/bin/su, enabling custom post-exploitation payloads such as Meterpreter. Exploit internals: do_kernel_injection() creates an AF_ALG socket, binds to the algorithm string authencesn(hmac(sha256),cbc(aes)), configures socket options, sends crafted ancillary data with sendmsg(), and uses a pair of splice() calls between the target file and the AF_ALG operation socket to corrupt page-cache contents. inject_payload() iterates over the payload in 4-byte chunks and invokes the primitive repeatedly. The exploit is clearly maliciously capable and functional as an LPE tool, but it is not heavily generalized or framework-integrated. Because it includes a working default payload and supports operator-supplied payload binaries, it is best classified as OPERATIONAL rather than a bare POC. The only attack vector present is local privilege escalation; there is no built-in network communication in the exploit itself, though the README demonstrates use with a reverse_tcp Meterpreter payload.iss4cf0ng · Disclosed Apr 30, 2026 · rust · bash · localOperationalcve-2026-31431This repository is a minimal standalone Rust local privilege-escalation exploit for CVE-2026-31431. It contains three files: Cargo.toml defining a small Rust project with libc and flate2 dependencies, README.md describing the exploit as '732 Bytes to Root' and noting that it targets /usr/bin/su, and src/main.rs containing the full exploit logic. The code is not a scanner or detector; it is an active exploit. In main(), it opens /usr/bin/su, decompresses an embedded zlib-compressed payload, and iterates over the resulting bytes in 4-byte chunks. For each chunk it calls trigger(), which sets up an AF_ALG socket using the authencesn(hmac(sha256),cbc(aes)) algorithm, configures it with crafted setsockopt and ancillary message data, and then uses sendmsg plus two splice() operations to abuse a kernel page-cache write primitive against the opened file descriptor. This appears intended to overwrite the page cache of the setuid su binary without directly writing the file through normal filesystem APIs. After all chunks are processed, the program executes su. Structurally, the exploit includes helper routines for hex decoding and control-message layout, a trigger() function implementing the kernel interaction and corruption primitive, and a main() function orchestrating payload decompression, chunked overwrite attempts, and post-exploitation execution. There are no network callbacks, C2 endpoints, or remote targets; the attack vector is purely local. The main fingerprintable targets are the local file /usr/bin/su and the AF_ALG/authencesn kernel crypto interface. The exploit is operational because it contains a built-in payload and end-to-end exploitation flow, but it is not framework-based or highly modular.adysec · Disclosed Apr 30, 2026 · rust · markdown · localOperationalcopy-fail-CVE-2026-31431-CThis repository is a small standalone local privilege-escalation exploit PoC for CVE-2026-31431. It contains only two files: a README with build/run instructions and a single C source file implementing the exploit. The code is not part of a larger framework. The exploit embeds a compressed payload blob in exploit.c, decompresses it with zlib at runtime, opens /usr/bin/su, and iterates over the decompressed payload in 4-byte chunks. For each chunk, run_exploit() creates an AF_ALG socket using the AEAD algorithm string authencesn(hmac(sha256),cbc(aes)), sets a key, prepares ancillary data, and calls sendmsg() with MSG_SPLICE_PAGES. It then uses splice() twice—first from the opened /usr/bin/su file descriptor into a pipe, then from the pipe into the AF_ALG operation socket—to exercise the vulnerable kernel path. This appears intended to corrupt or overwrite the su binary with attacker-controlled bytes derived from the decompressed payload. After all chunks are processed, the program runs system("su"), indicating the expected outcome is a modified su binary that yields root access. There are no network callbacks, remote C2 endpoints, or external URLs used by the exploit logic itself. The only notable fingerprintable targets are the local file path /usr/bin/su and the Linux AF_ALG crypto interface/algorithm selection. The README states it was verified on Ubuntu 24, Ubuntu 25, and Kali 2026, and provides normal and static compilation examples using gcc and zlib. Overall, this is an operational local Linux kernel exploit with a hardcoded payload and a specific post-exploitation goal: privilege escalation via tampering with su.novysodope · Disclosed Apr 30, 2026 · c · markdown · localOperationalcopy-fail-CVE-2026-31431-universalRepository contains a compact local privilege-escalation PoC for CVE-2026-31431 implemented in two languages: exploit.c and exploit-python3-8-10.py, plus a short README and .gitignore. Both implementations target a Linux AF_ALG AEAD splice use-after-free bug and use the same exploitation strategy: open /usr/bin/su, create an AF_ALG AEAD socket bound to authencesn(hmac(sha256),cbc(aes)), configure key/auth parameters, send crafted AEAD control messages, and then perform a splice chain from the su file descriptor through a pipe into the AF_ALG operation socket. This is repeated in 4-byte chunks to poison the page cache for /usr/bin/su with a replacement ELF payload. The payload is a minimal ELF64 stub that invokes setuid(0) and execve("/bin/sh"); after poisoning, the exploit executes su so the cached malicious image runs as root. The C version embeds the ELF bytes directly and ends with execl("/usr/bin/su", "su", NULL). The Python version is adapted for Python 3.8.10 compatibility by calling libc splice() via ctypes instead of os.splice(), storing the payload as zlib-compressed hex, and using Python socket APIs to reproduce the same AF_ALG control-message sequence. There are no remote network indicators; the exploit is entirely local and interacts only with kernel crypto sockets and local filesystem paths.Y5neKO · Disclosed Apr 30, 2026 · c · python · localOperationalcopy-fail-CVE-2026-31431-CThis repository is a small standalone local Linux privilege-escalation exploit for CVE-2026-31431, containing two nearly identical C programs and a short README. `exploit.c` targets the default architecture used by the author’s test systems, while `exploit_aarch64.c` contains an alternate embedded compressed payload for arm64/aarch64. The README provides simple compile-and-run commands using `gcc` and `-lz`. The exploit logic is straightforward: it decompresses an embedded payload blob with zlib, resolves the path to the local `su` binary using `which su`, opens that file, and repeatedly calls `run_exploit()` in 4-byte increments. Inside `run_exploit()`, the code creates an `AF_ALG` socket, binds it to the AEAD algorithm `authencesn(hmac(sha256),cbc(aes))`, sets a crafted key and ancillary control messages, sends associated data with `MSG_SPLICE_PAGES`, and then uses `splice()` from the opened `su` file through a pipe into the crypto socket. This strongly indicates abuse of a vulnerable Linux kernel crypto/splice code path to achieve unintended modification of page cache or file-backed data associated with the setuid `su` executable. After iterating over the full decompressed payload, the program closes resources, calls `sync()`, and executes `system("su")`, indicating the intended end state is a root shell or equivalent elevated access via a tampered setuid binary. There are no network callbacks, remote C2 endpoints, or external download URLs; the attack vector is purely local. The only meaningful fingerprintable targets are the local `su` executable and the Linux AF_ALG crypto subsystem/algorithm string used to trigger the bug. Overall, this is an operational local exploit with a built-in payload rather than a detector or proof-only sample.bigwario · Disclosed Apr 30, 2026 · c · markdown · localOperationalCVE-2026-31431-exploitThis repository is a small Linux local privilege escalation exploit set for CVE-2026-31431. It contains two C programs and two README files (English and Chinese). The code is not a scanner or detector; it is active exploit code intended to obtain root on vulnerable Linux systems by abusing an AF_ALG/splice-based page-cache overwrite primitive. Repository structure: (1) copyfail_portable_lpe.c is the main, more feature-complete exploit. It implements multiple modes: auto, auto-revert, helper, helper-revert, patch, and raw-su-elf. Its default behavior is auto-revert, which patches a privileged runtime target, gains root, attempts to restore the modified target, and then hands off to a root shell or command. It supports patching PAM configuration files such as /etc/pam.d/su and /etc/pam.d/su-l, executing a root command, and dropping a SUID bash helper at a user-chosen path (default ./.rootsh). It also includes a generic same-length string replacement mode for arbitrary files and retains a raw ELF su-patching fallback. (2) copyfail_raw_su_root.c is a minimal x86_64-only variant that directly patches /usr/bin/su or /bin/su in 4-byte chunks using AF_ALG, then immediately execs the patched su binary to obtain root. Main exploit capability: local privilege escalation to root. The portable variant is more operationally useful because it includes prechecks, multiple fallback modes, optional revert logic, and helper-drop functionality. The raw variant is simpler and more brittle, but directly replaces the runtime page-cache view of su with an embedded x86_64 ELF payload that ultimately executes /bin/sh. Notable observables: there are no network callbacks, C2 endpoints, or remote targets. All attack surface is local. Fingerprintable targets include /usr/bin/su, /bin/su, /etc/pam.d/su, /etc/pam.d/su-l, /bin/bash, /bin/sh, and the default helper path ./.rootsh. The exploit also uses the AF_ALG algorithm string authencesn(hmac(sha256),cbc(aes)) as part of the primitive setup. Overall, this is an operational local Linux LPE repository with destructive runtime patching behavior, optional revert attempts, and practical post-exploitation outcomes such as a root shell or SUID helper creation.wuwu001 · Disclosed Apr 30, 2026 · c · markdown · localOperational
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
Amazon Web ServicesAmazon Linuxoperating_system
Arista NetworksCloudvision Agniapplication
Arista NetworksCloudvision Portalapplication
Arista NetworksNetvisor Osoperating_system
Arista NetworksVelocloud Edgeapplication
Arista NetworksVelocloud Gatewayapplication
Arista NetworksVelocloud Orchestratorapplication
CanonicalUbuntu Linuxoperating_system
Debian ProjectDebian Linuxoperating_system
LinuxLinux Kerneloperating_system
NixosNixosoperating_system
NovellSuse Linuxoperating_system
OpensuseOpensuse Leapoperating_system
Red HatEnterprise Linux Ausoperating_system
Red HatEnterprise Linux Eusoperating_system
Red HatEnterprise Linux Tusoperating_system
Red HatEnterprise Linux Update Services For Sap Solutionsoperating_system
Red HatOpenshift Container Platformapplication
Red HatRed Hat Enterprise Linuxoperating_system
SiemensSimatic Ax Runtimeapplication
SiemensSimatic Cn 4100 Firmwareoperating_system
SiemensSimatic Hmi Unified Comfort Panels Firmwareoperating_system
SiemensSimatic Iot2050 Advanced Firmwareoperating_system
SiemensSimatic Ipc Ied-Osoperating_system
SiemensSimatic S7-1500 Cpu 1518-4 Pn/Dp Mfp Firmwareoperating_system
SiemensSimatic S7-1500 Cpu 1518f-4 Pn/Dp Mfp Firmwareoperating_system
SiemensSimatic S7-1500 Tm Mfp Firmwareoperating_system
SiemensSiplus S7-1500 Cpu 1518-4 Pn/Dp Mfp Firmwareoperating_system
SuseBasesystem Moduleoperating_system
SuseCaas Platformapplication
SuseDevelopment Tools Moduleoperating_system
SuseLegacy Moduleoperating_system
SuseLinux Enterprise High Availability Extensionoperating_system
SuseLinux Enterprise Live Patchingoperating_system
SuseLinux Enterprise Microoperating_system
SuseLinux Microoperating_system
SuseOpenstack Cloudapplication
SuseOpenstack Cloud Crowbarapplication
SusePublic Cloud Moduleoperating_system
SuseRealtime Moduleoperating_system
SuseSuse Enterprise Storageapplication
SuseSuse Linuxoperating_system
SuseSuse Linux Enterprise Desktopoperating_system
SuseSuse Linux Enterprise High Performance Computingapplication
SuseSuse Linux Enterprise Real Timeoperating_system
SuseSuse Linux Enterprise Serveroperating_system
SuseSuse Linux Enterprise Workstation Extensionoperating_system
SuseSuse Manager Proxyapplication
SuseSuse Manager Retail Branch Serverapplication
SuseSuse Manager Serverapplication
VMwareVelocloud Orchestratorapplication
FAQ

Frequently asked questions

Is CVE-2026-31431 exploited in the wild?
Yes. As of Nov 19, 2026, Mallory has reports of exploitation in the wild, and CISA added it to KEV on May 1, 2026.
Is there a public exploit for CVE-2026-31431?
Yes. Mallory tracks 225 public exploits or proofs of concept for CVE-2026-31431, the earliest disclosed Apr 29, 2026.
Is there a patch for CVE-2026-31431?
Install the Linux distribution or appliance vendor's kernel update explicitly addressing CVE-2026-31431, reboot as required, and verify that the fixed kernel is running. For Kubernetes and cloud fleets, update node images and replace or roll affected nodes rather than only updating workload images.
What products are affected by CVE-2026-31431?
Linux Kernel, Amazon Web Services Amazon Linux, Suse Basesystem Module, Suse Caas Platform, Arista Networks Cloudvision Agni, and at least 46 more.
How severe is CVE-2026-31431?
CVE-2026-31431 has a CVSS v3.1 score of 7.8 (High) and an EPSS score of 98.1% (100th percentile) as of Nov 19, 2026.
Activity feed

Recent activity

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

View more in app →
socradar blogNews · Nov 18, 2026PHP2Shell Exploited by AI Agents from Day One: Inside a Credential-Harvesting CampaignThe operator staged a C port of a Copy Fail exploit, with two variants listed among the recovered artifacts. No execution evidence was found. The content does not describe the underlying flaw or identify affected products.Read more ↗cyberveilleNews · Nov 17, 2026NGINX2Root : 5 vulnérabilités nginx + 1 kernel Linux permettant un RCE non authentifié jusqu'au root | CyberVeilleUnknown. Appears only in the automatically extracted IOC list, which the page warns has not undergone external verification. The narrative does not explicitly associate this identifier with the Linux SCTP vulnerability or provide technical details.Read more ↗orca security blogNews · Nov 6, 2026How to Triage a Kubernetes CVE: A 4-Step Workflow | OrcaA Linux kernel privilege-escalation vulnerability that allows an ordinary user to gain root privileges. In Kubernetes, the article describes how an attacker with a foothold inside a container could take over the underlying node and potentially access cloud roles, secrets, or other resources reachable from it. Public exploit code is available; remediation includes kernel patching or temporarily disabling the affected kernel module.Read more ↗malware newsNews · Nov 6, 2026Virtualization security: attack layers and misconfiguration impact - Malware News - Malware Analysis, News and IndicatorsA Linux kernel vulnerability allowing code inside a container to modify shared kernel page-cache pages through an AF_ALG crypto socket, potentially affecting the host and other containers. The article identifies a kernel update as the fix and Docker Engine security-profile changes as exposure reduction.Read more ↗
+69 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 evidence22Every report linking this CVE to a named adversary.
Associated malware8Malware families linked to this CVE, with evidence and IOCs.
Detection signatures5YARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Vendor-by-vendor mappingCross-references every affected SKU, including bundled OEM variants.
Social activity117Community discussion across Reddit, Mastodon, and other social sources.