Lecture 10 Return-oriented programming. Stephen Checkoway University of Illinois at Chicago Based on slides by Bailey, Brumley, and Miller

Transcription

1 Lecture 10 Return-oriented programming Stephen Checkoway University of Illinois at Chicago Based on slides by Bailey, Brumley, and Miller

2 ROP Overview Idea: We forge shellcode out of existing application logic gadgets Requirements: vulnerability + gadgets + some unrandomized code History: No code randomized: Code injection DEP enabled by default: ROP attacks using libc gadgets published 2007 ROP assemblers, compilers, shellcode generators ASLR library load points: ROP attacks use.text segment gadgets Today: all major OSes/compilers support position-independent executables 2

3 Image by Dino Dai Zovi 3

4 ROP Programming 1. Disassemble code (library or program) 2. Identify useful code sequences (usually ending in ) 3. Assemble the useful sequences into reusable gadgets* 4. Assemble gadgets into desired shellcode * Forming gadgets is mostly useful when constructing complicated urn-oriented shellcode by hand 4

5 A note on terminology When ROP was invented in 2007 Sequences of code ending in were the basic building blocks Multiple sequences and data are assembled into reusable gadgets Subsequently A gadget came to refer to any sequence of code ending in a In 2010 ROP without urns (e.g., code sequences ending in call or jmp)

6 There are many semantically equivalent ways to achieve the same net shellcode effect 6

7 Equivalence Mem[v2] = v1 Desired Logic v 2 v 1 Stack a 1 : mov eax, [] a 2 : mov ebx, [+8] a 3 : mov [ebx], eax Implementation 1 7

8 Constant store gadget Mem[v2] = v1 Desired Logic Suppose a 5 and a 3 on stack a 5 v 2 a 3 v 1 Stack eax ebx eip v 1 a 1 a 1 : pop eax; a 2 : a 3 : pop ebx; a 4 : a 5 : mov [ebx], eax Implementation 2 8

9 Constant store gadget Mem[v2] = v1 Desired Logic a 5 v 2 a 3 v 1 Stack eax ebx eip v 1 a 13 a 1 : pop eax; a 2 : a 3 : pop ebx; a 4 : a 5 : mov [ebx], eax Implementation 2 9

10 Constant store gadget Mem[v2] = v1 Desired Logic a 5 v 2 a 3 v 1 Stack eax ebx eip v 1 v 2 a 3 a 1 : pop eax; a 2 : a 3 : pop ebx; a 4 : a 5 : mov [ebx], eax Implementation 2 10

11 Constant store gadget Mem[v2] = v1 Desired Logic a 5 v 2 a 3 v 1 Stack eax ebx eip v 1 v 2 a 45 a 1 : pop eax; a 2 : a 3 : pop ebx; a 4 : a 5 : mov [ebx], eax Implementation 2 11

12 Constant store gadget Mem[v2] = v1 Desired Logic a 5 v 2 a 3 v 1 Stack eax ebx eip v 1 v 2 a 5 a 1 : pop eax; a 2 : a 3 : pop ebx; a 4 : a 5 : mov [ebx], eax Implementation 2 12

13 Equivalence Mem[v2] = v1 Desired Logic semantically equivalent a 3 v 2 a 2 v 1 Stack a 1 : mov eax, [] a 2 : mov ebx, [+8] a 3 : mov [ebx], eax Implementation 1 a 1 : pop eax; a 2 : pop ebx; a 3 : mov [ebx], eax Implementation 2 13

14 Return-Oriented Programming Mem[v2] = v1 Desired Shellcode Find needed instruction gadgets at esses a 1, a 2, and a 3 in existing code Overwrite stack to execute a 1, a 2, and then a 3 argv argc urn caller s ebp buf (64 bytes) argv[1] buf %ebp % 14

15 Return-Oriented Programming a 3 v 2 Mem[v2] = v1 Desired Shellcode argv a 2 argc v 1 urn a 1 caller s ebp %ebp a 1 : pop eax; a 2 : pop ebx; a 3 : mov [ebx], eax Desired store executed! buf (64 bytes) argv[1] buf % 15

16 What else can we do? Depends on the code we have access to Usually: Arbitrary Turing-complete behavior Arithmetic Logic Conditionals and loops Subroutines Calling existing functions System calls Sometimes: More limited behavior Often enough for straight-line code and system calls

17 Comparing ROP to normal programming Normal programming Instruction pointer eip No-op nop Unconditional jump jmp ess set to ess of gadget Conditional jump jnz ess set to ess of gadget if some condition is met Variables memory and registers mostly memory Inter-instruction (inter-gadget) register and memory interaction minimal, mostly explicit; e.g., adding two registers only affects the destination register ROP can be complex; e.g., adding two registers may involve modifying many registers which impacts other gadgets

