Buffer Overflow and Security Vulnerabilities

Study Notes

Buffer overflows are a primary source of software vulnerabilities.
Type-unsafe languages, such as C and C++, are especially prone to buffer overflow vulnerabilities.
A buffer overflow occurs when a program allows the user to enter more data than expected, which can lead to modifications in memory.
At the code level, buffer overflow vulnerabilities typically arise from a violation of programmer's assumptions.

The Heartbleed bug, a vulnerability in the OpenSSL library, allowed attackers to access sensitive data from the server's memory.
The bug caused a security crisis, compromising millions of websites and impacting businesses globally.
While the Heartbleed bug was patched in 2014, it highlights the importance of comprehensive security measures and proactive vulnerability management.

C-strings are sequences of characters stored in a character array.
C-strings MUST be null-terminated, indicated by the '\0' character.
The problem with C-strings is that they lack runtime bounds checking, making them vulnerable to overflow when handling strings.
Overflow occurs when more data is written to a string than its allocated memory space can hold, potentially overwriting adjacent memory locations.

C++ provides the std::string class to manage strings and address some security concerns with C-strings.
std::string uses a pointer to a character array on the heap, which can still be compromised but has built-in security handling in some member functions like at.
For example, in code demos, replacing subscript [] operator with the at member function helps mitigate potential overflow vulnerabilities.

An index-out-of-bounds error occurs when accessing elements in an array outside the bounds of its allocated memory.
This can be caused by incorrect calculations, logic errors, or user input validation issues.

Off-by-one errors occur when a loop iterates one too few or one too many times, leading to incorrect data processing.
This can be caused by issues in loop termination conditions or incorrect array indexing.

Buffer attacks can result in system crashes, affecting program availability.
Attackers can exploit vulnerabilities to gain access privileges through arbitrary code execution.
Buffer overflows compromise data integrity by overwriting sensitive information or altering control flow.
Attackers might also use buffer overflows to gain access to sensitive data like passwords stored in memory.

Implementing Secure Code: Use bounds checking, input validation, and safe string handling functions to prevent buffer overflows during development.
Compiler Warnings: Enable compiler warnings to identify potential buffer overflows and other coding issues during compilation.
Stack Canaries: Adding random values on the stack before functions can detect memory corruption by checking these values at function exit.
Data Execution Prevention (DEP): Preventing the execution of code in memory locations that are not intended for code execution.
Address Space Layout Randomization (ASLR): Randomizing the addresses of system components like libraries, making it more challenging for attackers to predict the location of vulnerable code.