CWE-783

Operator Precedence Logic Error. [Behavioral-Problems, Expression-Issues, Insufficient-Control-Flow-Management]

Required inputs: IR

The product uses an expression in which operator precedence causes incorrect logic to be used. While often just a bug, operator precedence logic errors can have serious consequences if they are used in security-critical code, such as making an authentication decision.

Demonstrative Examples

Example 1

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.

Example Language:C
    #define FAIL 0
    #define SUCCESS 1

    ...

    int validateUser(char *username, char *password) {
        int isUser = FAIL;

        // call method to authenticate username and password

        // if authentication fails then return failure otherwise return success
        if (isUser = AuthenticateUser(username, password) == FAIL) {
            return isUser;
        }
        else {
            isUser = SUCCESS;
        }

        return isUser;
    }

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.

Example Language:C
    ...

    if ((isUser = AuthenticateUser(username, password)) == FAIL) {

    ...

Example 2

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.

Example Language:Java (Unsupported language for documentation only)
    public double calculateReturnOnInvestment(double currentValue, double initialInvestment) {
        double returnROI = 0.0;

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

        return returnROI;
    }

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.

Example Language:Java (Unsupported language for documentation only)
    ...

    returnROI = (currentValue - initialInvestment) / initialInvestment;

    ...

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 (CWE-369).

Excerpts from CWE [https://cwe.mitre.org], Copyright (C) 2006-2026, the MITRE Corporation. See section 9.4. "3rd-Party Licenses" in the documentation for full details.

Possible Messages

Key	Text	Severity	Disabled
missing_parens_depends_on_precedence	Parentheses should be used to avoid dependence on precedence rules	None	False

Options

• This rule shares the following common options: 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

allow_algebraic_order

allow_algebraic_order : bool = False

Whether parens can be omitted for multiplicative operators as operands in additive operators.

 

allow_relations_in_logical

allow_relations_in_logical : bool = False

Whether parens can be omitted for relational operators in logical operators.

 

consider_assignments

consider_assignments : bool = True

Whether assignments inside expressions should be considered as well.

 

exception

exception : typing.Callable[[Expression, Expression], bool] | None = None

Programmable test if parens in physical node (1. argument) around operand (2. argument) and right, left or both sides can be omitted.