Chapter 1 Introduction

_#01 Reading unknown binary
_#02 Introduction to Assembly
_#03 Hello, World again!

Chapter 2 ELF Hack

_#04 Segment of ELF file
_#05 Using environment variables in ld-linux.so
_#06 Directory to search for shared libraries
_#07 Loading and application techniques when running a library using dlopen
_#08 Switching implementations at runtime using IFUNC
_#09 ELF's hash table structure
_#10 Understanding the Structure of TLS
_#11 Reading core file
_#12 Passing information to a process using auxiliary vectors
_#13 The relationship between static linking and ASLR
_#14 Linking dependent shared libraries later using sold
_#15 Hacking glibc
_#16 Modifying fields in ELF binaries with patchelf
_#17 Modifying ELF binaries using LIEF
_#18 Binary patch using PT_NOTE
_#19 Running DWARF Expression: DWARF I
_#20 Evaluating Formulas with DWARF: DWARF II
_#21 Outputting to standard output from DWARF: DWARF III

Chapter 3 OS Hack

_#22 Executable files and how to run them
_#23 Using Huge Pages in Linux
_#24 Saving and Resuming Processes Using CRIU
_#25 Understanding the basics of procfs/sysfs
_#26 Choosing the right file system for your needs
_#27 Replace files visible to a specific process
_#28 Creating a file system directly using FUSE
_#29 Special memory areas vsyscall and vDSO
_#30 Creating a Hypervisor Using KVM
_#31 Introduction to Linux Kernel Hacking
_#32 UniKernel: Running Applications on the OS
_#33 UEFI and Secure Boot
_#34 Outputting machine language files with the GNU toolchain
_#35 _#30 Creating firmware that runs on QEMU
_#36 Running your own custom firmware on your Chromebook

Chapter 4 Container Hack

_#37 Separating processes using Linux namespaces
_#38 Managing process resources with cgroups
_#39 Switching to the root directory with chroot/pivot_root
_#40 3 ways for regular users to act like root
_#41 Rootless container usage and structure
_#42 Creating various namespaces within the user namespace
_#43 Directly accessing files within a container from /proc/PID/root

Chapter 5 Debugger, Tracer Hack

_#44 gdb Tips
_#45 Debugging Record and Replay Using rr
_#46 Finding Low-Level Bugs with Sanitizers: Sanitizer I
_#47 Structure of Address Sanitizer: Sanitizer II
_#48 Introduction to Linux Performance Analysis
_#49 Tracing what happens inside the kernel using ftrace
_#50 Introduction to Tracing Using eBPF
_#51 Tracing and modifying execution commands with DBI
_#52 Obtaining traces at high speed using Intel PT

Chapter 6 Security Hack

_#53 Restricting the system calls a process can use with seccomp
_#54 Creating a non-privileged process sandbox with Landlock
_#55 ASLR: Security Mechanism for Invalid Memory Access
_#56 ROP: A standard attack technique that exploits memory corruption
_#57 Intel CET: Security Mechanism for ROP
_#58 Detecting incorrect control flow using Clang CFI
_#59 Observing changes in the stack frame
_#60 Overview and Classification of Purging
_#61 Finding bugs and vulnerabilities with graybox fuzzing
_#62 Implementing a fuzzer with LibAFL
_#63 Improving the fuzzer implemented with LibAFL
_#64 Running symbolic with angr
_#65 BadUSB: USB devices that deceive users
_#66 Row Hammer: An attack technique against DRAM vulnerabilities
_#67 Meltdown and Spectre: Attack Techniques for CPU Vulnerabilities

Chapter 7 Numerical Representation and Data Processing Hack

_#68 Basic knowledge of integer representation
_#69 Various integer representations
_#70 Understanding bit string representation of floating point numbers
_#71 Floating point exception
_#72 Change the rounding method for floating point numbers
_#73 Fighting compiler optimizations for code dealing with floating-point environments
_#74 Digging Deeper into NaN
_#75 Dealing with architectural differences in floating-point numbers
_#76 Basic knowledge of SIMD instruction set
_#77 Writing SIMD Parallel Code
_#78 Various techniques using SIMD instructions

