Machine-Level Programming III: Procedures Topics IA32 stack discipline Register saving conventions Creating pointers to local variables class07.ppt

– 2 – , F’02 IA32/Linux Stack Frame Current Stack Frame (“Top” to Bottom) Parameters for function about to call “Argument build” Local variables If can’t keep in registers Saved register context Old frame pointer Caller Stack Frame Return address Pushed by call instruction Arguments for this call Stack Pointer ( %esp ) Frame Pointer ( %ebp ) Return Addr Saved Registers + Local Variables Argument Build Old %ebp Arguments Caller Frame

– 3 – , F’02 Pointer Code void s_helper (int x, int *accum) { if (x <= 1) return; else { int z = *accum * x; *accum = z; s_helper (x-1,accum); } int sfact(int x) { int val = 1; s_helper(x, &val); return val; } Top-Level Call Recursive Procedure Pass pointer to update location

– 4 – , F’02 Temp. Space %esp Creating & Initializing Pointer int sfact(int x) { int val = 1; s_helper(x, &val); return val; } _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1 Using Stack for Local Variable Variable val must be stored on stack Need to create pointer to it Compute pointer as - 4(%ebp) Push on stack as second argument Initial part of sfact x Rtn adr Old %ebp %ebp val = 1 Unused _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1 _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1 _sfact: pushl %ebp# Save %ebp movl %esp,%ebp# Set %ebp subl $16,%esp# Add 16 bytes movl 8(%ebp),%edx# edx = x movl $1,-4(%ebp)# val = 1

– 5 – , F’02 Passing Pointer int sfact(int x) { int val = 1; s_helper(x, &val); return val; } leal -4(%ebp),%eax# Compute &val pushl %eax# Push on stack pushl %edx# Push x call s_helper# call movl -4(%ebp),%eax# Return val # Finish Calling s_helper from sfact x Rtn adr Old %ebp %ebp val = 1 -4 Unused %esp x &val Stack at time of call leal -4(%ebp),%eax# Compute &val pushl %eax# Push on stack pushl %edx# Push x call s_helper# call movl -4(%ebp),%eax# Return val # Finish leal -4(%ebp),%eax# Compute &val pushl %eax# Push on stack pushl %edx# Push x call s_helper# call movl -4(%ebp),%eax# Return val # Finish val =x!

– 6 – , F’02 Using Pointer movl %ecx,%eax# z = x imull (%edx),%eax# z *= *accum movl %eax,(%edx)# *accum = z void s_helper (int x, int *accum) { int z = *accum * x; *accum = z; } Register %ecx holds x Register %edx holds pointer to accum Use access (%edx) to reference memory %edx accum x x %eax %ecx accum*x

– 7 – , F’02 Summary The Stack Makes Recursion Work Private storage for each instance of procedure call Instantiations don’t clobber each other Addressing of locals + arguments can be relative to stack positions Can be managed by stack discipline Procedures return in inverse order of calls IA32 Procedures Combination of Instructions + Conventions Call / Ret instructions Register usage conventions Caller / Callee save %ebp and %esp Stack frame organization conventions

– 8 – , F’02 Basic Data Types Integral Stored & operated on in general registers Signed vs. unsigned depends on instructions used IntelGASBytesC byte b 1[ unsigned ] char word w 2[ unsigned ] short double word l 4[ unsigned ] int Floating Point Stored & operated on in floating point registers IntelGASBytesC Single s 4 float Double l 8 double Extended t 10/12 long double

– 9 – , F’02 Array Allocation Basic Principle T A[ L ]; Array of data type T and length L Contiguously allocated region of L * sizeof( T ) bytes char string[12]; xx + 12 int val[5]; x x + 4x + 8x + 12x + 16x + 20 double a[4]; x + 32 x + 24 x x + 8x + 16 char *p[3]; x x + 4x + 8

– 10 – , F’02 Array Access Basic Principle T A[ L ]; Array of data type T and length L Identifier A can be used as a pointer to array element 0 ReferenceTypeValue val[4]int3 valint * x val+1int * x + 4 &val[2]int * x + 8 val[5]int ?? *(val+1)int5 val + i int * x + 4 i int val[5]; x x + 4x + 8x + 12x + 16x + 20

– 11 – , F’02 Array Example Notes Declaration “ zip_dig cmu ” equivalent to “ int cmu[5] ” Example arrays were allocated in successive 20 byte blocks Not guaranteed to happen in general typedef int zip_dig[5]; zip_dig cmu = { 1, 5, 2, 1, 3 }; zip_dig mit = { 0, 2, 1, 3, 9 }; zip_dig ucb = { 9, 4, 7, 2, 0 }; zip_dig cmu; zip_dig mit; zip_dig ucb;

– 12 – , F’02 Array Accessing Example Memory Reference Code int get_digit (zip_dig z, int dig) { return z[dig]; } # %edx = z # %eax = dig movl (%edx,%eax,4),%eax # z[dig] Computation Register %edx contains starting address of array Register %eax contains array index Desired digit at 4*%eax + %edx Use memory reference (%edx,%eax,4)

– 13 – , F’02 Referencing Examples Code Does Not Do Any Bounds Checking! ReferenceAddressValueGuaranteed? mit[3]36 + 4* 3 = 483 mit[5]36 + 4* 5 = 569 mit[-1]36 + 4*-1 = 323 cmu[15]16 + 4*15 = 76?? Out of range behavior implementation-dependent No guaranteed relative allocation of different arrays zip_dig cmu; zip_dig mit; zip_dig ucb; Yes No No No

– 14 – , F’02 int zd2int(zip_dig z) { int i; int zi = 0; for (i = 0; i < 5; i++) { zi = 10 * zi + z[i]; } return zi; } Array Loop Example Original Source int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } Transformed Version As generated by GCC Eliminate loop variable i Convert array code to pointer code Express in do-while form No need to test at entrance