18 Return-oriented conditionals Processors support instructions that conditionally change the PC On x86 Jcc family: jz, jnz, jl, jle, etc. 33 in total loop, loope, loopne Based on condition codes mostly; and on ecx for some On MIPS beq, bne, blez, etc. Based on comparison of registers Processors generally don t support for conditionally changing the stack pointer (with some exceptions)

19 We want conditional jumps Unconditional jump movl %eax, %

20 We want conditional jumps Unconditional jump movl %eax, %

21 We want conditional jump Unconditional jump movl %eax, %

22 We want conditional jump Unconditional jump movl %eax, % eax

23 We want conditional jumps Unconditional jump movl %eax, % eax

24 We want conditional jumps Unconditional jump movl %eax, % eax,

25 We want conditional jumps Unconditional jump movl %eax, % eax

26 We want conditional jumps Unconditional jump movl %eax, % Conditional jump, one way Conditionally set a register to 0 or 0xffffffff Perform a logical AND with the register and an Add the result to

27 Conditionally set a register to 0 or 0xffffffff Compare registers eax and ebx and set ecx to 0xffffffff if eax < ebx 0 if eax >= ebx Ideally we would find a sequence like set carry flag cf according to eax - ebx ecx ecx - ecx - cf; or ecx -cf Unlikely to find this; instead look for cmp; and sbb; sequences

28 Performing a logical AND with a constant Pop the constant into a register using pop; Use an and; sequence

29 Updating the stack pointer Use an add ; sequence

30 Putting it together Useful instruction sequences movl %eax, % Conditional jump gadget Load constant in edx gadget Unconditional jump gadget addl %eax, %

31 Putting it together eax 10 ecx 108 edx 17 movl %eax, % addl %eax, %

32 Putting it together eax 10 ecx 108 edx 17 movl %eax, % addl %eax, %

33 Putting it together movl %eax, % eax 10 ecx 108 edx 17 cf = 1 addl %eax, %

34 Putting it together movl %eax, % eax 10 ecx 108 edx 17 cf = 1 addl %eax, %

35 Putting it together movl %eax, % eax 10 ecx 0xffffffff edx 17 cf = 1 addl %eax, %

36 Putting it together movl %eax, % eax 10 ecx 0xffffffff edx 17 addl %eax, %

37 Putting it together eax 20 = ecx 0xffffffff edx 17 movl %eax, % addl %eax, %

38 Putting it together movl %eax, % eax 20 = ecx 0xffffffff edx 17 addl %eax, %

39 Putting it together movl %eax, % eax 20 = ecx 0xffffffff edx 17 addl %eax, %

40 Putting it together movl %eax, % eax 20 = ecx 0xffffffff edx 17 addl %eax, %

41 Putting it together eax 20 = ecx 0xffffffff edx 17 movl %eax, % addl %eax, %

42 Putting it together eax 20 = ecx 0xffffffff edx 17 movl %eax, % addl %eax, %

43 Putting it together eax 20 = ecx 0xffffffff edx movl %eax, % addl %eax, %

44 Putting it together eax 20 = ecx 0xffffffff edx movl %eax, % addl %eax, %

45 And again! eax 500 ecx 108 edx 17 movl %eax, % addl %eax, %

46 And again! eax 500 ecx 108 edx 17 movl %eax, % addl %eax, %

47 And again! eax 500 ecx 108 edx 17 cf = 0 movl %eax, % addl %eax, %

48 And again! eax 500 ecx 108 edx 17 cf = 0 movl %eax, % addl %eax, %

49 And again! eax 500 ecx 0 edx 17 movl %eax, % addl %eax, %

50 And again! movl %eax, % eax 500 ecx 0 edx 17 addl %eax, %

51 And again! eax 20 = ecx 0 edx 17 movl %eax, % addl %eax, %

52 And again! movl %eax, % eax 20 = ecx 0 edx 17 addl %eax, %

53 And again! movl %eax, % eax 0 ecx 0 edx 17 addl %eax, %

54 And again! movl %eax, % eax 0 ecx 0 edx 17 addl %eax, %

55 And again! movl %eax, % eax 0 ecx 0 edx 17 addl %eax, %

56 And again! movl %eax, % eax 0 ecx 0 edx 17 addl %eax, %

57 And again! movl %eax, % eax 0 ecx 0 edx addl %eax, %

58 And again! movl %eax, % eax 0 ecx 0 edx addl %eax, %

59 And again! eax ecx 0 edx movl %eax, % addl %eax, %

60 And again! eax ecx 0 edx movl %eax, % addl %eax, %

61 And again! movl %eax, % eax ecx 0 edx addl %eax, %

62 And again! movl %eax, % eax ecx 0 edx addl %eax, %

63 Compare eax 10 ecx 108 edx 17 eax 20 ecx 0xffffffff edx if (eax < ebx) edx = ; else edx = ; eax 500 ecx 108 edx 17 eax ecx 0 edx