DOCSLIB.ORG

C++ Undefined Behavior

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
C++ Undefined Behavior C++ Undefined Behavior What is it, and why should I care? ● A presentation originally by Marshal Clow ● Original: https://www.youtube.com/watch?v=uHCLkb1vKaY ● Original Slides: https://github.com/boostcon/cppnow_presentations_2014/blob/master/files/Undefined-Behavior.pdf ● All errors in this slides or presentation are mine What is Undefined Behavior? 1.3.24 [defns.undefined] undefined behavior behavior for which this International Standard imposes no requirements [ Note: Undefined behavior may be expected when this International Standard omits any explicit definition of behavior or when a program uses an erroneous construct or erroneous data. Permissible undefined behavior ranges from ignoring the situation completely with unpredictable results, to behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message). Many erroneous program constructs do not engender undefined behavior; they are required to be diagnosed. No requirements Some examples what can happen ● Program crashes ● Program gives unexpected results ● Computer catches fire ● Daemons fly out of your nose ● Program appears to work fine ● There are no wrong answers! Example #1 No Wrong Answers! #include <iostream> /* what does this program print? */ int main() { int arr[] = { 0, 2, 4, 6, 8 }; int i = 1; std::cout << i + arr[++i] + arr[i++] << “\n”; } How can I get UB? (1) ● Signed integer overflow (but not unsigned!) ● Dereferencing nullptr (NULL) ● Dereferencing result of malloc(0); ● Shift greater than (or equal to) the width of the operand ● Reading from uninitializer variables ● Modifying a variable more than once in an expression ● Buffer overflow ● Comparing pointers to different data structures How can I get UB? (2) ● Pointer overflow ● Modifying a const object ● Modifying a string literal ● Negating INT_MIN ● Mismatch between new and delete ([]) ● Calling a library routine without fulfilling the prerequisites (z.B. memcpy with overlapping buffers) ● Data races Example #2 #include <new> class Foo { // some complicated class }; int main() { Foo *p = new Foo[4]; // lots of stuff here delete p; } atomic_is_lock_free 20.8.2.5 shared_ptr atomic access [util.smartptr.shared.atomic] ... template<class T> bool atomic_is_lock_free(const shared_ptr<T>* p); Requires: p shall not be null. ... Arithmetic Operations 5 Expressions [expr] ... If during the evaluation of an expression, the result is not mathematically defined or not in the range of representable values for its type, the behavior is undefined. ... Example #3 No Wrong Answers! #include <stdio.h> #include <stdbool.h> int main() { bool b; if (b) printf(“true\n”); If (!b) printf(“false\n”); } Why do C and C++ do this? ● It gives the compiler leeway to generate smaller code, by omitting checks ● By assuming no UB the compiler can generate simpler, faster and smaller code ● Different hardware reacts different Why is this important? ● Because compilers know it – and optimizers take advantage of it ● It is perfectly legal to transform a program exhibiting UB into any other program ● Remember: in UB there are no wrong answers Different kinds of routines ● Type 1: no UB, no matter what the inputs ● Type 2: UB for some subset of all possible inputs ● Type 3: UB, no matter what the inputs John Regehr, University of Utah Example #4 int *do_something( int *p) { log(“do_something %d”, *p); if (!p) { … p = malloc(...); ... } return p; } Beispiel #5 #include <stdio.h> int main() { int i = 0x10000000; int c = 0; do { c++; i += i; printf(“%d\n”, i); } while (I > 0); printf(“%d iterations\n”, c); } Why do we care? (1) ● It is surprisingly easy to write code with undefined behavior ● http://code.google.com/p/nativeclient/issues/detail?id=245 ● UB Code may “work” for a while, and the “break” when optimization level is increased or the compiler is upgraded (“optimization- unstable code” - STACK) Why do we care? (2) ● UB shows up in “tricky” code; frequently code that is attempting security checks ● http://gcc.gnu.org/bugzilla/show_bug.cgi?id=30475 ● Bugs that STACK found in Postgres Example #6 // Checks are hard to write correctly // From “Apple Secure Coding Guidelines” (second edition) void xxxx( int n, int m) { size_t bytes = n * m; if (n > 0 && m > 0 && SIZE_MAX / n >= m) { … /* allocate “bytes” space */ … } } Beispiel #7 Aliasing struct Foo { int a; }; struct Bar { int a; int b; }; Foo f{3}; Bar *p = (Bar *)&f; p->a = 4; std::cout << f.a << “\n”; What can I do about UB? ● Be aware of UB ● Don’t blame the compiler (“don't shoot the messenger”) ● When you do something tricky think about UB ● Build your code with several compilers and optimization levels Impact If you use Undefined Behavior you con no longer reason about what your program does It is too late You can not check if Undefined Behavior has already happened Example #8 // wrong bool will_this_overflow(int a) { return a + 100 < a; } // what the compiler can/will generate: bool will_this_overflow(int a) { return false; } ____________________________________________________________ // correct bool will_this_overflow(int a) { return a < (INT_MAX - 100); } Example #9 #include <sstream> void xxxx( int fh, int i) { std::stringstream ss; ss << I << “\n”; write(fh, ss.str().c_str(), ss.str().size()); } Tools ● Clang: -fsanitize=undefined ● John Regehr's Integer Overflow Checker ● STACK Quiz // Optimize this code void contains_null_check( int *p) { int dead = *p; if (p == nullptr) return; *p = 4; } References ● A Guide to Undefined Behavior in C and C++, Part 1 http://blog.regehr.org/archives/213 (links zu Teil 2 und 3) ● Towards optimization-safe systems http://pdos.csail.mit.edu/papers/stack:sosp13.pdf ● What every C programmer should know about undefined behavior http://blog.llvm.org/2011/05/what-every-c-programmer-should-know.html ● It's time to get serious about exploiting Undefined Behavior http://blog.regehr.org/archives/761 ● Finding Undefined Behavior by finding dead code http://blog.regehr.org/archives/970 ● About unspecified and undefined behavior in C (ACCU 2013) http://www.pvv.org/~oma/UnspecifiedAndUndefined_ACCU_Apr2013.pdf .
Load more

