1. – 1 – EECS213, S’08 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

2. – 2 – EECS213, S’08 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 0 2 4 bytes (e.g., int, float, char *, etc.) lowest 2 bits of address must be 00 2 8 bytes (e.g., double ) Windows (and most other OS’s & instruction sets): »lowest 3 bits of address must be 000 2 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

3. – 3 – EECS213, S’08 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

4. – 4 – EECS213, S’08 Linux vs. Windows Windows: 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

5. – 5 – EECS213, S’08 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)

6. – 6 – EECS213, S’08 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

7. – 7 – EECS213, S’08 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

8. – 8 – EECS213, S’08 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

9. – 9 – EECS213, S’08 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

10. – 10 – EECS213, S’08 Alignment Quiz For each struct, give the offset of each field, total size, and struct alignment (1, 2 or 4 byte) required in Linux. struct P1 {int i; char c; int j; char d; }; i: _1_ c: _2_ j: _3_ d: _4_ total: _5_ alignment: _6_ struct P2 {int i; char c; char d; int j; }; i: _7_ c: _8_ d: _9_ j: _10_ total: _11_ alignment: _12_ struct P3 {struct P1 a[2]; struct P2 *p; }; a: _13_ p: _14_ total: _15_ alignment: _16_

11. – 11 – EECS213, S’08 Union Allocation Principles Overlay union elements Allocate according to largest element Can only use one field at a time union U1 { char c; int i[2]; double v; } *up; c i[0]i[1] v up+0up+4up+8 struct S1 { char c; int i[2]; double v; } *sp; ci[0]i[1]v sp+0sp+4sp+8sp+16sp+24 (Windows alignment)

12. – 12 – EECS213, S’08 typedef union { float f; unsigned u; } bit_float_t; float bit2float(unsigned u) { bit_float_t arg; arg.u = u; return arg.f; } u f 04 unsigned float2bit(float f) { bit_float_t arg; arg.f = f; return arg.u; } Using Union to Access Bit Patterns Get direct access to bit representation of float bit2float generates float with given bit pattern NOT the same as (float) u float2bit generates bit pattern from float NOT the same as (unsigned) f

13. – 13 – EECS213, S’08 Byte Ordering Revisited Idea Short/long/quad words stored in memory as 2/4/8 consecutive bytes Which is most (least) significant? Can cause problems when exchanging binary data between machines Big Endian Most significant byte has lowest address PowerPC, Sparc Little Endian Least significant byte has lowest address Intel x86, Alpha

14. – 14 – EECS213, S’08 Byte Ordering Example union { unsigned char c[8]; unsigned short s[4]; unsigned int i[2]; unsigned long l[1]; } dw; c[3] s[1] i[0] c[2]c[1] s[0] c[0]c[7] s[3] i[1] c[6]c[5] s[2] c[4] l[0]

15. – 15 – EECS213, S’08 Byte Ordering Example (Cont). int j; for (j = 0; j < 8; j++) dw.c[j] = 0xf0 + j; printf("Characters 0-7 == [0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x]\n", dw.c[0], dw.c[1], dw.c[2], dw.c[3], dw.c[4], dw.c[5], dw.c[6], dw.c[7]); printf("Shorts 0-3 == [0x%x,0x%x,0x%x,0x%x]\n", dw.s[0], dw.s[1], dw.s[2], dw.s[3]); printf("Ints 0-1 == [0x%x,0x%x]\n", dw.i[0], dw.i[1]); printf("Long 0 == [0x%lx]\n", dw.l[0]);

16. – 16 – EECS213, S’08 Byte Ordering on x86 least significant byte has lowest address Little Endian ( least significant byte has lowest address ) Characters 0-7 == [0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7] Shorts 0-3 == [0xf1f0,0xf3f2,0xf5f4,0xf7f6] Ints 0-1 == [0xf3f2f1f0,0xf7f6f5f4] Long 0 == [f3f2f1f0] Output on Pentium: f0f1f2f3f4f5f6f7 c[3] s[1] i[0] LSBMSB c[2]c[1] s[0] c[0] LSBMSB LSBMSB c[7] s[3] i[1] LSBMSB c[6]c[5] s[2] c[4] LSBMSB LSBMSB Print l[0] LSBMSB

