Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

Do not use the assignment operator in the following cases because it contexts listed in the following table because doing so typically indicates programmer error and can result in unexpected behavior:.

OperatorContext 
ifControlling expression

...

whileControlling expression

...

do ... while

...

Controlling expression
forSecond operand
?:First operand
?:Second or third operands, where the ternary

...

expression is used in any of these contexts

...

&& Either operand 
|| either operand 
,

Second operand, when the comma expression is used in any of these contexts


 

Performing assignment statements in other contexts do not violate this rule. However, they may violate other rules, such as EXP30-C. Do not depend on the order of evaluation for side effects.


Noncompliant Code Example

In this noncompliant code example, an assignment expression is the outermost expression in an if statement:

...

Although the intent of the code may be to assign b to a and test the value of the result for equality to 0, it is very frequently a case of the programmer mistakenly using the assignment operator = instead of the equals operator ==. Consequently, many compilers will warn about this condition, making this coding error detectable by adhering to MSC00-C. Compile cleanly at high warning levels.

Compliant Solution (Unintentional Assignment)

When the assignment of b to a is not intended, this the conditional block is now executed when a is equal to b:

Code Block
bgColor#ccccff
langc
if (a == b) {
  /* ... */
}

Compliant Solution (Intentional Assignment)

When the assignment is intended, the following is an alternative compliant solutionthis compliant solution explicitly uses inequality as the outermost expression while performing the assignment in the inner expression:

Code Block
bgColor#ccccff
langc
if ((a = b) != 0) {
  /* ... */
}

It is less desirable in general, depending on what was intended, because it mixes the assignment in the condition, but it is clear that the programmer intended the assignment to occur.

Noncompliant Code Example

In this noncompliant code example, the expression x = y is used as the controlling expression of the while statement:

Code Block
bgColor#FFcccc
langc
 do { /* ... */ } while ( foo(), x = y ) ;

Compliant Solution (Unintentional Assignment)

When the assignment of y to x is not intended, this the conditional block is now should be executed only when x is equal to y, as in this compliant solution:

Code Block
bgColor#ccccff
langc
do { /* ... */ } while ( foo(), x == y ) ; 

Compliant Solution (Intentional Assignment)

When the assignment is intended, the following is an alternative this compliant solution can be used:

Code Block
bgColor#ccccff
langc
do { /* ... */ } while ( foo(), (x = y) != 0);

Compliant Solution (for statement)

The same result can be obtained using the for statement, which is specifically designed to evaluate an expression on each iteration of the loop, just before performing the test in its controlling expression. Remember that its controlling expression is the second operand, where the assignment occurs in its third operand:

Code Block
bgColor#ccccff
langc
 for ;
(; x; foo(), x = y) { /* ... */ }

Noncompliant Code Example

In this noncompliant example, the expression p = q is used as the controlling expression of the while statement:

Code Block
bgColor#FFcccc
langc
 do { /* ... */ } while ( x = y, p = q ) ;

Compliant Solution

This is a compliant example because In this compliant solution, the expression x = y is not used as the controlling expression of the while statement:

Code Block
bgColor#ccccff
langc
do { /* ... */ } while ( x = y, p == q); 

Noncompliant Code Example

This noncompliant code example has a typo that results in an assignment rather than a comparison.

Code Block
bgColor#FFcccc
langc
while (ch = '\t' || ch == ' ' 

...

|| ch == '\n') {
  /* ... */
}

Many compilers will warn about this condition. This coding error would typically be eliminated by adherence to MSC00-C. Compile cleanly at high warning levels. Although this code compiles, it will cause unexpected behavior to an unsuspecting programmer. If the intent was to verify a string such as a password, user name, or group user ID, the code may produce significant vulnerabilities and require significant debugging.

Compliant Solution (RHS Variable)

When comparisons are made between a variable and a literal or const-qualified variable, placing the variable on the right of the comparison operation can prevent a spurious assignment.

In this code example, the literals are placed on the left-hand side of each comparison. If the programmer were to inadvertently use an assignment operator, the statement would assign ch to '\t', which is invalid and produces a diagnostic message.

Code Block
bgColor#FFcccc
langc
while ('\t' = ch || ' ' == ch || '\n' == ch) {
  /* ... */
}

Due to the diagnostic, the typo will be easily spotted and fixed.

Code Block
bgColor#ccccff
langc
while ('\t' == ch || ' ' == ch || '\n' == ch) {
  

Exceptions

EXP18-EX1: Assignment can be used where the result of the assignment is itself a parameter to a comparison expression or relational expression. In this compliant example, the expression x = y  is itself a parameter to a comparison operation:

...

bgColor#ccccff
langc

...

/* ... */

...


}

As a result, any mistaken use of the assignment operator that could otherwise create a vulnerability for operations such as string verification will result in a compiler diagnostic regardless of compiler, warning level, or implementation.

Exceptions

EXP45-C-EX1

...

: Assignment can be

...

used where the result of the assignment is itself an operand to a comparison expression or relational expression. In this compliant example, the

...

expression x = y

...

  is itself an operand to a comparison operation:

Code Block
bgColor#ccccff
langc
if (

...

(

...

x = y) 

...

!= 0) { /* ... */ } 

...

EXP45-C-

...

EX2: Assignment can be

...

used where the expression consists of a single primary expression. The following code is compliant because the expression  x = y is a single primary expression:

 

