0 views collected around this technical thread.
In the 1950s programmers wrote directly to hardware, but the fragility of hard‑coded memory and I/O led to the invention of a privileged “expert” kernel mode and a restricted “novice” user mode, with a special instruction to switch, forming the basis of modern system calls and operating system protection.
The article explains the essence of process switching by comparing it to function calls, demonstrates how manipulating a function's return address can redirect execution to another function, and shows the underlying assembly and security implications of such control‑flow changes.
This article provides a comprehensive overview of the Linux ptrace system call, explaining its role in process debugging, detailing request parameters, demonstrating practical C examples for tracing system calls, single‑stepping, setting breakpoints, and exploring how DWARF debugging information links source code to executable addresses.
This guide provides a thorough introduction to x86 assembly language, covering GNU syntax, CPU architecture, registers, instruction formats, data types, memory models, and practical examples with NASM and GNU as, enabling readers to write efficient low‑level code and deepen their understanding of computer systems.
Ant Financial's MorseCrypto team secured first place in the 2024 Financial Cipher Cup second‑stage competition by delivering highly optimized SM2, SM3, and SM4 implementations on X86 and ARM platforms that achieve up to 4.3‑times faster verification while meeting strict security and memory constraints.
This article explains the relationship between Linux system calls and APIs, describes how system calls are implemented on x86 and ARM architectures, provides code examples in C and assembly, and discusses practical usage scenarios such as file operations, networking, and debugging techniques.
The article explains how assembly language serves as the foundational layer beneath all high‑level languages, illustrating its essential role in translating code to machine instructions, and argues that understanding assembly deepens comprehension of computer architecture despite its rare direct use today.
This article provides a comprehensive overview of how Linux kernel system calls are implemented on the x86-64 architecture, covering the conceptual differences from regular function calls, register conventions, initialization processes, syscall tables, and practical assembly examples such as write and getpid.
This article introduces x86 assembly language, explaining its historical origins, the role of CPU registers such as EAX and ESP, the heap and downward‑growing stack memory models, and demonstrates basic stack‑frame operations like push, call, mov, add, pop, and ret through a simple compiled example.
From raw binary on punched tape to mnemonic assembly and then to high‑level constructs like if, while, and functions, programmers created recursive grammars that compile source code into abstract syntax trees, which a compiler translates back into machine instructions, illustrating how recursion underpins both programming language design and computation.
The article analyzes a crash that occurs on Windows 10 when a 64‑bit program mixes RSP and ESP instructions, explains how writing to the 32‑bit ESP register zero‑extends the upper 32 bits of RSP, and shows how this stack‑pointer mismatch leads to an access‑violation error that does not appear on Windows 7.
The article investigates undocumented x86 opcodes, describing a depth‑first search that uses page‑faults to locate hidden instruction boundaries, and reports finding dozens of executable but undocumented instructions on Intel and AMD CPUs, highlighting potential security risks and the need for vigilant hardware analysis.
This article explains how Linux system calls serve as the primary interface between user‑space programs and the kernel, describes the transition from user mode to kernel mode, and provides step‑by‑step debugging examples and source‑code snippets for x86_64 architectures.
The article explains how AArch64 stack unwinding works using both frame‑pointer based methods and DWARF .eh_frame/.debug_frame CFI data, detailing the calling convention, compiler effects, CIE/FDE structures, and their integration into Android’s simpleperf profiler for accurate back‑traces.
A segmentation fault in a simple tile‑index copy loop was traced to GCC 9.2’s -O3 loop‑vectorization pass miscalculating structure offsets, and the issue was resolved by disabling -ftree-loop-vectorize or upgrading the compiler, as newer GCC versions and Clang handle the code correctly.
The article explores how a developer generated billions of if‑statements in C to decide odd or even for 32‑bit numbers, scaling the approach with Python‑generated code, custom assembly, memory‑mapped binaries, and discusses the practical limits and performance of such an extreme solution.
By reverse‑engineering the iOS 16 WKWebView image‑analysis crash, the team identified a nil‑buffer bug in VisionKitCore’s CGImage creation, then mitigated it by runtime‑hooking VKCRemoveBackgroundResult’s createCGImage (returning NULL) and suppressing the image‑analysis gesture, reducing crashes from thousands to near zero.
The article explains how C++ value categories—lvalue, prvalue, and xvalue—govern function return handling, parameter passing, and object lifetimes, detailing hidden out‑parameters, copy‑elision, const‑reference lifetime extension, rvalue references, and the role of std::move in enabling move semantics.
The article explains how to read and write a tiny 8‑byte memory without an operating system or high‑level language, introducing the concepts of memory addresses, store/load instructions, variables, references, pointers, indirect addressing, and their role in building data structures like linked lists.
Android’s Shadow Call Stack (SCS), silently enabled since Android R on AArch64 devices, stores return addresses in a protected register‑based stack separate from the regular stack, complementing stack canaries and requiring hardware support, while developers can activate it via -fsanitize=shadow-call-stack and avoid using X18 elsewhere.