17. – 17 – EECS213, S’08 Byte Ordering on Sun most significant byte has lowest address Big Endian ( most significant byte has lowest address ) Characters 0-7 == [0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7] Shorts 0-3 == [0xf0f1,0xf2f3,0xf4f5,0xf6f7] Ints 0-1 == [0xf0f1f2f3,0xf4f5f6f7] Long 0 == [0xf0f1f2f3] Output on Sun: c[3] s[1] i[0] LSBMSB c[2]c[1] s[0] c[0] MSBLSB MSB c[7] s[3] i[1] LSBMSB c[6]c[5] s[2] c[4] MSBLSB MSB f0f1f2f3f4f5f6f7 Print l[0] MSBLSB

18. – 18 – EECS213, S’08 Byte Ordering on Alpha Little Endian Characters 0-7 == [0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7] Shorts 0-3 == [0xf1f0,0xf3f2,0xf5f4,0xf7f6] Ints 0-1 == [0xf3f2f1f0,0xf7f6f5f4] Long 0 == [0xf7f6f5f4f3f2f1f0] Output on Alpha: c[3] s[1] i[0] LSBMSB c[2]c[1] s[0] c[0] LSBMSB LSBMSB c[7] s[3] i[1] LSBMSB c[6]c[5] s[2] c[4] LSBMSB LSBMSB f0f1f2f3f4f5f6f7 Print l[0] LSBMSB

19. – 19 – EECS213, S’08 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

20. Machine-Level Programming V: Miscellaneous Topics Apr 28, 2008 Topics Buffer Overflow Floating Point Code EECS213

21. – 21 – EECS213, S’08 Internet Worm and IM War November, 1998 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

22. – 22 – EECS213, S’08 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.

23. – 23 – EECS213, S’08 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; }

24. – 24 – EECS213, S’08 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); }

25. – 25 – EECS213, S’08 Buffer Overflow Executions unix>./bufdemo Type a string:123 123 unix>./bufdemo Type a string:12345 Segmentation Fault unix>./bufdemo Type a string:12345678 Segmentation Fault

26. – 26 – EECS213, S’08 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

27. – 27 – EECS213, S’08 Buffer Overflow Stack Example Before call to gets unix> gdb bufdemo (gdb) break echo Breakpoint 1 at 0x8048583 (gdb) run Breakpoint 1, 0x8048583 in echo () (gdb) print /x *(unsigned *)$ebp $1 = 0xbffff8f8 (gdb) print /x *((unsigned *)$ebp + 1) $3 = 0x804864d 8048648:call 804857c 804864d: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 bffff8 0804864d xx

28. – 28 – EECS213, S’08 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 bffff8 0804864d 00333231 Return Address Saved %ebp [3][2][1][0] buf %ebp Stack Frame for main Stack Frame for echo

29. – 29 – EECS213, S’08 Buffer Overflow Stack Example #2 Input = “12345” 8048592:push %ebx 8048593:call 80483e4 # gets 8048598:mov 0xffffffe8(%ebp),%ebx 804859b:mov %ebp,%esp 804859d:pop %ebp# %ebp gets set to invalid value 804859e:ret echo code: 0xbffff8d8 Return Address Saved %ebp [3][2][1][0] buf Stack Frame for main Stack Frame for echo bfff0035 0804864d 34333231 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

30. – 30 – EECS213, S’08 Buffer Overflow Stack Example #3 Input = “12345678” Return Address Saved %ebp [3][2][1][0] buf %ebp Stack Frame for main Stack Frame for echo 8048648:call 804857c 804864d:mov 0xffffffe8(%ebp),%ebx # Return Point 0xbffff8d8 Return Address Saved %ebp [3][2][1][0] buf Stack Frame for main Stack Frame for echo 38373635 08048600 34333231 Invalid address No longer pointing to desired return point %ebp and return address corrupted

31. – 31 – EECS213, S’08 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()

32. – 32 – EECS213, S’08 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 droh@cs.cmu.edu 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.

33. – 33 – EECS213, S’08 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.

34. – 34 – EECS213, S’08 Date: Wed, 11 Aug 1999 11:30:57 -0700 (PDT) From: Phil Bucking From: Phil Bucking Subject: AOL exploiting buffer overrun bug in their own software! To: rms@pharlap.com 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 philbucking@yahoo.com It was later determined that this email originated from within Microsoft!

35. – 35 – EECS213, S’08 Code Red Worm History June 18, 2001. Microsoft announces buffer overflow vulnerability in IIS Internet server July 19, 2001. 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" 400 325 "-" "-"

36. – 36 – EECS213, S’08 Code Red Exploit Code Starts 100 threads running Spread self Generate random IP addresses & send attack string Between 1st & 19th of month Attack www.whitehouse.gov 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

37. – 37 – EECS213, S’08 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

38. – 38 – EECS213, S’08 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); }