logo

Integer Overflow or Wraparound

Stable Base
Structure: Simple
Description

Integer overflow or wraparound occurs when a calculation produces a numeric result that exceeds the maximum value a variable can hold. Instead of increasing as expected, the value wraps around to a very small or negative number, breaking the program's logic.

Integer overflow or wraparound occurs when a calculation produces a numeric result that exceeds the maximum value a variable can hold. Instead of increasing as expected, the value wraps around to a very small or negative number, breaking the program's logic.
Extended Description

This vulnerability happens because computers store integers within fixed-size memory spaces. When an arithmetic operation like addition or multiplication exceeds this limit, the extra bits are discarded, causing the value to 'wrap around'—often to a minimum value or a negative number. For example, adding 1 to the maximum 32-bit integer doesn't create a larger number but flips it to a large negative value. Developers can prevent this by validating inputs before calculations, using safe math libraries, or choosing data types with larger capacity (like BigInteger in Java). Always assume user-provided or external data can trigger edge cases, and implement explicit checks for overflow conditions in critical operations like memory allocation, financial calculations, or loop counters.
Common Consequences 5
Scope: Availability

Impact: DoS: Crash, Exit, or RestartDoS: Resource Consumption (Memory)DoS: Instability

This weakness can generally lead to undefined behavior and therefore crashes. When the calculated result is used for resource allocation, this weakness can cause too many (or too few) resources to be allocated, possibly enabling crashes if the product requests more resources than can be provided.

Scope: Integrity

Impact: Modify Memory

If the value in question is important to data (as opposed to flow), simple data corruption has occurred. Also, if the overflow/wraparound results in other conditions such as buffer overflows, further memory corruption may occur.

Scope: ConfidentialityAvailabilityAccess Control

Impact: Execute Unauthorized Code or CommandsBypass Protection Mechanism

This weakness can sometimes trigger buffer overflows, which can be used to execute arbitrary code. This is usually outside the scope of the product's implicit security policy.

Scope: AvailabilityOther

Impact: Alter Execution LogicDoS: Crash, Exit, or RestartDoS: Resource Consumption (CPU)

If the overflow/wraparound occurs in a loop index variable, this could cause the loop to terminate at the wrong time - too early, too late, or not at all (i.e., infinite loops). With too many iterations, some loops could consume too many resources such as memory, file handles, etc., possibly leading to a crash or other DoS.

Scope: Access Control

Impact: Bypass Protection Mechanism

If integer values are used in security-critical decisions, such as calculating quotas or allocation limits, integer overflows can be used to cause an incorrect security decision.
Detection Methods 8
Automated Static AnalysisHigh
This weakness can often be detected using automated static analysis tools. Many modern tools use data flow analysis or constraint-based techniques to minimize the number of false positives.
Black BoxModerate
Sometimes, evidence of this weakness can be detected using dynamic tools and techniques that interact with the product using large test suites with many diverse inputs, such as fuzz testing (fuzzing), robustness testing, and fault injection. The product's operation may slow down, but it should not become unstable, crash, or generate incorrect results.
Manual AnalysisHigh
This weakness can be detected using tools and techniques that require manual (human) analysis, such as penetration testing, threat modeling, and interactive tools that allow the tester to record and modify an active session. Specifically, manual static analysis is useful for evaluating the correctness of allocation calculations. This can be useful for detecting overflow conditions (Integer Overflow or Wraparound) or similar weaknesses that might have serious security impacts on the program.
Automated Static Analysis - Binary or BytecodeHigh
According to SOAR [REF-1479], the following detection techniques may be useful: ``` Highly cost effective: ``` Bytecode Weakness Analysis - including disassembler + source code weakness analysis Binary Weakness Analysis - including disassembler + source code weakness analysis
Dynamic Analysis with Manual Results InterpretationSOAR Partial
According to SOAR [REF-1479], the following detection techniques may be useful: ``` Cost effective for partial coverage: ``` Fuzz Tester Framework-based Fuzzer
Manual Static Analysis - Source CodeSOAR Partial
According to SOAR [REF-1479], the following detection techniques may be useful: ``` Cost effective for partial coverage: ``` Manual Source Code Review (not inspections)
Automated Static Analysis - Source CodeHigh
According to SOAR [REF-1479], the following detection techniques may be useful: ``` Highly cost effective: ``` Source code Weakness Analyzer Context-configured Source Code Weakness Analyzer
Architecture or Design ReviewHigh
According to SOAR [REF-1479], the following detection techniques may be useful: ``` Highly cost effective: ``` Formal Methods / Correct-By-Construction ``` Cost effective for partial coverage: ``` Inspection (IEEE 1028 standard) (can apply to requirements, design, source code, etc.)
Potential Mitigations 7
Phase: Requirements
Ensure that all protocols are strictly defined, such that all out-of-bounds behavior can be identified simply, and require strict conformance to the protocol.
Phase: Requirements