– 15 – , F’02 # %ecx = z xorl %eax,%eax# zi = 0 leal 16(%ecx),%ebx# zend = z+4.L59: leal (%eax,%eax,4),%edx# 5*zi movl (%ecx),%eax# *z addl $4,%ecx# z++ leal (%eax,%edx,2),%eax# zi = *z + 2*(5*zi) cmpl %ebx,%ecx# z : zend jle.L59# if <= goto loop Array Loop Implementation Registers %ecxz %eaxzi %ebxzendComputations 10*zi + *z implemented as *z + 2*(zi+4*zi) z++ increments by 4 int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } # %ecx = z xorl %eax,%eax# zi = 0 leal 16(%ecx),%ebx# zend = z+4.L59: leal (%eax,%eax,4),%edx# 5*zi movl (%ecx),%eax# *z addl $4,%ecx# z++ leal (%eax,%edx,2),%eax# zi = *z + 2*(5*zi) cmpl %ebx,%ecx# z : zend jle.L59# if <= goto loop int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } # %ecx = z xorl %eax,%eax# zi = 0 leal 16(%ecx),%ebx# zend = z+4.L59: leal (%eax,%eax,4),%edx# 5*zi movl (%ecx),%eax# *z addl $4,%ecx# z++ leal (%eax,%edx,2),%eax# zi = *z + 2*(5*zi) cmpl %ebx,%ecx# z : zend jle.L59# if <= goto loop int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } # %ecx = z xorl %eax,%eax# zi = 0 leal 16(%ecx),%ebx# zend = z+4.L59: leal (%eax,%eax,4),%edx# 5*zi movl (%ecx),%eax# *z addl $4,%ecx# z++ leal (%eax,%edx,2),%eax# zi = *z + 2*(5*zi) cmpl %ebx,%ecx# z : zend jle.L59# if <= goto loop int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; } # %ecx = z xorl %eax,%eax# zi = 0 leal 16(%ecx),%ebx# zend = z+4.L59: leal (%eax,%eax,4),%edx# 5*zi movl (%ecx),%eax# *z addl $4,%ecx# z++ leal (%eax,%edx,2),%eax# zi = *z + 2*(5*zi) cmpl %ebx,%ecx# z : zend jle.L59# if <= goto loop int zd2int(zip_dig z) { int zi = 0; int *zend = z + 4; do { zi = 10 * zi + *z; z++; } while(z <= zend); return zi; }

