De basis van reverse-engineering en binaire analyse · Les

Geheugen en registers onderzoeken

Oefen met het inspecteren van geheugengebieden, het bekijken van registerwaarden en het wijzigen van de programmastatus tijdens de uitvoering.

Les 3 van 412 stappen

Geheugen en registers onderzoeken is een gratis De basis van reverse-engineering en binaire analyse-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject De basis van reverse-engineering en binaire analyse. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus De basis van reverse-engineering en binaire analyse bevat in totaal 4 lessen.

De kern van debuggen: geheugen en registers

Bij het analyseren van programma's, vooral tijdens dynamische analyse, is het belangrijk om te begrijpen wat er in de CPU gebeurt. Daarvoor moet je naar registers en geheugen kijken.

Dit zijn de directe werkruimten van de CPU. Ze bevatten gegevens en instructies die actief worden verwerkt.

Kladblok van de CPU: registers

Registers zijn kleine, zeer snelle opslaglocaties die zich rechtstreeks in de CPU bevinden. Je kunt ze zien als het "kladblok" van de CPU, waarin deze gegevens bewaart die hij direct nodig heeft.

Ze bevatten tijdelijke waarden, adressen en besturingsinformatie.
Gegevens in registers benaderen gaat veel sneller dan gegevens in RAM benaderen.
Verschillende architecturen (zoals x86 en ARM) hebben verschillende sets registers.

Veelgebruikte x86/x64-registers

Hoewel er veel registers zijn, zijn sommige bijzonder belangrijk voor reverse engineering:

Registers voor algemeen gebruik: RAX/EAX, RBX/EBX, RCX/ECX, RDX/EDX (voor gegevens, functieargumenten en retourwaarden).
Stackpointer: RSP/ESP (wijst naar de top van de stack).
Basispointer: RBP/EBP (wijst naar de basis van het huidige stackframe).
Instructiepointer: RIP/EIP (wijst naar de volgende uit te voeren instructie).

Registers bekijken in GDB

Bekijk hoe je registers inspecteert met een debugger zoals GDB. We gebruiken een eenvoudig C-programma.

Compileer het eerst met foutopsporingsinformatie (-g): gcc -g -o myprog myprog.c

Nadat je hebt gecompileerd en GDB hebt gestart (bijvoorbeeld met gdb -q ./myprog), kun je een onderbrekingspunt instellen (break main), het programma uitvoeren (run) en vervolgens info registers gebruiken.

    #include <stdio.h>

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

Werkruimte van het programma: geheugen

Geheugen (RAM) is de plek waar je programma grotere hoeveelheden gegevens opslaat die niet actief door de CPU worden verwerkt. Dit omvat variabelen, programmacode en andere bronnen.

Elke byte in het geheugen heeft een uniek adres. Wanneer een programma wordt uitgevoerd, krijgt het zijn eigen toegewezen "virtuele" geheugenruimte.

Vereenvoudigde geheugenindeling

Het geheugen van een programma is meestal verdeeld in secties:

Tekst-/codesegment: Bevat de uitvoerbare instructies.
Datasegment: Slaat globale en statische variabelen op.
Heap: Wordt gebruikt voor dynamisch toegewezen geheugen (bijvoorbeeld met malloc).
Stack: Wordt gebruikt voor lokale variabelen, functieargumenten en retouradressen.

Geheugen bekijken in GDB

Om geheugen in GDB te inspecteren, gebruiken we de opdracht x (geheugen onderzoeken). Deze heeft een flexibele syntaxis:

x /NFS ADDRESS
N: Het aantal weer te geven eenheden (optioneel).
F: De notatie (bijvoorbeeld x voor hexadecimaal, d voor decimaal, s voor tekenreeks en i voor instructie).
S: De grootte (bijvoorbeeld b voor byte, h voor halfwoord (2 bytes), w voor woord (4 bytes) en g voor groot (8 bytes)).

Voorbeeld: een stackvariabele bekijken

We gebruiken ons vorige programma. Compileer het en stel een onderbrekingspunt in vóór printf. Daarna kunnen we het adres van sum vinden en de inhoud ervan onderzoeken.

Voer deze code uit, koppel vervolgens GDB eraan (gdb -q ./myprog), stel een onderbrekingspunt in op regel 7 (break main.c:7) en voer het programma uit (run).

Gebruik in GDB p &sum om het adres ervan op te vragen. Gebruik ten slotte x /w ADDRESS_OF_SUM om de waarde van 4 bytes te bekijken.

    #include <stdio.h>

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

Registerwaarden wijzigen

Een krachtige debugtechniek is het direct wijzigen van registerwaarden. Zo kun je het gedrag van een programma veranderen zonder de code aan te passen.

In GDB kun je de opdracht set gebruiken:

set $rax = 0x1234
set $rip = *0x400500 (spring naar een nieuw adres)

Dit is nuttig om controles te omzeilen of de uitvoeringsstroom om te leiden.

Geheugeninhoud wijzigen

Net als registers kun je ook de inhoud van het geheugen tijdens het debuggen wijzigen. Hiermee kun je waarden van variabelen, tekenreeksen of zelfs instructies in het geheugen veranderen.

Gebruik hiervoor de opdracht set van GDB:

set var_name = new_value (als de variabele binnen bereik is)
set {int}0x400000 = 123 (wijzigt 4 bytes op adres 0x400000 in 123)

Wees voorzichtig: onjuiste wijzigingen kunnen het programma laten crashen!

Debuggeruitdaging

Je debugt een programma. Je wilt de waarde bekijken van een 4 bytes grote gehele getalvariabele met de naam counter, die zich op geheugenadres 0x7fffffff0000 bevindt. Welke GDB-opdracht zou je gebruiken?

Beantwoord dit in de interactieve les

Samenvatting: de kern van debuggen

Vandaag hebben we onderzocht hoe je de kernonderdelen van een actief programma kunt bekijken en wijzigen: registers en geheugen.

Registers zijn de snelle opslag van de CPU en worden bekeken met info registers.
Geheugen bevat grotere hoeveelheden gegevens en wordt bekeken met x /NFS ADDRESS.
Beide kunnen met set worden gewijzigd om de programmatoestand dynamisch aan te passen.

Deze vaardigheden zijn essentieel om programma-uitvoering en reverse engineering te begrijpen!

Gratis beginnen

Leer Assembly met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Geheugen en registers onderzoeken” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad De basis van reverse-engineering en binaire analyse, waaronder “Geheugen en registers onderzoeken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus De basis van reverse-engineering en binaire analyse bevat in totaal 4 lessen.

Wat leer ik in “Geheugen en registers onderzoeken”?

Oefen met het inspecteren van geheugengebieden, het bekijken van registerwaarden en het wijzigen van de programmastatus tijdens de uitvoering. Je oefent met De basis van reverse-engineering en binaire analyse door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met De basis van reverse-engineering en binaire analyse te beginnen?

Ervaring vooraf is niet nodig. De basis van reverse-engineering en binaire analyse op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Geheugen en registers onderzoeken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over De basis van reverse-engineering en binaire analyse?

Ja. Elke les over De basis van reverse-engineering en binaire analyse bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Basisprincipes van debuggers (GDB, WinDbg)
Breakpoints instellen en stapsgewijs uitvoeren
Geheugen en registers onderzoeken
API- en systeemaanroepen tijdens runtime traceren

← Terug naar De basis van reverse-engineering en binaire analyse