Strategy: Language Selection

Use a language that does not allow this weakness to occur or provides constructs that make this weakness easier to avoid. If possible, choose a language or compiler that performs automatic bounds checking.
Phase: Architecture and Design

Strategy: Libraries or Frameworks

Use a vetted library or framework that does not allow this weakness to occur or provides constructs that make this weakness easier to avoid [REF-1482]. Use libraries or frameworks that make it easier to handle numbers without unexpected consequences. Examples include safe integer handling packages such as SafeInt (C++) or IntegerLib (C or C++). [REF-106]
Phase: Implementation

Strategy: Input Validation

Perform input validation on any numeric input by ensuring that it is within the expected range. Enforce that the input meets both the minimum and maximum requirements for the expected range. Use unsigned integers where possible. This makes it easier to perform validation for integer overflows. When signed integers are required, ensure that the range check includes minimum values as well as maximum values.
Phase: Implementation
Understand the programming language's underlying representation and how it interacts with numeric calculation (Incorrect Conversion between Numeric Types). Pay close attention to byte size discrepancies, precision, signed/unsigned distinctions, truncation, conversion and casting between types, "not-a-number" calculations, and how the language handles numbers that are too large or too small for its underlying representation. [REF-7] Also be careful to account for 32-bit, 64-bit, and other potential differences that may affect the numeric representation.
Phase: Architecture and Design
For any security checks that are performed on the client side, ensure that these checks are duplicated on the server side, in order to avoid Client-Side Enforcement of Server-Side Security. Attackers can bypass the client-side checks by modifying values after the checks have been performed, or by changing the client to remove the client-side checks entirely. Then, these modified values would be submitted to the server.
Phase: Implementation

Strategy: Compilation or Build Hardening

Examine compiler warnings closely and eliminate problems with potential security implications, such as signed / unsigned mismatch in memory operations, or use of uninitialized variables. Even if the weakness is rarely exploitable, a single failure may lead to the compromise of the entire system.
Demonstrative Examples 4

ID : DX-33

The following image processing code allocates a table for images.

Code Example:

Bad
C
c
This code intends to allocate a table of size num_imgs, however as num_imgs grows large, the calculation determining the size of the list will eventually overflow (Integer Overflow or Wraparound). This will result in a very small list to be allocated instead. If the subsequent code operates on the list as if it were num_imgs long, it may result in many types of out-of-bounds problems (Improper Restriction of Operations within the Bounds of a Memory Buffer).
The following code excerpt from OpenSSH 3.3 demonstrates a classic case of integer overflow:

Code Example:

Bad
C
c
If nresp has the value 1073741824 and sizeof(char*) has its typical value of 4, then the result of the operation nresp*sizeof(char*) overflows, and the argument to xmalloc() will be 0. Most malloc() implementations will happily allocate a 0-byte buffer, causing the subsequent loop iterations to overflow the heap buffer response.
Integer overflows can be complicated and difficult to detect. The following example is an attempt to show how an integer overflow may lead to undefined looping behavior:

Code Example:

Bad
C
c
In the above case, it is entirely possible that bytesRec may overflow, continuously creating a lower number than MAXGET and also overwriting the first MAXGET-1 bytes of buf.
In this example the method determineFirstQuarterRevenue is used to determine the first quarter revenue for an accounting/business application. The method retrieves the monthly sales totals for the first three months of the year, calculates the first quarter sales totals from the monthly sales totals, calculates the first quarter revenue based on the first quarter sales, and finally saves the first quarter revenue results to the database.

Code Example:

Bad
C
c

// Variable for sales revenue for the quarter* float quarterRevenue = 0.0f;

