...
To prevent information leakage, sensitive information must be cleared from dynamically allocated buffers before they are freed.
free()
Non-Compliant Code Example
...
Calling free() on a block of dynamic memory causes the space to be deallocated, that is, the memory block is made available for future allocation. However, the data stored in the block of memory to be recycled may be preserved. If this memory block contains sensitive information, that information may be unintentionally exposed.
In this example, sensitive information stored in the dynamically allocated memory referenced by secret is copied to the dynamically allocated buffer, new_secret, which is processed and eventually deallocated by a call to free(). Because the memory is not cleared, it may be reallocated to another section of the program where the information stored in new_secret may be unintentionally leaked.
| Code Block | ||
|---|---|---|
| ||
/* ... */ char *new_secret; size_t size = strlen(secret); if (size == SIZE_MAX) { /* Handle Error */ } new_secret = malloc(size+1); if (!new_secret) { /* Handle Error */ } strcpy(new_secret, secret); /* Process new_secret... */ free(new_secret); /* ... */ |
Compliant Solution
...
To prevent information leakage, dynamic memory containing sensitive information should be sanitized before being freed. This is commonly accomplished by clearing the allocated space (that is, filling the space with '\0' characters).
| Code Block | ||
|---|---|---|
| ||
/* ... */ char *new_secret; size_t size = strlen(secret); if (size == SIZE_MAX) { /* Handle Error */ } /* use calloc() to zero-out allocated space */ new_secret = calloc(size+1,sizeof(char)); if (!new_secret) { /* Handle Error */ } strcpy(new_secret, secret); /* Process new_secret... */ /* sanitize memory */ memset(new_secret, '\0', size); free(new_secret); /* ... */ |
| Wiki Markup |
|---|
The {{calloc()}} function ensures that the newly allocated memory has also been cleared. Because {{sizeof(char)}} is guaranteed to be 1, this solution does not need to check for a numeric overflow as a result of using {{calloc()}} \[[MEM37-C | MEM37-C. Ensure that size arguments to calloc() do not result in an integer overflow]\]. |
realloc()
Non-Compliant Code Example
...
Reallocating memory using the realloc() function is a degenerative regenerative case of freeing memory. The realloc() function deallocates the old object and returns a pointer to a new object.
| Wiki Markup |
|---|
Using {{realloc()}} to resize dynamic memory may inadvertently expose sensitive information, or it may allow heap inspection as described in Fortify's _Taxonomy of Software Security Errors_ \[[vulncat|http://vulncat.fortifysoftware.com/2/HI.html]\] and NIST's _Source Code Analysis Tool Functional Specification_ \[[NIST 06b|AA. C References#NIST 06b]\]. When {{realloc()}} is called it may allocate a new, larger object, copy the contents of {{secret}} to this new object, {{free()}} the original object, and assign the newly allocated object to {{secret}}. However, the contents of the original object may remain in memory. |
| Code Block | ||
|---|---|---|
| ||
/* ... */ size_t secret_size; /* ... */ if (secret_size > SIZE_MAX/2) { /* handle error condition */ } secret = realloc(secret, secret_size * 2); /* ... */ |
| Wiki Markup |
|---|
A test is added at the beginning of this code to make sure that the integer multiplication does not result in an integer overflow \[[INT32-C|INT32-C. Ensure that integer operations do not result in an overflow]\]. |
Compliant Solution
...
A compliant program cannot rely on realloc() because it is not possible to clear the memory prior to the call.
Instead, a custom function must be used that operates similar to realloc() but sanitizes sensitive information as heap-based buffers are resized. Again, this is done by overwriting the space to be deallocated with '\0' characters.
| Code Block | ||
|---|---|---|
| ||
/* ... */ size_t secret_size; /* ... */ if (secret_size > SIZE_MAX/2) { /* handle error condition */ } /* calloc() initializes memory to zero */ temp_buff = calloc(secret_size * 2, sizeof(char)); if (temp_buff == NULL) { /* Handle Error */ } memcpy(temp_buff, secret, secret_size); /* sanitize the buffer */ memset(secret, '\0', secret_size); free(secret); secret = temp_buff; /* install the resized buffer */ temp_buff = NULL; /* ... */ |
| Wiki Markup |
|---|
The {{calloc()}} function ensures that the newly allocated memory has also been cleared. Because {{sizeof(char)}} is guaranteed to be 1, this solution does not need to check for a numeric overflow as a result of using {{calloc()}} \[[MEM37-C | MEM37-C. Ensure that size arguments to calloc() do not result in an integer overflow]\]. |
...