Code Block
bgColor#ccccff
langc
if ( foo( x = y ) ) { /* ... */ } 

This The following controlling expression is a noncompliant example because because && is  is not a comparison or relational operator and the entire expression is not primary:

Code Block
bgColor#FFcccc
langc
if ( ( v = w ) && flag ) { /* ... */ } 

When the assignment of of v to  to w is not intended, this the following controlling expression can be used to execute the conditional block is now executed when when v is equal to to w:

Code Block
bgColor#ccccff
langc
if ( ( v == w ) && flag ) { /* ... */ }; 

When the assignment is intended, the following is an alternative compliant solutioncontrolling expression can be used:

Code Block
bgColor#ccccff
langc
if ( ( (v = w) != 0 ) && flag) { /* ... */ }; 

EXP45-C-EX3: Assignment can be used in a function argument or array index. In this compliant solution, the expression x = y is used in a function argument:


Code Block
bgColor#ccccff
langc
if (foo(x = y)) { /* ... */ }
;
 


Risk Assessment

Errors of omission can result in unintended program flow.

Recommendation

Severity

Likelihood

Remediation Cost

Priority

Level

EXP18

EXP45-C

Low

Likely

Medium

P6

L2

Automated Detection

Tool

Version

Checker

Description

Astrée
Include Page
Astrée_V
Astrée_V
assignment-conditionalFully checked
Axivion Bauhaus Suite

Include Page
Axivion Bauhaus Suite_V
Axivion Bauhaus Suite_V

CertC-EXP45
Clang
Include Page
Clang_V
Clang_V
-WparenthesesCan detect some instances of this rule, but does not detect all
CodeSonar
Include Page
CodeSonar_V
CodeSonar_V
LANG.STRUCT.CONDASSIG
LANG.STRUCT.SE.COND
LANG.STRUCT.USEASSIGN
Assignment in conditional
Condition contains side effects
Assignment result in expression
Compass/ROSE

 

 



Could detect violations of this recommendation by identifying any assignment expression as the top-level expression in an if or while statement

Cppcheck Premium

Include Page
Cppcheck Premium_V
Cppcheck Premium_V

premium-cert-exp45-cPartially implemented

ECLAIR

Include Page
ECLAIR_V
ECLAIR_V

CC2.EXP18
CC2.EXP21

Fully implemented

GCC
Include Page
GCC_V
GCC_V
 


Can detect violations of this recommendation when the -Wall flag is used

Helix QAC

Include Page
Helix QAC_V
Helix QAC_V

C3314, C3326, C3344, C3416

C++4071, C++4074


Klocwork
Include Page
Klocwork_V
Klocwork_V

ASSIGCOND.

GEN

CALL
ASSIGCOND.

CALL 

GEN
MISRA.ASSIGN.COND


LDRA tool suite
Include Page
LDRA_V
LDRA_V

9 S

 

PRQA QA-C Include PagePRQA_VPRQA_V3314Partially implemented

114 S, 132 S

Enhanced Enforcement
Parasoft C/C++test
Include Page
Parasoft_V
Parasoft_V

CERT_C-EXP45-b
CERT_C-EXP45-d

Assignment operators shall not be used in conditions without brackets
Assignment operators shall not be used in expressions that yield a Boolean value

PC-lint Plus

Include Page
PC-lint Plus_V
PC-lint Plus_V

720

Partially supported: reports Boolean test of unparenthesized assignment

Polyspace Bug Finder

Include Page
Polyspace Bug Finder_V
Polyspace Bug Finder_V

CERT C: Rule EXP45-CChecks for invalid use of = (assignment) operator (rule fully covered)
PVS-Studio

Include Page
PVS-Studio_V
PVS-Studio_V

V559, V633, V699
RuleChecker

Include Page
RuleChecker_V
RuleChecker_V

assignment-conditionalFully checked
SonarQube C/C++ Plugin
Include Page
SonarQube C/C++ Plugin_V
SonarQube C/C++ Plugin_V
AssignmentInSubExpression

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
EXP19-CPP. Do not perform assignments in conditional expressionsPrior to 2018-01-12: CERT: Unspecified Relationship
CERT Oracle Secure Coding Standard for Java
53
EXP51-J. Do not perform assignments in conditional expressionsPrior to 2018-01-12: CERT: Unspecified Relationship
ISO/IEC TR 24772:2013Likely Incorrect Expression [KOA]Prior to 2018-01-12: CERT: Unspecified Relationship
ISO/IEC TS 17961No assignment in conditional expressions [boolasgn]
MITRE CWE
Prior to 2018-01-12: CERT: Unspecified Relationship
CWE 2.11CWE-480, Use of Incorrect Operator2017-07-05: CERT: Rule subset of CWE
CWE 2.11CWE-4812017-07-05: CERT: Rule subset of CWE

CERT-CWE Mapping Notes

Key here for mapping notes

CWE-480 and EXP45-C

Intersection( EXP45-C, EXP46-C) = Ø

CWE-480 = Union( EXP45-C, list) where list =

  • Usage of incorrect operator besides s/=/==/

CWE-569 and EXP45-C

CWE-480 = Subset( CWE-569)

Bibliography

[Dutta 03]"Best Practices for Programming in C"
[Hatton 1995]Section 2.7.2, "Errors of Omission and Addition"

...


...

Image Modified Image Modified Image Modified