Grunnleggende teknikker for reversering

Reverse engineering (RE) er prosessen med å analysere programvare for å forstå hvordan den fungerer internt, uten tilgang til den opprinnelige kildekoden. Tenk på det som å være detektiv for programmer!

Det innebærer å ta et kompilert program (en binærfil) og arbeide bakover for å finne ut hva det gjør, hvordan det gjør det og noen ganger hvorfor.

For å utføre reverse engineering bruker De hovedsakelig to typer verktøy:

• Disassembleringsverktøy: Disse verktøyene konverterer maskinkode (de rå byt­ene i et program) tilbake til assembler-språk som mennesker kan lese. Populære eksempler er objdump, IDA Pro og Ghidra. De er Deres «øyne» inn i programmets instruksjoner.
• Feilsøkere: Verktøy som GDB (GNU Debugger) lar Dem kjøre et program steg for steg, sette kjøringen på pause og undersøke innholdet i registre og minne når som helst. De er Deres «hender» for å samhandle med programmet mens det kjører.

I denne leksjonen skal vi analysere et enkelt x86-assemblerprogram. Tenk Dem at De bare har den kompilerte versjonen og må finne ut hvordan logikken fungerer!

Programmet simulerer en enkel «passordsjekk» ved å sammenligne to hardkodede verdier og skrive ut en melding basert på resultatet.

Først kompilerer vi assemblerprogrammet til en kjørbar fil. På Linux innebærer dette vanligvis en assembler (som NASM) og en linker (som LD).

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

Deretter bruker vi et disassembleringsverktøy som objdump for å se maskinkoden konvertert tilbake til assembler:

objdump -d program

Her er et utdrag av det De kan 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 De utfører reverse engineering, er noe av det første De ser etter programmets startpunkt. Det er her kjøringen begynner.

For Linux-kjørbare filer som er kompilert fra assembler, er startpunktet ofte merket _start. I resultatet fra disassembleringen kan De se etiketten <_start> på adressen 08048060.

Dette forteller Dem nøyaktig hvor CPU-en begynner å utføre instruksjoner når programmet lastes inn.

For å forstå logikken i et program må De følge kjøringsflyten. Instruksjoner for betingede hopp er sentrale for å forstå beslutninger (som if/else-setninger).

I eksempelet vårt ser vi je 804808a <.access_granted> etter at eax og ebx er sammenlignet med cmp %ebx,%eax.

• cmp: Sammenligner to verdier og setter CPU-flagg.
• je (Jump if Equal): Hvis sammenligningen viste at verdiene var like, hopper kjøringen til adressen 0804808a (blokken vår .access_granted).
• Hvis verdiene ikke er like, fortsetter kjøringen med neste instruksjon i sekvensen (blokken .access_denied).

Programmer samhandler med operativsystemet gjennom systemkall. På Linux x86 (32-bit) startes disse vanligvis med instruksjonen int 0x80.

Før int 0x80 lastes bestemte registre med verdier:

• eax: Inneholder nummeret til systemkallet (for eksempel 4 for sys_write og 1 for sys_exit).
• ebx, ecx, edx: Inneholder argumenter til systemkallet (for eksempel fildeskriptor, bufferadresse og lengde for sys_write).

Ved å observere disse mønstrene kan De identifisere handlinger som å skrive til konsollen eller avslutte programmet.

Meldinger og andre statiske data lagres i dataseksjoner i binærfilen. De kan ofte vise disse med objdump -s -j .data program eller objdump -s -j .rodata program.

I assemblerkoden ser De instruksjoner som laster adressen til disse strengene inn i et register (for eksempel mov ecx, 0x8049080, der 0x8049080 peker på en streng).

I eksempelet vårt finnes meldingene «Access granted!» og «Access denied.» i .data-seksjonen, og adressene deres sendes til sys_write.

Ved å kombinere alle disse observasjonene kan vi rekonstruere programmets opprinnelige logikk:

• Det starter ved _start.
• Det laster to bestemte heltallsverdier inn i eax og ebx.
• Det sammenligner disse to verdiene.
• Hvis de er like, hopper det til en seksjon som skriver ut «Access granted!» på konsollen.
• Hvis de ikke er like, fortsetter det til en seksjon som skriver ut «Access denied.» på konsollen.
• Etter utskriften avsluttes programmet på normal måte.

Dette er kjernen i reverse engineering: å forstå programmets hensikt og oppførsel ut fra den kompilerte formen.

I denne leksjonen har du lært de grunnleggende teknikkene innen enkel reverse engineering:

• Forstå hva RE er, og hvorfor det er viktig.
• Identifisere viktige verktøy som disassemblerere (objdump) og debuggere (GDB).
• Finne programmets startpunkt (_start).
• Følge programflyten ved hjelp av betingede hopp (cmp, je).
• Gjenkjenne systemkall (int 0x80) og parameterne deres.
• Hente ut meningsfulle strenger og data fra binærfilen.

Ved å bruke disse teknikkene kan du begynne å rekonstruere logikken og virkemåten til programmer, selv uten den opprinnelige kildekoden!