CSCE 548 Building Secure Software Buffer Overflow. Professor Lisa Luo Spring 2018

Transcription

1 CSCE 548 Building Secure Software Buffer Overflow Professor Lisa Luo Spring 2018

2 Previous Class Virus vs. Worm vs. Trojan & Drive-by download Botnet & Rootkit Malware detection Scanner Polymorphic malware Metamorphic malware Real time monitor Anti-debugger detection 2

3 Trojan vs. Virus vs. Worm Trojan Virus Worm Self-replicated N Y Y Self-contained Y N Y Relying on exploitation of vulnerabilities N Maybe (e.g., scripting viruses) Y 3

4 Previous Class Describe the main components in a classic botnet structure (1) Botmaster (2) Command & Control (C&C) Servers (3) Bots 4

5 Buffer Overflow Also called Buffer Overrun It occurs when the access to a buffer is out of the bounds of the buffer, e.g. char dst[5]; strcpy(dst, some user provided input ); 5

6 Common and dangerous E.g., strcpy(buffer, long-src-str); 6

7 Types of buffer overflows Direction Access beyond upper bound: overflow Access beyond lower bound: underflow People usually call both as Buffer Overflows The out-of-bound access can be read or write Overread (leak info) Overwrite (manipulate memory content) The access can occur on stack or heap (or data) Stack-based / heap-based buffer overflows 7

8 Improving Software Security with Monitoring, Automated Diagnosis, and Self-shielding 8 If buffer overflow vulnerabilities could be effectively eliminated, a very large portion of the most serious security threats would also be eliminated. C. Cowan 8

9 Improving Software Security with Monitoring, Automated Diagnosis, and Self-shielding 9 If buffer overflow vulnerabilities could be effectively eliminated, a very large portion of the most serious security threats would also be eliminated. C. Cowan It is now safe to declare the buffer overflow the vulnerability of the quarter-century. Y. Younan 9

10 Background representation of C string H e l l o \0 In C/C++ programming strlen( Hello ) returns 5 The space needed by Hello is 6 Each string needs a \0 to flag the ending Q: What problems will occur? memcpy(dst, src, strlen(src)) Bug 1: buffer overflow when dst is too small Bug 2: the ending \0 is not copied 10

11 Background - Calling a procedure Given this C program: void main() { f(1,2,3); exit(0); } The invocation of f() generates code (parameters are pushed from right to left): pushl $3 ; // constant 3 pushl $2 ; pushl $1 call f // push the return address on stack and jump to f() 11

12 Background: Stack Lower-numbered addresses Higher-numbered addresses 3 Stack pointer (SP) (current top of stack) 12

13 Background: Stack Lower-numbered addresses Higher-numbered addresses 2 Stack pointer (SP) (current top of stack) 3 Stack grows, e.g., due to procedure call 13

14 Background: Stack Lower-numbered addresses Higher-numbered addresses 1 2 Stack pointer (SP) (current top of stack) 3 Stack grows, e.g., due to procedure call 14

15 Background: Stack Lower-numbered addresses Return address in main() Stack pointer (SP) (current top of stack) Higher-numbered addresses Stack grows, e.g., due to procedure call 15

16 Background: Function prologue Imagine f() has local variables, e.g. in C: void f(int a, int b, int c) { char buffer1[5]; char buffer2[10]; strcpy(buffer2, "This is a very long string!!!!!!!"); } 16

17 After prologue Lower-numbered addresses Local array buffer2 Stack pointer (SP) (current top of stack) Local array buffer1 Saved (old) frame pointer Return address in main() Frame pointer (FP) use this to access local variables & parameters Higher-numbered addresses Stack grows, e.g., due to procedure call 17

18 Overflowing buffer2 Lower-numbered addresses strcpy(buffer2, "This is a very long string!!!!!!!"); Local array buffer2 Stack pointer (SP) (current top of stack) Local array buffer1 Overwrite Saved (old) frame pointer Return address in main() Frame pointer (FP) use this to access local variables & parameters Higher-numbered addresses Stack grows, e.g., due to procedure call 18

19 What happens if we write past the end of buffer2? Overwrites whatever is past buffer2! As you go further, overwrite higher addresses Impact depends on system details In our example, can overwrite: Local values (buffer1) Saved frame pointer Return value (changing what we return to) Parameters to function Previous frames 19

20 Inserting code in the buffer overflow attack (e.g., shell code) Attacker can also include machine code that they want us to run If setting the return value to point to this malicious code, the victim will run that code on return Significant portion of the famous Smashing the Stack paper describes how to insert such code 20

21 Stack: One possible result after attack Lower-numbered addresses Malicious code Local array buffer2 Stack pointer (SP) (current top of stack) Higher-numbered addresses Local array buffer1 Saved (old) frame pointer Return Ptrto address malicious in main() code 1 2 Frame pointer (FP) use this to access local variables & parameters 3 Stack grows, e.g., due to procedure call 21