Chapter 8 Language Processing Hack

_#79 Storing tagged values ​​in 64-bit values ​​using NaN
_#80 Implementing coroutines with ucontext.h
_#81 Profile Guided Optimization
_#82 Replacing the memory allocator using LD_PRELOAD
_#83 Understanding ABI and Calling Conventions
_#84 Calling a function whose signature is unknown until runtime with libffi
_#85 Generating machine code at runtime
_#86 Using GCC/Clang's built-in functions

Chapter 9 Other Hacks

_#87 Glossary
_#88 Tools Needed for Binary Hacks
_#89 Literature Guide

● Chapter 1 (Introduction): This is the introduction to this book, explaining ‘Binary Hacks’ and introducing basic hacks.
● Chapter 2 (ELF Hack): Introduces the structure of the Executable and Linkable Format (ELF), which is widely used in Linux, and how to hack it.
● Chapter 3 (OS Hack): Introduces hacks that make advanced use of the functions of the OS, especially Linux.
Let's explore the backstory of the OS we normally use.
● Chapter 4 (Container Hack): Introduces hacks on container technology.
Container technology is now taken for granted, but it is actually realized through a combination of many binary hacks.
● Chapter 5 (Debugger, Tracer Hack): Introduces how to use and implement debuggers and tracers.

● Chapter 6 (Security Hack): Covers technologies related to computer security.
In this field, attackers and defenders are fiercely competing every day, and we will introduce one aspect of this.
● Chapter 7 (Numerical Representation and Data Processing Hack): Introduces hacks related to numerical representation and data processing.
In both fields, there is the fun of dealing directly with the computers themselves.
● Chapter 8 (Language Processing Hack): Covers topics surrounding compilers and interpreters that are difficult to find in general compiler textbooks.
● Chapter 9 (Other Hacks): Explains the terms, tools, and references used in this book.
This book will serve as a milestone not only when reading but also when challenging various binary hacks.

In any era, the spirit of Binary will be immortal!
We invite you to the new world of Binary Hacks.

We live in an era where technologies from diverse fields, including AI, cloud, security, and robotics, are converging to create more complex systems than ever before.
While generative AI is revolutionizing programming and debugging methods and driving automation, understanding the fundamental principles of hardware and software remains—and is becoming increasingly—critical. A solid foundation in low-level technologies is essential for correctly interpreting AI results and responding to unexpected situations.
Therefore, the world of binary numbers and low-level programming, which can be considered the roots of computer systems, still holds value today.

Published in 2007, "Binary Hacks: 100 Hacking Techniques" created a sensation in the fields of low-level programming and binary hacking, serving as a valuable guide for many who wish to learn these topics.
This book is a good introductory book, covering a wide range of topics including reverse engineering, ELF binary analysis, how linkers and loaders work, memory management, debugging strategies, and security vulnerability analysis.
However, since it is currently out of print and difficult to obtain, it may be a disappointment to those who have not had the opportunity to read it in person.

The newly released book, "Between 0 and 1 (original title: Binary Hacks Rebooted)," fills that gap while broadening the horizons of low-level programming by providing knowledge and techniques suited to the changing times and environment.
While minimizing content overlap with existing books, it covers practical content encompassing low-level mechanisms of virtualization and containers, enhanced security techniques such as ASLR, PIE, and Stack Canary, vulnerability analysis, debugging and tracing techniques, and multi-architecture and diverse operating system environments.

This book alone is enough to delve deeply into the world of low-level programming and binary.
Furthermore, we will serve as a reliable guide for system, software, and security engineers and researchers who want to understand the fundamentals of low-level technology and gain a clearer understanding of today's complex systems.
I believe this book will remain with you for a long time as a foundation of unwavering knowledge, even in an ever-changing technological environment.
We cordially invite you once again to the unfolding world of Binary Hacks.
- From the 'Translator's Note'