Page History

Wiki MarkupThe C99 standard \[The C Standard, 6.7.3.2, paragraph 20 [ISO/IEC 9899:1999|AA. C References#ISO/IEC 9899-1999]\] introduces flexible array members into the language. While flexible array members are a useful addition they need to be understood and used with care. 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 ﬂexible 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:

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

This definition means that , when allocating storagewhen computing 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 dynamically. Flexible array structures must

Have dynamic storage duration (be allocated

...

via malloc() or another dynamic allocation function)
Be dynamically 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 value

Noncompliant Code Example (Storage

...

Duration)

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

Code Block

bgColor	#FFcccc
lang	c

#include <stddef.h>
 
struct flexArrayStruct flexStruct;
flex_array_struct {
  size_t array_size;
size_t i;

/* Initialize array_size */

num;
  int data[];
};
 
void func(void) {
  struct flex_array_struct flex_struct;
  size_t array_size = 4;

  /* Initialize structure */
flexStruct  flex_struct.num = 0array_size;

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

Wiki Markup

The problem with this code is that the {{flexArrayStruct}} does not actually reserve space for the integer array data - it can't as the size hasn't been specified. Consequently, while 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 bounds of the object.

Because 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 struct flexArrayStruct. flex_array_struct:

Code Block

bgColor	#ccccff
lang	c

#include <stdlib.h>
 
struct flexArrayStruct *flexStruct;
flex_array_struct {
  size_t array_sizenum;
size_t i;

/* Initialize  int data[];
};
 
void func(void) {
  struct flex_array_struct *flex_struct;
  size_t array_size = */4;

  /* Dynamically allocate memory for the structurestruct */
flexStruct  flex_struct = (struct flexArrayStructflex_array_struct *)malloc(
    sizeof(struct flexArrayStructflex_array_struct)
    + sizeof(int) * array_size
);
  if (flexStructflex_struct == NULL) {
    /* Handle mallocerror failure */
  }

  /* Initialize structure */
flexStruct  flex_struct->num = 0array_size;

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

...

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.:

Code Block

bgColor	#FFcccc
lang	c

#include <stddef.h>
 
struct flexArrayStruct *flexStructA;
struct flexArrayStruct *flexStructB;
flex_array_struct {
  size_t array_sizenum;
size_t i  int data[];
};
 
/* Initialize void func(struct flex_array_sizestruct */

/* Allocate memory for flexStructA */

/* Allocate memory for flexStructB */

/* Initialize flexStructA */

/* ... */

*flexStructB = *flexStructA;
struct_a,
          struct flex_array_struct *struct_b) {
  *struct_b = *struct_a;
}

When the structure is copied, The problem with this noncompliant code example is that 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 flexStructA into flexStructB.of struct_a into struct_b:

Code Block

bgColor	#ccccff
lang	c

#include <string.h>
 
struct flexArrayStruct *flexStructA;
struct flexArrayStruct *flexStructB;
flex_array_struct {
  size_t array_sizenum;
size_t i  int data[];
};
 
/* Initialize void func(struct flex_array_sizestruct */

/* Allocate memory for flexStructA */

/* Allocate memory for flexStructB */

/* Initialize flexStructA */

/* ... */

memcpy(
  flexStructB, 
  flexStructA, 
  (sizeof(struct flexArrayStruct) + sizeof(int) * array_size)
);

This compliant solutions ensures that the entire structure, including the flexible array member, is correctly copied.

struct_a,
          struct flex_array_struct *struct_b) {
  if (struct_a->num > struct_b->num) {
    /* Insufficient space; handle error */
    return;
  }
  memcpy(struct_b, struct_a,
         sizeof(struct flex_array_struct) + (sizeof(int)
           * struct_a->num));
}

Noncompliant Code Example (Function Arguments)

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

Code Block

bgColor	#FFcccc
lang	c

#include <stdio.h>
#include <stdlib.h>
 
struct flex_array_struct
void print_array(struct flexArrayStruct structP) {
  size_t i num;
  int data[];
};
 
void print_array(struct flex_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;
size_t i = 4;

/* initialize array_size */

/* spaceSpace is allocated for the struct */
structP  struct_p = (struct flexArrayStructflex_array_struct *)malloc(
    sizeof(struct flexArrayStruct) flex_array_struct)
    + sizeof(int) * array_size
);
  if (structPstruct_p == NULL) {
    /* Handle malloc failureerror */
  }

structP  struct_p->num = array_size;

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

  print_array(*structPstruct_p);
}

Because C passes the argument is passed by value, a 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 is passed by reference and not .by value:

Code Block

bgColor	#ccccff
lang	c

#include <stdio.h>
#include <stdlib.h>
 
struct flex_array_struct 
void print_array(struct flexArrayStruct *structP) {
  size_t i;
 num;
  int data[];
};
 
void print_array(struct flex_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;
size_t i = 4;

/* initialize array_size */

/* spaceSpace is allocated for the struct */
structP = (struct flexArrayStruct *)malloc(
  sizeof(struct flexArrayStruct) + sizeof(int) * array_size
);
if (structP == NULL) {
  /* Handle malloc failure */
}

structP->num = array_size;

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

print_array(structP);
and initialized... */

  print_array(struct_p);
}

Risk Assessment

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

Rule	Severity	Likelihood	Remediation Cost	Priority	Level
MEM33-C

low

Low

unlikely

Unlikely

low

Low

P3

L3

Automated Detection

Tool

Version

Checker

Description

Astrée

Include Page

	Astrée_V
	Astrée_V

flexible-array-member-assignment
flexible-array-member-declaration

Fully checked

Axivion Bauhaus Suite

Include Page

	Axivion Bauhaus Suite_V
	Axivion Bauhaus Suite_V

CertC-MEM33

Fully implemented

CodeSonar

Include Page

	CodeSonar_V
	CodeSonar_V

LANG.STRUCT.DECL.FAM

Declaration of Flexible Array Member

Compass/ROSE

...

Can detect

...

all of these

Cppcheck Premium

Include Page

	Cppcheck Premium_V
	Cppcheck Premium_V

premium-cert-mem33-c

Partially implemented

Helix QAC

Include Page

	Helix QAC_V
	Helix QAC_V

C1061, C1062, C1063, C1064

Klocwork

Include Page

	Klocwork_V
	Klocwork_V

MISRA.INCOMPLETE.STRUCT
MISRA.MEMB.FLEX_ARRAY.2012

LDRA tool suite

Include Page

	LDRA_V
	LDRA_V

649 S, 650 S

Fully implemented

Parasoft C/C++test

Include Page

	Parasoft_V
	Parasoft_V

CERT_C-MEM33-a
CERT_C-MEM33-b

Allocate structures containing a flexible array member dynamically
Do not copy instances of structures containing a flexible array member

Polyspace Bug Finder

Include Page

	Polyspace Bug Finder_V
	Polyspace Bug Finder_V

CERT C: Rule MEM33-C

Checks for misuse of structure with flexible array member (rule fully covered)

RuleChecker

Include Page

	RuleChecker_V
	RuleChecker_V

flexible-array-member-assignment
flexible-array-member-declaration

Fully checked

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)

Taxonomy	Taxonomy item	Relationship
CERT C Secure Coding Standard	DCL38-C.

...

Use the correct syntax when declaring a flexible array member

Prior to 2018-01-12: CERT: Unspecified Relationship

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

References

...

[ISO/IEC

...

9899:

...

2024]	Subclause 6.7.3.2, "Structure and Union Specifiers"
[JTC1/SC22/WG14

...

N791]

Solving the Struct Hack Problem

...

Image Added Image Added |http://www.open-std.org/jtc1/sc22/wg14/www/docs/n791.htm]\]MEM32-C. Detect and handle memory allocation errors 08. Memory Management (MEM) Image Modified

Space shortcuts

Page tree

Versions Compared

Old Version 58

New Version Current

Key

Noncompliant Code Example (Storage

Duration)

Compliant Solution (Storage Duration

)

Noncompliant Code Example (Copying)

Compliant Solution (Copying)

Noncompliant Code Example (Function Arguments)

Compliant Solution (Function Arguments)

Risk Assessment

Automated Detection

Related Vulnerabilities

Related Guidelines

CERT-CWE Mapping Notes

CWE-401 and MEM33-CPP

Bibliography

References