Operator Precedence Logic Error

Draft Base

Structure: Simple

Description

This vulnerability occurs when a developer writes a conditional expression where the intended logic is broken due to misunderstanding or misapplying the rules of operator precedence.

Extended Description

At its core, this is a programming mistake where the order in which operations are evaluated (like comparison before logical AND) doesn't match the developer's intent. For example, writing `if (x & 1 == 0)` might be intended to check if the least significant bit is zero, but due to precedence, it's actually evaluated as `if (x & (1 == 0))`, leading to an incorrect result. While this can manifest as a simple bug in non-critical code, it becomes a serious security flaw when it appears in security-critical decision points. A common and dangerous example is within authentication or authorization logic, where a flawed expression could incorrectly grant access or bypass a security check entirely, directly compromising the application's security.

Common Consequences 1

Scope: ConfidentialityIntegrityAvailability

Impact: Varies by ContextUnexpected State

The consequences will vary based on the context surrounding the incorrect precedence. In a security decision, integrity or confidentiality are the most likely results. Otherwise, a crash may occur due to the software reaching an unexpected state.

Potential Mitigations 1

Phase: Implementation

Regularly wrap sub-expressions in parentheses, especially in security-critical code.

Demonstrative Examples 2

In the following example, the method validateUser makes a call to another method to authenticate a username and password for a user and returns a success or failure code.

Code Example:

Bad

// call method to authenticate username and password*

However, the method that authenticates the username and password is called within an if statement with incorrect operator precedence logic. Because the comparison operator "==" has a higher precedence than the assignment operator "=", the comparison operator will be evaluated first and if the method returns FAIL then the comparison will be true, the return variable will be set to true and SUCCESS will be returned. This operator precedence logic error can be easily resolved by properly using parentheses within the expression of the if statement, as shown below.

Code Example:Good
C
c

In this example, the method calculates the return on investment for an accounting/financial application. The return on investment is calculated by subtracting the initial investment costs from the current value and then dividing by the initial investment costs.

Code Example:

Bad

Java

java

// calculate return on investment* returnROI = currentValue - initialInvestment / initialInvestment;

java

However, the return on investment calculation will not produce correct results because of the incorrect operator precedence logic in the equation. The divide operator has a higher precedence than the minus operator, therefore the equation will divide the initial investment costs by the initial investment costs which will only subtract one from the current value. Again this operator precedence logic error can be resolved by the correct use of parentheses within the equation, as shown below.

Code Example:Good
Java
java

Note that the initialInvestment variable in this example should be validated to ensure that it is greater than zero to avoid a potential divide by zero error (Divide By Zero).

Observed Examples 3

CVE-2008-2516Authentication module allows authentication bypass because it uses "(x = call(args) == SUCCESS)" instead of "((x = call(args)) == SUCCESS)".

CVE-2008-0599Chain: Language interpreter calculates wrong buffer size (Incorrect Calculation of Buffer Size) by using "size = ptr ? X : Y" instead of "size = (ptr ? X : Y)" expression.

CVE-2001-1155Chain: product does not properly check the result of a reverse DNS lookup because of operator precedence (Operator Precedence Logic Error), allowing bypass of DNS-based access restrictions.

References 2

EXP00-C. Use parentheses for precedence of operation

CERT

https://www.securecoding.cert.org/confluence/display/seccode/EXP00-C.+Use+parentheses+for+precedence+of+operation

ID: REF-704

The Art of Software Security Assessment

Mark Dowd, John McDonald, and Justin Schuh

Addison Wesley

2006

ID: REF-62

Likelihood of Exploit

Low

Applicable Platforms

Languages:

C : RarelyC++ : RarelyNot Language-Specific : Rarely

Modes of Introduction

Implementation

Related Weaknesses

ChildOf:

Always-Incorrect Control Flow Implementation (CWE-670)

Taxonomy Mapping

CERT C Secure Coding
SEI CERT Perl Coding Standard