– 16 – , F’02 Nested Array Example Declaration “ zip_dig pgh[4] ” equivalent to “ int pgh[4][5] ” Variable pgh denotes array of 4 elements »Allocated contiguously Each element is an array of 5 int ’s »Allocated contiguously “Row-Major” ordering of all elements guaranteed #define PCOUNT 4 zip_dig pgh[PCOUNT] = {{1, 5, 2, 0, 6}, {1, 5, 2, 1, 3 }, {1, 5, 2, 1, 7 }, {1, 5, 2, 2, 1 }}; zip_dig pgh[4];

– 17 – , F’02 Nested Array Allocation Declaration T A[ R ][ C ]; Array of data type T R rows, C columns Type T element requires K bytes Array Size R * C * K bytesArrangement Row-Major Ordering A[0][0]A[0][C-1] A[R-1][0] A[R-1][C-1] int A[R][C]; A [0] A [0] [C-1] A [1] [0] A [1] [C-1] A [R-1] [0] A [R-1] [C-1] 4*R*C Bytes

– 18 – , F’02 Nested Array Row Access Row Vectors A[i] is array of C elements Each element of type T Starting address A + i * C * K A [i] [0] A [i] [C-1] A[i] A [R-1] [0] A [R-1] [C-1] A[R-1] A A [0] A [0] [C-1] A[0] int A[R][C]; A+i*C*4A+(R-1)*C*4

– 19 – , F’02 struct rec { int i; int a[3]; int *p; }; Assembly # %eax = val # %edx = r movl %eax,(%edx)# Mem[r] = val void set_i(struct rec *r, int val) { r->i = val; } Structures Concept Contiguously-allocated region of memory Refer to members within structure by names Members may be of different types Accessing Structure Member Memory Layout iap

– 20 – , F’02 struct rec { int i; int a[3]; int *p; }; # %ecx = idx # %edx = r leal 0(,%ecx,4),%eax# 4*idx leal 4(%eax,%edx),%eax# r+4*idx+4 int * find_a (struct rec *r, int idx) { return &r->a[idx]; } Generating Pointer to Struct. Member Generating Pointer to Array Element Offset of each structure member determined at compile time iap 0416 r *idx r

– 21 – , F’02 struct rec { int i; int a[3]; int *p; }; # %edx = r movl (%edx),%ecx# r->i leal 0(,%ecx,4),%eax# 4*(r->i) leal 4(%edx,%eax),%eax# r+4+4*(r->i) movl %eax,16(%edx)# Update r->p void set_p(struct rec *r) { r->p = &r->a[r->i]; } Structure Referencing (Cont.) C Code ia 0416 Element i iap 0416

– 22 – , F’02 Alignment Aligned Data Primitive data type requires K bytes Address must be multiple of K Required on some machines; advised on IA32 treated differently by Linux and Windows! Motivation for Aligning Data Memory accessed by (aligned) double or quad-words Inefficient to load or store datum that spans quad word boundaries Virtual memory very tricky when datum spans 2 pagesCompiler Inserts gaps in structure to ensure correct alignment of fields

– 23 – , F’02 Specific Cases of Alignment Size of Primitive Data Type: 1 byte (e.g., char) no restrictions on address 2 bytes (e.g., short ) lowest 1 bit of address must be bytes (e.g., int, float, char *, etc.) lowest 2 bits of address must be bytes (e.g., double ) Windows (and most other OS’s & instruction sets): »lowest 3 bits of address must be Linux: »lowest 2 bits of address must be 00 2 »i.e., treated the same as a 4-byte primitive data type 12 bytes ( long double ) Linux: »lowest 2 bits of address must be 00 2 »i.e., treated the same as a 4-byte primitive data type

