Skip to content
Research Series

Memory Corruption & Kernel Exploitation

Deep-dive root-cause analyses and full exploit chains across Linux kernel modules, hypervisors, glibc heap allocators, and modern compiler mitigations (SafeStack, CFI).

7 parts published

Series Entries

Featured
Signed Cursor Arithmetic Explained: When Counting Backward Writes All Over Your Heap — cover illustration
• 43 min read • Series: memory-exploitation

Signed Cursor Arithmetic Explained: When Counting Backward Writes All Over Your Heap

From a single zero-length request to a full guest-to-host escape: a technical teardown of how a signed 16-bit cursor in a virtual device's decrypt queue walks negative, turns into a backward heap overflow, and ends with the emulator calling system() on attacker's orders.

#Virtualization #Hypervisor Security #Memory Corruption +2
Featured
SHA-256/SHA-384 Type Confusion OOB Write Explained: When a struct Lies About Its Age, the Kernel Believes It — cover illustration
• 37 min read • Series: memory-exploitation

SHA-256/SHA-384 Type Confusion OOB Write Explained: When a struct Lies About Its Age, the Kernel Believes It

From 15 out-of-bounds bytes to full root and a walk out of a chroot jail: a technical teardown of a Linux kernel exploit chain that starts with a size mix-up between SHA-256 and SHA-384 inside a custom crypto module, travels through MSG_COPY, pipe_buffer, and struct page, and ends with a data-only write into cred followed by swapping task->fs for init_fs.

#Linux Kernel #Exploit Development #Heap Exploitation +2
Featured
SafeStack Bypass Explained: The Vault Is Solid, the Ledger Isn't — cover illustration
• 15 min read • Series: memory-exploitation

SafeStack Bypass Explained: The Vault Is Solid, the Ledger Isn't

SafeStack splits your stack so a buffer overflow can only smash the half nobody misses. Solid plan, except the pointer that defines where the smashable half lives is stored in TLS, and TLS was sitting right next to the overflow. This is the story of how one bad memory layout took down a shadow stack, a canary, and a homemade CFI check in a single chain.

#Binary Exploitation #Memory Safety #Exploit Development
Non-Transitive Comparators Explained: When Sorting Quietly Walks Off the Array — cover illustration
• 10 min read • Series: memory-exploitation

Non-Transitive Comparators Explained: When Sorting Quietly Walks Off the Array

A comparison function that looks innocent can turn qsort into an out-of-bounds write primitive. This article breaks down how integer overflow in comparators breaks the assumptions of insertion sort, forces the slow path with a memory limit, and opens a full chain from stack corruption to code execution.

#Memory Corruption #Integer Overflow #Binary Exploitation +1
⌘
Suggested Searches