Search the public rule index by CVE, GHSA, CWE, language, framework, author, or rule slug. Filter by language, framework, severity, confidence, license, and validation status.
A lexer or parser loop iterates based solely on a negated peek/match function without checking for the end of the input (EOF). If the peek function handles out-of-bounds by returning false, the negation will evaluate to true at EOF, resulting in an infinite loop (Denial of Service). Ensure buffer boundaries are explicitly checked in the loop condition (e.g.,
DNS decompression parses pointer lengths via offset tracking but lacks loop detection. This allows remote attackers to trigger an infinite loop using deeply chained or cyclic compression pointers, causing a Denial of Service (DoS). Ensure offset references are tracked in a set and reject duplicates.
A while loop compares start and end dates/values, but both are incremented using `.add()` without an explicit bounding check or maximum iteration guard. This can lead to infinite loops (DoS) if user input forces the loop to continuously evaluate the increment condition. Introduce a maximum iteration limit combined with a throw, break, or return statement.
A BigInteger `modInverse` implementation (typically originating from the jsbn library) was found to be lacking a check for a zero instance (`this`). If executed with a zero value, the Extended Euclidean Algorithm enters an unreachable exit condition resulting in an infinite loop and Denial of Service (DoS).
Sequence expansion logic computes a step increment using `Math.abs` without enforcing a non-zero minimum. If the step evaluates to 0, this can lead to an infinite loop (Denial of Service). Enforce a minimum increment, e.g. with `Math.max(Math.abs(step), 1)`.
Potential infinite loop detected. Loop iterates over xref/trailer offsets without tracking and validating visited offsets to prevent circular references (CVE-2026-27628).
Missing cycle detection during iterative object traversal can lead to infinite loops (DoS). Ensure that visited nodes are tracked.
Infinite loop vulnerability in Tonelli-Shanks algorithm implementation. The loop terminates using an exact equality check (`i == e`) combined with an increment (`i++`) before the check. If `e` is 1, `i` increments to 2 and bypasses the `e` check. When the evaluated modulo is not prime, this bypass causes the loop to run indefinitely, leading to a Denial of S
A new lookup node is created and processed without checking for CNAME loops, which could lead to unbounded recursion.
A loop decrements its counter by the result of a read operation without checking if the read returned 0. If the read fails or reaches end-of-file (EOF), it may return 0, causing the loop counter to never reach 0 and resulting in an infinite loop (Denial of Service). Ensure there is a break or return condition that asserts the read payload length is greater t
Missing dynamic bounds check for block length against window size in filter parser. This can allow attackers to supply a nonsensically large block length, causing an infinite loop. Ensure the block length is bounded by a reasonable fraction of the dynamic window size.
A BigNumber or similar structure applies a bitwise mask to an array of components based on length, but fails to account for the state where length becomes 0. This corrupts the instance invariants, causing operations like `isZero()` to fail and resulting in infinite loops.
The QuoRem implementation performs division via truncation (using `Div`) instead of symmetric rounding. This mathematically violates the Euclidean domain property, leading to infinite loops in Half-GCD operations (Denial of Service). Additionally, mutating the receiver `z` early before completion can lead to aliasing bugs if it points to the same memory as t
A byte count is padded to a block size using `divmod` without validating if the count is negative. In Python, `divmod` with a negative dividend and positive divisor yields a negative quotient. This can result in negative padded lengths that propagate into file offsets or buffer sizes, potentially leading to backwards-seeking pointer errors, infinite loops, o