– 24 – , F’02 struct S1 { char c; int i[2]; double v; } *p; Satisfying Alignment with Structures Offsets Within Structure Must satisfy element’s alignment requirement Overall Structure Placement Each structure has alignment requirement K Largest alignment of any element Initial address & structure length must be multiples of K Example (under Windows): K = 8, due to double element ci[0]i[1]v p+0p+4p+8p+16p+24 Multiple of 4Multiple of 8

– 25 – , F’02 Linux vs. Windows Windows (including Cygwin): K = 8, due to double elementLinux: K = 4; double treated like a 4-byte data type struct S1 { char c; int i[2]; double v; } *p; ci[0]i[1]v p+0p+4p+8p+16p+24 Multiple of 4Multiple of 8 ci[0]i[1] p+0p+4p+8 Multiple of 4 v p+12p+20 Multiple of 4

– 26 – , F’02 Overall Alignment Requirement struct S2 { double x; int i[2]; char c; } *p; struct S3 { float x[2]; int i[2]; char c; } *p; p+0p+12p+8p+16 Windows : p+24 Linux : p+20 ci[0]i[1]xci[0]i[1] p+0p+12p+8p+16p+20 x[0]x[1] p+4 p must be multiple of: 8 for Windows 4 for Linux p must be multiple of 4 (in either OS)

– 27 – , F’02 Ordering Elements Within Structure struct S4 { char c1; double v; char c2; int i; } *p; struct S5 { double v; char c1; char c2; int i; } *p; c1iv p+0p+20p+8p+16p+24 c2c1iv p+0p+12p+8p+16 c2 10 bytes wasted space in Windows 2 bytes wasted space

– 28 – , F’02 Arrays of Structures Principle Allocated by repeating allocation for array type In general, may nest arrays & structures to arbitrary depth a[0] a+0 a[1]a[2] a+12a+24a+36 a+12a+20a+16a+24 struct S6 { short i; float v; short j; } a[10]; a[1].ia[1].ja[1].v

– 29 – , F’02 Accessing Element within Array Compute offset to start of structure Compute 12*i as 4*(i+2i) Access element according to its offset within structure Offset by 8 Assembler gives displacement as a + 8 »Linker must set actual value a[0] a+0 a[i] a+12i short get_j(int idx) { return a[idx].j; } # %eax = idx leal (%eax,%eax,2),%eax # 3*idx movswl a+8(,%eax,4),%eax a+12ia+12i+8 struct S6 { short i; float v; short j; } a[10]; a[i].ia[i].ja[i].v

– 30 – , F’02 Satisfying Alignment within Structure Achieving Alignment Starting address of structure array must be multiple of worst-case alignment for any element a must be multiple of 4 Offset of element within structure must be multiple of element’s alignment requirement v ’s offset of 4 is a multiple of 4 Overall size of structure must be multiple of worst-case alignment for any element Structure padded with unused space to be 12 bytes struct S6 { short i; float v; short j; } a[10]; a[0] a+0 a[i] a+12i a+12ia+12i+4 a[1].ia[1].ja[1].v Multiple of 4

– 31 – , F’02 Summary Arrays in C Contiguous allocation of memory Pointer to first element No bounds checking Compiler Optimizations Compiler often turns array code into pointer code ( zd2int ) Uses addressing modes to scale array indices Lots of tricks to improve array indexing in loopsStructures Allocate bytes in order declared Pad in middle and at end to satisfy alignmentUnions Overlay declarations Way to circumvent type system

