C library functions that make changes to arrays or objects take at least two arguments: a pointer to the array or object and an integer indicating the number of elements or bytes to be manipulated. If improper arguments are supplied to such a function, it might cause the function to form a pointer that does not point into or just past the end of the object, resulting in undefined behavior.

For the purposes of this rule, the element count of a pointer is the size of the object to which it points, expressed by the number of elements which are valid to access.

In the following code,

int arr[5];
int *p = arr;

unsigned char *p2 = (unsigned char *)arr;
unsigned char *p3 = arr + 2;
void *p4 = arr;

the element count of the pointer p is sizeof(arr) / sizeof(arr[0]), that is, 5.  The element count of the pointer p2, is sizeof(arr), that is, 20 on platforms where sizeof(int) == 4.  The element count of the pointer p3 is 12 on platforms where sizeof(int) == 4, because p3 points two elements past the start of the array arr.  The element count of p4 is treated as though it were unsigned char * instead of void *, and so is the same as p2.

Standard Library Functions

The following are lists of C library functions to which this rule applies.

Library Functions That Take a Pointer and Integer

The following standard library functions take a pointer argument and a size argument, with the constraint that the pointer must point to a valid memory object of at least the number of elements indicated by the size argument.

¹ Takes two pointers and an integer, but the integer only specifies the element count of the output buffer. not the input buffer.
² Takes two pointers and an integer, but the integer only specifies the element count of the input buffer, not the output buffer.
³ Takes two pointers and two integers; each integer corresponds to the element count of one of the pointers.
⁴ Takes a pointer and two size-related integers; the first size-related integer parameter specifies the number of bytes available in the buffer, the second size-related integer parameter specifies the number of bytes to write within the buffer.

Library Functions That Take Two Pointers and an Integer

The following standard library functions take two pointer arguments and a size argument, with the constraint that both pointers must point to valid memory objects of at least the number of elements indicated by the size argument.

Library Functions That Take a Pointer and Two Integers

The following standard library functions take a pointer argument and two size arguments, with the constraint that the pointer must point to a valid memory object containing at least as many bytes as the product of the two size arguments.

Noncompliant Code Example (Element Count)

In this noncompliant code example, the incorrect element count is used in a call to wmemcpy().  The sizeof operator returns the size expressed in bytes, but wmemcpy() uses an element count based on wchar_t *.

#include <string.h>
#include <wchar.h>
 
static const char str[] = "Hello world";
static const wchar_t w_str[] = L"Hello world";
void func(void) {
  char buffer[32];
  wchar_t w_buffer[32];
  memcpy(buffer, str, sizeof(str));
  wmemcpy(w_buffer, w_str, sizeof(w_str));
}

Compliant Solution (Element Count)

When using functions that operate on pointed-to regions, programmers must always express the integer size in terms of the element count expected by the function.  For instance, memcpy() expects the element count expressed in terms of void *, but wmemcpy() expects the element count expressed in terms of wchar_t *.  Instead of using the sizeof operator, calls to return the number of elements in the string are used, which matches the expected element count for the copy functions.

#include <string.h>
#include <wchar.h>
 
static const char str[] = "Hello world";
static const wchar_t w_str[] = L"Hello world";
void func(void) {
  char buffer[32];
  wchar_t w_buffer[32];
  memcpy(buffer, str, strlen(str) + 1);
  wmemcpy(w_buffer, w_str, wcslen(w_str) + 1);
} 

Noncompliant Code Example (Pointer + Integer)

This noncompliant code example assigns a value greater than the size of available memory to n, which is then passed to memset():

#include <stdlib.h>
#include <string.h>
 
void f1(size_t nchars) {
  char *p = (char *)malloc(nchars);
  const size_t n = nchars + 1;

  memset(p, 0, n);
}

Compliant Solution (Pointer + Integer)

For calls that take a pointer and an integer size, the given size should not be greater than the element count of the pointer.  This compliant solution ensures that the value of n is not greater than the size of the dynamic memory pointed to by the pointer p:

#include <stdlib.h>
#include <string.h>
 
void f1(size_t nchars) {
  char *p = (char *)malloc(nchars);
  const size_t n = nchars;

  memset(p, 0, n);
}

Noncompliant Code Example (Pointer + Integer)

In this noncompliant code example, the element count of the array a is ARR_SIZE elements.  Because memset expects a byte count, the size of the array is scaled incorrectly by sizeof(int) instead of sizeof(float), which can form an invalid pointer on architectures where sizeof(int) != sizeof(float).

#include <string.h>
 
void f2() {
  const size_t ARR_SIZE = 4;
  float a[ARR_SIZE];
  const size_t n = sizeof(int) * ARR_SIZE;
  void *p = a;

  memset(p, 0, n);
}

Compliant Solution (Pointer + Integer)

In this compliant solution, the element count required by memset is properly calculated without resorting to scaling.

#include <string.h>
 
void f2() {
  const size_t ARR_SIZE = 4;
  float a[ARR_SIZE];
  const size_t n = sizeof(a);
  void *p = a;

  memset(p, 0, n);
}

Noncompliant Code Example (Two Pointers + One Integer)

In this noncompliant example, a diagnostic is required because the value of n is not computed correctly, allowing a possible write past the end of the object referenced by p:

#include <string.h>
 
void f4(char p[], const char *q) {
  const size_t n = sizeof(p); 
  if ((memcpy(p, q, n)) == p) {
  }
}

This example is also a violation of ARR01-C. Do not apply the sizeof operator to a pointer when taking the size of an array.

Compliant Solution (Two Pointers + One Integer)

For calls that take a two pointers and an integer size, the given size should not be greater than the element count of either pointer.  This compliant solution ensures that n is equal to the size of the character array:

#include <string.h>
 
void f4(char p[], const char *q, size_t size_p) {
  const size_t n = size_p; 
  if ((memcpy(p, q, n)) == p) {
  }
}

Noncompliant Code Example (One Pointer + Two Integers)

In this noncompliant code example, the size of struct obj is assumed to be eight bytes to account for padding.  However, the padding is dependent on the target architecture as well as compiler settings, so this may be the incorrect size of the object, which then yields the incorrect element count.

#include <stdint.h>
#include <stdio.h>
 
struct obj {
  char c;
  int i;
};
 
void func(FILE *f, struct obj *objs, size_t numObjs) {
  const size_t obj_size = 8;
  if (numObjs > (SIZE_MAX / obj_size) ||
      numObjs != fwrite(objs, obj_size, numObjs, f)) {
    /* Handle error */
  }
}

Note that this example is compliant with INT30-C. Ensure that unsigned integer operations do not wrap. 

Compliant Solution (One Pointer + Two Integers)

For calls that take a pointer and two integers, generally accept one integer representing the size of an individual object, and a second integer representing the number of objects in the array.  The resulting product of the two integers should not be greater than the element count of the pointer were it expressed as an unsigned char *.   See INT30-C. Ensure that unsigned integer operations do not wrap for more information.

#include <stdint.h>
#include <stdio.h>
 
struct obj {
  char c;
  int i;
};
 
void func(FILE *f, struct obj *objs, size_t numObjs) {
  if (numObjs > (SIZE_MAX / sizeof(*objs)) ||
      numObjs != fwrite(objs, sizeof(*objs), numObjs, f)) {
    /* Handle error */
  }
}

Risk Assessment

Depending on the library function called, the attacker may be able to use a heap overflow vulnerability to run arbitrary code.

Automated Detection

Related Vulnerabilities

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

Related Guidelines

Bibliography