22 Other types of attacks possible with a stack buffer overflow Make return point to existing code that the attacker wants us to run now E.g., Return to libc Change value of adjacent local variables, e.g., a function pointer or a critical bool variable Change value of parameters... and so on 22

23 Obvious solution in C Obvious solution when using C is to always check bounds E.g., if (strlen(src) + 1 > dst_buffer_size) return error; However Programmers do not necessarily do that 23

24 Many C functions don t check bounds gets() reads input without checking. Don t use it! strcpy() strcpy(dest, src) copies from src to dest If src longer than dest buffer, keeps writing! strcat() strcat(dest, src) appends src to dest If src + data in dest longer than dest buffer, keeps writing! scanf() family of input functions e.g., scanf( %s, buf); scanf(), fscanf(), sscanf(), vscanf(), vsscanf(), vfscanf() Many options don t control max length (e.g., bare %s ) It s not just functions; ordinary loops can overflow Q: Whether strncpy(dst, src, n) is secure? 24

25 Do not use strncpy() First thing first, do not use strncpy(dst, src, n) Very weird behaviors If src is too long (strlen(src) >= n): copy the first n characters of src to dst (so the ending null is not copied) If src is short (strlen(src) < n): any extra space will be padded with 0 s (so inefficient) 25

26 Solution 1: strlcpy -- OpenBSD only strlcpy (dst, src, dst_size): size-bounded string copy strlcpy truncates src to fit in the destination buffer It Copies up to (dst_size 1) characters from src to dst The ending null is guaranteed It does not use \0 to fill the extra dst space Easy to detect if terminates in the middle => Returns bytes would have been written strlcpy(dst, src, dst_size) >= dst_size // truncation detected! 26

27 Solution 2: Best solution snprintf int snprintf(char *dst, size_t n, const char * format, char * src); Writes src to buffer dst up to n bytes Always writes \0 at end if n>=1 Returns length that would have been written (excluding the ending null) if n is large enough or negative if error, so result-checking can be slightly annoying Sample: len = snprintf(dst, n, "%s", src); if (len < 0 len >= n) // handle error/truncation If src is too long (strlen(src) >= n), only the (n-1) characters of src will be copied to dst, then an ending null will be attached; that is, truncation occurs. If src is short (strlen(src) < n), src (including the ending null) will be copied 27

28 Question Write the equivalent code of n = strlcpy(dst, src, len); n = snprintf(dst, len, "%s, src); 28

29 Solution 3: C++ std::string class (resize) If using C++, avoid using char* strings Instead, use std::string class Automatically resizes Avoids buffer overflow E.g., str1 = str2; str1.append(str2); 29

30 The System Has Done the Following Canary Insert a secret value (cookie) between the return address and the buffer on the stack at call entry, and check the canary integrity at the call exit If the canary is corrupted, a buffer overflow is detected Very effective against stack based overflows DEP: Data Execution Prevention Data on stack and heap cannot be executed Prevent injected code from being executed ASLR: Address Space Layout Randomization Scramble the locations of libraries and executables So attackers do not know how to reuse their code 30

31 The Compiler Can Do the Following Enabled by default in may systems, such as Ubuntu -fstack-protector --param=ssp-buffer-size=4 Any function that has a buffer whose size >=4 will be protected with canary checking -D_FORTIFY_SOURCE=2 Add overflow compile-time/runtime checking for strcpy/memcpy Needs O1 to take effect; -O2 is preferred To disable the protection above (very bad; but sometimes you may want to be crazy) -fno-stack-protector -D_FORTIFY_SOURCE=0 31

32 Question Compare strcpy, strncpy, and snprintf (1) strcpy(dst, src): regardless of the size of the dst buffer, copy the src (including the ending null) to dst (2) strncpy(dst, src, n): copy at most n characters from src to dst (the ending null is not guaranteed); extra space will be padded with 0 s (so inefficient) (3) snprintf(dst, n, "%s", src): copy at most n-1 characters from src to dst and the ending null is guaranteed 32

33 Question What concrete attacks can be launched by exploiting a buffer overflow vulnerability? List at least four. 1. Stack buffer overflow can conveniently overwrites the return address on the stack to hijack the control flow 2. Stack buffer overflow can overwrite local variables 3. Heap buffer overflow can modify buffers adjacent to the vulnerable buffer 4. A sub-object buffer overflow can modify the adjacent fields of the containing object * Thanks to some compilation option, 1 and 2 have been largely mitigated 33

34 Recap Buffer overflows can be devastating C/C++/Objective-C vulnerable to them Most other languages not natively vulnerable But many components/languages are in C/C++ The system has done a lot for us (but it is insufficient) Canary DEP (Data Execution Prevention) ASLR (Address Space Layout Randomization) What you should do Always enforce bounds checking in your code Use snprintf/strlcpy/strlcat in your code Do not use strncpy 34