Numeric Range Comparison Without Minimum Check

Incomplete Base

Structure: Simple

Description

This vulnerability occurs when software validates that a number is within an acceptable range by only checking that it's less than or equal to a maximum value, but fails to also verify that it is greater than or equal to a required minimum. This oversight can allow negative or otherwise invalid low values to pass the check, leading to unexpected behavior.

Extended Description

Developers often use signed data types like integers or floats for values that should logically only be positive or zero. When input validation only enforces an upper limit, a negative value can slip through. This becomes dangerous when that negative number is used in operations like memory allocation, array indexing, or buffer calculations, potentially causing buffer overflows, memory corruption, or application crashes. Beyond memory issues, this flaw can impact application logic in surprising ways. For instance, an e-commerce system that checks 'item count <= 10' but not 'item count >= 0' might process an order for -3 items. This could trigger faulty calculations, like crediting money to an attacker's account instead of charging it. Always validate both the lower and upper bounds to ensure data integrity and security.

Common Consequences 3

Scope: IntegrityConfidentialityAvailability

Impact: Modify Application DataExecute Unauthorized Code or Commands

An attacker could modify the structure of the message or data being sent to the downstream component, possibly injecting commands.

Scope: Availability

Impact: DoS: Resource Consumption (Other)

in some contexts, a negative value could lead to resource consumption.

Scope: ConfidentialityIntegrity

Impact: Modify MemoryRead Memory

If a negative value is used to access memory, buffers, or other indexable structures, it could access memory outside the bounds of the buffer.

Potential Mitigations 2

Phase: Implementation

Strategy: Enforcement by Conversion

If the number to be used is always expected to be positive, change the variable type from signed to unsigned or size_t.

Phase: Implementation

Strategy: Input Validation

If the number to be used could have a negative value based on the specification (thus requiring a signed value), but the number should only be positive to preserve code correctness, then include a check to ensure that the value is positive.

Demonstrative Examples 4

ID : DX-21

The following code is intended to read an incoming packet from a socket and extract one or more headers.

Code Example:Bad
C
c

The code performs a check to make sure that the packet does not contain too many headers. However, numHeaders is defined as a signed int, so it could be negative. If the incoming packet specifies a value such as -3, then the malloc calculation will generate a negative number (say, -300 if each header can be a maximum of 100 bytes). When this result is provided to malloc(), it is first converted to a size_t type. This conversion then produces a large value such as 4294966996, which may cause malloc() to fail or to allocate an extremely large amount of memory (Signed to Unsigned Conversion Error). With the appropriate negative numbers, an attacker could trick malloc() into using a very small positive number, which then allocates a buffer that is much smaller than expected, potentially leading to a buffer overflow.

ID : DX-23

The following code reads a maximum size and performs a sanity check on that size. It then performs a strncpy, assuming it will not exceed the boundaries of the array. While the use of "short s" is forced in this particular example, short int's are frequently used within real-world code, such as code that processes structured data.

Code Example:Bad
C
c

This code first exhibits an example of Numeric Range Comparison Without Minimum Check, allowing "s" to be a negative number. When the negative short "s" is converted to an unsigned integer, it becomes an extremely large positive integer. When this converted integer is used by strncpy() it will lead to a buffer overflow (Improper Restriction of Operations within the Bounds of a Memory Buffer).

ID : DX-100

In the following code, the method retrieves a value from an array at a specific array index location that is given as an input parameter to the method

Code Example:

Bad

// check that the array index is less than the maximum*

However, this method only verifies that the given array index is less than the maximum length of the array but does not check for the minimum value (Numeric Range Comparison Without Minimum Check). This will allow a negative value to be accepted as the input array index, which will result in reading data before the beginning of the buffer (Buffer Under-read) and may allow access to sensitive memory. The input array index should be checked to verify that is within the maximum and minimum range required for the array (Improper Validation of Array Index). In this example the if statement should be modified to include a minimum range check, as shown below.

Code Example:

Good

// check that the array index is within the correct*

The following code shows a simple BankAccount class with deposit and withdraw methods.

Code Example:

Bad

Java

java

// variable for bank account balance* private double accountBalance;

java

java

// other methods for accessing the BankAccount object* ...}

The withdraw method includes a check to ensure that the withdrawal amount does not exceed the maximum limit allowed, however the method does not check to ensure that the withdrawal amount is greater than a minimum value (Improper Validation of Array Index). Performing a range check on a value that does not include a minimum check can have significant security implications, in this case not including a minimum range check can allow a negative value to be used which would cause the financial application using this class to deposit money into the user account rather than withdrawing. In this example the if statement should the modified to include a minimum range check, as shown below.

Code Example:

Good

Java

java

// method to withdraw amount from BankAccount* public void withdraw(double withdrawAmount) { ``` if (withdrawAmount < MAXIMUM_WITHDRAWAL_LIMIT && withdrawAmount > MINIMUM_WITHDRAWAL_LIMIT) { ...

Note that this example does not protect against concurrent access to the BankAccount balance variable, see Improper Resource Locking and Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition').

While it is out of scope for this example, note that the use of doubles or floats in financial calculations may be subject to certain kinds of attacks where attackers use rounding errors to steal money.

Observed Examples 8

CVE-2010-1866Chain: integer overflow (Integer Overflow or Wraparound) causes a negative signed value, which later bypasses a maximum-only check (Numeric Range Comparison Without Minimum Check), leading to heap-based buffer overflow (Heap-based Buffer Overflow).

CVE-2009-1099Chain: 16-bit counter can be interpreted as a negative value, compared to a 32-bit maximum value, leading to buffer under-write.

CVE-2011-0521Chain: kernel's lack of a check for a negative value leads to memory corruption.

CVE-2010-3704Chain: parser uses atoi() but does not check for a negative value, which can happen on some platforms, leading to buffer under-write.

CVE-2010-2530Chain: Negative value stored in an int bypasses a size check and causes allocation of large amounts of memory.

CVE-2009-3080Chain: negative offset value to IOCTL bypasses check for maximum index, then used as an array index for buffer under-read.

CVE-2008-6393chain: file transfer client performs signed comparison, leading to integer overflow and heap-based buffer overflow.

CVE-2008-4558chain: negative ID in media player bypasses check for maximum index, then used as an array index for buffer under-read.

References 2

The Art of Software Security Assessment

Mark Dowd, John McDonald, and Justin Schuh

Addison Wesley

2006

ID: REF-62

The Art of Software Security Assessment

Mark Dowd, John McDonald, and Justin Schuh

Addison Wesley

2006

ID: REF-62

Applicable Platforms

Languages:

C : OftenC++ : Often

Alternate Terms

Signed comparison

The "signed comparison" term is often used to describe when the product uses a signed variable and checks it to ensure that it is less than a maximum value (typically a maximum buffer size), but does not verify that it is greater than 0.

Related Weaknesses

ChildOf:

Incomplete Comparison with Missing Factors (CWE-1023)

CanPrecede:

Signed to Unsigned Conversion Error (CWE-195)

CanPrecede:

Incorrect Calculation (CWE-682)

CanPrecede:

Improper Restriction of Operations within the Bounds of a Memory Buffer (CWE-119)

CanPrecede:

Buffer Underwrite ('Buffer Underflow') (CWE-124)