Author: Haco

Memory Layout(global data, code, stack, heap, etc) with TLS

  • Haco
  • December 22, 2025
  • 6 min read

On AArch64 (ARM64), the memory layout for Thread Local Storage (TLS) follows TLS Variant 1. This is distinct from x86_64 (which uses Variant 2). The key difference is the location of the TLS data relative to the thread pointer. 1. The High-Level View (Process Memory) For a standard Linux process on AArch64, the memory is laid out as follows (from Low Address to High Address): +----------------------+ <-- High Address (e.g., 0x0000ffff...) | Stack | (Main Thread Stack, grows DOWN) +----------------------+ | ... | | Memory Mapping | <--…

AFL Coverage Instrumentation Callback

  • Haco
  • December 22, 2025
  • 14 min read

0000000000000bc0 <bbCallback>: bc0: 90000102 adrp x2, 20000 <_exit@GLIBC_2.17> bc4: f9404c43 ldr x3, [x2, #152] bc8: b4000263 cbz x3, c14 <bbCallback+0x54> bcc: d53bd042 mrs x2, tpidr_el0 bd0: a9bf7bfd stp x29, x30, [sp, #-16]! bd4: 12003c01 and w1, w0, #0xffff bd8: 910003fd mov x29, sp bdc: 90000100 adrp x0, 20000 <_exit@GLIBC_2.17> be0: f9403404 ldr x4, [x0, #104] be4: 9101a000 add x0, x0, #0x68 be8: d63f0080 blr x4 bec: 78606844 ldrh w4, [x2, x0] bf0: 53017c25 lsr w5, w1, #1 bf4: 78206845 strh w5, [x2, x0] bf8: 4a040021 eor w1, w1,…

Executable Startup And Initialization

  • Haco
  • December 22, 2025
  • 7 min read

CRT (C Runtime) "glue code" refers to a set of pre-compiled object files (typically crt1.o, crti.o, crtn.o, crtbegin.o, and crtend.o) that are automatically linked with your program. They "glue" the operating system's process loader to your main() function by handling low-level setup (stack, environment) and high-level initialization (global constructors). Execution Order Summary: _start (Entry Point) __libc_start_main (Standard C Library setup) __libc_csu_init / _init (Generic initialization hooks) .init_array (Global constructors/C++ initializers) main() (Your code) Detailed Explanation 1. What is CRT Glue Code? The "glue" consists of startup files provided…

The difference between soundness and completeness

  • Haco
  • December 22, 2025
  • 2 min read

In logic and computer science, soundness and completeness are two fundamental properties of a formal system (a set of rules for proving things). They describe the relationship between Provability (can the system prove it?) and Truth (is it actually true?). Here is the simple breakdown: 1. Soundness: "Everything you prove is true." A system is sound if it never lies to you. If the system produces a proof for a statement, that statement must be valid. The Direction: Proof $\rightarrow$ Truth. The Fear: You don't want False Positives.…

Global variable declaration inside function (Python

  • Haco
  • November 26, 2025
  • 2 min read

If you only want to read (access) the value of a global variable, you do not need the global keyword. Python automatically looks up the variable in the global scope if it doesn't find it locally. However, the global keyword is mandatory if you want to modify (write to) that variable. Here is the breakdown of why it exists. 1. Reading (No global needed) As you noticed, this works fine. Python looks for count locally, fails, looks globally, and finds it. code Pythondownloadcontent_copyexpand_less count = 10 def read_variable():…

Why the load of main by _start uses got entry, not adrp+add pair?

  • Haco
  • November 26, 2025
  • 6 min read

The _start function uses a Global Offset Table (GOT) entry to load the address of main primarily because _start is defined in a pre-compiled object file (typically Scrt1.o) that was built with Position-Independent Code (PIC) enabled. Here is the detailed explanation of why this happens and why adrp + add isn't used by default: 1. _start is Pre-Compiled Generic Code The _start function is not compiled at the same time as your application's main.c. It is part of the C Runtime (CRT) startup files (specifically Scrt1.o for Position…

AArch64 Pre/Post Indexing

  • Haco
  • November 25, 2025
  • 6 min read

In AArch64 (ARMv8-A 64-bit architecture), Pre-indexing and Post-indexing are memory addressing modes used with Load (LDR) and Store (STR) instructions. Their primary purpose is to perform Writeback: they automatically update the base register (the pointer) with a new address as part of the instruction execution. This is extremely efficient for iterating through arrays or managing stacks because it eliminates the need for a separate ADD or SUB instruction to move the pointer. Here is the breakdown of how they work. 1. Pre-Indexed Addressing Syntax: [base, #offset]!Key Symbol: The…

Check whether an executable is pure C or CPP

  • Haco
  • November 22, 2025
  • 5 min read

Distinguishing between a pure C and a C++ executable can be achieved by examining the symbols and library dependencies of the binary file. C++ compilers employ a technique called "name mangling" to support function overloading and namespaces, which is absent in C. Furthermore, C++ programs have a distinct set of standard library dependencies. Inspecting Symbol Tables for Name Mangling A primary indicator of C++ code is the presence of "mangled" names in the executable's symbol table. C++ compilers alter function and variable names to encode information about their…

Setup Docker on Ubuntu 25.10

  • Haco
  • November 22, 2025
  • 2 min read

To set up Docker on Ubuntu 25.10 (Questing Quokka), follow these steps. These instructions use the official Docker repository to ensure you get the latest version. Step 1: Uninstall Old Versions Conflicting packages (like docker.io or podman-docker) might be installed by default. Remove them to prevent conflicts: sudo apt-get remove docker.io docker-doc docker-compose docker-compose-v2 podman-docker containerd runc Step 2: Set Up the Docker Repository 1、Update your package index and install necessary dependencies: sudo apt-get update sudo apt-get install ca-certificates curl 2、Add Docker’s official GPG key: sudo install -m 0755 -d /etc/apt/keyrings sudo curl…

PIE Relocation: Tagging Addresses

  • Haco
  • November 22, 2025
  • 8 min read

In a Position-Independent Executable (PIE), absolute addresses aren't "tagged" directly within the machine code. Instead, the linker creates a separate list of instructions and data locations that need fixing, and this list is stored in a special section of the binary called the relocation table. The dynamic loader uses this table at runtime to patch the code with the correct memory addresses once the binary's actual location in memory is known. The Core Mechanism: Linker and Loader Teamwork 🤝 Think of it like moving into a new apartment building. You…