Spezielle Techniken und Technologien der Informatik

Transkript

1 1 / 32 Spezielle Techniken und Technologien der Informatik Reverse Engineering Robert Baumgartl 23. Mai 2016

2 Reverse Engineering Unter Reverse Engineering versteht man die Analyse von Software mit dem Ziel, ihren inneren Aufbau, ihre Struktur zu erkennen und zu verstehen. Zwei typische Anwendungsfälle sind die Rekonstruktion des Quellcodes von Programmen, die nur als Binärabbild vorliegen, z.b. Schadsoftware die Analyse von Kommunikationsprotokollen proprietärer Software 1 In der Lehrveranstaltung werden wir entsprechende Techniken und Werkzeuge kennenlernen, als Übungsplattform nutzen wir die Intel-IA-32-Architektur unter dem Betriebssystem Linux. Empfehlenswerte Literatur Bruce Dang, Alexandre Gazet und Elias Bachaalany. Practical Reverse Engineering. Wiley, 2014 Eldad Eilam. Reversing: Secrets of Reverse Engineering. Wiley, Beispielsweise ist das der populären Software Samba zugrundeliegende Protokoll SMB/CIFS per Reverse Engineering aufgeklärt worden. 2 / 32

3 3 / 32 Weitere Informationsquellen Intel 64 and IA-32 Architectures Software Developer s Manual (3 Volumes, knapp 4000 S.); frei verfügbar: Einführung in die AT&T-Assembler-Syntax für IA-32 Informationen zum Gnu Debugger gdb

4 Wozu? Sicherheitsbezogene Arbeiten Analyse bösartiger Software (z. B. Kryptotrojaner) Analyse von Applikationen und Betriebssystemen mit dem Ziel, Schwachstellen zu finden Analyse kryptografischer Algorithmen und deren Implementierung (Vortrag 2 von Philippe Oechslin auf dem 26C3) Unterwanderung von DRM Softwareentwicklung Herstellung der Interoperabilität zu proprietärer Software bzw. Protokollen (.doc-format, NTFS-Treiber in Linux, Samba, Hacking der Sony Playstation 3) Entwicklung konkurrierender Software Test der Robustheit und allgemeinen Qualität von Software / 32

5 5 / 32 Rechtliche Aspekte unterschiedliche nationale Gesetzgebung in Dt. grundsätzlich zunächst erlaubt; Ausnahme: Umgehung von Kopierschutzmechanismen aka Cracking (privat legal, gewerblich illegal 95a UrhG) Lizenz verbietet das Reverse Engineering häufig Analyse von protokollen ist grundsätzlich erlaubt USA: DMCA (vgl. Sony vs. Georg Hotz; PS3-Hack)

6 Beschränkung HLL 3 : C, weil leicht zu disassemblieren, da maschinennah, BS und die meisten Applikationen (und Schadcode) in C implementiert wurden und werden, alle Teilnehmer C könnten müssten. ISA 4 : IA-32 = Intel-Prozessoren im 32-Bit-Betrieb, weil in den Laboren diese Prozessoren verbaut sind, Befehlssatz gut zu verstehen; viel Literatur. (IMHO) leichter zu verstehen, als 64-Bit-Assembler BS: Linux, weil offene und freie Werkzeuge existieren, ich offene und freie Software bevorzuge. 3 High Level Language Höhere Programmiersprache 4 Instruction Set Architecture - der Befehlssatz und die Architektur des Prozessors 6 / 32

7 Werkzeuge 7 / Disassembler überführt (maschinenlesbares) Binary in (menschenlesbaren) Assemblercode objdump -d gdb 2. Decompiler überführt (maschinenlesbares) Binary in Hochsprachencode (bzw. versucht dies) z. B. Hex-Rays IDAPro (kommerziell) 3. Debugger zur schrittweisen Ausführung des zu analysierenden Codes, Speicherinspektion usw. 4. keine vergleichbaren Open-Source-Tools

8 Intel-Syntax vs. AT&T-Syntax 8 / 32

