Grundläggande reverse engineering-tekniker

Reverse engineering (RE) är processen att analysera programvara för att förstå hur den fungerar internt utan tillgång till den ursprungliga källkoden. Tänk på det som att vara detektiv för program!

Det innebär att ta ett kompilerat program (en binärfil) och arbeta bakifrån för att ta reda på vad det gör, hur det gör det och ibland varför.

För reverse engineering använder ni huvudsakligen två typer av verktyg:

• Disassemblerare: Dessa verktyg omvandlar maskinkod (programmets råa byte) tillbaka till assemblerkod som människor kan läsa. Populära exempel är objdump, IDA Pro och Ghidra. De är era ”ögon” mot programmets instruktioner.
• Felsökare: Verktyg som GDB (GNU Debugger) låter er köra ett program steg för steg, pausa körningen och granska innehållet i register och minne när som helst. De är era ”händer” för att interagera med programmet under körning.

I den här lektionen analyserar vi ett enkelt x86-assemblerprogram. Föreställ er att ni bara har den kompilerade versionen och behöver ta reda på dess logik!

Programmet simulerar en enkel ”lösenordskontroll” genom att jämföra två hårdkodade värden och skriva ut ett meddelande baserat på resultatet.

Först skulle vi kompilera assemblerprogrammet till en körbar fil. I Linux innebär detta vanligtvis en assembler (som NASM) och en länkare (som LD).

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

Sedan använder vi en disassemblerare som objdump för att se maskinkoden omvandlad tillbaka till assemblerkod:

objdump -d program

Här är ett utdrag av det ni kan tänkas se:

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>

När ni ägnar er åt reverse engineering är programmets startpunkt en av de första sakerna ni letar efter. Det är där körningen börjar.

I Linux-körbara filer som kompilerats från assembler är startpunkten ofta märkt _start. I vårt disassemblerade resultat kan ni se etiketten <_start> vid adressen 08048060.

Detta visar exakt var processorn börjar köra instruktioner när programmet läses in.

För att förstå ett programs logik måste ni följa dess körningsflöde. Instruktioner för villkorsstyrda hopp är centrala för att förstå beslutslogik (som if/else-satser).

I vårt exempel ser vi je 804808a <.access_granted> efter att eax och ebx har jämförts med cmp %ebx,%eax.

• cmp: Jämför två värden och ställer in processorns flaggor.
• je (Jump if Equal): Om jämförelsen gav lika värden hoppar körningen till adressen 0804808a (blocket .access_granted).
• Om värdena inte är lika fortsätter körningen med nästa instruktion i ordningsföljden (blocket .access_denied).

Program interagerar med operativsystemet genom systemanrop. I Linux x86 (32-bitars) görs dessa vanligtvis med instruktionen int 0x80.

Före int 0x80 läses specifika register in med värden:

• eax: Innehåller systemanropsnumret (till exempel 4 för sys_write och 1 för sys_exit).
• ebx, ecx, edx: Innehåller argument för systemanropet (till exempel filbeskrivare, buffertadress och längd för sys_write).

Genom att observera dessa mönster kan ni identifiera åtgärder som att skriva till konsolen eller avsluta programmet.

Meddelanden och andra statiska data lagras i binärfilens datasektioner. Ni kan ofta visa dem med objdump -s -j .data program eller objdump -s -j .rodata program.

I assemblerkoden ser ni instruktioner som läser in adressen till dessa strängar i ett register (till exempel mov ecx, 0x8049080, där 0x8049080 pekar på en sträng).

I vårt exempel finns meddelandena ”Access granted!” och ”Access denied.” i sektionen .data, och deras adresser skickas till sys_write.

Genom att kombinera alla dessa observationer kan vi återskapa programmets ursprungliga logik:

• Det startar vid _start.
• Det läser in två specifika heltalsvärden i eax och ebx.
• Det jämför dessa två värden.
• Om de är lika hoppar det till en sektion som skriver ut ”Access granted!” i konsolen.
• Om de inte är lika fortsätter det till en sektion som skriver ut ”Access denied.” i konsolen.
• Efter utskriften avslutas programmet på ett ordnat sätt.

Detta är kärnan i reverse engineering: att förstå programmets avsikt och beteende utifrån dess kompilerade form.

I den här lektionen har du lärt dig grundläggande tekniker inom reverse engineering:

• Förstå vad RE är och varför det är viktigt.
• Identifiera viktiga verktyg som disassemblers (objdump) och debuggers (GDB).
• Lokalisera programmets startpunkt (_start).
• Följa programmets flöde med villkorliga hopp (cmp, je).
• Känna igen systemanrop (int 0x80) och deras parametrar.
• Extrahera meningsfulla strängar och data ur binärfilen.

Genom att använda dessa tekniker kan du börja återskapa programs logik och beteende även utan den ursprungliga källkoden!