– 32 – , F’02 Internet Worm and IM War November, 1988 Internet Worm attacks thousands of Internet hosts. How did it happen? July, 1999 Microsoft launches MSN Messenger (instant messaging system). Messenger clients can access popular AOL Instant Messaging Service (AIM) servers AIM server AIM client AIM client MSN client MSN server

– 33 – , F’02 Internet Worm and IM War (cont.) August 1999 Mysteriously, Messenger clients can no longer access AIM servers. Microsoft and AOL begin the IM war: AOL changes server to disallow Messenger clients Microsoft makes changes to clients to defeat AOL changes. At least 13 such skirmishes. How did it happen? The Internet Worm and AOL/Microsoft War were both based on stack buffer overflow exploits! many Unix functions do not check argument sizes. allows target buffers to overflow.

– 34 – , F’02 String Library Code Implementation of Unix function gets No way to specify limit on number of characters to read Similar problems with other Unix functions strcpy : Copies string of arbitrary length scanf, fscanf, sscanf, when given %s conversion specification /* Get string from stdin */ char *gets(char *dest) { int c = getc(); char *p = dest; while (c != EOF && c != '\n') { *p++ = c; c = getc(); } *p = '\0'; return dest; }

– 35 – , F’02 Vulnerable Buffer Code int main() { printf("Type a string:"); echo(); return 0; } /* Echo Line */ void echo() { char buf[4]; /* Way too small! */ gets(buf); puts(buf); }

– 36 – , F’02 Buffer Overflow Executions unix>./bufdemo Type a string: unix>./bufdemo Type a string:12345 Segmentation Fault unix>./bufdemo Type a string: Segmentation Fault

– 37 – , F’02 Buffer Overflow Stack echo: pushl %ebp# Save %ebp on stack movl %esp,%ebp subl $20,%esp# Allocate space on stack pushl %ebx# Save %ebx addl $-12,%esp# Allocate space on stack leal -4(%ebp),%ebx# Compute buf as %ebp-4 pushl %ebx# Push buf on stack call gets# Call gets... /* Echo Line */ void echo() { char buf[4]; /* Way too small! */ gets(buf); puts(buf); } Return Address Saved %ebp [3][2][1][0] buf %ebp Stack Frame for main Stack Frame for echo

– 38 – , F’02 Buffer Overflow Stack Example Before call to gets unix> gdb bufdemo (gdb) break echo Breakpoint 1 at 0x (gdb) run Breakpoint 1, 0x in echo () (gdb) print /x *(unsigned *)$ebp $1 = 0xbffff8f8 (gdb) print /x *((unsigned *)$ebp + 1) $3 = 0x804864d :call c d:mov 0xffffffe8(%ebp),%ebx # Return Point Return Address Saved %ebp [3][2][1][0] buf %ebp Stack Frame for main Stack Frame for echo 0xbffff8d8 Return Address Saved %ebp [3][2][1][0] buf Stack Frame for main Stack Frame for echo bffff d xx

– 39 – , F’02 Buffer Overflow Example #1 Before Call to gets Input = “123” No Problem 0xbffff8d8 Return Address Saved %ebp [3][2][1][0] buf Stack Frame for main Stack Frame for echo bffff d Return Address Saved %ebp [3][2][1][0] buf %ebp Stack Frame for main Stack Frame for echo

– 40 – , F’02 Buffer Overflow Stack Example #2 Input = “12345” :push %ebx :call 80483e4 # gets :mov 0xffffffe8(%ebp),%ebx b:mov %ebp,%esp d:pop %ebp# %ebp gets set to invalid value e:ret echo code: 0xbffff8d8 Return Address Saved %ebp [3][2][1][0] buf Stack Frame for main Stack Frame for echo bfff d Return Address Saved %ebp [3][2][1][0] buf %ebp Stack Frame for main Stack Frame for echo Saved value of %ebp set to 0xbfff0035 Bad news when later attempt to restore %ebp