9 9 / 32 IA-32 CPU Wichtigste Register 2 Chapter 1 x86 and x64 by having user-mode applications run in ring 3, and the kernel in ring 0. The ring level is encoded in the CS register and sometimes referred to as the current privilege level (CPL) in official documentation. This chapter discusses the x86/ia-32 architecture as defined in the Intel 64 8 Universalregister and IA-32 Architectures ásoftware 32 Bit: Developer s EAX, Manual, EBX, Volumes ECX, 1 3 EDX, ( ESI, EDI,.com/content/www/us/en/processors/architectures-software-developer- EBP, ESP manuals.html). Befehlszähler EIP Register Set and Data Types Flagregister EFLAGS When operating in protected mode, the x86 architecture has eight 32-bit general- Datentypen: purpose registers 8 Bit (GPRs): (Byte), EAX, EBX, 16 ECX, Bit EDX, (Word), EDI, ESI, 32 EBP, Bit and (Double ESP. Some of Word), 64 them can be further divided into 8- and 16-bit registers. The instruction pointer Bit (Quad Word, nur EDX:EAX) is stored in the EIP register. The register set is illustrated in Figure 1-1. Table 1-1 describes some of these GPRs and how they are used EAX EBP AX BP AH AL ESP ESI SP SI EIP EDI EFLAGS Figure 1-1 DI

10 IA-32 CPU Registerbedeutungen Register EAX ECX ESP EBP ESI EDI Semantik Resultatregister Zählerregister in Schleifen Stack Pointer (TOS) zeigt auf Beginn des aktuellen Stackframes Quelladresse bei Blockoperationen Zieladresse bei Blockoperationen Viele weitere Register existieren, haben aber Spezialbedeutung Gleitkommaarithmetik, Control Registers CR, Model-Specific-Registers (MSR), MMX & SSE Co.) 10 / 32

11 11 / 32 IA-32 CPU EFLAGS 18 Chapter 1 x86 and x System flags. Flags There can be up to OF 16 conditional S codes, Z but the most CF common ones are described in Table 1-3. Carry: 1, wenn Übertrag (unsigned) Zero: 1, wenn Resultat=0 Sign: =MSB des Resultats Table 1-3: Common Conditional Codes Overflow: 1, wenn Resultat die max. Länge übersteigt (signed) CONDITIONAL CODE B/NAE ENGLISH DESCRIPTION Below/Neither Above nor Equal. Used for unsigned operations. MACHINE DESCRIPTION CF=1 NB/AE Not Below/Above or Equal. Used for CF=0 unsigned operations. E/Z Equal/Zero ZF=1 NE/NZ Not Equal/Not Zero ZF=0 L GE/NL G/NLE Less than/neither Greater nor Equal. Used for signed operations. Greater or Equal/Not Less than. Used for signed operations. Greater/Not Less nor Equal. Used for signed operations. (SF ^ OF) = 1 (SF ^ OF) = 0 ((SF ^ OF) ZF) = 0

12 12 / 32 Übersicht Kopieren von Daten Speicher Register und Register Register: mov arithmetische Operationen: mul, add, sub, inc, dec logische Operationen: or, and, shr, shl, xor Stackoperationen und Funktionsaufrufe: push, pop, call, ret Sprünge/bedingte Sprünge mit Vergleichen: jmp, jcc mit cmp und test

13 Der Stack 13 / 32 Bereich des Speichers wächst in Richtung kleinerer Adressen LIFO- (Last In First Out) Prinzip für Daten mit begrenzter Gültigkeitsdauer Parameter einer Funktion Rückkehradresse beim Sprung in eine Funktion (CALL) lokale Variablen einer Funktion temporäre Kopien von Registerinhalten (Save/Restore) nutzerdefinierte DS alloca() organisiert in Frames, die jeweils durch die Register EBP und ESP begrenzt werden ESP zeigt stets auf oberstes Element des Stacks (Top of Stack, TOS) Instruktionen: pop und push

14 Der Stack Aufbau eines Stackframes hohe Adressen EBP ESP niedrige Adressen Funktionsparameter <Ret> SFP lokale Variablen Top of Stack (TOS) Stack- Frame 14 / 32

15 15 / 32 push und pop push pop inkrementiert zuerst ESP (gewöhnlich +=4, da 32-Bit-Worte abgelegt werden) legt danach den Operanden auf die Adresse, auf die ESP verweist schreibt zuerst das Datum, auf das ESP verweist, in den übergebenen Operanden dekrementiert danach den Stackpointer ESP Operand ist in beiden Fällen ein Register oder eine Speicherstelle

16 16 / 32 push und pop Ablauf bei einer push-instruktion EBP ESP Hi Lo Funktionsparameter <Ret> SFP lokale Variablen 0xaffedead Register EAX enthält Wert 0x23. ausgeführte Instruktion: pushl %eax EBP ESP Funktionsparameter <Ret> SFP lokale Variablen 0xaffedead 0x a) vor push-operation b) nach push-operation

