Executable Files for Linux: Under the Hood of ELFs for Flexible and Secure Low-Level Coding

What happens between compiling a C program and the first instruction running? Executable Files for Linux traces that path through the Executable and Linkable Format (ELF), from the structure of a binary to the work performed by the linker, dynamic loader, and Linux kernel. Mohit Mishra makes the details of executable files the subject of a practical systems-programming exploration.

The book pairs explanations of ELF internals with hands-on examination of real program components. Readers can follow how code and data are organized, how symbols and relocations connect separate pieces, and how an executable is loaded and prepared to run.

Read an ELF file from the inside out

The opening chapters unpack ELF headers, program headers, sections, and memory layout. Examples introduce ways to inspect executable structure, dependencies, symbols, and disassembly, while also considering how section permissions and binary layout relate to security.

Follow the work of the linker

From object files and symbol resolution to relocation, the book shows how separately compiled code is brought together. It also explores linker scripts, static and dynamic libraries, lazy loading, weak symbols, and environment variables that affect dynamic linking.

Understand what happens before and after main()

Global-variable initialization, startup routines, and constructor and destructor functions help explain the work that takes place before a program reaches its familiar entry point. Later, the discussion turns to Linux executable loading and the kernel processes involved in starting a binary.

Practical grounding for low-level work

Examples and tools connect the concepts to binary inspection, debugging, and optimization. Security topics include memory permissions, position-independent executables, stack canaries, and RELRO. These connections make the book relevant to C programmers and readers pursuing Linux systems programming, embedded development, or binary analysis.

For readers curious about the machinery behind an executable, this book offers a structured route from file format to runtime behavior—one layer at a time.