Problem - Kevin Tafuro

cates failure, it’s likely that no randomness was put into the buffer. If the programmer
does not check the return code, predictable data will be used.
In general, those functions that are not directly security-critical when their return
value goes unchecked are often indirect security problems. (This can often happen
with memory allocation functions, for example.) At the very least, such problems are
often denial of service risks when they lead to a crash.
One solution to this problem is to ensure that you always check return values from
functions. That approach works in theory, but it is very burdensome on the programmer
and also hard to validate.
A more practical answer is to use exception handling. Using exception handling, any
error conditions that the programmer does not explicitly handle will cause the program
to terminate (which is generally a good idea, unless the premature termination
somehow causes an insecure state).
The problem with exception handling is that it does not solve the denial of service
problem. If a developer forgets to handle a particular exception, the program will
generally still terminate. Of course, the entire program can be wrapped by an exception
handler that restarts the program or performs a similar action.
In C++, exception handling is built into the language and should be familiar to many
programmers. We will illustrate via example:
try {
somefunc( );
}
catch (MyException &e) {
// Recover from error type MyException.
}
catch (int e) {
// Recover if we got an integer exception code.
}
The try block designates code we would like to execute that may throw an exception.
It also says that if the code does throw an exception, the following catch blocks
may be able to handle the exception.
If an exception is not handled by one of the specified catch blocks, there may be
some calling code that catches the exception. If no code wants to catch the exception,
the program will abort.
In C++, the catch block used is selected based on the static type of the exception
thrown. Generally, if the exception is not a primitive type, we use the & to indicate
that the exception value should be passed to the handler by reference instead of
being copied.
To raise an exception, we use the throw keyword:
throw 12; // Throw an integer as an error. You can throw arbitrary objects in C++.
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Performing Error Handling | 701