CertC-EXP03

Do not assume the size of a structure is the sum of the sizes of its members

Required inputs: IR

The size of a structure is not always equal to the sum of the sizes of its members. Subclause 6.7.2.1 of the C Standard states, "There may be unnamed padding within a structure object, but not at its beginning" [ ISO/IEC 9899:2011 ].

This unnamed padding is often called structure padding . Structure members are arranged in memory as they are declared in the program text. Padding may be added to the structure to ensure the structure is properly aligned in memory. Structure padding allows for faster member access on many architectures.

Rearranging the fields in a struct can change the size of the struct . It is possible to minimize padding anomalies if the fields are arranged in such a way that fields of the same size are grouped together.

Padding is also called struct member alignment . Many compilers provide a flag that controls how the members of a structure are packed into memory. Modifying this flag may cause the size of the structures to vary. Most compilers also include a keyword that removes all padding; the resulting structures are called packed structures . Overriding the default behavior is often unwise because it leads to interface compatibility problems (the nominally same struct has its layout interpreted differently in different modules).

Noncompliant Code Example

This noncompliant code example assumes that the size of struct buffer is equal to the sum of the size of its individual components, which may not be the case [ Dowd 2006 ]. The size of struct buffer may actually be larger because of structure padding.

enum { buffer_size = 50 };

struct buffer {
  size_t size;
  char bufferC[buffer_size];
};

/* ... */

void func(const struct buffer *buf) {

  /*
   * Incorrectly assumes sizeof(struct buffer) =
   * sizeof(size_t) + sizeof(bufferC)
   */
  struct buffer *buf_cpy = (struct buffer *)malloc(
    sizeof(size_t) + (buffer_size * sizeof(char) /* 1 */)
  );

  if (buf_cpy == NULL) {
    /* Handle malloc() error */
  }

  /*
   * With padding, sizeof(struct buffer) may be greater than
   * sizeof(size_t) + sizeof(buff.bufferC), causing some data
   * to be written outside the bounds of the memory allocated.
   */
  memcpy(buf_cpy, buf, sizeof(struct buffer));

  /* ... */

  free(buf_cpy);
}
Compliant Solution

Accounting for structure padding prevents these types of errors:

enum { buffer_size = 50 };

struct buffer {
  size_t size;
  char bufferC[buffer_size];
};

/* ... */

void func(const struct buffer *buf) {

  struct buffer *buf_cpy =
    (struct buffer *)malloc(sizeof(struct buffer));

  if (buf_cpy == NULL) {
    /* Handle malloc() error */
  }

  /* ... */

  memcpy(buf_cpy, buf, sizeof(struct buffer));

  /* ... */

  free(buf_cpy);
}
Risk Assessment

Failure to correctly determine the size of a structure can lead to subtle logic errors and incorrect calculations, the effects of which can lead to abnormal program termination, memory corruption, or execution of arbitrary code.

Recommendation Severity Likelihood Detectable Repairable Priority Level
EXP03-C High Unlikely No No P3 L3
Related Guidelines
SEI CERT C++ Coding Standard VOID EXP03-CPP. Do not assume the size of a class or struct is the sum of the sizes of its members
Bibliography
[ Dowd 2006 ] Chapter 6, "C Language Issues" ("Structure Padding," pp. 284–287)
[ ISO/IEC 9899:2011 ] Subclause 6.7.2.1, "Structure and Union Specifiers"
[ Sloss 2004 ] Section 5.7, "Structure Arrangement"
Excerpt from SEI CERT C Coding Standard: Rules for Developing Safe, Reliable, and Secure Systems (2016 Edition) and SEI CERT C Coding Standard [https://cmu-sei.github.io/secure-coding-standards/sei-cert-c-coding-standard/recommendations/expressions-exp/exp03-c], Copyright (C) 1995-2026 Carnegie Mellon University. See 9.4 3rd-Party Licenses in the documentation for full details.

Possible Messages

Key

Text

Severity

Disabled

assumed_struct_size

Do not assume the size of a structure is the sum of the sizes of its members.

None

False

Options

sized_write_functions

sized_write_functions

Type: set[bauhaus.analysis.config.QualifiedName]

Default: {'__builtin___memcpy_chk', '__builtin___memmove_chk', '__builtin___memset_chk', 'memcpy', 'memmove', 'memset'}

Names of functions writing a size-in-bytes argument (argument 2) through a destination pointer argument (argument 0), checked in addition to malloc/calloc/realloc.