Grundlæggende reverse engineering og binæranalyse · Lektion

Kontrolflow og funktionskald

Lær om betingede spring, løkker og mekanikken bag funktionskald, herunder brugen af stacken.

Lektion 3 af 411 trin

Kontrolflow og funktionskald er en gratis Grundlæggende reverse engineering og binæranalyse-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Grundlæggende reverse engineering og binæranalyse, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Grundlæggende reverse engineering og binæranalyse-kurset indeholder 4 lektioner i alt.

Styringsflow: Gør programmer intelligente

I assembly kører instruktioner normalt én efter én. Det kaldes sekventiel udførelse. Men virkelige programmer skal kunne træffe beslutninger, gentage handlinger og kalde funktioner.

Det er her, styringsflow kommer ind i billedet! Det beskriver, hvordan et program ændrer sin udførelsessti ud fra betingelser, opretter løkker og kalder underprogrammer.

Betingede spring: If-sætninger

Betingede spring svarer til if-sætninger i højniveausprog. De lader dit program udføre forskellige kodeblokke afhængigt af en betingelse.

Instruktionen CMP sammenligner to værdier og indstiller CPU-flag. Derefter kontrollerer springinstruktioner som JE (spring hvis lig med) eller JNE (spring hvis ikke lig med) disse flag for at afgøre, om der skal springes.

; Example: if (EAX == EBX) goto equal_label;
MOV EAX, 10
MOV EBX, 10
CMP EAX, EBX    ; Compare EAX and EBX
JE  equal_label ; Jump if Equal
; Code here runs if EAX != EBX
JMP end_label

equal_label:
; Code here runs if EAX == EBX

end_label:
; Program continues

Flere springbetingelser

Ud over JE og JNE findes der mange andre betingede springinstruktioner til håndtering af forskellige sammenligninger:

JG: Spring hvis større
JL: Spring hvis mindre
JGE: Spring hvis større end eller lig med
JLE: Spring hvis mindre end eller lig med
JZ: Spring hvis nul (bruges ofte efter CMP eller aritmetik)
JNZ: Spring hvis ikke nul

Disse instruktioner fortolker CPU'ens flagregister, som gemmer resultaterne af tidligere handlinger.

Opret løkker i assembly

Du kan oprette løkker ved hjælp af betingede spring. En løkke omfatter typisk:

En initialisering (f.eks. indstilling af en tæller).
Et betingelsestjek (ved hjælp af CMP og et betinget spring).
Løkkens krop (instruktioner, der skal gentages).
En opdatering (f.eks. forøgelse af tælleren).
Et ubetinget spring tilbage til betingelsestjekket.

; Example: int i = 0; while (i < 3) { i++; }
MOV ECX, 0      ; Initialize counter i = 0

loop_start:
CMP ECX, 3      ; Compare i with 3
JGE loop_end    ; Jump if i >= 3 (exit loop)

INC ECX         ; Increment i
JMP loop_start  ; Jump back to loop_start

loop_end:
; Loop has finished, continue here

Stakken: LIFO-lager

Stakken er et vigtigt hukommelsesområde, der bruges til midlertidig lagring, især under funktionskald. Den følger princippet LIFO (sidst ind, først ud).

Tænk på den som en stak tallerkener: Du kan kun lægge en ny tallerken øverst (PUSH) eller fjerne den øverste tallerken (POP).

PUSH: Formindsker stack pointer (ESP/RSP) og placerer data på stakken.
POP: Henter data fra toppen af stakken og forøger stack pointer.

Funktionskald: CALL og RET

Når et program skal udføre en separat kodeblok (en funktion eller et underprogram), bruger det instruktionen CALL. Det er grundlæggende for modulær programmering.

Instruktionen CALL lægger først returadressen (adressen på instruktionen umiddelbart efter CALL) på stakken.
Derefter springer den ubetinget til mål-funktionens startpunkt.
Instruktionen RET, som typisk findes i slutningen af en funktion, henter returadressen fra stakken og springer tilbage til den adresse, så udførelsen fortsætter i den kaldende kode.

