Blog

Introduction

Hey there, fellow tech enthusiasts! Welcome to a wild ride through the world of assembly language programming. Before we dive in, let’s get comfortable. So, grab a cold beer, cup of coffee, or refreshing juice, and let’s embark on this journey together.

I know, I know. Assembly language sounds intimidating, like trying to understand ancient hieroglyphics or deciphering your doctor’s handwriting. But fear not! We will break down these dense concepts into bite-sized, digestible chunks. By the end of this post, you’ll not only understand assembly language but might even find it… fun! (Yes, I said it!)

Why Should You Stick Around?

I get it – low-level programming can seem tedious at first, but trust me, it’s worth the effort. Understanding assembly language will give you superpowers!

Explanation of Assembly Language

Assembly language is a low-level programming language closely related to machine code, the native language of a computer’s central processing unit (CPU). Each instruction in assembly language corresponds directly to a single machine code instruction, making it a powerful tool for understanding how software interacts directly with hardware. To illustrate this better, I will present you with a scenario. Imagine you have a recipe and are trying to communicate with someone who only speaks French to provide instructions for a dish. In this scenario, you have two friends; one speaks Mandarin and French, and the other speaks Mandarin and English. Assuming you only speak English, you would need to tell your second friend the instructions, and then he would translate it to your other friend in Mandarin so that he could tell the last person in French the steps. You probably can already tell where I am going with this; that’s basically what happens when you are programming on a higher-level language like Python and compiling it into machine code. Given the blasting speeds of computers nowadays, it might still be better to use this chain rather than learning Frech. Heck, you might never have to speak a word, and everything will still work amazingly. Still, if you ever want to look at a French recipe and your friends are nowhere near, that’s the end of it. You will never figure out what delicious meal you are missing, So learn Frech! Well, I mean Assemby…

Importance of Knowing Assembly

Learning assembly language gives you a solid understanding of how computers work under the hood. You will also learn to appreciate the sophistication and abstraction of modern programming languages. Still, knowing assembly is priceless for tasks that require fine-grained control over system resources, such as writing operating systems, developing embedded systems, and performing low-level hardware manipulation. Understanding assembly can help optimize code and debug complex issues, even for higher-level programming. Additionally, if you enjoy participating in CTFs, assembly knowledge will prove essential for understanding and solving any pwn/binary exploitation challenge.

Practical Uses of Assembly Language

Assembly language is used in various fields, such as:

• Embedded Systems Development: Programming microcontrollers and other embedded devices.
• Operating System Development: Writing kernels and other low-level system components.
• Reverse Engineering: Analyzing software to understand its functionality and discover vulnerabilities.
• Performance Optimization: Fine-tuning critical sections of code for maximum efficiency.

How Assembly Works

Assembly language works by providing human-readable mnemonics that correspond to machine code instructions. The process typically involves writing assembly code, which an assembler converts into machine code. This machine code can then be executed directly by the CPU.

Understanding Registers

Registers are small, fast storage locations within a CPU that hold data and addresses. They are crucial in executing instructions by providing quick access to operands and intermediate results. Different types of registers include:

• General Purpose Registers (GPRs): Used for various functions.
• Special Purpose Registers: Used for specific tasks like instruction pointers and status flags.

32-bit vs. 64-bit vs. x86 Architecture

The main differences between 32-bit and 64-bit architectures lie in the width of the data bus and the size of the registers. The bigger the bus, the more people you can carry around, right? A 64-bit architecture can handle more memory and perform operations on larger data sizes compared to a 32-bit architecture. The x86 architecture, originally 32-bit, has evolved to include x86-64, which supports 64-bit processing.

In the following sections, I will provide you with a basic understanding of registers, their use, and standard instructions for manipulating them in Assembly. The registers I am using are for 64-bit architecture, but if you understand them, you can easily transfer that knowledge to other types of architecture. Don’t let any of this intimidate you. Stick around; I promise to make it easier to understand further on.

Registers and Their Usage

Expand

Collapse

Assembly Most Frequent Commands

Expand

Collapse

Concepts to Understand Assembly Code

Now that we have all the jargon out of the way, I will attempt to make it easier to understand.

