Reverse Engineering & Binary Analysis Basics · Lekcja

Badanie pamięci i rejestrów

Poćwicz analizowanie obszarów pamięci, wyświetlanie wartości rejestrów i modyfikowanie stanu programu podczas jego wykonywania.

Badanie pamięci i rejestrów to bezpłatna lekcja Reverse Engineering & Binary Analysis Basics na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Reverse Engineering & Binary Analysis Basics, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Reverse Engineering & Binary Analysis Basics zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Debugging's Core: Memory & Registers

When analyzing programs, especially during dynamic analysis, understanding what's happening inside the CPU is key. This means looking at registers and memory.

These are the CPU's direct workspaces, holding data and instructions that are actively being processed.

CPU's Scratchpad: Registers

Registers are tiny, super-fast storage locations directly within the CPU itself. Think of them as the CPU's "scratchpad" where it keeps data it needs immediately.

They hold temporary values, addresses, and control information.
Accessing data in registers is much faster than accessing RAM.
Different architectures (like x86, ARM) have different sets of registers.

Common x86/x64 Registers

While there are many registers, some are crucial for reverse engineering:

General-Purpose: RAX/EAX, RBX/EBX, RCX/ECX, RDX/EDX (used for data, function arguments, return values).
Stack Pointer: RSP/ESP (points to the top of the stack).
Base Pointer: RBP/EBP (points to the base of the current stack frame).
Instruction Pointer: RIP/EIP (points to the next instruction to execute).

Viewing Registers in GDB

Let's see how to inspect registers using a debugger like GDB. We'll use a simple C program.

First, compile with debug info (-g): gcc -g -o myprog myprog.c

After compiling and starting GDB (e.g., gdb -q ./myprog), you can set a breakpoint (break main), run (run), and then use info registers.

    #include <stdio.h>

    int main() {
        int a = 10;
        int b = 20;
        int sum = a + b;
        printf("Sum: %d\n", sum);
        return 0;
    }

Program's Workspace: Memory

Memory (RAM) is where your program stores larger amounts of data that aren't actively being processed by the CPU. This includes variables, program code, and other resources.

Every byte in memory has a unique address. When a program runs, it gets its own dedicated "virtual" memory space.

Simplified Memory Layout

A program's memory is typically divided into sections:

Text/Code Segment: Contains the executable instructions.
Data Segment: Stores global and static variables.
Heap: Used for dynamically allocated memory (e.g., with malloc).
Stack: Used for local variables, function arguments, and return addresses.

Viewing Memory in GDB

To inspect memory in GDB, we use the x command (examine memory). It has a flexible syntax:

x /NFS ADDRESS
N: Number of units to display (optional).
F: Format (e.g., x for hex, d for decimal, s for string, i for instruction).
S: Size (e.g., b for byte, h for halfword (2 bytes), w for word (4 bytes), g for giant (8 bytes)).

Example: Viewing a Stack Variable

Let's use our previous program. Compile it and set a breakpoint before printf. Then, we can find the address of sum and examine its content.

Run this code, then attach GDB (gdb -q ./myprog), set a breakpoint at line 7 (break main.c:7), and run (run).

In GDB: p &sum to get its address. Finally, x /w ADDRESS_OF_SUM to view its 4-byte value.

    #include <stdio.h>

    int main() {
        int a = 10;
        int b = 20;
        int sum = a + b; // Breakpoint here
        printf("Sum: %d\n", sum);
        return 0;
    }

Changing Register Values

A powerful debugging technique is to modify register values on the fly. This can change how a program behaves without altering its code.

In GDB, you can use the set command:

set $rax = 0x1234
set $rip = *0x400500 (jump to a new address)

This is useful for bypassing checks or redirecting execution flow.

Altering Memory Content

Just like registers, you can also modify memory content while debugging. This allows you to change variable values, strings, or even instructions in memory.

Using GDB's set command:

set var_name = new_value (if the variable is in scope)
set {int}0x400000 = 123 (change 4 bytes at address 0x400000 to 123)

Be careful, incorrect modifications can crash the program!

Debugger Challenge

You're debugging a program. You want to see the value of a 4-byte integer variable named counter located at memory address 0x7fffffff0000. What GDB command would you use?

Recap: Debugging's Core

Today, we explored how to examine and modify the core components of a running program: registers and memory.

Registers are CPU's fast storage, viewed with info registers.
Memory holds larger data, viewed with x /NFS ADDRESS.
Both can be modified with set to alter program state dynamically.

These skills are fundamental for understanding program execution and reverse engineering!

Często zadawane pytania

Czy lekcja „Badanie pamięci i rejestrów” jest bezpłatna?

Tak — pełny tekst „Badanie pamięci i rejestrów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Reverse Engineering & Binary Analysis Basics, przejdź na CoddyKit PRO. Kurs Reverse Engineering & Binary Analysis Basics zawiera 4 lekcji w sumie.

Co nauczysz się w „Badanie pamięci i rejestrów”?

Poćwicz analizowanie obszarów pamięci, wyświetlanie wartości rejestrów i modyfikowanie stanu programu podczas jego wykonywania. Ćwiczysz Reverse Engineering & Binary Analysis Basics z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Reverse Engineering & Binary Analysis Basics?

Nie wymagamy żadnego doświadczenia. Reverse Engineering & Binary Analysis Basics w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Badanie pamięci i rejestrów”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Reverse Engineering & Binary Analysis Basics?

Tak. Każda lekcja Reverse Engineering & Binary Analysis Basics zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Podstawy debuggera (GDB, WinDbg)
Ustawianie punktów przerwania i wykonywanie krokowe
Badanie pamięci i rejestrów
Śledzenie wywołań API i systemowych w czasie działania

← Powrót do Reverse Engineering & Binary Analysis Basics