c
However, in this example the primitive type short int is used for both the monthly and the quarterly sales variables. In C the short int primitive type has a maximum value of 32768. This creates a potential integer overflow if the value for the three monthly sales adds up to more than the maximum value for the short int primitive type. An integer overflow can lead to data corruption, unexpected behavior, infinite loops and system crashes. To correct the situation the appropriate primitive type should be used, as in the example below, and/or provide some validation mechanism to ensure that the maximum value for the primitive type is not exceeded.

Code Example:

Good
C
c

// Calculate quarterly total* long quarterSold = JanSold + FebSold + MarSold;

c
Note that an integer overflow could also occur if the quarterSold variable has a primitive type long but the method calculateRevenueForQuarter has a parameter of type short.
Observed Examples 18
CVE-2025-27363Font rendering library does not properly handle assigning a signed short value to an unsigned long (Signed to Unsigned Conversion Error), leading to an integer wraparound (Integer Overflow or Wraparound), causing too small of a buffer (Incorrect Calculation of Buffer Size), leading to an out-of-bounds write (Out-of-bounds Write).
CVE-2021-43537Chain: in a web browser, an unsigned 64-bit integer is forcibly cast to a 32-bit integer (Incorrect Conversion between Numeric Types) and potentially leading to an integer overflow (Integer Overflow or Wraparound). If an integer overflow occurs, this can cause heap memory corruption (Heap-based Buffer Overflow)
CVE-2019-19911Chain: Python library does not limit the resources used to process images that specify a very large number of bands (Improper Validation of Specified Quantity in Input), leading to excessive memory consumption (Memory Allocation with Excessive Size Value) or an integer overflow (Integer Overflow or Wraparound).
CVE-2022-0545Chain: 3D renderer has an integer overflow (Integer Overflow or Wraparound) leading to write-what-where condition (Write-what-where Condition) using a crafted image.
CVE-2021-30860Chain: improper input validation (Improper Input Validation) leads to integer overflow (Integer Overflow or Wraparound) in mobile OS, as exploited in the wild per CISA KEV.
CVE-2021-30663Chain: improper input validation (Improper Input Validation) leads to integer overflow (Integer Overflow or Wraparound) in mobile OS, as exploited in the wild per CISA KEV.
CVE-2018-10887Chain: unexpected sign extension (Unexpected Sign Extension) leads to integer overflow (Integer Overflow or Wraparound), causing an out-of-bounds read (Out-of-bounds Read)
CVE-2019-1010006Chain: compiler optimization (Compiler Optimization Removal or Modification of Security-critical Code) removes or modifies code used to detect integer overflow (Integer Overflow or Wraparound), allowing out-of-bounds write (Out-of-bounds Write).
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-2010-2753Chain: integer overflow leads to use-after-free
CVE-2005-1513Chain: integer overflow in securely-coded mail program leads to buffer overflow. In 2005, this was regarded as unrealistic to exploit, but in 2020, it was rediscovered to be easier to exploit due to evolutions of the technology.
CVE-2002-0391Integer overflow via a large number of arguments.
CVE-2002-0639Integer overflow in OpenSSH as listed in the demonstrative examples.
CVE-2005-1141Image with large width and height leads to integer overflow.
CVE-2005-0102Length value of -1 leads to allocation of 0 bytes and resultant heap overflow.
CVE-2004-2013Length value of -1 leads to allocation of 0 bytes and resultant heap overflow.
CVE-2017-1000121chain: unchecked message size metadata allows integer overflow (Integer Overflow or Wraparound) leading to buffer overflow (Improper Restriction of Operations within the Bounds of a Memory Buffer).
CVE-2013-1591Chain: an integer overflow (Integer Overflow or Wraparound) in the image size calculation causes an infinite loop (Loop with Unreachable Exit Condition ('Infinite Loop')) which sequentially allocates buffers without limits (Improperly Controlled Sequential Memory Allocation) until the stack is full.
References 10
An overview of common programming security vulnerabilities and possible solutions
Yves Younan
Student thesis section 5.4.3
08-2003
https://fort-knox.org/thesis.pdf(2025-07-24)
ID: REF-145
Basic Integer Overflows
blexim
Phrack - Issue 60, Chapter 10
28-12-2002
https://phrack.org/issues/60/10(2025-07-24)
ID: REF-146
Writing Secure Code
Michael Howard and David LeBlanc
Microsoft Press
04-12-2002
https://www.microsoftpressstore.com/store/writing-secure-code-9780735617223
ID: REF-7
24 Deadly Sins of Software Security
Michael Howard, David LeBlanc, and John Viega
McGraw-Hill
2010
ID: REF-44
SafeInt
David LeBlanc and Niels Dekker
https://github.com/dcleblanc/SafeInt/(2025-07-29)
ID: REF-106
Top 25 Series - Rank 17 - Integer Overflow Or Wraparound
Johannes Ullrich
SANS Software Security Institute
18-03-2010
http://software-security.sans.org/blog/2010/03/18/top-25-series-rank-17-integer-overflow-or-wraparound
ID: REF-150
The Art of Software Security Assessment
Mark Dowd, John McDonald, and Justin Schuh
Addison Wesley
2006
ID: REF-62
Integer overflow
Wikipedia
11-06-2024
https://en.wikipedia.org/wiki/Integer_overflow(2024-06-30)
ID: REF-1440
State-of-the-Art Resources (SOAR) for Software Vulnerability Detection, Test, and Evaluation
Gregory Larsen, E. Kenneth Hong Fong, David A. Wheeler, and Rama S. Moorthy
07-2014
https://www.ida.org/-/media/feature/publications/s/st/stateoftheart-resources-soar-for-software-vulnerability-detection-test-and-evaluation/p-5061.ashx(2025-09-05)
ID: REF-1479
D3FEND: D3-TL Trusted Library
D3FEND
https://d3fend.mitre.org/technique/d3f:TrustedLibrary/(2025-09-06)
ID: REF-1482
Likelihood of Exploit

