Page History

...

struct flexArrayStruct *structP;
size_t array_size;
size_t i;

/* Initialize array_size */

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

structP->num = 0;

/*
 * Access data[] as if it had been allocated
 * as data[array_size]
 */
for (i = 0; i < array_size; i++) {
  structP->data[i] = 1;
}

Noncompliant Code Example (Use Flexible Array Members)

When using C99 compliant compilers the one element array hack described above should not be used.  In this noncompliant code, just such an array is used where a flexible array member should be used instead.

...

As described above, the problem with this code is that strictly speaking the only member that is guaranteed to be valid is {{flexStruct->data\[0\]}}. Unfortunately, when using compilers that do not support the C99 standard in full, or at all, this approach may be the only solution.  Microsoft Visual Studio 2005, for example, does not implement the C99 syntax.

Compliant Solution (Use Flexible Array Members)

Fortunately, when working with C99 compliant compilers, the solution is simple - remove the 1 from the array declaration and adjust the size passed to the malloc() call accordingly.  In other words, use flexible array members.

...

In this case, the structure will be treated as if the member {{data\[\]}} had been declared to be {{data\[array_size\].}}

Noncompliant Code Example (Declaration)

When using structures with a flexible array member you should never directly declare an instance of the structure.  In this noncompliant code, a variable of type struct flexArrayStruct is declared.

...

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\]}}) will likely overwrite memory not owned by the structure.

Compliant Code Example (Declaration)

The solution is to always declare pointers to structures containing a flexible array member and dynamically allocate memory for them.  The following code snippet illustrates this.

...

In this code snippet the resolves the issue by declaring a pointer to {{flexArrayStruct}} and then dynamically allocating memory for the pointer to point to.  In this case it is acceptable to access the elements of the {{data\[\]}} member as described in C99 Section 6.7.2.1, paragraph 16.

Noncompliant Code Example (Copying)

When using structures with a flexible array member you should never directly copy an instance of the structure.  This noncompliant code attempts to replicate a copy of struct flexArrayStruct.

...

The problem with this code 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.

Compliant Solution (Copying)

This compliant solution uses memcpy() to properly copy the content of flexStructA into flexStructB.

...

In this case the copy is explicit and the flexible array member is accounted for and copied as well.

Noncompliant Code Example (Reference)

When using structures with a flexible array member you should never directly pass an instance of the structure in a function call.  In this noncompliant code, the flexible array structure is passed directly to a function which tries to print the array elements.

...

The problem with this code is that passing the structure directly to the function actually makes a copy of the structure.  This copied fails for the same reason as the copy example above.

Compliant Solution (Reference)

Never allow a structure with a flexible array member to be passed directly in a function call.  The above code can be fixed by changing the function to accept a pointer to the structure.

void print_array(struct flexArrayStruct *structP) {
  size_t i;

  printf("Array is: ");
  for (i = 0; i < structP->num; i++) {
    printf("%d", structP->data[i]);
  }
  printf("\n");
}

struct flexArrayStruct *structP;
size_t array_size;
size_t i;

/* initialize array_size */

/* space 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);

Risk Assessment

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

Automated Detection

Compass/ROSE can detect some violations of this rule.  In particular, it warns if the last element of a struct is an array with a small index (0 or 1).

Related Vulnerabilities

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

References

\[[ISO/IEC 9899:1999|AA. C References#ISO/IEC 9899-1999]\]
\[[JTC1/SC22/WG14 N791|http://www.open-std.org/jtc1/sc22/wg14/www/docs/n791.htm]\]

...