– 41 – , F’02 Buffer Overflow Stack Example #3 Input = “ ” Return Address Saved %ebp [3][2][1][0] buf %ebp Stack Frame for main Stack Frame for echo :call c d:mov 0xffffffe8(%ebp),%ebx # Return Point 0xbffff8d8 Return Address Saved %ebp [3][2][1][0] buf Stack Frame for main Stack Frame for echo Invalid address No longer pointing to desired return point %ebp and return address corrupted

– 42 – , F’02 Malicious Use of Buffer Overflow Input string contains byte representation of executable code Overwrite return address with address of buffer When bar() executes ret, will jump to exploit code void bar() { char buf[64]; gets(buf);... } void foo(){ bar();... } Stack after call to gets() B return address A foo stack frame bar stack frame B exploit code pad data written by gets()

– 43 – , F’02 Exploits Based on Buffer Overflows Buffer overflow bugs allow remote machines to execute arbitrary code on victim machines. Internet worm Early versions of the finger server (fingerd) used gets() to read the argument sent by the client: finger Worm attacked fingerd server by sending phony argument: finger “exploit-code padding new-return-address” exploit code: executed a root shell on the victim machine with a direct TCP connection to the attacker.

– 44 – , F’02 Exploits Based on Buffer Overflows Buffer overflow bugs allow remote machines to execute arbitrary code on victim machines. IM War AOL exploited existing buffer overflow bug in AIM clients exploit code: returned 4-byte signature (the bytes at some location in the AIM client) to server. When Microsoft changed code to match signature, AOL changed signature location.

– 45 – , F’02 Date: Wed, 11 Aug :30: (PDT) From: Phil Bucking From: Phil Bucking Subject: AOL exploiting buffer overrun bug in their own software! To: Mr. Smith, I am writing you because I have discovered something that I think you might find interesting because you are an Internet security expert with experience in this area. I have also tried to contact AOL but received no response. I am a developer who has been working on a revolutionary new instant messaging client that should be released later this year.... It appears that the AIM client has a buffer overrun bug. By itself this might not be the end of the world, as MS surely has had its share. But AOL is now *exploiting their own buffer overrun bug* to help in its efforts to block MS Instant Messenger..... Since you have significant credibility with the press I hope that you can use this information to help inform people that behind AOL's friendly exterior they are nefariously compromising peoples' security. Sincerely, Phil Bucking Founder, Bucking Consulting It was later determined that this originated from within Microsoft!

– 46 – , F’02 Code Red Worm History June 18, Microsoft announces buffer overflow vulnerability in IIS Internet server July 19, over 250,000 machines infected by new virus in 9 hours White house must change its IP address. Pentagon shut down public WWW servers for day When We Set Up CS:APP Web Site Received strings of form GET /default.ida?NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN....NNNN NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN%u9090%u6858%ucbd3%u780 1%u9090%u6858%ucbd3%u7801%u9090%u6858%ucbd3%u7801%u9090%u909 0%u8190%u00c3%u0003%u8b00%u531b%u53ff%u0078%u0000%u00=a HTTP/1.0" "-" "-"

– 47 – , F’02 Code Red Exploit Code Starts 100 threads running Spread self Generate random IP addresses & send attack string Between 1st & 19th of month Attack Send 98,304 packets; sleep for 4-1/2 hours; repeat »Denial of service attack Between 21st & 27th of month Deface server’s home page After waiting 2 hours

– 48 – , F’02 Code Red Effects Later Version Even More Malicious Code Red II As of April, 2002, over 18,000 machines infected Still spreading Paved Way for NIMDA Variety of propagation methods One was to exploit vulnerabilities left behind by Code Red II

– 49 – , F’02 Avoiding Overflow Vulnerability Use Library Routines that Limit String Lengths fgets instead of gets strncpy instead of strcpy Don’t use scanf with %s conversion specification Use fgets to read the string /* Echo Line */ void echo() { char buf[4]; /* Way too small! */ fgets(buf, 4, stdin); puts(buf); }