17 Calling Conventions aka Wie werden Parameter und Resultate beim Funktionsaufruf kommuniziert? In welcher Reihenfolge werden Parameter übergeben? Wie werden Parameter übergeben (in Register oder über den Stack)? Wie wird das Funktionsergebnis zurückgeliefert? 16 Chapter 1 x86 and x64 Welche Registerwerte dürfen durch die Funktion nicht zerstört werden (müssen ggf. innerhalb der Funktion gesichert und restauriert werden)? Table 1-2: Calling Conventions Parameters CDECL STDCALL FASTCALL Pushed on the stack from rightto-left. Caller must clean up the stack after the call. Same as CDECL except that the callee must clean the stack. First two parameters are passed in ECX and EDX. The rest are on the stack. Return value Stored in EAX. Stored in EAX. Stored in EAX. Non-volatile registers EBP, ESP, EBX, ESI, EDI. EBP, ESP, EBX, ESI, EDI. EBP, ESP, EBX, ESI, EDI. We now return to the code snippet to discuss how the function addme is Abbildung: Die wichtigsten Calling Conventions der IA-32 5 invoked. In line 1 and 3, the two parameters are pushed on the stack; ECX and EAX are the first and second parameter, respectively. Line 4 invokes the addme function with the CALL instruction. This immediately pushes the return address, 0x4129FE, on the stack and begins execution at 0x4113A0. Figure 1-4 illustrates 5 Bruce Dang, Alexandre Gazet und Elias Bachaalany. Practical Reverse Engineering. Wiley, 2014, S / 32

18 18 / 32 Elementare Konstrukte in C if-else-statement Schleifen Funktionsaufrufe Systemrufe (Linux) switch-case-statement ( Praktikum)

19 if-else-statement 19 / 32 Listing 1: ifelse.c #include <stdio.h> #include <stdlib.h> int main(int argc, char* argv[]) { int a, b=1; if (b==42) { a=23; } else { a=42; } exit(0); }

20 if-else-statement 20 / 32 Listing 2: Disassemblat zu ifelse.c (gdb) disas main Dump of assembler code for function main: 0x080483fb <+0>: lea 0x4(%esp),%ecx 0x080483ff <+4>: and $0xfffffff0,%esp 0x <+7>: pushl -0x4(%ecx) 0x <+10>: push %ebp 0x <+11>: mov %esp,%ebp 0x <+13>: push %ecx 0x <+14>: sub $0x14,%esp 0x c <+17>: movl $0x1,-0xc(%ebp) 0x <+24>: cmpl $0x2a,-0xc(%ebp) 0x <+28>: jne 0x <main+39> 0x <+30>: movl $0x17,-0x10(%ebp) 0x <+37>: jmp 0x <main+46> 0x <+39>: movl $0x2a,-0x10(%ebp) 0x <+46>: sub $0xc,%esp 0x c <+49>: push $0x0 0x e <+51>: call 0x80482e0 <exit@plt> End of assembler dump.

21 21 / 32 if-else-konstrukt PAP für den Assemblerquelltext Start b=1 no b = 42? yes a=42 a=23 exit(0) Stop

22 22 / 32 Schleifen for-konstrukt Listing 3: loop1.c #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int c; for(c=0; c<23; c++) { printf("%d\n", c); } exit(0); }

23 23 / 32 Schleifen for-konstrukt Listing 4: Disassemblat zu loop1.c (gdb) disas main Dump of assembler code for function main: 0x b <+0>: lea 0x4(%esp),%ecx 0x f <+4>: and $0xfffffff0,%esp 0x <+7>: pushl -0x4(%ecx) 0x <+10>: push %ebp 0x <+11>: mov %esp,%ebp 0x <+13>: push %ecx 0x <+14>: sub $0x14,%esp 0x c <+17>: movl $0x0,-0xc(%ebp) 0x <+24>: jmp 0x804845c <main+49> 0x <+26>: sub $0x8,%esp 0x <+29>: pushl -0xc(%ebp) 0x b <+32>: push $0x x <+37>: call 0x80482f0 <printf@plt> 0x <+42>: add $0x10,%esp 0x <+45>: addl $0x1,-0xc(%ebp) 0x c <+49>: cmpl $0x16,-0xc(%ebp) 0x <+53>: jle 0x <main+26> 0x <+55>: sub $0xc,%esp 0x <+58>: push $0x0 0x <+60>: call 0x <exit@plt>

24 24 / 32 for-konstrukt PAP für den Assemblerquelltext Start c=0 c 22? no yes printf("%d\n",c); exit(0) c++ Stop

25 25 / 32 Schleifen Nutzung von goto Listing 5: loop2.c #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int c; c = 0; label: printf("%d\n", c); c++; if (c<23) goto label; exit(0); } es resultiert gleiches Assemblat