Recommended publications
  • Undefined Behaviour in the C Language
    FAKULTA INFORMATIKY, MASARYKOVA UNIVERZITA Undefined Behaviour in the C Language BAKALÁŘSKÁ PRÁCE Tobiáš Kamenický Brno, květen 2015 Declaration Hereby I declare, that this paper is my original authorial work, which I have worked out by my own. All sources, references, and literature used or excerpted during elaboration of this work are properly cited and listed in complete reference to the due source. Vedoucí práce: RNDr. Adam Rambousek ii Acknowledgements I am very grateful to my supervisor Miroslav Franc for his guidance, invaluable help and feedback throughout the work on this thesis. iii Summary This bachelor’s thesis deals with the concept of undefined behavior and its aspects. It explains some specific undefined behaviors extracted from the C standard and provides each with a detailed description from the view of a programmer and a tester. It summarizes the possibilities to prevent and to test these undefined behaviors. To achieve that, some compilers and tools are introduced and further described. The thesis contains a set of example programs to ease the understanding of the discussed undefined behaviors. Keywords undefined behavior, C, testing, detection, secure coding, analysis tools, standard, programming language iv Table of Contents Declaration ................................................................................................................................ ii Acknowledgements .................................................................................................................. iii Summary .................................................................................................................................
    [Show full text]
  • Defining the Undefinedness of C
    Technical Report: Defining the Undefinedness of C Chucky Ellison Grigore Ros, u University of Illinois {celliso2,grosu}@illinois.edu Abstract naturally capture undefined behavior simply by exclusion, be- This paper investigates undefined behavior in C and offers cause of the complexity of undefined behavior, it takes active a few simple techniques for operationally specifying such work to avoid giving many undefined programs semantics. behavior formally. A semantics-based undefinedness checker In addition, capturing the undefined behavior is at least as for C is developed using these techniques, as well as a test important as capturing the defined behavior, as it represents suite of undefined programs. The tool is evaluated against a source of many subtle program bugs. While a semantics other popular analysis tools, using the new test suite in of defined programs can be used to prove their behavioral addition to a third-party test suite. The semantics-based tool correctness, any results are contingent upon programs actu- performs at least as well or better than the other tools tested. ally being defined—it takes a semantics capturing undefined behavior to decide whether this is the case. 1. Introduction C, together with C++, is the king of undefined behavior—C has over 200 explicitly undefined categories of behavior, and A programming language specification or semantics has dual more that are left implicitly undefined [11]. Many of these duty: to describe the behavior of correct programs and to behaviors can not be detected statically, and as we show later identify incorrect programs. The process of identifying incor- (Section 2.6), detecting them is actually undecidable even rect programs can also be seen as describing which programs dynamically.
    [Show full text]
  • The Art, Science, and Engineering of Fuzzing: a Survey
    1 The Art, Science, and Engineering of Fuzzing: A Survey Valentin J.M. Manes,` HyungSeok Han, Choongwoo Han, Sang Kil Cha, Manuel Egele, Edward J. Schwartz, and Maverick Woo Abstract—Among the many software vulnerability discovery techniques available today, fuzzing has remained highly popular due to its conceptual simplicity, its low barrier to deployment, and its vast amount of empirical evidence in discovering real-world software vulnerabilities. At a high level, fuzzing refers to a process of repeatedly running a program with generated inputs that may be syntactically or semantically malformed. While researchers and practitioners alike have invested a large and diverse effort towards improving fuzzing in recent years, this surge of work has also made it difficult to gain a comprehensive and coherent view of fuzzing. To help preserve and bring coherence to the vast literature of fuzzing, this paper presents a unified, general-purpose model of fuzzing together with a taxonomy of the current fuzzing literature. We methodically explore the design decisions at every stage of our model fuzzer by surveying the related literature and innovations in the art, science, and engineering that make modern-day fuzzers effective. Index Terms—software security, automated software testing, fuzzing. ✦ 1 INTRODUCTION Figure 1 on p. 5) and an increasing number of fuzzing Ever since its introduction in the early 1990s [152], fuzzing studies appear at major security conferences (e.g. [225], has remained one of the most widely-deployed techniques [52], [37], [176], [83], [239]). In addition, the blogosphere is to discover software security vulnerabilities. At a high level, filled with many success stories of fuzzing, some of which fuzzing refers to a process of repeatedly running a program also contain what we consider to be gems that warrant a with generated inputs that may be syntactically or seman- permanent place in the literature.
    [Show full text]
  • Lenient Execution of C on a JVM How I Learned to Stop Worrying and Execute the Code
    Lenient Execution of C on a JVM How I Learned to Stop Worrying and Execute the Code Manuel Rigger Roland Schatz Johannes Kepler University Linz, Austria Oracle Labs, Austria [email protected] [email protected] Matthias Grimmer Hanspeter M¨ossenb¨ock Oracle Labs, Austria Johannes Kepler University Linz, Austria [email protected] [email protected] ABSTRACT that rely on undefined behavior risk introducing bugs that Most C programs do not strictly conform to the C standard, are hard to find, can result in security vulnerabilities, or and often show undefined behavior, e.g., on signed integer remain as time bombs in the code that explode after compiler overflow. When compiled by non-optimizing compilers, such updates [31, 44, 45]. programs often behave as the programmer intended. However, While bug-finding tools help programmers to find and optimizing compilers may exploit undefined semantics for eliminate undefined behavior in C programs, the majority more aggressive optimizations, thus possibly breaking the of C code will still contain at least some occurrences of non- code. Analysis tools can help to find and fix such issues. Alter- portable code. This includes unspecified and implementation- natively, one could define a C dialect in which clear semantics defined patterns, which do not render the whole program are defined for frequent program patterns whose behavior invalid, but can still cause surprising results. To address would otherwise be undefined. In this paper, we present such this, it has been advocated to come up with a more lenient a dialect, called Lenient C, that specifies semantics for behav- C dialect, that better suits the programmers' needs and ior that the standard left open for interpretation.
    [Show full text]
  • In Using the GNU Compiler Collection (GCC)
    Using the GNU Compiler Collection For gcc version 6.1.0 (GCC) Richard M. Stallman and the GCC Developer Community Published by: GNU Press Website: http://www.gnupress.org a division of the General: [email protected] Free Software Foundation Orders: [email protected] 51 Franklin Street, Fifth Floor Tel 617-542-5942 Boston, MA 02110-1301 USA Fax 617-542-2652 Last printed October 2003 for GCC 3.3.1. Printed copies are available for $45 each. Copyright c 1988-2016 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being \Funding Free Software", the Front-Cover Texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in the section entitled \GNU Free Documentation License". (a) The FSF's Front-Cover Text is: A GNU Manual (b) The FSF's Back-Cover Text is: You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development. i Short Contents Introduction ::::::::::::::::::::::::::::::::::::::::::::: 1 1 Programming Languages Supported by GCC ::::::::::::::: 3 2 Language Standards Supported by GCC :::::::::::::::::: 5 3 GCC Command Options ::::::::::::::::::::::::::::::: 9 4 C Implementation-Defined Behavior :::::::::::::::::::: 373 5 C++ Implementation-Defined Behavior ::::::::::::::::: 381 6 Extensions to
    [Show full text]
  • Automatic Program Generation for Detecting Vulnerabilities and Errors in Compilers and Interpreters
    Automatic program generation for detecting vulnerabilities and errors in compilers and interpreters 0368-3500 Nurit Dor Noam Rinetzky Preliminaries • Students will group in teams of 2-3 students. • Each group will do one of the projects presented. Administration • Workshop meetings will take place only on Tuesdays 16-18 o No meetings (with us) during other hours • Attendance in all meetings is mandatory • Grading: 100% of grade will be given after final project submission. • Projects will be graded based on: • Code correctness and functionality • Original and innovative ideas • Level of technical difficulty of solution Administration • Workshop staff should be contacted by email. • Please address all emails to all of the staff: • Noam Rinetzky - [email protected] • Nurit Dor - [email protected] • Follow updates on the workshop website: http://www.cs.tau.ac.il/~maon/teaching/2015-2016/workshop/workshop1516b.html Tentative Schedule • Meeting 1, 8/03/2016 (today) – Project presentation • Meeting 2, 5/04/2016 (or 12/4) – Each group presents its initial design • Meeting 3, 17/05/2016 – Progress report – meeting with each group • Meeting 4, 7/06/2016 – First phase submission • Submission: 01/09/2016 • Presentation: ~08/09/2016 – Each group separately Automatic program generation for detecting vulnerabilities and errors in compilers and interpreters Programming Errors “As soon as we started programming, we found to our surprise that it wasn’t as easy to get programs right as we had thought. Debugging had to be discovered. I can remember the
    [Show full text]
  • Integer Arithmetic and Undefined Behavior in C Brad Karp UCL Computer Science
    Carnegie Mellon Integer Arithmetic and Undefined Behavior in C Brad Karp UCL Computer Science CS 3007 23rd January 2018 (lecture notes derived from material from Eddie Kohler, John Regehr, Phil Gibbons, Randy Bryant, and Dave O’Hallaron) 1 Carnegie Mellon Outline: Integer Arithmetic and Undefined Behavior in C ¢ C primitive data types ¢ C integer arithmetic § Unsigned and signed (two’s complement) representations § Maximum and minimum values; conversions and casts § Perils of C integer arithmetic, unsigned and especially signed ¢ Undefined behavior (UB) in C § As defined in the C99 language standard § Consequences for program behavior § Consequences for compiler and optimizer behavior § Examples § Prevalence of UB in real-world Linux application-level code ¢ Recommendations for defensive programming in C 2 Carnegie Mellon Example Data Representations C Data Type Typical 32-bit Typical 64-bit x86-64 char 1 1 1 signed short (default) 2 2 2 and int 4 4 4 unsigned variants long 4 8 8 float 4 4 4 double 8 8 8 pointer 4 8 8 3 Carnegie Mellon Portable C types with Fixed Sizes C Data Type all archs {u}int8_t 1 {u}int16_t 2 {u}int32_t 4 {u}int64_t 8 uintptr_t 4 or 8 Type definitions available in #include <stdint.h> 4 Carnegie Mellon Shift Operations ¢ Left Shift: x << y Argument x 01100010 § Shift bit-vector x left y positions << 3 00010000 – Throw away extra bits on left Log. >> 2 00011000 § Fill with 0’s on right Arith. >> 2 00011000 ¢ Right Shift: x >> y § Shift bit-vector x right y positions Argument 10100010 § Throw away extra bits on right x § Logical shift << 3 00010000 § Fill with 0’s on left Log.
    [Show full text]
  • A Differential Approach to Undefined Behavior
    1 A Differential Approach to Undefined Behavior Detection XI WANG, NICKOLAI ZELDOVICH, M. FRANS KAASHOEK, and ARMANDO SOLAR-LEZAMA, Massachusetts Institute of Technology This article studies undefined behavior arising in systems programming languages such as C/C++. Undefined behavior bugs lead to unpredictable and subtle systems behavior, and their effects can be further amplified by compiler optimizations. Undefined behavior bugs are present in many systems, including the Linux kernel and the Postgres database. The consequences range from incorrect functionality to missing security checks. This article proposes a formal and practical approach that finds undefined behavior bugs by finding “unstable code” in terms of optimizations that leverage undefined behavior. Using this approach, we introduce a new static checker called STACK that precisely identifies undefined behavior bugs. Applying STACK to widely used systems has uncovered 161 new bugs that have been confirmed and fixed by developers. Categories and Subject Descriptors: D.4.6 [Operating Systems]: Security and Protection; F.3.2 [Logics and Meanings of Programs]: Semantics of Programming Languages General Terms: Languages, Reliability, Security Additional Key Words and Phrases: Undefined behavior, compiler optimizations ACM Reference Format: Xi Wang, Nickolai Zeldovich, M. Frans Kaashoek, and Armando Solar-Lezama. 2015. A differential approach to undefined behavior detection. ACM Trans. Comput. Syst. 33, 1, Article 1 (March 2015), 29 pages. DOI: http://dx.doi.org/10.1145/2699678 1. INTRODUCTION Undefined behavior in systems programming languages is a dark side of systems pro- gramming. It introduces unpredictable systems behavior and has a significant impact on reliability and security. This article proposes a new approach that identifies unde- fined behavior by finding code fragments that have divergent behavior under different interpretations of the language specification.
    [Show full text]
  • C++ Undefined Behavior What Is It, and Why Should I Care?
    C++ Undefined Behavior What is it, and why should I care? Marshall Clow Qualcomm [email protected] http://cplusplusmusings.wordpress.com (intermittent) Twitter: @mclow ACCU 2014 April 2014 What is Undefined Behavior? (from N3691 - C++) 1.3.24: undefined behavior Behavior for which this International Standard imposes no requirements. [ Note: Undefined behavior may be expected when this International Standard omits any explicit definition of behavior or when a program uses an erroneous construct or erroneous data. Permissible undefined behavior ranges from ignoring the situation completely with unpredictable results, to behaving during translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message). Many erroneous program constructs do not engender undefined behavior; they are required to be diagnosed. — end note ] Some examples of UB Program crashes Program gives unexpected results Computer catches fire Cat gets pregnant Program appears to work fine There are no wrong answers! Example #1: No Wrong Answers! #include <iostream> // g++ sequence_points.cpp && ./a.out --> 10 // clang++ sequence_points.cpp && ./a.out --> 9 using namespace std; int main () { !int arr [] = { 0, 2, 4, 6, 8 }; !int i = 1; !cout << i + arr[++i] + arr[i++] << endl; !} How can I get UB? (I) Signed integer overflow (but not unsigned!) Dereferencing NULL pointer or result of malloc(0) Shift greater than (or equal
    [Show full text]
  • Finding Bugs Compiler Knows but Doesn't Tell You: Dissecting Undefined Behavior Optimizations in LLVM
    Finding Bugs Compiler Knows but Doesn't Tell You: Dissecting Undefined Behavior Optimizations in LLVM Zekai Wu (@hellowuzekai) Wei Liu Mingyue Liang (@MoonL1ang) Kai Song (@ExpSky) #BHEU @BLACKHATEVENTS Who We Are • Tencent Security Xuanwu LaB • ApplieD anD real worlD security research • ABout us: MemBers of FounDational Security Research Team • Zekai Wu(@hellowuzekai) • Wei Liu • Mingyue Liang(@MoonL1ang) • Kai Song(@ExpSky) #BHEU @BLACKHATEVENTS Quiz class A { public: void read(int x) { int *addr = internalRead(x); printf("0x%x\n", *addr); } Nullptr Dereference is "expecteD" if bound check fails private: int* internalRead(int x) { if (x < 0 || x >= 100){ return nullptr;} Array Bound Check return array+x; } xxx@ubuntu:~$ clang++ demo.cpp -o demo int flag = 0xdeadbeef; xxx@ubuntu:~$ ./demo int array[100] = {0}; Segmentation fault (core dumped) expected }; xxx@ubuntu:~$ clang++ demo.cpp -O3 -o demo void main() { xxx@ubuntu:~$ ./demo A a; a.read(-1); 0xdeadbeef What??? } #BHEU @BLACKHATEVENTS Agenda • Undefined Behavior in LLVM • Undefined Behavior Detections • Detection Result Case Study • From Undefined Behavior to RCE • Conclusions #BHEU @BLACKHATEVENTS Undefined Behavior •Undefined Behavior(UB): • Behavior upon use of a nonportable or erroneous program construct or of erroneous Data • International StanDarD imposes no requirements •C/C++ have lots of UB • C17 stanDarD has 211 unDefineD Behaviors • More new UBs will Be aDDeD to the stanDarD #BHEU @BLACKHATEVENTS Undefined Behavior int *p = 0; int a = 1; int b = *p + 1; Nullptr Oversiz
    [Show full text]
  • Defining Undefined Behavior David Svoboda [email protected] Date: 2019-03-22 the Problem
    WG 14, N2365 Defining Undefined Behavior David Svoboda [email protected] Date: 2019-03-22 The Problem C17 defines many categories of undefined behavior (203 in this count). Many examples of undefined behavior (UB) are assumed to be well-defined by programmers, typically because their platform specifies the behavior. For example, signed integer overflow is undefined behavior. However, on x86 platforms, and, in fact, most platforms that use twos-complement arithmetic, signed integer overflow wraps; that is INT_MIN == INT_MAX + 1 == -INT_MIN. Consequently, many programs rely on undefined behavior, and their developers only learn that the behavior is undefined when porting their code to a new platform. This leaves developers in a nasty position: a large body of code that works properly only on platforms that make the same assumptions about certain undefined behaviors as the developers’ platform. This is not a new problem, it was popularized in the eighties as vaxocentrism. Today one can argue that Intel has replaced the VAX as a platform ubiquitous enough to fool many developers into incorrect assumptions of undefined behavior. Furthermore, compilers and their optimizers can change how programs with UB actually behave. One of the first such instances, reported in 2008, was CERT Vul# 162289, where a compiler’s optimizer silently removed bounds checks because they exhibited UB, even though without optimization the bounds checks performed as expected. Related Work In document N2278, Yodaiken proposes that the definition of undefined behavior (in C17, Section 3.4.3) be constrained to prevent optimizers from changing working code. While this would plug many security holes, it would disable too many useful optimizations; a more fine- grained solution is required.
    [Show full text]
  • Undefined Behavior in 2017
    Undefined Behavior in 2017 John Regehr University of Utah, USA Today: • What is undefined behavior (UB)? • Why does it exist? • What are the consequences of UB in C and C++? • Modern UB detecFon and miFgaon sqrt(-1) = ? • i • NaN • An arbitrary value • Throw an excepFon • Abort the program • Undefined behavior • Undefined behavior (UB) is a design choice • UB is the most efficient alternave because it imposes the fewest requirements – “… behavior, upon use of a nonportable or erroneous program construct or of erroneous data, for which this Internaonal Standard imposes no requirements” C and C++ have lots of UB • To avoid overhead • To avoid compiler complexity • To provide maximal compability across implementaons and targets According to Appendix J of the standard, C11 has 199 undefined behaviors • But this list isn’t complete • And there’s no comparable list for C++ • And new UBs are being added From: hp://en.cppreference.com/w/cpp/language/stac_cast What happens when you execute undefined behavior? • Case 1: Program breaks immediately (segfault, math excepFon) • Case 2: Program conFnues, but will fail later (corrupted RAM, etc.) • Case 3: Program works as expected – However, the UB is a “Fme bomb” – a latent problem waiFng to go off when the compiler, compiler version, or compiler flags is changed • Case 4: You don’t know how to trigger the UB but someone else does Important trends over the last 25 years: • UB detecFon tools have been geng beTer – StarFng perhaps with Purify in the early 1990s – More about these later • Compilers have been geng cleverer at exploiFng UB to improve code generaon – Making the Fme bombs go off – More about this soon • Security has become a primary consideraon in sodware development • But of course legacy C and C++ contain plenty of UB • What can we do about that? – Sane opFon 1: Go back and fix the old code • Expensive..
    [Show full text]