Page History

Sensitive data stored in reusable resources may be inadvertently leaked to a less privileged user or attacker if not properly cleared. Examples of reusable resources include

• Dynamically allocated memory
• Statically allocated memory
• Automatically allocated (stack) memory
• Memory caches
• Disk
• Disk caches

The manner in which sensitive information can be properly cleared varies depending on the resource type and platform.

Noncompliant Code Example (free())

Dynamic memory managers are not required to clear freed memory and generally do not because of the additional runtime overhead. Furthermore, dynamic memory managers are free to reallocate this same memory. As a result, it is possible to accidentally leak sensitive information if it is not cleared before calling a function that frees dynamic memory. Programmers also cannot rely on memory being cleared during allocation.

To prevent information leakage, sensitive information must be cleared

Dynamic memory managers are not required to clear freed memory and generally do not because of the additional runtime overhead.  Furthermore, dynamic memory managers are free to reallocate this same memory.  As a result, it is possible to accidently leak sensitive information if it is not cleared before calling a function which frees, or may free, dynamic memory.  An example of this risk is the "Sun tarball" vulnerability described in \[Graff 03\].  Programmers cannot rely on memory being cleared during allocation either \[[MEM33-C. Do not assume memory allocation routines initialize memory]\].

In practice, this type of security flaw can expose sensitive information to unintended parties. The Sun tarball vulnerability discussed in _Secure Coding Principles & Practices: Designing and Implementing Secure Applications_ \[[Graf 03|AA. C References#Graf 03]\] and [Sun Security Bulletin #00122 | http://sunsolve.sun.com/search/document.do?assetkey=1-22-00122-1] illustrates a violation of this recommendation leading to sensitive data being leaked. Attackers may also be able to leverage this defect to retrieve sensitive information using techniques, such as _heap inspection_.

To prevent information leakage it is necessary to clear sensitive information from dynamically allocated buffers before they are freed.

Non-Compliant Code Example: free()

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 noncompliant 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 linkedleaked.

...
char *new_secret;
size_t size = strlen(secret);
if (size ==/* Initialize secret to a null-terminated byte string, 
   of less than SIZE_MAX) {
  /* Handle Error */
}

 chars */

size_t size = strlen(secret);
char *new_secret;
new_secret = (char *)malloc(size+1);
if (!new_secret) {
  /* Handle Errorerror */
}
strcpy(new_secret, secret);

/* Process new_secret... */

free(new_secret);
...new_secret = NULL;

Compliant Solution

...

To prevent information leakage, dynamic memory containing sensitive information should be sanitized before it is marked for deallocation. This being freed. Sanitization is commonly accomplished by clearing the allocated space (that is, filling the space with '\0' characters).

Code Block
bgColor #ccccff lang c
... char *new_secret; size_t size = strlen(secret); if (size == SIZE_MAX) { /* Handle Error */ } new_secret = calloc(size+1,sizeof(char)); /* use/* Initialize secret to a null-terminated byte string, of less than SIZE_MAX chars */ size_t size = strlen(secret); char *new_secret; /* Use calloc() to zero-out allocated space */ new_secret = (char *)calloc(size+1, sizeof(char)); if (!new_secret) { /* Handle Errorerror */ } strcpy(new_secret, secret); /* Process new_secret... */ /* Sanitize memory */ memset_s(new_secret, '\0', size); /* sanitize memory */ free(new_secret); ... new_secret = NULL;

The Wiki MarkupThe {{calloc()}} function is used in this example to ensure that the newly allocated memory has also be cleared. Because {{ 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]\].

Non-Compliant Code Example: realloc()

. (See MEM07-C. Ensure that the arguments to calloc(), when multiplied, do not wrap.)

See MSC06-C. Beware of compiler optimizations for a definition and discussion of using the memset_s() function.

Noncompliant Code Example (realloc())

Reallocating memory using realloc() can have the same problem as freeing memory. The realloc() function deallocates the old object and returns a pointer to a new object. Using realloc() to resize dynamic memory may inadvertently expose sensitive information, or it may allow heap inspection, as described in Fortify Taxonomy: Software Security Errors [Fortify 2006] and NIST's Source Code Analysis Tool Functional Specification [Black 2007].

In this example, 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 Wiki MarkupUsing {{realloc()}} to resize dynamic memory may inadvertently expose sensitive information, or allow heap inspection as is 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 \[[SAMATE|http://samate.nist.gov/docs/SAMATE_source_code_analysis_tool_spec_09_15_06.pdf]\]. When {{realloc()}} is called it may allocate a new, larger block of memory, copy the contents, of {{secret}} to this new block, {{free()}} the original block, and assign the newly allocated block to {{secret}}. However, the contents of the original block may remain in heap memory after being marked for deallocation.

char *secret;

/* Initialize secret */

size_t secret_size = strlen(secret);
/* ... */
if (secret_size > SIZE_MAX/2) {
   /* Handle error condition */
}
else {
secret = (char *)realloc(secret, newsecret_size * 2);
}

The secret_size is tested to ensure that the integer multiplication (secret_size * 2) does not result in an integer overflow. (See INT30-C.

...

Ensure that unsigned integer operations do not wrap.)

Compliant Solution

...

A compliant program cannot rely on realloc()

...

Correcting this example requires the programmer to write a custom routine that operates similar because it is not possible to clear the memory before the call. Instead, a custom function must be used that operates similarly to realloc(), but sanitizes sensitive information as heap-based buffers are resized. Again, this sanitization is done by overwriting the space to be deallocated with '\0' characters.

Code Block
bgColor #ccccff lang c
char *secret; /* Initialize secret */ size_t secret_size ... temp_buff = calloc(new_size,sizeof(char)strlen(secret); char *temp_buff; /* use calloc() to zero-out allocated space... */ if (tempsecret_buffsize == NULL> SIZE_MAX/2) { /* Handle error Errorcondition */ } if /* calloc() initializes memory to zero */ temp_buff = (char *)calloc(secret_size > new_size) * 2, sizeof(char)); if (temp_buff == NULL) { /* may lead to truncationHandle error */ secret_size = new_size;} memcpy(temp_buff, secret, secret_size); /* Sanitize the buffer */ memset((volatile char *)secret, '\0', secret_size); /* sanitize the buffer */ free(secret); secret = temp_buff; /* installInstall the resized buffer */ temp_buff = NULL; ...

Wiki Markup
Note that this solution may truncate the contents of the original buffer, {{secret}}, if the size of the resized buffer is smaller. This behavior is similar to how {{realloc()}} handles resizing to a smaller block of memory \[[ISO/IEC 9899-1999|AA. C References#ISO/IEC 9899-1999]\].

Risk Assessment

Failure to clear dynamic memory can result in leaked information.

The calloc() function ensures that the newly allocated memory is also 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(). (See MEM07-C. Ensure that the arguments to calloc(), when multiplied, do not wrap.)

Risk Assessment

In practice, this type of security flaw can expose sensitive information to unintended parties. The Sun tarball vulnerability discussed in Secure Coding Principles & Practices: Designing and Implementing Secure Applications [Graf 2003] and Sun Security Bulletin #00122 [Sun 1993] shows a violation of this recommendation, leading to sensitive data being leaked. Attackers may also be able to leverage this defect to retrieve sensitive information using techniques such as heap inspection.

References

...

Automated Detection

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

Related Guidelines

Bibliography

...

Image Added Image Added Image Added

...