26 26 / 32 Funktionsaufrufe Beispiel Listing 6: mul.c #include <stdio.h> #include <stdlib.h> int mul(int x, int y) { int res; res = x * y; return res; } int main(int argc, char* argv[]) { int a=23, b=42, erg; erg = mul(a, b); printf("ergebnis: %d\n", erg); exit(0); }

27 Funktionsaufrufe Listing 7: Disassemblat zu mul.c (gdb) disas main... 0x b <+11>: mov %esp,%ebp ; neuer Stackframe 0x d <+13>: push %ecx 0x e <+14>: sub $0x14,%esp ; Platz fuer lokale Variablen 0x <+17>: movl $0x17,-0xc(%ebp) ; a=23 0x <+24>: movl $0x2a,-0x10(%ebp) ; b=42 0x f <+31>: pushl -0x10(%ebp) ; push b 0x <+34>: pushl -0xc(%ebp) ; push a 0x <+37>: call 0x804842b <mul> 0x a <+42>: add $0x8,%esp ; Parameter vom Stack 0x d <+45>: mov %eax,-0x14(%ebp) ; erg=mul(a,b); 0x <+48>: sub $0x8,%esp 0x <+51>: pushl -0x14(%ebp) ; push erg 0x <+54>: push $0x ; push &"Ergebnis: %d\n" 0x b <+59>: call 0x80482f0 <printf@plt> 0x <+64>: add $0x10,%esp ; Parameter vom Stack 0x <+67>: sub $0xc,%esp 0x <+70>: push $0x0 ; push 0 0x <+72>: call 0x <exit@plt> ; exit(0) (gdb) disas mul 0x b <+0>: push %ebp ; akt. Stackframe sichern 0x c <+1>: mov %esp,%ebp ; neuer Stackframe 0x e <+3>: sub $0x10,%esp ; Platz fuer lokale Variablen 0x <+6>: mov 0x8(%ebp),%eax ; eax:=a (Parameter) 0x <+9>: imul 0xc(%ebp),%eax ; eax:=a*b 0x <+13>: mov %eax,-0x4(%ebp) ; result=a*b 0x b <+16>: mov -0x4(%ebp),%eax ; Resultat in eax 0x e <+19>: leave ; esp:=ebp; pop ebp 0x f <+20>: ret ; pop eip 27 / 32

28 28 / 32 Funktionsaufrufe Parameter- und Ergebniskommunikation Funktionsparameter per Stack übergeben (Parameterliste wird von rechts nach links auf den Stack gepusht ) Parameter-Bereich wird auf Vielfaches von 16 Byte aufgefüllt Resultat einer Funktion in Register EAX geliefert rufende Instanz räumt Parameter nach Rückkehr vom Stack (Caller Cleanup) CDECL-Konvention genutzt

29 29 / 32 Funktionsaufrufe Struktur Struktur einer Funktion 1. Prolog: aktuellen Framepointer auf Stack sichern (push %ebp) neuen Framepointer setzen (mov %esp,%ebp) Platz für lokale Variablen schaffen (sub imm16,%esp) 2. Funktionskörper 3. Epilog aktuellen Frame zerstören (mov %ebp,%esp) gesicherten Framepointer restaurieren (pop %ebp) beides zusammen ist die leave-instruktion Fortsetzung an auf Funktionsaufruf folgender Adresse (pop eip aka ret)

30 30 / 32 Systemrufe Wiederholung BS1: Systemrufe sind Dienste, die das Betriebssystem mitbringt werden im Adressraum des Kernels erbracht (Umschaltung Usermode Kernelmode nötig) können daher nicht durch Call-Return-Mechanismus erbracht werden stattdessen: Nutzung eines Interrupts oder sysenterund sysleave-instruktionen Beispiele: fork(), open(), read(), socket() usw.

31 31 / 32 Aufrufkonvention Systemruf Linux (32Bit) Systemrufnummer in eax Argumente in ebx, ecx, edx, esi, edi, ebp (in dieser Reihenfolge) Systemeintritt durch int 0x80 (Systemdienst wird im Kernelmode ausgeführt) Resultatwert in eax Systemaustritt mittels iret Systemrufnummern:

32 32 / 32 Systemrufe Beispiel Listing 8: helloasm.text.global _start _start: movl $0, %eax xorl %ebx, %ebx xorl %edx, %edx jmp string /* push string addr */ code: pop %ecx /* ecx <-- string addr */ movb $01, %bl /* filedesc, stdout */ movb $15, %dl /* string lgth */ movb $04, %al /* write(stdout, addr, lgth) */ int $0x80 decb %bl movb $01,%al /* exit(0) */ int $0x80 string: call code.ascii "Hello, world!\x0a\x00"