Page History

The C Standard provides flexible array members in the C language. While flexible array members are useful, they need to be understood and used with care, 6.7.3.2, paragraph 20 [ISO/IEC 9899:2024], says

As a special case, the last element of a structure with more than one named member may have an incomplete array type; this is called a flexible array member. In most situations, the flexible array member is ignored. In particular, the size of the structure is as if the flexible array member were omitted except that it may have more trailing padding than the omission would imply.

The following is an example of a structure that contains a flexible array member:

struct flexArrayStructflex_array_struct {
  int num;
  int data[];
};

This definition means that when allocating storagecomputing the size of such a structure, only the first member, num, is considered. ConsequentlyUnless the appropriate size of the flexible array member has been explicitly added when allocating storage for an object of the struct, the result of accessing the member data of a variable of type struct flexArrayStruct nonpointer type struct flex_array_struct is undefined. DCL38-C. Use the correct syntax when declaring a flexible array membersmember describes the correct way to declare a struct with a flexible array member.

To avoid the potential for undefined behavior, structures that contain a flexible array member should always be allocated and operated on dynamically. Flexible array structures should not be:structures must

• Have dynamic storage duration (be allocated via malloc() or another dynamic allocation function)
• Be dynamically copied
• declared on the stack; they should be on the heap.
• copied via assignment; they should be copied using memcpy() or a similar function .and not by assignment
• When used as an argument to a function, be passed by pointer and not copied by valuepassed as raw arguments to functions; should be passed as a pointer instead.

Noncompliant Code Example (Storage

...

Duration)

This noncompliant code example statically allocates uses automatic storage for a structure containing a flexible array member:

#include <stddef.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
void func(void) {
  struct flexArrayStruct flexStructflex_array_struct flex_struct;
  size_t array_size = 4;

  /* Initialize structure */
  flexStructflex_struct.num = array_size;

  for (size_t i = 0; i < array_size; i++i) {
    flexStructflex_struct.data[i] = 0;
  }
}

The problem with this code is that the flexArrayStruct does not actually reserve space for the integer array data; it can't because the size is not specified. Consequently, although initializing the num member to zero is allowed, attempting to write even one value into data (that is, data[0]) is likely to overwrite memory outside of the object's boundsBecause the memory for flex_struct is reserved on the stack, no space is reserved for the data member. Accessing the data member is undefined behavior.

Compliant Solution (Storage

...

Duration)

This compliant solution dynamically allocates storage for flex_array_struct flexArrayStruct:

#include <stdlib.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
void func(void) {
  struct flexArrayStructflex_array_struct *flexStructflex_struct;
  size_t array_size = 4;

  /* Dynamically allocate memory for the structure.struct */
  flexStructflex_struct = (struct flexArrayStructflex_array_struct *)malloc(
    sizeof(struct flexArrayStructflex_array_struct)
    + sizeof(int) * array_size);
  if (flexStructflex_struct == NULL) {
    /* Handle error */
  }

  /* Initialize structure */
  flexStructflex_struct->num = array_size;

  for (size_t i = 0; i < array_size; i++i) {
    flexStructflex_struct->data[i] = 0;
  }
}

The data[] member of flexStruct can now be accessed as described in the C Standard, subclause 6.7.2.1, paragraph 18 [ISO/IEC 9899:2011].

Noncompliant Code Example (Copying)

This noncompliant code example attempts to copy an instance of a structure containing a flexible array member (struct flex_array_struct flexArrayStruct) by assignment:

#include <stddef.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
void func(struct flexArrayStructflex_array_struct *structAstruct_a,
          struct flexArrayStructflex_array_struct *structBstruct_b) {
  *flexStructBstruct_b = *flexStructAstruct_a;
}

The problem with this noncompliant code example is that when When the structure is copied, the size of the flexible array member is not considered, and only the first member of the structure, num, is copied, leaving the array contents untouched.

Compliant Solution (Copying)

This compliant solution uses memcpy() to properly copy the content of structA into structBstruct_a into struct_b:

#include <string.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
void func(struct flexArrayStructflex_array_struct *structAstruct_a,
          struct flexArrayStruct *structB) {flex_array_struct *struct_b) {
  if (struct_a->num > struct_b->num) {
    /* Insufficient space; handle error */
    return;
  }
  memcpy(structBstruct_b, structAstruct_a,
         sizeof(struct flexArrayStructflex_array_struct) + (sizeof(int)
           * arraystruct_sizea->num));
}

...

Noncompliant Code Example (Function Arguments)

In this noncompliant code example, the flexible array structure is passed directly by value to a function that tries to print prints the array elements:

#include <stdio.h>
#include <stdlib.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
void print_array(struct flexArrayStruct structPflex_array_struct struct_p) {
  puts("Array is: ");
  for (size_t i = 0; i < structPstruct_p.num; i++i) {
    printf("%d ", structPstruct_p.data[i]);
  }
  putsputchar("'\n"');
}

void func(void) {
  struct flexArrayStructflex_array_struct *structPstruct_p;
  size_t array_size = 4;

  /* Space is allocated for the struct. */
  structPstruct_p = (struct flexArrayStructflex_array_struct *)malloc(
    sizeof(struct flexArrayStructflex_array_struct)
    + sizeof(int) * array_size);
  if (structPstruct_p == NULL) {
    /* Handle error */
  }
  structPstruct_p->num = array_size;

  for (size_t i = 0; i < array_size; i++i) {
    structPstruct_p->data[i] = i;
  }
  print_array(*structPstruct_p);
}

Because C passes the argument is passed by value, the structure is copied onto the stack. The size of the flexible array member is not considered when the structure is copied, and only the first member of the structure, num, is copied.

Compliant Solution (Function Arguments)

In this compliant solution, the print_array() function accepts a pointer to the structure rather than the structure itselfthe structure is passed by reference and not by value:

#include <stdio.h>
#include <stdlib.h>
 
struct flexArrayStructflex_array_struct {
  intsize_t num;
  int data[];
};
 
void print_array(struct flexArrayStructflex_array_struct *structPstruct_p) {
  puts("Array is: ");
  for (size_t i = 0; i < structPstruct_p->num; i++i) {
    printf("%d ", structPstruct_p->data[i]);
  }
  putsputchar("'\n"');
}
 
void func(void) {
  struct flexArrayStructflex_array_struct *structPstruct_p;
  size_t array_size = 4;

  /* Space is allocated for the struct. */
  structP = (struct flexArrayStruct *)malloc(
    sizeof(struct flexArrayStruct) + sizeof(int) * array_size);
  if (structP == NULL) {
    /* Handle error */
  }
  structP->num = array_size;

  for (size_t i = 0; i < array_size; i++) {
    structP->data[i] = i;
  }
  print_array(structPand initialized... */

  print_array(struct_p);
}

Risk Assessment

Failure to use structures with flexible array members correctly can result in undefined behavior. 

Automated Detection

Related Vulnerabilities

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

Related Guidelines

Key here (explains table format and definitions)

CERT-CWE Mapping Notes

Key here for mapping notes

CWE-401 and MEM33-CPP

There is no longer a C++ rule for MEM33-CPP. (In fact, all C++ rules from 30-50 are gone, because we changed the numbering system to be 50-99 for C++ rules.)

Bibliography

...

Image Modified Image Modified Image Modified