StackWarp
StackWarp (CVE-2025-29943) is a hardware/microarchitectural vulnerability in AMD Zen 1 through Zen 5 processors that affects confidential virtual machines protected by AMD SEV-SNP. The issue allows an admin-privileged host attacker, such as a malicious hypervisor or compromised cloud host, to modify CPU pipeline configuration in a way that corrupts the stack pointer inside an SEV-SNP guest. Public technical reporting attributes the flaw to improper synchronization in the CPU speculative stack engine and abuse of bit 19 of an undocumented core-scoped MSR (0xC0011029). By toggling this control from a sibling hyperthread, an attacker can freeze and later release stack-pointer updates, injecting a chosen offset into the guest VM’s stack pointer with deterministic precision. This breaks SEV-SNP integrity guarantees without requiring decryption of guest memory and can be used to hijack control flow or data flow inside the protected VM.
Are you exposed to this one?
Mallory correlates every CVE against your assets, your vendors, and active adversary campaigns. Know which vulnerabilities matter for you, not just which ones are loud.
Impact, mitigation & remediation
What it means. What to do now. Patch path, mitigations, and the assume-compromise checklist.
Impact
What an attacker gets, and what they’ve been doing with it.
Mitigation
If you can’t patch tonight, do this now.
Remediation
Patch, then assume compromise.
Exploits
1 valid exploit after Mallory filtered fakes, detection scripts, and README-only repos.
Repository purpose and structure: - This repo is presented as a proof-of-concept for a hardware/virtualization vulnerability dubbed “StackWarp” (CVE-2025-29943) affecting AMD Zen CPUs and SEV-SNP guests. The stated threat model is a malicious/compromised hypervisor with root privileges manipulating CPU MSRs to corrupt a guest VM’s stack pointer (RSP), enabling control-flow hijack and potential secret extraction. Key components: 1) Kernel-module PoC (file: exploit) - A Linux kernel module named stackwarp_exploit (DRIVER_NAME "stackwarp_exploit"). - Core behavior: - Checks CPU vendor is AMD and family range 0x17–0x1A (intended to represent Zen 1–Zen 5). - In a kernel thread, reads MSR 0xC00110FF, sets bit 58 (STACKWARP_ENABLE_BIT), sleeps ~1000ms, then logs that it “triggered” corruption (actual trigger is a placeholder), and finally clears the bit. - This is primarily demonstrative: it shows MSR toggling and the intended exploitation phases, but does not implement VMID discovery, precise SMT synchronization, or a real corruption primitive. 2) Configuration and build artifacts (config/*, scripts/*) - config/environment.yaml documents assumed environment (kernel 5.15+, required modules kvm/kvm_amd/msr, SEV-SNP enabled, MSR address 0xC00110FF, control bit 58, delays, safety checks). - config/makefile builds stackwarp_exploit.o into stackwarp_exploit.ko. - scripts/setup.sh installs build dependencies and QEMU, and clones https://github.com/qemu/kvmtool.git. - scripts/build.sh compiles the kernel module (requires root). - scripts/test.sh (truncated in provided content) checks /proc/cpuinfo for AMD vendor/model and heuristically matches “Zen 1..5” strings. 3) Payload and post-exploitation tooling (payload/*) - payload/shellcode/stackwarp_shellcode.asm: x86_64 shellcode intended to run after RSP corruption; reads SYSCFG and SEV_STATUS MSRs, dumps registers, and scans nearby memory for PEM RSA key markers. - payload/memory_analysis/memory_scanner.py: Python tool to scan memory dumps for sensitive patterns (private keys, etc.). - Additional key-extraction logic appears in truncated docs content (searching for RSA/AES keys in a memory_dump.bin). 4) Documentation and references (docs/*, references/*) - docs/methodology.md outlines phases: reconnaissance (CPU/SEV-SNP/VMID), configuration (MSR bit), execution (timing/trigger), exploitation (shellcode/exfiltration). - references/cve-2025-29943.md and other reference docs describe affected CPU lines and mitigations (microcode update, kernel patches, disabling SMT, restricting MSR access). Notable observables / fingerprintable targets: - Local system files: /proc/cpuinfo, /dev/cpu/*/msr, /sys/devices/system/cpu/smt/control. - MSR addresses: 0xC00110FF (control), 0xC0010010 (SYSCFG), 0xC0010130 (SEV_STATUS). - External network endpoint used by setup: https://github.com/qemu/kvmtool.git. Overall assessment: - The kernel module is a PoC-style scaffold demonstrating the claimed MSR toggle and workflow, but the actual exploitation steps (precise trigger, VM targeting, reliable corruption, and code execution chain) are not implemented in the provided C code. The repo includes more aggressive “payload” artifacts (shellcode and memory scanners) consistent with a hypothetical post-compromise demonstration, but they are not integrated into an end-to-end exploit chain here.
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.
Vendor-confirmed product mapping. Mallory continuously reconciles this list against your asset inventory.
Recent activity
13 sources tracked across advisories, community write-ups, and news. New activity surfaces here as Mallory finds it.
A hardware/architectural flaw in AMD Zen 1–5 CPUs’ speculative stack engine (in SEV-SNP contexts) that allows a privileged host/hypervisor attacker to deterministically corrupt a guest VM’s stack pointer, enabling control-flow/data-flow manipulation leading to guest compromise (e.g., auth bypass, privilege escalation) and cryptographic key extraction via faulted operations.
A hardware/CPU microarchitectural vulnerability in AMD Zen 1 through Zen 5 affecting SEV-SNP confidential VMs, where a malicious, privileged host/hypervisor can manipulate a guest VM’s stack pointer via the stack engine, enabling control/data-flow hijack leading to code execution and privilege escalation inside the confidential VM.
A microarchitectural weakness in AMD Zen CPUs impacting AMD SEV-SNP confidential VMs, where an attacker with host access can manipulate a control bit to interfere with a VM’s stack pointer, enabling recovery of sensitive data (e.g., private keys), authentication bypass, and privilege escalation—undermining SEV-SNP integrity guarantees.
A microarchitectural vulnerability in AMD Zen CPUs affecting AMD SEV-SNP confidential VMs when SMT is enabled, enabling a malicious host/hypervisor-side attacker to deterministically manipulate a guest’s stack pointer via the CPU stack engine and potentially recover secrets (e.g., private keys), bypass authentication, and escalate privileges up to ring-0.
The version that knows your environment.
Query your assets running an affected version, and investigate the blast radius.
Every observed campaign linking this CVE to a named adversary.
Malware families riding this exploit, with evidence and IOCs.
YARA, Sigma, Snort, and vendor rules, auto-deployed to your SIEM.
Cross-references every affected SKU, including bundled OEM variants.
Community discussion across Reddit, Mastodon, and other social sources.