; Caller code:
; ... instructions
CALL my_function ; Calls the function
; ... execution continues here after my_function returns

; my_function definition:
my_function:
; ... function's body instructions
RET              ; Returns to the caller

Sende argumenter til funktioner

Hvordan modtager funktioner input? I x86/x64-assembly sendes argumenter ofte via stakken eller registre.

Når stakken bruges, skubbes argumenterne på stakken af den kaldende funktion før CALL-instruktionen. Den kaldte funktion får derefter adgang til disse argumenter i forhold til stack pointeren (ESP/RSP) eller base pointeren (EBP/RBP).

Kaldkonventionen bestemmer rækkefølgen og metoden for overførsel af argumenter.

Lokale variable og stakrammen

Funktioner har også brug for plads til deres egne lokale variable. Denne plads allokeres på stakken i det, der kaldes en stakramme.

En stakramme oprettes typisk ved at:

Gemme den gamle base pointer (PUSH EBP/RBP).
Sætte den nye base pointer til den aktuelle stack pointer (MOV EBP, ESP/RBP, RSP).
Allokere plads til lokale variable (SUB ESP, size).

Base pointeren (EBP/RBP) giver et stabilt referencepunkt, så du kan få adgang til argumenter og lokale variable i den aktuelle funktion.

Gennemgang af et funktionskald

Lad os se på en simpel C-funktion og forstå, hvordan dens kald, argumenter og lokale variable hænger sammen med assembly og stakken.

Når main kalder calculate_sum, skubbes argumenterne 15 og 25 på stakken. Inde i calculate_sum allokeres der plads til local_var på stakken. Funktionens returværdi placeres typisk i et register som EAX.

#include <stdio.h>

int calculate_sum(int a, int b) {
  int local_var = a + b; // Local variable on stack
  return local_var;
}

int main() {
  int result = calculate_sum(15, 25);
  printf("Result: %d\n", result);
  return 0;
}

Hurtig kontrol: funktionskald

Det er afgørende at forstå stackens rolle i funktionskald, når du laver reverse engineering.

Hvilke af følgende handlinger udføres, når en x86/x64 CALL-instruktion eksekveres?

Besvar den i den interaktive lektion

Opsamling: kontrolflow og funktioner

Godt gået! Du har lært, hvordan programmer træffer beslutninger og udfører funktioner i assembly.

Betingede spring (JE, JNE, JG osv.) kombineret med CMP gør if-sætninger og løkker mulige.
Stakken er en LIFO-struktur, der er afgørende for midlertidige data og administreres med PUSH og POP.
Funktionskald bruger CALL til at skubbe returadressen på stakken og springe, og RET til at hente den frem igen og returnere.
Argumenter og lokale variable håndteres ofte via stakken inden for en funktions stakramme.

Det er vigtigt at forstå disse begreber, når du skal følge et programs kørsel og analysere binærfiler!

Gratis at komme i gang

Lær Assembly med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Kontrolflow og funktionskald” gratis?

Ja — alle 3 lektioner i læringssporet Grundlæggende reverse engineering og binæranalyse, inklusive “Kontrolflow og funktionskald”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Grundlæggende reverse engineering og binæranalyse-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Kontrolflow og funktionskald”?

Lær om betingede spring, løkker og mekanikken bag funktionskald, herunder brugen af stacken. Du øver dig i Grundlæggende reverse engineering og binæranalyse med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Grundlæggende reverse engineering og binæranalyse?

Der kræves ingen tidligere erfaring. Grundlæggende reverse engineering og binæranalyse på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Kontrolflow og funktionskald”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Grundlæggende reverse engineering og binæranalyse-lektion?

Ja. Alle Grundlæggende reverse engineering og binæranalyse-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Grundlæggende reverse engineering og binæranalyse