CertC-EXP08¶
Ensure pointer arithmetic is used correctly
Required inputs: IR
When performing pointer arithmetic, the size of the value to add to a pointer is automatically scaled to the size of the type of the pointed-to object. For instance, when adding a value to the byte address of a 4-byte integer, the value is scaled by a factor of 4 and then added to the pointer. Failing to understand how pointer arithmetic works can lead to miscalculations that result in serious errors, such as buffer overflows.
Noncompliant Code Example
In this noncompliant code example, integer values returned by parseint(getdata()) are stored into an array of INTBUFSIZE elements of type int called buf [ Dowd 2006 ]. If data is available for insertion into buf (which is indicated by havedata() ) and buf_ptr has not been incremented past buf + sizeof(buf) , an integer value is stored at the address referenced by buf_ptr . However, the sizeof operator returns the total number of bytes in buf , which is typically a multiple of the number of elements in buf . This value is scaled to the size of an integer and added to buf . As a result, the check to make sure integers are not written past the end of buf is incorrect, and a buffer overflow is possible.
int buf[INTBUFSIZE];
int *buf_ptr = buf;
while (havedata() && buf_ptr < (buf + sizeof(buf))) {
*buf_ptr++ = parseint(getdata());
}
|
Compliant Solution
In this compliant solution, the size of buf , INTBUFSIZE , is added directly to buf and used as an upper bound. The integer literal INTBUFSIZE is scaled to the size of an integer, and the upper bound of buf is checked correctly.
int buf[INTBUFSIZE];
int *buf_ptr = buf;
while (havedata() && buf_ptr < (buf + INTBUFSIZE)) {
*buf_ptr++ = parseint(getdata());
}
|
An arguably better solution is to use the address of the nonexistent element following the end of the array, as follows:
int buf[INTBUFSIZE];
int *buf_ptr = buf;
while (havedata() && buf_ptr < &buf[INTBUFSIZE]) {
*buf_ptr++ = parseint(getdata());
}
|
This solution works because the C Standard guarantees the address of buf[INTBUFSIZE] even though no such element exists.
Noncompliant Code Example
This noncompliant code example is based on a flaw in the OpenBSD operating system. An integer, skip , is added as an offset to a pointer of type struct big . The adjusted pointer is then used as a destination address in a call to memset() . However, when skip is added to the struct big pointer, it is automatically scaled by the size of struct big , which is 32 bytes (assuming 4-byte integers, 8-byte long long integers, and no structure padding). This scaling results in the call to memset() writing to unintended memory.
struct big {
unsigned long long ull_1; /* Typically 8 bytes */
unsigned long long ull_2; /* Typically 8 bytes */
unsigned long long ull_3; /* Typically 8 bytes */
int si_4; /* Typically 4 bytes */
int si_5; /* Typically 4 bytes */
};
/* ... */
int f(void) {
size_t skip = offsetof(struct big, ull_2);
struct big *s = (struct big *)malloc(sizeof(struct big));
if (!s) {
return -1; /* Indicate malloc() failure */
}
memset(s + skip, 0, sizeof(struct big) - skip);
/* ... */
free(s);
s = NULL;
return 0;
}
|
A similar situation occurred in OpenBSD's make command [ Murenin 2007 ].
Compliant Solution
To correct this example, the struct big pointer is cast as a char * , which causes skip to be scaled by a factor of 1:
struct big {
unsigned long long ull_1; /* Typically 8 bytes */
unsigned long long ull_2; /* Typically 8 bytes */
unsigned long long ull_3; /* Typically 8 bytes */
int si_4; /* Typically 4 bytes */
int si_5; /* Typically 4 bytes */
};
/* ... */
int f(void) {
size_t skip = offsetof(struct big, ull_2);
struct big *s = (struct big *)malloc(sizeof(struct big));
if (!s) {
return -1; /* Indicate malloc() failure */
}
memset((char *)s + skip, 0, sizeof(struct big) - skip);
/* ... */
free(s);
s = NULL;
return 0;
}
|
Risk Assessment
Failure to understand and properly use pointer arithmetic can allow an attacker to execute arbitrary code.
| Recommendation | Severity | Likelihood | Detectable | Repairable | Priority | Level |
|---|---|---|---|---|---|---|
| EXP08-C | High | Probable | No | No | P6 | L2 |
Related Guidelines
| SEI CERT C++ Coding Standard | VOID EXP08-CPP. Ensure pointer arithmetic is used correctly |
| ISO/IEC TR 24772:2013 | Pointer Casting and Pointer Type Changes [HFC] Pointer Arithmetic [RVG] |
| ISO/IEC TS 17961 | Forming or using out-of-bounds pointers or array subscripts [invptr] |
| MISRA C:2012 | Rule 18.1 (required) Rule 18.2 (required) Rule 18.3 (required) Rule 18.4 (advisory) |
| MITRE CWE | CWE-468 , Incorrect pointer scaling |
Bibliography
| [ Dowd 2006 ] | Chapter 6, "C Language Issues" |
| [ Murenin 2007 ] |
|
Possible Messages
Key |
Text |
Severity |
Disabled |
|---|---|---|---|
scaled_arith |
Do not add or subtract a scaled integer to a pointer. |
None |
False |
Options
This rule shares the following common options: confidence, exclude_in_macros, exclude_messages_in_system_headers, excludes, extend_exclude_to_macro_invocations, includes, justification_checker, languages, post_processing, provider, report_at, severity
The following places define options that affect this rule: Stylechecks, Analysis-GlobalOptions
This rule has no individual options.