Page History

The C Standard, Annex J (184) [ISO/IEC 9899:2024], states that the behavior of a program is undefined when

The pointer argument to the free or realloc function does not match a pointer earlier returned by a memory management function, or the space has been deallocated by a call to free or realloc.

See also undefined behavior 184.

Freeing memory that is not allocated dynamically can lead to result in heap corruption and other serious errors. The specific consequences of this error depends on the compiler, but ranges from nothing to abnormal program termination. Regardless of the compiler, avoid calling free() on non-dynamic memoryDo not call free() on a pointer other than one returned by a standard memory allocation function, such as malloc(), calloc(), realloc(), or aligned_alloc().

A similar situation arises when realloc() is supplied a pointer to non-dynamically allocated memory. The realloc() function is used to resize a block of dynamic memory. If realloc() is supplied a pointer to memory not allocated by a standard memory allocation function, such as malloc(), the behavior is undefined. One consequence is that the program may also terminate abnormally.

Non-compliant Code Example 1

The following piece of code validates the number of command line arguemnts. If the correct number of commmand line arguments have been specified, then the requested amount of memory is validated to assure it is a acceptable size and the memory allocated with malloc(). Next, the second command line argument is copied into str for further processing. Once this processing is complete, str is freed. However, if the incorrect number of arguments have been specified, str is set to a string literal and printed. Because str now references memory that was not dynamically allocated, an error will occur when str memory is freed.

.

This rule does not apply to null pointers. The C Standard guarantees that if free() is passed a null pointer, no action occurs.

Noncompliant Code Example

This noncompliant code example sets c_str to reference either dynamically allocated memory or a statically allocated string literal depending on the value of argc. In either case, c_str is passed as an argument to free(). If anything other than dynamically allocated memory is referenced by c_str, the call to free(c_str) is erroneous.

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
enum { MAX_ALLOCATION = 1000 };

#define MAX_SIZE_ALLOWED 1000

int main(int argc, const char *argv[]) {
  char *c_str = NULL;
  size_t len;

  if (argc == 2) {
    len = strlen(argv[1]) + 1;
    if (len > MAX_SIZE_ALLOWEDALLOCATION) {
      /* Handle Errorerror */
    }
    c_str = (char *)malloc(len);
    if (c_str == NULL) {
      /* Handle Allocationerror Error */
    }
    strcpy(c_str, argv[1]);
  }
  else {
    c_str = "usage: $>a.exe [string]";
    printf("%s\n", c_str);
  }
  /* ... */
  free(c_str);
  return 0;
}

Compliant Solution

...

In the This compliant solution , the program has been changed to eliminate eliminates the possibility of str referencing non-dynamic memory and when it is supplied c_str referencing memory that is not allocated dynamically when passed to free().:

Code Block
bgColor #ccccff lang c
#include <stdlib.h> #include <string.h> #include <stdio.h>   enum { #define MAX_SIZE_ALLOWEDALLOCATION = 1000 }; int main(int argc, const char *argv[]) { char *c_str = NULL; size_t len; if (argc == 2) { len = strlen(argv[1]) + 1; if (len > MAX_SIZE_ALLOWEDALLOCATION) { /* Handle Errorerror */ } c_str = (char *)malloc(len); if (c_str == NULL) { /* Handle Allocation Errorerror */ } strcpy(c_str, argv[1]); } else { printf("%s\n", "usage: $>a.exe [string]\n"); return EXIT_FAILURE; } free(c_str); return -1; } /* ... */ free(str); return 0; }

...

0; }

Noncompliant Code Example (realloc())

In this noncompliant example, the pointer parameter to realloc(), buf, does not refer to dynamically allocated memory:

#include <stdlib.h>
 
enum { BUFSIZE = 256 };
 
void f(void) {
  char buf[BUFSIZE];
  char *p = (char *)realloc(buf, 2 * BUFSIZE);
  if (p == NULL) {
    /* Handle error */
  }
}

Compliant Solution (realloc())

In this compliant solution, buf refers to dynamically allocated memory:

#include <stdlib.h>
 
enum { BUFSIZE = 256 };
 
void f(void) {
  char *buf = (char *)malloc(BUFSIZE * sizeof(char));
  char *p = (char *)realloc(buf, 2 * BUFSIZE);
  if (p == NULL) {
    /* Handle error */
  }
}

Note that realloc() will behave properly even if malloc() failed, because when given a null pointer, realloc() behaves like a call to malloc().

Risk Assessment

The consequences of this error depend on the implementation, but they range from nothing to arbitrary code execution if that memory is reused by malloc(). 

Automated Detection

Related Vulnerabilities

CVE-2015-0240 describes a vulnerability in which an uninitialized pointer is passed to TALLOC_FREE(), which is a Samba-specific memory deallocation macro that wraps the talloc_free() function. The implementation of  talloc_free() would access the uninitialized pointer, resulting in a remote exploit.

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

Related Guidelines

Key here (explains table format and definitions)

Bibliography

...

Image Added Image Added Image Added