1. Stack Frame: Imagine your program’s memory like a stack of plates at a buffet. Each plate represents a function call, with the top plate being the currently active function. When you call a new function, you add a new plate to the stack (push). When the function finishes, you remove the top plate (pop). The stack frame is like a section on that plate where the function keeps all its variables, return addresses, and other important data.
2. Base Pointer (rbp): Think of the base pointer (rbp) as a bookmark in your favorite book. When you open a new chapter (function), you place a bookmark to remember where you started. This way, no matter how deep you go into sub-chapters (nested function calls), you can always find your way back to the beginning of the chapter.
3. Stack Pointer (rsp): If the base pointer is the bookmark, the stack pointer (rsp) is your finger that moves along the page as you read. It points to the current position in the stack where the next piece of data will be added or removed. It’s constantly changing as you call and return from functions.
4. Registers: Registers are like super-fast sticky notes that the CPU uses to keep track of important information. They’re limited in number but incredibly quick to access. General-purpose registers (like eax, ebx, etc.) can hold anything from data to addresses, while special-purpose registers have specific jobs (e.g., instruction pointer rip keeps track of the next instruction to execute).
5. Prologue and Epilogue: These are the opening and closing acts of a function. The prologue sets up the stage (creates the stack frame, saves the previous base pointer), and the epilogue cleans up (restores the base pointer, resets the stack pointer) before the function exits. It’s like setting up and breaking down a party – you prepare before guests arrive and clean up after they leave.

Imagine you’re organizing a treasure hunt at a summer camp. Each camper represents a function in your program.

Step 1: Prologue (Preparing for the Hunt)

• When a camper (function) starts the hunt, they grab a new backpack (create a stack frame) and put a name tag inside (push rbp).
• They write down the map coordinates of the camp entrance (mov rbp, rsp) so they can find their way back.

Step 2: The Hunt (Executing the Function)

• The camper collects clues (operands and results) and stores them in their pockets (registers like eax, ebx).
• They keep track of where they found each clue using sticky notes (general-purpose registers).

Step 3: Nested Hunts (Calling Another Function)

• If a camper needs help, they call another camper (function call), giving them a new backpack (new stack frame) and sharing some clues (pushing arguments on the stack).
• The new camper follows the same preparation steps (push rbp, mov rbp, rsp) and goes off to gather more clues.

Step 4: Returning with Clues (Returning from Function)

• When a camper finishes their hunt, they return to the campfire (return from function), giving back their backpack (pop rbp) and sharing the final clue they found (return value in eax).

Step 5: Epilogue (Cleaning Up)

• They remove their name tag from the backpack (pop rbp), ensuring everything is back in place.
• The camp director (CPU) checks the final clue and decides the next step in the treasure hunt (next instruction).

By thinking of functions as campers on a treasure hunt, stack frames as their backpacks, base pointers as bookmarks, and stack pointers as their moving fingers, the concepts become more intuitive and fun to understand. Plus, who doesn’t love a good treasure hunt?

Applying the knowledge

C Code

// Takes two numbers and returns their sum 
int add(int a, int b) {
    return a + b;
}

// Main function and entry point of the program
int main() {
    int x = 2;
    int y = 10;
    int result = add(x, y);
    if(result > 11) {
        return result;
    } else {
        return 0;
    }
}

Assembly Code (x86-64)

; add:
push   rbp
mov    rbp,rsp
mov    DWORD PTR [rbp-0x4],edi
mov    DWORD PTR [rbp-0x8],esi
mov    edx,DWORD PTR [rbp-0x4]
mov    eax,DWORD PTR [rbp-0x8]
add    eax,edx
pop    rbp
ret

; main:
push   rbp
mov    rbp,rsp
sub    rsp,0x10
mov    DWORD PTR [rbp-0x4],0x2
mov    DWORD PTR [rbp-0x8],0xa
mov    edx,DWORD PTR [rbp-0x8]
mov    eax,DWORD PTR [rbp-0x4]
mov    esi,edx
mov    edi,eax
call   0x555555555129 <add>
mov    DWORD PTR [rbp-0xc],eax
cmp    DWORD PTR [rbp-0xc],0xb
jle    0x555555555170 <main+51>
mov    eax,DWORD PTR [rbp-0xc]
jmp    0x555555555175 <main+56>
mov    eax,0x0
leave
ret

Let’s Break Down the Code!

Alright, let’s dive into our treasure hunt step by step. We’ll go over the assembly code, and I will explain what each part does in a friendly, easy-to-understand way.

And there you have it! You’ve taken your first steps into the fascinating world of assembly language. From registers and stack frames to the detailed mechanics of function calls, you’ve seen what really goes on under the hood of your programs.

Understanding assembly isn’t just for creating low-level magic—it’s about appreciating the intricacies of how your code actually runs. It’s like knowing how the gears and springs work in a watch; you get a deeper sense of the precision and complexity involved.

So, next time you write code in a high-level language, you’ll have a newfound respect for the tiny instructions and the diligent registers making it all happen. Whether you’re optimizing performance or just curious, assembly language gives you a closer look at the true nuts and bolts of computing.

Thanks for joining me on this journey through the basics of assembly. Keep exploring, stay curious, and happy coding!