Memory corruption
|
|
Memory corruption occurs when a memory location or register is accidentally overwritten by a program, due to a programming error. Most often, corruption happens as a result of the mis-use of an invalid memory address.
There are some very common mistakes that cause corruption:
1) Most advanced programming languages allow you to allocate and de-allocate memory units. In 'C', for example, a 'pointer' is used to represent a specific address to an 'allocated' unit of memory. If the data your program writes to that address is larger than the size that was allocated for the unit, you will 'overwrite' into a different unit of memory that may or may not be used by some other part of the program. Later, when the offended area of memory is accessed by the program, it would contain unexpected data (thus the seemingly random results).
2) You would get a similar result if you wrote to a random or otherwise invalid or unallocated address. Let's say you write to address '1' without allocating that address. In some languages, there is no verification of whether or not that's ok. The compiler assumes you know what you're doing. If, later in the code, you try to allocate a unit of memory properly, the program (unaware that you're already using '1') might return that address or something nearby. You write completely different data to that address and then de-allocate it. That data you were expecting at '1' is now long gone or corrupt and once again, unexpected results.
3) Un-allocating (commonly called 'freeing') a memory address that you never actually allocated. This may or may not change the data at the address in question and once again, you would get unexpected results (sometimes).
This kind of error may crash a program immediately, or lurk undetected for years, only occasionally causing the wrong behaviour.
Finding such bugs can be extremely difficult. Therefore, programming tools that detect such errors automatically, such as Valgrind, can be invaluable.