Medium

Applicable Platforms
Languages:
C : OftenNot Language-Specific : Undetermined
Modes of Introduction
Implementation
Related Attack Patterns
Alternate Terms

Overflow

The terms "overflow" and "wraparound" are used interchangeably by some people, but they can have more precise distinctions by others. See Terminology Notes.

Wraparound

The terms "overflow" and "wraparound" are used interchangeably by some people, but they can have more precise distinctions by others. See Terminology Notes.

wrap, wrap-around, wrap around

Alternate spellings of "wraparound"
Functional Areas
  1. Number Processing
  2. Memory Management
  3. Counters
Related Weaknesses
ChildOf: Incorrect Calculation (CWE-682)
ChildOf: Incorrect Calculation (CWE-682)
ChildOf: Improper Input Validation (CWE-20)
CanPrecede: Improper Restriction of Operations within the Bounds of a Memory Buffer (CWE-119)
Taxonomy Mapping
  • PLOVER
  • 7 Pernicious Kingdoms
  • CLASP
  • CERT C Secure Coding
  • CERT C Secure Coding
  • CERT C Secure Coding
  • CERT C Secure Coding
  • CERT C Secure Coding
  • CERT C Secure Coding
  • WASC
  • Software Fault Patterns
  • ISA/IEC 62443
  • ISA/IEC 62443
  • ISA/IEC 62443
  • ISA/IEC 62443
  • ISA/IEC 62443
  • ISA/IEC 62443
  • ISA/IEC 62443
  • ISA/IEC 62443
Notes
RelationshipInteger overflows can be primary to buffer overflows when they cause less memory to be allocated than expected.
Terminology "Integer overflow" is sometimes used to cover several types of errors, including signedness errors, or buffer overflows that involve manipulation of integer data types instead of characters. Part of the confusion results from the fact that 0xffffffff is -1 in a signed context. Other confusion also arises because of the role that integer overflows have in chains. A "wraparound" is a well-defined, standard behavior that follows specific rules for how to handle situations when the intended numeric value is too large or too small to be represented, as specified in standards such as C11. "Overflow" is sometimes conflated with "wraparound" but typically indicates a non-standard or undefined behavior. The "overflow" term is sometimes used to indicate cases where either the maximum or the minimum is exceeded, but others might only use "overflow" to indicate exceeding the maximum while using "underflow" for exceeding the minimum. Some people use "overflow" to mean any value outside the representable range - whether greater than the maximum, or less than the minimum - but CWE uses "underflow" for cases in which the intended result is less than the minimum. See [REF-1440] for additional explanation of the ambiguity of terminology.
OtherWhile there may be circumstances in which the logic intentionally relies on wrapping - such as with modular arithmetic in timers or counters - it can have security consequences if the wrap is unexpected. This is especially the case if the integer overflow can be triggered using user-supplied inputs.