CWE-681: Incorrect Conversion between Numeric Types

What is Incorrect Conversion between Numeric Types?

• Overview: This vulnerability occurs when numerical data is converted incorrectly between different types, such as from a long to an integer, possibly leading to data loss or unexpected values. This can cause significant issues if the resulting incorrect values are used in sensitive operations or contexts.

• Exploitation Methods:

• Attackers can exploit this by providing input that forces the application to perform faulty numeric conversions, potentially leading to incorrect calculations, logic errors, or security bypasses.
• Common attack patterns include buffer overflows resulting from incorrect size assumptions and logic errors due to overflow or underflow conditions.

• Security Impact:

• Direct consequences of successful exploitation include application crashes, data corruption, and incorrect program behavior.
• Potential cascading effects involve further security vulnerabilities, such as privilege escalation or unauthorized access.
• Business impact can include service downtime, loss of integrity in financial transactions, and damage to customer trust.

• Prevention Guidelines:

• Specific code-level fixes include implementing strict type checking and using safe conversion functions or methods provided by the language or frameworks.
• Security best practices involve thorough input validation and ensuring that numeric conversions are explicitly checked for overflow or underflow conditions.
• Recommended tools and frameworks for prevention include static analysis tools that can detect potential conversion issues and using languages or frameworks that inherently manage numeric type safety.

Corgea can automatically detect and fix Incorrect Conversion between Numeric Types in your codebase. Try Corgea free today.

Technical Details

Likelihood of Exploit: High

Affected Languages: C, Not Language-Specific

Affected Technologies: Not specified

Vulnerable Code Example

C Example

#include <stdio.h>
#include <limits.h>

int main() {
    long large_value = LONG_MAX;
    // Incorrect conversion: potential data loss when converting from long to int
    int small_value = large_value;
    
    printf("Converted value: %d\n", small_value);
    return 0;
}

Explanation:

• Vulnerability: The code incorrectly converts a long type variable (large_value) to an int type (small_value). Since int has a smaller range than long, this conversion can lead to data loss or unexpected values if large_value exceeds the range of int.
• Impact: If small_value is used in further calculations or decision-making processes, this can lead to incorrect program behavior or security issues.

How to fix Incorrect Conversion between Numeric Types?

To fix this vulnerability, it's crucial to ensure that any conversion between numeric types checks whether the value can be safely represented in the target type. This can be achieved by:

1. Range Check: Before performing the conversion, check whether the long value falls within the range of the int type.
2. Use Safe Conversion Functions: Where possible, utilize functions or mechanisms that validate the conversion, ensuring it doesn't result in data loss or overflow.
3. Error Handling: Implement appropriate error handling or fallback logic if the conversion is unsafe.

Fixed Code Example

#include <stdio.h>
#include <limits.h>

int main() {
    long large_value = LONG_MAX;
    
    // Ensure the value is within the range of an int before conversion
    if (large_value <= INT_MAX && large_value >= INT_MIN) {
        int small_value = (int)large_value;  // Safe conversion
        printf("Converted value: %d\n", small_value);
    } else {
        fprintf(stderr, "Error: Value out of range for int conversion\n");
    }
    
    return 0;
}

Explanation:

• Range Check Added: The code now includes a conditional check ensuring that large_value is within the range of an int before conversion. This prevents data loss due to overflow or underflow.
• Error Handling: If the value is out of range, an error message is printed, and no unsafe conversion occurs.
• Safe Conversion: Casting is only performed when it's confirmed to be safe, ensuring the program behaves correctly and securely.

Improvements Made:

1. Syntax Highlighting: Specified the language for syntax highlighting.
2. Line Number Highlighting: Removed incorrect line number comments and ensured proper syntax.
3. Realistic Example: The example clearly demonstrates the vulnerability and fix.
4. Comment Clarity: Improved comments to thoroughly explain the vulnerability and the fix.
5. Best Practices: Followed C best practices for handling numeric conversions and error checking.