C for Ethical Hackers — Complete Learning Roadmap

• Get a working C toolchain (compiler, debugger).
• Learn core syntax and basic I/O.
• Compile, run, and iterate comfortably from the terminal.

• Variables, types, operators
• Control flow: if, switch, loops
• Functions & headers; compilation and linking
• Console and file I/O

• Installed GCC or Clang
• Compiled and ran hello.c
• Wrote a program that reads a file and prints line counts
• Learned to use gdb to set a breakpoint and inspect variables

• Learn‑C.org (interactive)
• Harvard CS50 (free)
• K. N. King — C Programming: A Modern Approach (2e)
• Kernighan & Ritchie — The C Programming Language (2e)

• Develop fluency with pointers, arrays, and strings.
• Understand dynamic memory management.
• Learn the preprocessor and build basics.

• Pointers & pointer arithmetic; arrays & strings
• Dynamic memory: malloc, calloc, free
• Structs & unions
• Preprocessor: #define, macros
• Build systems: Makefiles

• Implemented a dynamic array (vector) in C
• Wrote a string library with safe functions
• Built a project using a Makefile with multiple objects

• Beej’s Guide to C
• K. N. King — C Programming: A Modern Approach

• Learn the POSIX/Linux system call interface.
• Write concurrent and networked programs.
• Use tracing tools to understand program behavior.

• Filesystem syscalls: open, read, write, lseek
• Processes: fork, exec, wait
• Signals; pipes; pthreads
• Networking: sockets (TCP, UDP, raw)
• Observability: strace, ltrace (where available)

• Built a parallel file copier using pread/pwrite
• Implemented a multithreaded echo server and client
• Used strace to map a program’s syscalls

• Michael Kerrisk — The Linux Programming Interface
• Stevens & Rago — Advanced Programming in the UNIX Environment
• Beej’s Guide to Network Programming

• Write C that avoids common vulnerability classes.
• Recognize and refactor insecure patterns.
• Use sanitizers and static analysis tools effectively.

• Bounds checking; buffer overflows; lifetime management
• Integer overflows/underflows
• Format string vulnerabilities
• Use‑after‑free, double free, and dangling pointers
• Undefined behavior (per the C standard)
• Static & dynamic analysis: clang-tidy, cppcheck, ASan

• Enabled -fsanitize=address,undefined and fixed reported issues
• Rewrote an unsafe string routine using safe patterns
• Ran clang-tidy on a small project and addressed warnings

• SEI CERT C Secure Coding Standard (online)
• Peter van der Linden — Expert C Programming: Deep C Secrets

• Understand how C bugs become exploits.
• Use debuggers and disassemblers to analyze binaries.
• Practice exploit patterns safely in lab environments.

• Calling conventions; stack frames; x86/x86_64 basics
• Stack overflows; shellcode; ROP
• Format string exploits
• Heap exploitation: overflow, UAF, double free
• Race conditions (TOCTOU)

• Solved classic stack overflow challenges (safe lab)
• Built a simple ROP chain bypassing NX
• Completed beginner CTF pwn challenges

• Jon Erickson — Hacking: The Art of Exploitation (2e)
• Practical Binary Analysis (No Starch)
• Exploit Education (Protostar/Nebula/Phoenix/Fusion)
• pwn.college — free exploitation course
• CTFtime — find live CTFs
• Shacham (2007) — ROP seminal paper (PDF)

• Explore kernel, drivers, and embedded targets.
• Adopt modern safe instrumentation (eBPF).
• Integrate C with other languages (FFI) for workflows.

• Linux kernel modules; character devices; ioctl interfaces
• eBPF basics and userspace interaction
• Embedded/firmware C (resource constraints, safety)
• Inline assembly; calling conventions
• Foreign Function Interfaces (C ↔ Python/Go/Rust)

• Built a simple Linux kernel misc device with one ioctl
• Wrote and loaded a tiny eBPF program; exchanged data via a map
• Used C as an FFI layer (e.g., Python ctypes)

• Corbet, Rubini & Kroah‑Hartman — Linux Device Drivers (LDD3, free)
• Robert Love — Linux Kernel Development
• Linux Kernel docs — eBPF

• Linux: typically sudo apt install build-essential gdb valgrind
• macOS: xcode-select --install (then consider Homebrew GCC/LLVM)

# compile
cc -Wall -Wextra -O2 hello.c -o hello

# run
./hello

cc -g -fsanitize=address,undefined -fno-omit-frame-pointer app.c -o app

gdb ./app
(gdb) break main
(gdb) run
(gdb) bt    # backtrace