Basistechnieken voor reverse-engineering

Reverse engineering (RE) is het proces waarbij je software analyseert om de interne werking ervan te begrijpen zonder toegang tot de oorspronkelijke broncode. Zie jezelf als een detective voor programma's!

Je neemt een gecompileerd programma (een binair bestand) en werkt terug om te achterhalen wat het doet, hoe het dat doet en soms waarom.

Voor reverse engineering gebruik je voornamelijk twee soorten programma's:

• Disassemblers: deze programma's zetten machinecode (de onbewerkte bytes van een programma) terug om in voor mensen leesbare assemblytaal. Bekende voorbeelden zijn objdump, IDA Pro en Ghidra. Ze zijn je 'ogen' op de instructies van het programma.
• Debuggers: met programma's zoals GDB (GNU Debugger) kun je een programma stap voor stap uitvoeren, de uitvoering pauzeren en op elk moment de inhoud van registers en geheugen inspecteren. Ze zijn je 'handen' om met het actieve programma te werken.

Voor deze les analyseren we een eenvoudig x86-assemblyprogramma. Stel je voor dat je alleen de gecompileerde versie hebt en de logica ervan moet achterhalen!

Dit programma simuleert een eenvoudige 'wachtwoordcontrole' door twee hardgecodeerde waarden te vergelijken en op basis van het resultaat een bericht af te drukken.

Eerst zouden we ons assemblyprogramma compileren naar een uitvoerbaar bestand. Op Linux gebruik je hiervoor meestal een assembler, zoals NASM, en een linker, zoals LD.

nasm -f elf32 program.asm -o program.o
ld -m elf_i386 program.o -o program

Daarna gebruiken we een disassembler zoals objdump om de machinecode terugvertaald naar assembly te bekijken:

objdump -d program

Dit is een voorbeeld van wat je kunt zien:

08048060 <_start>:
8048060: b8 d2 04 00 00 mov $0x4d2,%eax
8048065: bb 36 16 00 00 mov $0x1636,%ebx
804806a: 39 d8 cmp %ebx,%eax
804806c: 74 1c je 804808a <.access_granted>

Bij reverse engineering zoek je een van de eerste dingen naar het beginpunt van het programma. Hier begint de uitvoering.

Bij Linux-uitvoerbare bestanden die vanuit assembly zijn gecompileerd, heet het beginpunt vaak _start. In onze gedisassembleerde uitvoer zie je het label <_start> op adres 08048060.

Hieraan zie je precies waar de CPU begint met het uitvoeren van instructies wanneer het programma wordt geladen.

Om de logica van een programma te begrijpen, moet je de uitvoeringsstroom volgen. Voorwaardelijke sprong-instructies zijn belangrijk om beslissingen te begrijpen, zoals if/else-instructies.

In ons voorbeeld zien we na het vergelijken van eax en ebx met cmp %ebx,%eax de instructie je 804808a <.access_granted>.

• cmp: vergelijkt twee waarden en stelt CPU-vlaggen in.
• je (Jump if Equal): als het resultaat van de vergelijking gelijk was, springt de uitvoering naar adres 0804808a, ons blok .access_granted.
• Als de waarden niet gelijk zijn, gaat de uitvoering verder met de volgende instructie in de reeks, het blok .access_denied.

Programma's communiceren met het besturingssysteem via systeemaanroepen. Op Linux x86 (32-bits) worden deze meestal aangeroepen met de instructie int 0x80.

Vóór int 0x80 worden specifieke registers met waarden geladen:

• eax: bevat het nummer van de systeemaanroep, bijvoorbeeld 4 voor sys_write en 1 voor sys_exit.
• ebx, ecx, edx: bevatten argumenten voor de systeemaanroep, bijvoorbeeld de bestandsdescriptor, het bufferadres en de lengte voor sys_write.

Door deze patronen te observeren, kun je acties herkennen zoals schrijven naar de console of het beëindigen van het programma.

Berichten en andere statische gegevens worden opgeslagen in gegevenssecties van het binaire bestand. Je kunt deze vaak bekijken met objdump -s -j .data program of objdump -s -j .rodata program.

In de assembly zie je instructies die het adres van deze tekenreeksen in een register laden, bijvoorbeeld mov ecx, 0x8049080, waarbij 0x8049080 naar een tekenreeks verwijst.

In ons voorbeeld staan de berichten "Access granted!" en "Access denied." in de sectie .data, en worden hun adressen doorgegeven aan sys_write.

Door al deze observaties te combineren, kunnen we de oorspronkelijke logica van het programma reconstrueren:

• Het begint bij _start.
• Het laadt twee specifieke gehele waarden in eax en ebx.
• Het vergelijkt deze twee waarden.
• Als ze gelijk zijn, springt het naar een sectie die "Access granted!" naar de console afdrukt.
• Als ze niet gelijk zijn, gaat het verder naar een sectie die "Access denied." naar de console afdrukt.
• Na het afdrukken wordt het programma netjes beëindigd.

Dit is de kern van reverse engineering: de bedoeling en het gedrag van een programma begrijpen op basis van de gecompileerde vorm.

In deze les heb je de fundamentele technieken van elementaire reverse-engineering geleerd:

• Begrijpen wat RE is en waarom het belangrijk is.
• Belangrijke hulpmiddelen herkennen, zoals disassemblers (objdump) en debuggers (GDB).
• Het startpunt van het programma (_start) lokaliseren.
• De programmastroom volgen met voorwaardelijke sprongen (cmp, je).
• Systeemaanroepen (int 0x80) en hun parameters herkennen.
• Betekenisvolle tekenreeksen en gegevens uit het binaire bestand halen.

Door deze technieken toe te passen kun je beginnen met het reconstrueren van de logica en het gedrag van programma's, zelfs zonder hun oorspronkelijke broncode!