Hacking- The Art of Exploitation (2nd ed. 2008) - Erickson.pdf

International Best-Seller! CD INside...

International Best-Seller! CD INside CD INside the fundamental techniques of Serious hacking 2nd Edition Hacking is the art of creative problem solving, j Outsmart common security measures like non- HACKING whether that means finding an unconventional executable stacks and intrusion detection systems solution to a difficult problem or exploiting holes in j Gain access to a remote server using port-binding 2nd Edition sloppy programming. Many people call themselves or connect-back shellcode, and alter a server’s log- hackers, but few have the strong technical founda- ging behavior to hide your presence tion needed to really push the envelope. j Redirect network traffic, conceal open ports, and Rather than merely showing how to run existing hijack TCP connections exploits, author Jon Erickson explains how arcane hacking techniques actually work. To share the art j Crack encrypted wireless traffic using the FMS Hacking and science of hacking in a way that is accessible attack, and speed up brute-force attacks using a to everyone, Hacking: The Art of Exploitation, 2nd password probability matrix Edition introduces the fundamentals of C program- Hackers are always pushing the boundaries, inves- ming from a hacker’s perspective. tigating the unknown, and evolving their art. Even The included LiveCD provides a complete Linux if you don’t already know how to program, Hacking: programming and debugging environment—all The Art of Exploitation, 2nd Edition will give you a without modifying your current operating system. complete picture of programming, machine archi- the art of exploitation Use it to follow along with the book’s examples as tecture, network communications, and existing you fill gaps in your knowledge and explore hack- hacking techniques. Combine this knowledge with ing techniques on your own. Get your hands dirty the included Linux environment, and all you need is debugging code, overflowing buffers, hijacking network communications, bypassing protections, exploiting cryptographic weaknesses, and perhaps your own creativity. about the author the art of exploitation even inventing new exploits. This book will teach Jon Erickson has a formal education in computer you how to: science and has been hacking and programming j Program computers using C, assembly language, since he was five years old. He speaks at com- and shell scripts puter security conferences and trains security teams around the world. Currently, he works as a j Corrupt system memory to run arbitrary code vulnerability researcher and security specialist in using buffer overflows and format strings Northern California. j Inspect processor registers and system memory with a debugger to gain a real understanding of jon erickson what is happening livecd provides a complete linux programming and debugging environment erickson T H E F I N E ST I N G E E K E N T E RTA I N M E N T ™ $49.95 ($54.95 cdn) w w w.nostarch.com shelve in : computer security/network security “I LAY FLAT.” This book uses RepKover—a durable binding that won’t snap shut. Printed on recycled paper  PRAISE FOR THE FIRST EDITION OF HACKING: THE ART OF EXPLOITATION “Most complete tutorial on hacking techniques. Finally a book that does not just show how to use the exploits but how to develop them.” —PHRACK “From all the books I’ve read so far, I would consider this the seminal hackers handbook.” —SECURITY FORUMS “I recommend this book for the programming section alone.” —UNIX REVIEW “I highly recommend this book. It is written by someone who knows of what he speaks, with usable code, tools and examples.” —IEEE CIPHER “Erickson’s book, a compact and no-nonsense guide for novice hackers, is filled with real code and hacking techniques and explanations of how they work.” —COMPUTER POWER USER (CPU) MAGAZINE “This is an excellent book. Those who are ready to move on to [the next level] should pick this book up and read it thoroughly.” —ABOUT.COM INTERNET/NETWORK SECURITY  ® San Francisco HACKING: THE ART OF EXPLOITATION, 2ND EDITION. Copyright © 2008 by Jon Erickson. All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher. Printed on recycled paper in the United States of America 11 10 09 08 07 123456789 ISBN-10: 1-59327-144-1 ISBN-13: 978-1-59327-144-2 Publisher: William Pollock Production Editors: Christina Samuell and Megan Dunchak Cover Design: Octopod Studios Developmental Editor: Tyler Ortman Technical Reviewer: Aaron Adams Copyeditors: Dmitry Kirsanov and Megan Dunchak Compositors: Christina Samuell and Kathleen Mish Proofreader: Jim Brook Indexer: Nancy Guenther For information on book distributors or translations, please contact No Starch Press, Inc. directly: No Starch Press, Inc. 555 De Haro Street, Suite 250, San Francisco, CA 94107 phone: 415.863.9900; fax: 415.863.9950; [email protected]; www.nostarch.com Librar y of Congress Cataloging-in-Publication Data Erickson, Jon, 1977- Hacking : the art of exploitation / Jon Erickson. -- 2nd ed. p. cm. ISBN-13: 978-1-59327-144-2 ISBN-10: 1-59327-144-1 1. Computer security. 2. Computer hackers. 3. Computer networks--Security measures. I. Title. QA76.9.A25E75 2008 005.8--dc22 2007042910 No Starch Press and the No Starch Press logo are registered trademarks of No Starch Press, Inc. Other product and company names mentioned herein may be the trademarks of their respective owners. Rather than use a trademark symbol with every occurrence of a trademarked name, we are using the names only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The information in this book is distributed on an “As Is” basis, without warranty. While every precaution has been taken in the preparation of this work, neither the author nor No Starch Press, Inc. shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in it.  BRIEF CONTENTS Preface......................................................................................................................... xi Acknowledgments......................................................................................................... xii 0x100 Introduction.......................................................................................................1 0x200 Programming.....................................................................................................5 0x300 Exploitation...................................................................................................115 0x400 Networking...................................................................................................195 0x500 Shellcode......................................................................................................281 0x600 Countermeasures............................................................................................319 0x700 Cryptology....................................................................................................393 0x800 Conclusion....................................................................................................451 Index.........................................................................................................................455  CONTENTS IN DETAIL P R E F A CE xi A CK N O W LE D G M E N T S xii 0x100 INTRODUCTION 1 0x200 PROGRAMMING 5 0x210 What Is Programming?................................................................................. 6 0x220 Pseudo-code................................................................................................ 7 0x230 Control Structures......................................................................................... 8 0x231 If-Then-Else...................................................................................... 8 0x232 While/Until Loops........................................................................... 9 0x233 For Loops..................................................................................... 10 0x240 More Fundamental Programming Concepts................................................... 11 0x241 Variables..................................................................................... 11 0x242 Arithmetic Operators..................................................................... 12 0x243 Comparison Operators.................................................................. 14 0x244 Functions...................................................................................... 16 0x250 Getting Your Hands Dirty............................................................................ 19 0x251 The Bigger Picture......................................................................... 20 0x252 The x86 Processor......................................................................... 23 0x253 Assembly Language....................................................................... 25 0x260 Back to Basics............................................................................................ 37 0x261 Strings......................................................................................... 38 0x262 Signed, Unsigned, Long, and Short................................................. 41 0x263 Pointers........................................................................................ 43 0x264 Format Strings............................................................................... 48 0x265 Typecasting.................................................................................. 51 0x266 Command-Line Arguments.............................................................. 58 0x267 Variable Scoping.......................................................................... 62 0x270 Memory Segmentation................................................................................ 69 0x271 Memory Segments in C.................................................................. 75 0x272 Using the Heap............................................................................. 77 0x273 Error-Checked malloc()................................................................... 80 0x280 Building on Basics...................................................................................... 81 0x281 File Access................................................................................... 81 0x282 File Permissions............................................................................. 87 0x283 User IDs....................................................................................... 88 0x284 Structs.......................................................................................... 96 0x285 Function Pointers......................................................................... 100 0x286 Pseudo-random Numbers............................................................. 101 0x287 A Game of Chance..................................................................... 102 0x300 E X PL O I T A T I O N 115 0x310 Generalized Exploit Techniques................................................................. 118 0x320 Buffer Overflows...................................................................................... 119 0x321 Stack-Based Buffer Overflow Vulnerabilities.................................... 122 0x330 Experimenting with BASH.......................................................................... 133 0x331 Using the Environment.................................................................. 142 0x340 Overflows in Other Segments.................................................................... 150 0x341 A Basic Heap-Based Overflow...................................................... 150 0x342 Overflowing Function Pointers....................................................... 156 0x350 Format Strings.......................................................................................... 167 0x351 Format Parameters....................................................................... 167 0x352 The Format String Vulnerability...................................................... 170 0x353 Reading from Arbitrary Memory Addresses.................................... 172 0x354 Writing to Arbitrary Memory Addresses......................................... 173 0x355 Direct Parameter Access............................................................... 180 0x356 Using Short Writes...................................................................... 182 0x357 Detours with.dtors....................................................................... 184 0x358 Another notesearch Vulnerability................................................... 189 0x359 Overwriting the Global Offset Table.............................................. 190 0x400 N E T W O RK IN G 195 0x410 OSI Model.............................................................................................. 196 0x420 Sockets................................................................................................... 198 0x421 Socket Functions.......................................................................... 199 0x422 Socket Addresses........................................................................ 200 0x423 Network Byte Order.................................................................... 202 0x424 Internet Address Conversion......................................................... 203 0x425 A Simple Server Example............................................................. 203 0x426 A Web Client Example................................................................ 207 0x427 A Tinyweb Server........................................................................ 213 0x430 Peeling Back the Lower Layers.................................................................... 217 0x431 Data-Link Layer............................................................................ 218 0x432 Network Layer............................................................................ 220 0x433 Transport Layer........................................................................... 221 0x440 Network Sniffing...................................................................................... 224 0x441 Raw Socket Sniffer....................................................................... 226 0x442 libpcap Sniffer............................................................................ 228 0x443 Decoding the Layers.................................................................... 230 0x444 Active Sniffing............................................................................. 239 0x450 Denial of Service...................................................................................... 251 0x451 SYN Flooding............................................................................. 252 0x452 The Ping of Death........................................................................ 256 0x453 Teardrop.................................................................................... 256 0x454 Ping Flooding............................................................................. 257 0x455 Amplification Attacks................................................................... 257 0x456 Distributed DoS Flooding.............................................................. 258 0x460 TCP/IP Hijacking...................................................................................... 258 0x461 RST Hijacking............................................................................. 259 0x462 Continued Hijacking.................................................................... 263 viii C on t en t s in D et ai l 0x470 Port Scanning.......................................................................................... 264 0x471 Stealth SYN Scan........................................................................ 264 0x472 FIN, X-mas, and Null Scans.......................................................... 264 0x473 Spoofing Decoys......................................................................... 265 0x474 Idle Scanning.............................................................................. 265 0x475 Proactive Defense (shroud)............................................................ 267 0x480 Reach Out and Hack Someone.................................................................. 272 0x481 Analysis with GDB....................................................................... 273 0x482 Almost Only Counts with Hand Grenades...................................... 275 0x483 Port-Binding Shellcode................................................................. 278 0x500 SH E L L CO D E 281 0x510 Assembly vs. C........................................................................................ 282 0x511 Linux System Calls in Assembly..................................................... 284 0x520 The Path to Shellcode................................................................................ 286 0x521 Assembly Instructions Using the Stack............................................ 287 0x522 Investigating with GDB................................................................. 289 0x523 Removing Null Bytes.................................................................... 290 0x530 Shell-Spawning Shellcode.......................................................................... 295 0x531 A Matter of Privilege.................................................................... 299 0x532 And Smaller Still.......................................................................... 302 0x540 Port-Binding Shellcode.............................................................................. 303 0x541 Duplicating Standard File Descriptors............................................. 307 0x542 Branching Control Structures......................................................... 309 0x550 Connect-Back Shellcode............................................................................ 314 0x600 C O U N T E R M E AS U R E S 319 0x610 Countermeasures That Detect..................................................................... 320 0x620 System Daemons...................................................................................... 321 0x621 Crash Course in Signals............................................................... 322 0x622 Tinyweb Daemon........................................................................ 324 0x630 Tools of the Trade..................................................................................... 328 0x631 tinywebd Exploit Tool................................................................... 329 0x640 Log Files.................................................................................................. 334 0x641 Blend In with the Crowd............................................................... 334 0x650 Overlooking the Obvious.......................................................................... 336 0x651 One Step at a Time..................................................................... 336 0x652 Putting Things Back Together Again............................................... 340 0x653 Child Laborers............................................................................ 346 0x660 Advanced Camouflage............................................................................. 348 0x661 Spoofing the Logged IP Address.................................................... 348 0x662 Logless Exploitation..................................................................... 352 0x670 The Whole Infrastructure........................................................................... 354 0x671 Socket Reuse.............................................................................. 355 0x680 Payload Smuggling.................................................................................. 359 0x681 String Encoding.......................................................................... 359 0x682 How to Hide a Sled..................................................................... 362 0x690 Buffer Restrictions..................................................................................... 363 0x691 Polymorphic Printable ASCII Shellcode........................................... 366 C on t en ts in D et ail ix 0x6a0 Hardening Countermeasures...................................................................... 376 0x6b0 Nonexecutable Stack................................................................................ 376 0x6b1 ret2libc...................................................................................... 376 0x6b2 Returning into system().................................................................. 377 0x6c0 Randomized Stack Space.......................................................................... 379 0x6c1 Investigations with BASH and GDB................................................ 380 0x6c2 Bouncing Off linux-gate................................................................ 384 0x6c3 Applied Knowledge..................................................................... 388 0x6c4 A First Attempt............................................................................. 388 0x6c5 Playing the Odds......................................................................... 390 0x700 C R YP T O LO G Y 393 0x710 Information Theory................................................................................... 394 0x711 Unconditional Security................................................................. 394 0x712 One-Time Pads............................................................................ 395 0x713 Quantum Key Distribution............................................................. 395 0x714 Computational Security................................................................ 396 0x720 Algorithmic Run Time................................................................................ 397 0x721 Asymptotic Notation.................................................................... 398 0x730 Symmetric Encryption................................................................................ 398 0x731 Lov Grover’s Quantum Search Algorithm........................................ 399 0x740 Asymmetric Encryption.............................................................................. 400 0x741 RSA........................................................................................... 400 0x742 Peter Shor’s Quantum Factoring Algorithm..................................... 404 0x750 Hybrid Ciphers........................................................................................ 406 0x751 Man-in-the-Middle Attacks............................................................ 406 0x752 Differing SSH Protocol Host Fingerprints......................................... 410 0x753 Fuzzy Fingerprints....................................................................... 413 0x760 Password Cracking................................................................................... 418 0x761 Dictionary Attacks....................................................................... 419 0x762 Exhaustive Brute-Force Attacks....................................................... 422 0x763 Hash Lookup Table...................................................................... 423 0x764 Password Probability Matrix......................................................... 424 0x770 Wireless 802.11b Encryption.................................................................... 433 0x771 Wired Equivalent Privacy............................................................. 434 0x772 RC4 Stream Cipher..................................................................... 435 0x780 WEP Attacks............................................................................................ 436 0x781 Offline Brute-Force Attacks............................................................ 436 0x782 Keystream Reuse......................................................................... 437 0x783 IV-Based Decryption Dictionary Tables........................................... 438 0x784 IP Redirection.............................................................................. 438 0x785 Fluhrer, Mantin, and Shamir Attack............................................... 439 0x800 C O N C LU S I O N 451 0x810 References............................................................................................... 452 0x820 Sources................................................................................................... 454 I ND E X 455 x C on t en ts in D et ai l  PREFACE The goal of this book is to share the art of hacking with everyone. Understanding hacking techniques is often difficult, since it requires both breadth and depth of knowledge. Many hacking texts seem esoteric and confusing because of just a few gaps in this prerequisite education. This second edition of Hacking: The Art of Exploitation makes the world of hacking more accessible by providing the complete picture—from programming to machine code to exploitation. In addition, this edition features a bootable LiveCD based on Ubuntu Linux that can be used in any computer with an x 86 processor, without modifying the computer’s existing OS. This CD contains all the source code in the book and provides a development and exploitation environment you can use to follow along with the book’s examples and experiment along the way.  ACKNOWLEDGMENTS I would like to thank Bill Pollock and everyone else at No Starch Press for making this book a possibility and allowing me to have so much creative control in the process. Also, I would like to thank my friends Seth Benson and Aaron Adams for proofreading and editing, Jack Matheson for helping me with assembly, Dr. Seidel for keeping me interested in the science of computer science, my parents for buying that first Commodore VIC-20, and the hacker community for the innovation and creativity that produced the techniques explained in this book.  0x100 INTRODUCTION The idea of hacking may conjure stylized images of electronic vandalism, espionage, dyed hair, and body piercings. Most people associate hacking with breaking the law and assume that everyone who engages in hack- ing activities is a criminal. Granted, there are people out there who use hacking techniques to break the law, but hacking isn’t really about that. In fact, hacking is more about following the law than breaking it. The essence of hacking is finding unintended or overlooked uses for the laws and properties of a given situation and then applying them in new and inventive ways to solve a problem—whatever it may be. The following math problem illustrates the essence of hacking: Use each of the numbers 1, 3, 4, and 6 exactly once with any of the four basic math operations (addition, subtraction, multiplication, and division) to total 24. Each number must be used once and only once, and you may define the order of operations; for example, 3 * (4 + 6) + 1 = 31 is valid, however incorrect, since it doesn’t total 24.  The rules for this problem are well defined and simple, yet the answer eludes many. Like the solution to this problem (shown on the last page of this book), hacked solutions follow the rules of the system, but they use those rules in counterintuitive ways. This gives hackers their edge, allowing them to solve problems in ways unimaginable for those confined to conventional thinking and methodologies. Since the infancy of computers, hackers have been creatively solving problems. In the late 1950s, the MIT model railroad club was given a dona- tion of parts, mostly old telephone equipment. The club’s members used this equipment to rig up a complex system that allowed multiple operators to con- trol different parts of the track by dialing in to the appropriate sections. They called this new and inventive use of telephone equipment hacking ; many people consider this group to be the original hackers. The group moved on to programming on punch cards and ticker tape for early computers like the IBM 704 and the TX-0. While others were content with writing programs that just solved problems, the early hackers were obsessed with writing programs that solved problems well. A new program that could achieve the same result as an existing one but used fewer punch cards was considered better, even though it did the same thing. The key difference was how the program achieved its results—elegance. Being able to reduce the number of punch cards needed for a program showed an artistic mastery over the computer. A nicely crafted table can hold a vase just as well as a milk crate can, but one sure looks a lot better than the other. Early hackers proved that technical problems can have artistic solu- tions, and they thereby transformed programming from a mere engineering task into an art form. Like many other forms of art, hacking was often misunderstood. The few who got it formed an informal subculture that remained intensely focused on learning and mastering their art. They believed that information should be free and anything that stood in the way of that freedom should be circum- vented. Such obstructions included authority figures, the bureaucracy of college classes, and discrimination. In a sea of graduation-driven students, this unofficial group of hackers defied conventional goals and instead pursued knowledge itself. This drive to continually learn and explore transcended even the conventional boundaries drawn by discrimination, evident in the MIT model railroad club’s acceptance of 12-year-old Peter Deutsch when he demonstrated his knowledge of the TX-0 and his desire to learn. Age, race, gender, appearance, academic degrees, and social status were not primary criteria for judging another’s worth—not because of a desire for equality, but because of a desire to advance the emerging art of hacking. The original hackers found splendor and elegance in the conventionally dry sciences of math and electronics. They saw programming as a form of artistic expression and the computer as an instrument of that art. Their desire to dissect and understand wasn’t intended to demystify artistic endeavors; it was simply a way to achieve a greater appreciation of them. These knowledge- driven values would eventually be called the Hacker Ethic: the appreciation of logic as an art form and the promotion of the free flow of information, surmounting conventional boundaries and restrictions for the simple goal of 2 0x 100 better understanding the world. This is not a new cultural trend; the Pythagoreans in ancient Greece had a similar ethic and subculture, despite not owning computers. They saw beauty in mathematics and discovered many core concepts in geometry. That thirst for knowledge and its beneficial by- products would continue on through history, from the Pythagoreans to Ada Lovelace to Alan Turing to the hackers of the MIT model railroad club. Modern hackers like Richard Stallman and Steve Wozniak have continued the hacking legacy, bringing us modern operating systems, programming languages, personal computers, and many other technologies that we use every day. How does one distinguish between the good hackers who bring us the wonders of technological advancement and the evil hackers who steal our credit card numbers? The term cracker was coined to distinguish evil hackers from the good ones. Journalists were told that crackers were supposed to be the bad guys, while hackers were the good guys. Hackers stayed true to the Hacker Ethic, while crackers were only interested in breaking the law and making a quick buck. Crackers were considered to be much less talented than the elite hackers, as they simply made use of hacker-written tools and scripts without understanding how they worked. Cracker was meant to be the catch-all label for anyone doing anything unscrupulous with a computer— pirating software, defacing websites, and worst of all, not understanding what they were doing. But very few people use this term today. The term’s lack of popularity might be due to its confusing etymology— cracker originally described those who crack software copyrights and reverse engineer copy-protection schemes. Its current unpopularity might simply result from its two ambiguous new definitions: a group of people who engage in illegal activity with computers or people who are relatively unskilled hackers. Few technology journalists feel compelled to use terms that most of their readers are unfamiliar with. In contrast, most people are aware of the mystery and skill associated with the term hacker, so for a journalist, the decision to use the term hacker is easy. Similarly, the term script kiddie is sometimes used to refer to crackers, but it just doesn’t have the same zing as the shadowy hacker. There are some who will still argue that there is a distinct line between hackers and crackers, but I believe that anyone who has the hacker spirit is a hacker, despite any laws he or she may break. The current laws restricting cryptography and cryptographic research further blur the line between hackers and crackers. In 2001, Professor Edward Felten and his research team from Princeton University were about to publish a paper that discussed the weaknesses of various digital watermarking schemes. This paper responded to a challenge issued by the Secure Digital Music Initiative (SDMI) in the SDMI Public Challenge, which encouraged the public to attempt to break these watermarking schemes. Before Felten and his team could publish the paper, though, they were threatened by both the SDMI Foundation and the Recording Industry Association of America (RIAA). The Digital Millennium Copyright Act (DCMA) of 1998 makes it illegal to discuss or provide technology that might be used to bypass industry con- sumer controls. This same law was used against Dmitry Sklyarov, a Russian computer programmer and hacker. He had written software to circumvent In t ro duc ti on 3  overly simplistic encryption in Adobe software and presented his findings at a hacker convention in the United States. The FBI swooped in and arrested him, leading to a lengthy legal battle. Under the law, the complexity of the industry consumer controls doesn’t matter—it would be technically illegal to reverse engineer or even discuss Pig Latin if it were used as an industry con- sumer control. Who are the hackers and who are the crackers now? When laws seem to interfere with free speech, do the good guys who speak their minds suddenly become bad? I believe that the spirit of the hacker transcends governmental laws, as opposed to being defined by them. The sciences of nuclear physics and biochemistry can be used to kill, yet they also provide us with significant scientific advancement and modern medicine. There’s nothing good or bad about knowledge itself; morality lies in the application of knowledge. Even if we wanted to, we couldn’t suppress the knowledge of how to convert matter into energy or stop the continued technological progress of society. In the same way, the hacker spirit can never be stopped, nor can it be easily categorized or dissected. Hackers will constantly be pushing the limits of knowledge and acceptable behavior, forcing us to explore further and further. Part of this drive results in an ultimately beneficial co-evolution of security through competition between attacking hackers and defending hackers. Just as the speedy gazelle adapted from being chased by the cheetah, and the cheetah became even faster from chasing the gazelle, the competi- tion between hackers provides computer users with better and stronger security, as well as more complex and sophisticated attack techniques. The introduction and progression of intrusion detection systems (IDSs) is a prime example of this co-evolutionary process. The defending hackers create IDSs to add to their arsenal, while the attacking hackers develop IDS-evasion techniques, which are eventually compensated for in bigger and better IDS products. The net result of this interaction is positive, as it produces smarter people, improved security, more stable software, inventive problem-solving techniques, and even a new economy. The intent of this book is to teach you about the true spirit of hacking. We will look at various hacker techniques, from the past to the present, dissecting them to learn how and why they work. Included with this book is a bootable LiveCD containing all the source code used herein as well as a preconfigured Linux environment. Exploration and innovation are critical to the art of hacking, so this CD will let you follow along and experiment on your own. The only requirement is an x86 processor, which is used by all Microsoft Windows machines and the newer Macintosh computers—just insert the CD and reboot. This alternate Linux environment will not disturb your existing OS, so when you’re done, just reboot again and remove the CD. This way, you will gain a hands-on understanding and appreciation for hacking that may inspire you to improve upon existing techniques or even to invent new ones. Hopefully, this book will stimulate the curious hacker nature in you and prompt you to contribute to the art of hacking in some way, regardless of which side of the fence you choose to be on. 4 0x 100  0x200 PROGRAMMING Hacker is a term for both those who write code and those who exploit it. Even though these two groups of hackers have different end goals, both groups use similar problem-solving techniques. Since an understanding of programming helps those who exploit, and an under- standing of exploitation helps those who program, many hackers do both. There are interesting hacks found in both the techniques used to write elegant code and the techniques used to exploit programs. Hacking is really just the act of finding a clever and counterintuitive solution to a problem. The hacks found in program exploits usually use the rules of the computer to bypass security in ways never intended. Programming hacks are similar in that they also use the rules of the computer in new and inventive ways, but the final goal is efficiency or smaller source code, not necessarily a security compromise. There are actually an infinite number of programs that  can be written to accomplish any given task, but most of these solutions are unnecessarily large, complex, and sloppy. The few solutions that remain are small, efficient, and neat. Programs that have these qualities are said to have elegance, and the clever and inventive solutions that tend to lead to this efficiency are called hacks. Hackers on both sides of programming appreciate both the beauty of elegant code and the ingenuity of clever hacks. In the business world, more importance is placed on churning out func- tional code than on achieving clever hacks and elegance. Because of the tremendous exponential growth of computational power and memory, spending an extra five hours to create a slightly faster and more memory- efficient piece of code just doesn’t make business sense when dealing with modern computers that have gigahertz of processing cycles and gigabytes of memory. While time and memory optimizations go without notice by all but the most sophisticated of users, a new feature is marketable. When the bottom line is money, spending time on clever hacks for optimization just doesn’t make sense. True appreciation of programming elegance is left for the hackers: computer hobbyists whose end goal isn’t to make a profit but to squeeze every possible bit of functionality out of their old Commodore 64s, exploit writers who need to write tiny and amazing pieces of code to slip through narrow security cracks, and anyone else who appreciates the pursuit and the challenge of finding the best possible solution. These are the people who get excited about programming and really appreciate the beauty of an elegant piece of code or the ingenuity of a clever hack. Since an understanding of programming is a prerequisite to understanding how programs can be exploited, programming is a natural starting point. 0x210 What Is Programming? Programming is a very natural and intuitive concept. A program is nothing more than a series of statements written in a specific language. Programs are everywhere, and even the technophobes of the world use programs every day. Driving directions, cooking recipes, football plays, and DNA are all types of programs. A typical program for driving directions might look something like this: Start out down Main Street headed east. Continue on Main Street until you see a church on your right. If the street is blocked because of construction, turn right there at 15th Street, turn left on Pine Street, and then turn right on 16th Street. Otherwise, you can just continue and make a right on 16th Street. Continue on 16th Street, and turn left onto Destination Road. Drive straight down Destination Road for 5 miles, and then you'll see the house on the right. The address is 743 Destination Road. Anyone who knows English can understand and follow these driving directions, since they’re written in English. Granted, they’re not eloquent, but each instruction is clear and easy to understand, at least for someone who reads English. 6 0x 200  But a computer doesn’t natively understand English; it only understands machine language. To instruct a computer to do something, the instructions must be written in its language. However, machine language is arcane and difficult to work with—it consists of raw bits and bytes, and it differs from architecture to architecture. To write a program in machine language for an Intel x86 processor, you would have to figure out the value associated with each instruction, how each instruction interacts, and myriad low-level details. Programming like this is painstaking and cumbersome, and it is certainly not intuitive. What’s needed to overcome the complication of writing machine language is a translator. An assembler is one form of machine-language translator—it is a program that translates assembly language into machine-readable code. Assembly language is less cryptic than machine language, since it uses names for the different instructions and variables, instead of just using numbers. However, assembly language is still far from intuitive. The instruction names are very esoteric, and the language is architecture specific. Just as machine language for Intel x86 processors is different from machine language for Sparc processors, x86 assembly language is different from Sparc assembly language. Any program written using assembly language for one processor’s architecture will not work on another processor’s architecture. If a program is written in x86 assembly language, it must be rewritten to run on Sparc architecture. In addition, in order to write an effective program in assembly language, you must still know many low-level details of the processor archi- tecture you are writing for. These problems can be mitigated by yet another form of translator called a compiler. A compiler converts a high-level language into machine language. High-level languages are much more intuitive than assembly language and can be converted into many different types of machine language for differ- ent processor architectures. This means that if a program is written in a high- level language, the program only needs to be written once; the same piece of program code can be compiled into machine language for various specific architectures. C, C++, and Fortran are all examples of high-level languages. A program written in a high-level language is much more readable and English-like than assembly language or machine language, but it still must follow very strict rules about how the instructions are worded, or the com- piler won’t be able to understand it. 0x220 Pseudo-code Programmers have yet another form of programming language called pseudo-code. Pseudo-code is simply English arranged with a general structure similar to a high-level language. It isn’t understood by compilers, assemblers, or any computers, but it is a useful way for a programmer to arrange instruc- tions. Pseudo-code isn’t well defined; in fact, most people write pseudo-code slightly differently. It’s sort of the nebulous missing link between English and high-level programming languages like C. Pseudo-code makes for an excel- lent introduction to common universal programming concepts. Pro gr am mi n g 7  0x230 Control Structures Without control structures, a program would just be a series of instructions executed in sequential order. This is fine for very simple programs, but most programs, like the driving directions example, aren’t that simple. The driv- ing directions included statements like, Continue on Main Street until you see a church on your right and If the street is blocked because of construction.... These statements are known as control structures, and they change the flow of the program’s execution from a simple sequential order to a more complex and more useful flow. 0x231 If-Then-Else In the case of our driving directions, Main Street could be under construction. If it is, a special set of instructions needs to address that situation. Otherwise, the original set of instructions should be followed. These types of special cases can be accounted for in a program with one of the most natural control structures: the if-then-else structure. In general, it looks something like this: If (condition) then { Set of instructions to execute if the condition is met; } Else { Set of instruction to execute if the condition is not met; } For this book, a C-like pseudo-code will be used, so every instruction will end with a semicolon, and the sets of instructions will be grouped with curly braces and indentation. The if-then-else pseudo-code structure of the pre- ceding driving directions might look something like this: Drive down Main Street; If (street is blocked) { Turn right on 15th Street; Turn left on Pine Street; Turn right on 16th Street; } Else { Turn right on 16th Street; } Each instruction is on its own line, and the various sets of conditional instructions are grouped between curly braces and indented for readability. In C and many other programming languages, the then keyword is implied and therefore left out, so it has also been omitted in the preceding pseudo-code. 8 0x 200  Of course, other languages require the then keyword in their syntax— BASIC, Fortran, and even Pascal, for example. These types of syntactical differences in programming languages are only skin deep; the underlying structure is still the same. Once a programmer understands the concepts these languages are trying to convey, learning the various syntactical vari- ations is fairly trivial. Since C will be used in the later sections, the pseudo- code used in this book will follow a C-like syntax, but remember that pseudo-code can take on many forms. Another common rule of C-like syntax is when a set of instructions bounded by curly braces consists of just one instruction, the curly braces are optional. For the sake of readability, it’s still a good idea to indent these instructions, but it’s not syntactically necessary. The driving directions from before can be rewritten following this rule to produce an equivalent piece of pseudo-code: Drive down Main Street; If (street is blocked) { Turn right on 15th Street; Turn left on Pine Street; Turn right on 16th Street; } Else Turn right on 16th Street; This rule about sets of instructions holds true for all of the control structures mentioned in this book, and the rule itself can be described in pseudo-code. If (there is only one instruction in a set of instructions) The use of curly braces to group the instructions is optional; Else { The use of curly braces is necessary; Since there must be a logical way to group these instructions; } Even the description of a syntax itself can be thought of as a simple program. There are variations of if-then-else, such as select/case statements, but the logic is still basically the same: If this happens do these things, otherwise do these other things (which could consist of even more if-then statements). 0x232 While/Until Loops Another elementary programming concept is the while control structure, which is a type of loop. A programmer will often want to execute a set of instructions more than once. A program can accomplish this task through looping, but it requires a set of conditions that tells it when to stop looping, Pro gr am mi n g 9  lest it continue into infinity. A while loop says to execute the following set of instructions in a loop while a condition is true. A simple program for a hungry mouse could look something like this: While (you are hungry) { Find some food; Eat the food; } The set of two instructions following the while statement will be repeated while the mouse is still hungry. The amount of food the mouse finds each time could range from a tiny crumb to an entire loaf of bread. Similarly, the number of times the set of instructions in the while statement is executed changes depending on how much food the mouse finds. Another variation on the while loop is an until loop, a syntax that is available in the programming language Perl (C doesn’t use this syntax). An until loop is simply a while loop with the conditional statement inverted. The same mouse program using an until loop would be: Until (you are not hungry) { Find some food; Eat the food; } Logically, any until-like statement can be converted into a while loop. The driving directions from before contained the statement Continue on Main Street until you see a church on your right. This can easily be changed into a standard while loop by simply inverting the condition. While (there is not a church on the right) Drive down Main Street; 0x233 For Loops Another looping control structure is the for loop. This is generally used when a programmer wants to loop for a certain number of iterations. The driving direction Drive straight down Destination Road for 5 miles could be converted to a for loop that looks something like this: For (5 iterations) Drive straight for 1 mile; In reality, a for loop is just a while loop with a counter. The same state- ment can be written as such: Set the counter to 0; While (the counter is less than 5) 10 0x200  { Drive straight for 1 mile; Add 1 to the counter; } The C-like pseudo-code syntax of a for loop makes this even more apparent: For (i=0; i b) Less than or equal to = b) Equal to == (a == b) Not equal to != (a != b) Most of these operators are self-explanatory; however, notice that the shorthand for equal to uses double equal signs. This is an important distinc- tion, since the double equal sign is used to test equivalence, while the single equal sign is used to assign a value to a variable. The statement a = 7 means Put the value 7 in the variable a, while a == 7 means Check to see whether the variable a is equal to 7. (Some programming languages like Pascal actually use := for variable assignment to eliminate visual confusion.) Also, notice that an exclamation point generally means not. This symbol can be used by itself to invert any expression. !(a < b) is equivalent to (a >= b) These comparison operators can also be chained together using short- hand for OR and AND. Logic Symbol Example OR || ((a < b) || (a < c)) AND && ((a < b) && !(a < c)) 14 0x200  The example statement consisting of the two smaller conditions joined with OR logic will fire true if a is less than b, OR if a is less than c. Similarly, the example statement consisting of two smaller comparisons joined with AND logic will fire true if a is less than b AND a is not less than c. These statements should be grouped with parentheses and can contain many different variations. Many things can be boiled down to variables, comparison operators, and control structures. Returning to the example of the mouse searching for food, hunger can be translated into a Boolean true/false variable. Naturally, 1 means true and 0 means false. While (hungry == 1) { Find some food; Eat the food; } Here’s another shorthand used by programmers and hackers quite often. C doesn’t really have any Boolean operators, so any nonzero value is considered true, and a statement is considered false if it contains 0. In fact, the comparison operators will actually return a value of 1 if the comparison is true and a value of 0 if it is false. Checking to see whether the variable hungry is equal to 1 will return 1 if hungry equals 1 and 0 if hungry equals 0. Since the program only uses these two cases, the comparison operator can be dropped altogether. While (hungry) { Find some food; Eat the food; } A smarter mouse program with more inputs demonstrates how compari- son operators can be combined with variables. While ((hungry) && !(cat_present)) { Find some food; If(!(food_is_on_a_mousetrap)) Eat the food; } This example assumes there are also variables that describe the presence of a cat and the location of the food, with a value of 1 for true and 0 for false. Just remember that any nonzero value is considered true, and the value of 0 is considered false. P rog ra m min g 15  0x244 Functions Sometimes there will be a set of instructions the programmer knows he will need several times. These instructions can be grouped into a smaller sub- program called a function. In other languages, functions are known as sub- routines or procedures. For example, the action of turning a car actually consists of many smaller instructions: Turn on the appropriate blinker, slow down, check for oncoming traffic, turn the steering wheel in the appropriate direction, and so on. The driving directions from the beginning of this chap- ter require quite a few turns; however, listing every little instruction for every turn would be tedious (and less readable). You can pass variables as arguments to a function in order to modify the way the function operates. In this case, the function is passed the direction of the turn. Function Turn(variable_direction) { Activate the variable_direction blinker; Slow down; Check for oncoming traffic; while(there is oncoming traffic) { Stop; Watch for oncoming traffic; } Turn the steering wheel to the variable_direction; while(turn is not complete) { if(speed < 5 mph) Accelerate; } Turn the steering wheel back to the original position; Turn off the variable_direction blinker; } This function describes all the instructions needed to make a turn. When a program that knows about this function needs to turn, it can just call this function. When the function is called, the instructions found within it are executed with the arguments passed to it; afterward, execution returns to where it was in the program, after the function call. Either left or right can be passed into this function, which causes the function to turn in that direction. By default in C, functions can return a value to a caller. For those familiar with functions in mathematics, this makes perfect sense. Imagine a function that calculates the factorial of a number—naturally, it returns the result. In C, functions aren’t labeled with a “function” keyword; instead, they are declared by the data type of the variable they are returning. This format looks very similar to variable declaration. If a function is meant to return an 16 0x200 integer (perhaps a function that calculates the factorial of some number x), the function could look like this: int factorial(int x) { int i; for(i=1; i < x; i++) x *= i; return x; } This function is declared as an integer because it multiplies every value from 1 to x and returns the result, which is an integer. The return statement at the end of the function passes back the contents of the variable x and ends the function. This factorial function can then be used like an integer variable in the main part of any program that knows about it. int a=5, b; b = factorial(a); At the end of this short program, the variable b will contain 120, since the factorial function will be called with the argument of 5 and will return 120. Also in C, the compiler must “know” about functions before it can use them. This can be done by simply writing the entire function before using it later in the program or by using function prototypes. A function prototype is simply a way to tell the compiler to expect a function with this name, this return data type, and these data types as its functional arguments. The actual function can be located near the end of the program, but it can be used any- where else, since the compiler already knows about it. An example of a func- tion prototype for the factorial() function would look something like this: int factorial(int); Usually, function prototypes are located near the beginning of a program. There’s no need to actually define any variable names in the prototype, since this is done in the actual function. The only thing the compiler cares about is the function’s name, its return data type, and the data types of its functional arguments. If a function doesn’t have any value to return, it should be declared as void, as is the case with the turn() function I used as an example earlier. However, the turn() function doesn’t yet capture all the functionality that our driving directions need. Every turn in the directions has both a direction and a street name. This means that a turning function should have two variables: the direction to turn and the street to turn on to. This complicates the function of turning, since the proper street must be located before the turn can be made. A more complete turning function using proper C-like syntax is listed below in pseudo-code. P rog ra m min g 17  void turn(variable_direction, target_street_name) { Look for a street sign; current_intersection_name = read street sign name; while(current_intersection_name != target_street_name) { Look for another street sign; current_intersection_name = read street sign name; } Activate the variable_direction blinker; Slow down; Check for oncoming traffic; while(there is oncoming traffic) { Stop; Watch for oncoming traffic; } Turn the steering wheel to the variable_direction; while(turn is not complete) { if(speed < 5 mph) Accelerate; } Turn the steering wheel right back to the original position; Turn off the variable_direction blinker; } This function includes a section that searches for the proper intersection by looking for street signs, reading the name on each street sign, and storing that name in a variable called current_intersection_name. It will continue to look for and read street signs until the target street is found; at that point, the remaining turning instructions will be executed. The pseudo-code driving instructions can now be changed to use this turning function. Begin going East on Main Street; while (there is not a church on the right) Drive down Main Street; if (street is blocked) { Turn(right, 15th Street); Turn(left, Pine Street); Turn(right, 16th Street); } else Turn(right, 16th Street); Turn(left, Destination Road); for (i=0; i ~/.gdbinit reader@hacking:~/booksrc $ cat ~/.gdbinit set dis intel reader@hacking:~/booksrc $ Now that GDB is configured to use Intel syntax, let’s begin understanding it. The assembly instructions in Intel syntax generally follow this style: operation , The destination and source values will either be a register, a memory address, or a value. The operations are usually intuitive mnemonics: The mov operation will move a value from the source to the destination, sub will subtract, inc will increment, and so forth. For example, the instructions below will move the value from ESP to EBP and then subtract 8 from ESP (storing the result in ESP). 8048375: 89 e5 mov ebp,esp 8048377: 83 ec 08 sub esp,0x8 P rog ra m min g 25  There are also operations that are used to control the flow of execution. The cmp operation is used to compare values, and basically any operation beginning with j is used to jump to a different part of the code (depending on the result of the comparison). The example below first compares a 4-byte value located at EBP minus 4 with the number 9. The next instruction is short- hand for jump if less than or equal to, referring to the result of the previous comparison. If that value is less than or equal to 9, execution jumps to the instruction at 0x8048393. Otherwise, execution flows to the next instruction with an unconditional jump. If the value isn’t less than or equal to 9, exe- cution will jump to 0x80483a6. 804838b: 83 7d fc 09 cmp DWORD PTR [ebp-4],0x9 804838f: 7e 02 jle 8048393 8048391: eb 13 jmp 80483a6 These examples have been from our previous disassembly, and we have our debugger configured to use Intel syntax, so let’s use the debugger to step through the first program at the assembly instruction level. The -g flag can be used by the GCC compiler to include extra debugging information, which will give GDB access to the source code. reader@hacking:~/booksrc $ gcc -g firstprog.c reader@hacking:~/booksrc $ ls -l a.out -rwxr-xr-x 1 matrix users 11977 Jul 4 17:29 a.out reader@hacking:~/booksrc $ gdb -q./a.out Using host libthread_db library "/lib/libthread_db.so.1". (gdb) list 1 #include 2 3 int main() 4 { 5 int i; 6 for(i=0; i < 10; i++) 7 { 8 printf("Hello, world!\n"); 9 } 10 } (gdb) disassemble main Dump of assembler code for function main(): 0x08048384 : push ebp 0x08048385 : mov ebp,esp 0x08048387 : sub esp,0x8 0x0804838a : and esp,0xfffffff0 0x0804838d : mov eax,0x0 0x08048392 : sub esp,eax 0x08048394 : mov DWORD PTR [ebp-4],0x0 0x0804839b : cmp DWORD PTR [ebp-4],0x9 0x0804839f : jle 0x80483a3 0x080483a1 : jmp 0x80483b6 26 0x200 0x080483a3 : mov DWORD PTR [esp],0x80484d4 0x080483aa : call 0x80482a8 0x080483af : lea eax,[ebp-4] 0x080483b2 : inc DWORD PTR [eax] 0x080483b4 : jmp 0x804839b 0x080483b6 : leave 0x080483b7 : ret End of assembler dump. (gdb) break main Breakpoint 1 at 0x8048394: file firstprog.c, line 6. (gdb) run Starting program: /hacking/a.out Breakpoint 1, main() at firstprog.c:6 6 for(i=0; i < 10; i++) (gdb) info register eip eip 0x8048394 0x8048394 (gdb) First, the source code is listed and the disassembly of the main() function is displayed. Then a breakpoint is set at the start of main(), and the program is run. This breakpoint simply tells the debugger to pause the execution of the program when it gets to that point. Since the breakpoint has been set at the start of the main() function, the program hits the breakpoint and pauses before actually executing any instructions in main(). Then the value of EIP (the Instruction Pointer) is displayed. Notice that EIP contains a memory address that points to an instruction in the main() function’s disassembly (shown in bold). The instructions before this (shown in italics) are collectively known as the function prologue and are gen- erated by the compiler to set up memory for the rest of the main() function’s local variables. Part of the reason variables need to be declared in C is to aid the construction of this section of code. The debugger knows this part of the code is automatically generated and is smart enough to skip over it. We’ll talk more about the function prologue later, but for now we can take a cue from GDB and skip it. The GDB debugger provides a direct method to examine memory, using the command x, which is short for examine. Examining memory is a critical skill for any hacker. Most hacker exploits are a lot like magic tricks—they seem amazing and magical, unless you know about sleight of hand and misdirection. In both magic and hacking, if you were to look in just the right spot, the trick would be obvious. That’s one of the reasons a good magician never does the same trick twice. But with a debugger like GDB, every aspect of a program’s execution can be deterministically examined, paused, stepped through, and repeated as often as needed. Since a running program is mostly just a processor and segments of memory, examining memory is the first way to look at what’s really going on. The examine command in GDB can be used to look at a certain address of memory in a variety of ways. This command expects two arguments when it’s used: the location in memory to examine and how to display that memory. P rog ra m min g 27  The display format also uses a single-letter shorthand, which is optionally preceded by a count of how many items to examine. Some common format letters are as follows: o Display in octal. x Display in hexadecimal. u Display in unsigned, standard base-10 decimal. t Display in binary. These can be used with the examine command to examine a certain memory address. In the following example, the current address of the EIP register is used. Shorthand commands are often used with GDB, and even info register eip can be shortened to just i r eip. (gdb) i r eip eip 0x8048384 0x8048384 (gdb) x/o 0x8048384 0x8048384 : 077042707 (gdb) x/x $eip 0x8048384 : 0x00fc45c7 (gdb) x/u $eip 0x8048384 : 16532935 (gdb) x/t $eip 0x8048384 : 00000000111111000100010111000111 (gdb) The memory the EIP register is pointing to can be examined by using the address stored in EIP. The debugger lets you reference registers directly, so $eip is equivalent to the value EIP contains at that moment. The value 077042707 in octal is the same as 0x00fc45c7 in hexadecimal, which is the same as 16532935 in base-10 decimal, which in turn is the same as 00000000111111000100010111000111 in binary. A number can also be prepended to the format of the examine com- mand to examine multiple units at the target address. (gdb) x/2x $eip 0x8048384 : 0x00fc45c7 0x83000000 (gdb) x/12x $eip 0x8048384 : 0x00fc45c7 0x83000000 0x7e09fc7d 0xc713eb02 0x8048394 : 0x84842404 0x01e80804 0x8dffffff 0x00fffc45 0x80483a4 : 0xc3c9e5eb 0x90909090 0x90909090 0x5de58955 (gdb) The default size of a single unit is a four-byte unit called a word. The size of the display units for the examine command can be changed by adding a size letter to the end of the format letter. The valid size letters are as follows: b A single byte h A halfword, which is two bytes in size w A word, which is four bytes in size g A giant, which is eight bytes in size 28 0x200  This is slightly confusing, because sometimes the term word also refers to 2-byte values. In this case a double word or DWORD refers to a 4-byte value. In this book, words and DWORDs both refer to 4-byte values. If I’m talking about a 2-byte value, I’ll call it a short or a halfword. The following GDB output shows memory displayed in various sizes. (gdb) x/8xb $eip 0x8048384 : 0xc7 0x45 0xfc 0x00 0x00 0x00 0x00 0x83 (gdb) x/8xh $eip 0x8048384 : 0x45c7 0x00fc 0x0000 0x8300 0xfc7d 0x7e09 0xeb02 0xc713 (gdb) x/8xw $eip 0x8048384 : 0x00fc45c7 0x83000000 0x7e09fc7d 0xc713eb02 0x8048394 : 0x84842404 0x01e80804 0x8dffffff 0x00fffc45 (gdb) If you look closely, you may notice something odd about the data above. The first e xamine command shows the first eight bytes, and naturally, the examine commands that use bigger units display more data in total. However, the first examine shows the first two bytes to be 0xc7 and 0x45, but when a halfword is examined at the exact same memory address, the value 0x45c7 is shown, with the bytes reversed. This same byte-reversal effect can be seen when a full four-byte word is shown as 0x00fc45c7, but when the first four bytes are shown byte by byte, they are in the order of 0xc7, 0x45, 0xfc, and 0x00. This is because on the x86 processor values are stored in little-endian byte order, which means the least significant byte is stored first. For example, if four bytes are to be interpreted as a single value, the bytes must be used in reverse order. The GDB debugger is smart enough to know how values are stored, so when a word or halfword is examined, the bytes must be reversed to display the correct values in hexadecimal. Revisiting these values displayed both as hexadecimal and unsigned decimals might help clear up any confusion. (gdb) x/4xb $eip 0x8048384 : 0xc7 0x45 0xfc 0x00 (gdb) x/4ub $eip 0x8048384 : 199 69 252 0 (gdb) x/1xw $eip 0x8048384 : 0x00fc45c7 (gdb) x/1uw $eip 0x8048384 : 16532935 (gdb) quit The program is running. Exit anyway? (y or n) y reader@hacking:~/booksrc $ bc -ql 199*(256^3) + 69*(256^2) + 252*(256^1) + 0*(256^0) 3343252480 0*(256^3) + 252*(256^2) + 69*(256^1) + 199*(256^0) 16532935 quit reader@hacking:~/booksrc $ P rog ra m min g 29  The first four bytes are shown both in hexadecimal and standard unsigned decimal notation. A command-line calculator program called bc is used to show that if the bytes are interpreted in the incorrect order, a horribly incorrect value of 3343252480 is the result. The byte order of a given architecture is an important detail to be aware of. While most debugging tools and compilers will take care of the details of byte order automatically, eventually you will directly manipulate memory by yourself. In addition to converting byte order, GDB can do other conversions with the examine command. We’ve already seen that GDB can disassemble machine language instructions into human-readable assembly instructions. The examine command also accepts the format letter i, short for instruction, to display the memory as disassembled assembly language instructions. reader@hacking:~/booksrc $ gdb -q./a.out Using host libthread_db library "/lib/tls/i686/cmov/libthread_db.so.1". (gdb) break main Breakpoint 1 at 0x8048384: file firstprog.c, line 6. (gdb) run Starting program: /home/reader/booksrc/a.out Breakpoint 1, main () at firstprog.c:6 6 for(i=0; i < 10; i++) (gdb) i r $eip eip 0x8048384 0x8048384 (gdb) x/i $eip 0x8048384 : mov DWORD PTR [ebp-4],0x0 (gdb) x/3i $eip 0x8048384 : mov DWORD PTR [ebp-4],0x0 0x804838b : cmp DWORD PTR [ebp-4],0x9 0x804838f : jle 0x8048393 (gdb) x/7xb $eip 0x8048384 : 0xc7 0x45 0xfc 0x00 0x00 0x00 0x00 (gdb) x/i $eip 0x8048384 : mov DWORD PTR [ebp-4],0x0 (gdb) In the output above, the a.out program is run in GDB, with a breakpoint set at main(). Since the EIP register is pointing to memory that actually con- tains machine language instructions, they disassemble quite nicely. The previous objdump disassembly confirms that the seven bytes EIP is pointing to actually are machine language for the corresponding assembly instruction. 8048384: c7 45 fc 00 00 00 00 mov DWORD PTR [ebp-4],0x0 This assembly instruction will move the value of 0 into memory located at the address stored in the EBP register, minus 4. This is where the C vari- able i is stored in memory; i was declared as an integer that uses 4 bytes of memory on the x86 processor. Basically, this command will zero out the 30 0x200 variable i for the for loop. If that memory is examined right now, it will contain nothing but random garbage. The memory at this location can be examined several different ways. (gdb) i r ebp ebp 0xbffff808 0xbffff808 (gdb) x/4xb $ebp - 4 0xbffff804: 0xc0 0x83 0x04 0x08 (gdb) x/4xb 0xbffff804 0xbffff804: 0xc0 0x83 0x04 0x08 (gdb) print $ebp - 4 $1 = (void *) 0xbffff804 (gdb) x/4xb $1 0xbffff804: 0xc0 0x83 0x04 0x08 (gdb) x/xw $1 0xbffff804: 0x080483c0 (gdb) The EBP register is shown to contain the address 0xbffff808, and the assembly instruction will be writing to a value offset by 4 less than that, 0xbffff804. The examine command can examine this memory address directly or by doing the math on the fly. The print command can also be used to do simple math, but the result is stored in a temporary variable in the debugger. This variable named $1 can be used later to quickly re-access a particular location in memory. Any of the methods shown above will accom- plish the same task: displaying the 4 garbage bytes found in memory that will be zeroed out when the current instruction executes. Let’s execute the current instruction using the command nexti, which is short for next instruction. The processor will read the instruction at EIP, execute it, and advance EIP to the next instruction. (gdb) nexti 0x0804838b 6 for(i=0; i < 10; i++) (gdb) x/4xb $1 0xbffff804: 0x00 0x00 0x00 0x00 (gdb) x/dw $1 0xbffff804: 0 (gdb) i r eip eip 0x804838b 0x804838b (gdb) x/i $eip 0x804838b : cmp DWORD PTR [ebp-4],0x9 (gdb) As predicted, the previous command zeroes out the 4 bytes found at EBP minus 4, which is memory set aside for the C variable i. Then EIP advances to the next instruction. The next few instructions actually make more sense to talk about in a group. P rog ra m min g 31  (gdb) x/10i $eip 0x804838b : cmp DWORD PTR [ebp-4],0x9 0x804838f : jle 0x8048393 0x8048391 : jmp 0x80483a6 0x8048393 : mov DWORD PTR [esp],0x8048484 0x804839a : call 0x80482a0 0x804839f : lea eax,[ebp-4] 0x80483a2 : inc DWORD PTR [eax] 0x80483a4 : jmp 0x804838b 0x80483a6 : leave 0x80483a7 : ret (gdb) The first instruction, cmp, is a compare instruction, which will compare the memory used by the C variable i with the value 9. The next instruction, jle stands for jump if less than or equal to. It uses the results of the previous comparison (which are actually stored in the EFLAGS register) to jump EIP to point to a different part of the code if the destination of the previous comparison operation is less than or equal to the source. In this case the instruction says to jump to the address 0x8048393 if the value stored in memory for the C variable i is less than or equal to the value 9. If this isn’t the case, the EIP will continue to the next instruction, which is an unconditional jump instruction. This will cause the EIP to jump to the address 0x80483a6. These three instructions combine to create an if-then-else control structure: If the i is less than or equal to 9, then go to the instruction at address 0x8048393 ; otherwise, go to the instruction at address 0x80483a6. The first address of 0x8048393 (shown in bold) is simply the instruction found after the fixed jump instruction, and the second address of 0x80483a6 (shown in italics) is located at the end of the function. Since we know the value 0 is stored in the memory location being com- pared with the value 9, and we know that 0 is less than or equal to 9, EIP should be at 0x8048393 after executing the next two instructions. (gdb) nexti 0x0804838f 6 for(i=0; i < 10; i++) (gdb) x/i $eip 0x804838f : jle 0x8048393 (gdb) nexti 8 printf("Hello, world!\n"); (gdb) i r eip eip 0x8048393 0x8048393 (gdb) x/2i $eip 0x8048393 : mov DWORD PTR [esp],0x8048484 0x804839a : call 0x80482a0 (gdb) As expected, the previous two instructions let the program execution flow down to 0x8048393, which brings us to the next two instructions. The 32 0x200 first instruction is another mov instruction that will write the address 0x8048484 into the memory address contained in the ESP register. But what is ESP pointing to? (gdb) i r esp esp 0xbffff800 0xbffff800 (gdb) Currently, ESP points to the memory address 0xbffff800, so when the mov instruction is executed, the address 0x8048484 is written there. But why? What’s so special about the memory address 0x8048484? There’s one way to find out. (gdb) x/2xw 0x8048484 0x8048484: 0x6c6c6548 0x6f57206f (gdb) x/6xb 0x8048484 0x8048484: 0x48 0x65 0x6c 0x6c 0x6f 0x20 (gdb) x/6ub 0x8048484 0x8048484: 72 101 108 108 111 32 (gdb) A trained eye might notice something about the memory here, in par- ticular the range of the bytes. After examining memory for long enough, these types of visual patterns become more apparent. These bytes fall within the printable ASCII range. ASCII is an agreed-upon standard that maps all the characters on your keyboard (and some that aren’t) to fixed numbers. The bytes 0x48, 0x65, 0x6c, and 0x6f all correspond to letters in the alphabet on the ASCII table shown below. This table is found in the man page for ASCII, available on most Unix systems by typing man ascii. ASCII Table Oct Dec Hex Char Oct Dec Hex Char ------------------------------------------------------------ 000 0 00 NUL '\0' 100 64 40 @ 001 1 01 SOH 101 65 41 A 002 2 02 STX 102 66 42 B 003 3 03 ETX 103 67 43 C 004 4 04 EOT 104 68 44 D 005 5 05 ENQ 105 69 45 E 006 6 06 ACK 106 70 46 F 007 7 07 BEL '\a' 107 71 47 G 010 8 08 BS '\b' 110 72 48 H 011 9 09 HT '\t' 111 73 49 I 012 10 0A LF '\n' 112 74 4A J 013 11 0B VT '\v' 113 75 4B K 014 12 0C FF '\f' 114 76 4C L 015 13 0D CR '\r' 115 77 4D M 016 14 0E SO 116 78 4E N 017 15 0F SI 117 79 4F O 020 16 10 DLE 120 80 50 P 021 17 11 DC1 121 81 51 Q P rog ra m min g 33  022 18 12 DC2 122 82 52 R 023 19 13 DC3 123 83 53 S 024 20 14 DC4 124 84 54 T 025 21 15 NAK 125 85 55 U 026 22 16 SYN 126 86 56 V 027 23 17 ETB 127 87 57 W 030 24 18 CAN 130 88 58 X 031 25 19 EM 131 89 59 Y 032 26 1A SUB 132 90 5A Z 033 27 1B ESC 133 91 5B [ 034 28 1C FS 134 92 5C \ '\\' 035 29 1D GS 135 93 5D ] 036 30 1E RS 136 94 5E ^ 037 31 1F US 137 95 5F _ 040 32 20 SPACE 140 96 60 ` 041 33 21 ! 141 97 61 a 042 34 22 " 142 98 62 b 043 35 23 # 143 99 63 c 044 36 24 $ 144 100 64 d 045 37 25 % 145 101 65 e 046 38 26 & 146 102 66 f 047 39 27 ' 147 103 67 g 050 40 28 ( 150 104 68 h 051 41 29 ) 151 105 69 i 052 42 2A * 152 106 6A j 053 43 2B + 153 107 6B k 054 44 2C , 154 108 6C l 055 45 2D - 155 109 6D m 056 46 2E. 156 110 6E n 057 47 2F / 157 111 6F o 060 48 30 0 160 112 70 p 061 49 31 1 161 113 71 q 062 50 32 2 162 114 72 r 063 51 33 3 163 115 73 s 064 52 34 4 164 116 74 t 065 53 35 5 165 117 75 u 066 54 36 6 166 118 76 v 067 55 37 7 167 119 77 w 070 56 38 8 170 120 78 x 071 57 39 9 171 121 79 y 072 58 3A : 172 122 7A z 073 59 3B ; 173 123 7B { 074 60 3C < 174 124 7C | 075 61 3D = 175 125 7D } 076 62 3E > 176 126 7E ~ 077 63 3F ? 177 127 7F DEL Thankfully, GDB’s examine command also contains provisions for look- ing at this type of memory. The c format letter can be used to automatically look up a byte on the ASCII table, and the s format letter will display an entire string of character data. 34 0x200 (gdb) x/6cb 0x8048484 0x8048484: 72 'H' 101 'e' 108 'l' 108 'l' 111 'o' 32 ' ' (gdb) x/s 0x8048484 0x8048484: "Hello, world!\n" (gdb) These commands reveal that the data string "Hello, world!\n" is stored at memory address 0x8048484. This string is the argument for the printf() func- tion, which indicates that moving the address of this string to the address stored in ESP (0x8048484) has something to do with this function. The following output shows the data string’s address being moved into the address ESP is pointing to. (gdb) x/2i $eip 0x8048393 : mov DWORD PTR [esp],0x8048484 0x804839a : call 0x80482a0 (gdb) x/xw $esp 0xbffff800: 0xb8000ce0 (gdb) nexti 0x0804839a 8 printf("Hello, world!\n"); (gdb) x/xw $esp 0xbffff800: 0x08048484 (gdb) The next instruction is actually called the printf() function; it prints the data string. The previous instruction was setting up for the function call, and the results of the function call can be seen in the output below in bold. (gdb) x/i $eip 0x804839a : call 0x80482a0 (gdb) nexti Hello, world! 6 for(i=0; i < 10; i++) (gdb) Continuing to use GDB to debug, let’s examine the next two instructions. Once again, they make more sense to look at in a group. (gdb) x/2i $eip 0x804839f : lea eax,[ebp-4] 0x80483a2 : inc DWORD PTR [eax] (gdb) These two instructions basically just increment the variable i by 1. The lea instruction is an acronym for Load Effective Address, which will load the P rog ra m min g 35  familiar address of EBP minus 4 into the EAX register. The execution of this instruction is shown below. (gdb) x/i $eip 0x804839f : lea eax,[ebp-4] (gdb) print $ebp - 4 $2 = (void *) 0xbffff804 (gdb) x/x $2 0xbffff804: 0x00000000 (gdb) i r eax eax 0xd 13 (gdb) nexti 0x080483a2 6 for(i=0; i < 10; i++) (gdb) i r eax eax 0xbffff804 -1073743868 (gdb) x/xw $eax 0xbffff804: 0x00000000 (gdb) x/dw $eax 0xbffff804: 0 (gdb) The following inc instruction will increment the value found at this address (now stored in the EAX register) by 1. The execution of this instruction is also shown below. (gdb) x/i $eip