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.
The function tokenizes an HTML string and writes all resulting text tokens to a buffer in a loop that only exits on EOF or error. Without an early-exit mechanism (such as short-circuiting via an iterator or length check), excessively large HTML payloads can lead to Denial of Service (DoS) due to CPU and memory exhaustion. Consider replacing rigid loops with
The `formatDate` function lacks an explicit length check on the `format` parameter. This can lead to memory exhaustion and Denial of Service (DoS) due to continuous regular expression evaluation loops down the execution path.
Unbounded audio decoding detected. An attacker can provide a highly compressed audio file (decompression bomb) that expands into gigabytes of raw PCM data, leading to memory exhaustion and Denial of Service. Limit the maximal amount of frames, samples, or duration decoded, and exit early if limits are exceeded.
Dynamically creating atoms from untrusted input using `String.to_atom/1` or `List.to_atom/1` can lead to a Denial of Service (DoS) due to atom table exhaustion. BEAM atoms are never garbage collected, and creating them from unbounded user input allows attackers to continuously allocate them until the entire BEAM node crashes. Use `String.to_existing_atom/1`
Missing string length boundary checks before parsing digit strings. In the context of standard-library or low-level parsers, unbounded iteration or conversion of digit strings into integers can result in Uncontrolled Resource Consumption (DoS). Evaluate strings with `byte_size/1` prior to accumulation.
Converting an unbounded or untrusted string (like a URI scheme) to an atom dynamically using `String.to_atom/1` can lead to an atom memory exhaustion Denial of Service (DoS) vulnerability. Erlang VM atoms are not garbage-collected, so an attacker who can provide unique inputs can exhaust the bounded atom table and crash the application. Use pattern matching
Parsed ranges and step sizes from user input are created without bounds validation. Downstream eager evaluation of large unbounded intervals can cause memory exhaustion and Denial of Service (DoS). Validate bounds during parsing before returning ranges or steps.
Deserializing the output of a dynamically retrieved method using `json.loads` can cause massive memory expansion (Out-Of-Memory crashes) if the method generates large strings, such as `to_json()` on mapped data structures like Pandas DataFrames. Instead of round-tripping through JSON strings locally, rely on APIs that return serializable objects directly.
Unbounded accumulation into a dictionary of lists detected. If this structure processes untrusted or network input, it can lead to memory exhaustion and Denial of Service (DoS) because there is no limit on the number of keys or the size of the lists. Ensure you enforce length limits before setting keys or appending values.
The application relies on an outdated version of libp2p (< v0.43.0) which is vulnerable to an ICMP packet attack leading to Denial of Service (CVE-2026-47249). Please update github.com/libp2p/go-libp2p to v0.43.0 or higher. Use an SCA tool for optimal tracking of vulnerable dependencies.
When performing operations on a shared dictionary or cache in concurrent access, returning early on cache hits can bypass the eviction process. If the eviction process breaks on concurrent modification exceptions (like RuntimeError), the dictionary size can drift above bounds. Subsequent cache hits skip the eviction logic, maintaining the inflated unbounded
The SQLFluff Databricks dialect is missing definitions for named parameter logic, causing excessive backtracking and Denials of Service (uncontrolled resource consumption) when parsing valid parameterized inputs.
A sequence generation loop does not enforce an incremental capacity limit, leading to potentially unbounded CPU/memory consumption.
User input was passed directly to the standard Python `re` module. The standard `re` module is vulnerable to Regular Expression Denial of Service (ReDoS) when processing untrusted complex patterns, as it lacks a timeout mechanism. To fix this, consider using the third-party `regex` module which allows setting execution timeouts to protect against catastrophi
Failing to restrict the WebSocket frame or message payload size can allow unauthenticated attackers to consume excessive memory, leading to Denial of Service (DoS). Ensure both `maxMessagePayloadSize` and `maxFramePayloadSize` are set to reasonable limits when configuring autobahn's WebSocketFactory via `setProtocolOptions`.
Calling a blocking sleep function within a network `accept` or `handshake` error-handling block can block the entire multiplexer or event loop thread. An attacker can supply malformed requests that trigger this error path, causing a Denial of Service (DoS) for all connected clients. Remove the blocking sleep and manage retries or backoff asynchronously via e
A ReplayingDecoder checks the currently available `readableBytes()` against a maximum limit inside a `Signal` catch block, rather than the message's declared size. An attacker can send an oversized message in small chunks, bypassing early rejection. The decoder will repeatedly re-parse the growing buffer, causing severe CPU and memory exhaustion. Compare aga
The ASN.1 parser restricts Object Identifier (OID) lengths to an unsafe size (e.g. 4096 bytes). This is insufficient to prevent CPU exhaustion on malformed data. The limit should be strictly tightened to 128 bytes.
Directly calling `qUncompress` on data read from an external source without validating the 4-byte expected size header can lead to massive memory allocation and resource exhaustion (DoS/Zip Bomb). Extract the first 4 bytes of the data and check the uncompressed size against a safe limit before uncompressing.
The binary parsing logic extracts a payload of `binary-size($LEN)` before evaluating a size limit check (e.g., `when $LEN > $MAX`). This forces the Erlang VM to fully buffer up to `$LEN` bytes into memory prior to evaluating the guard and rejecting the oversized input, which can be abused for unauthenticated memory exhaustion. To prevent this, validate the f
WebSocket continuation frames are accumulated into the connection's fragment state without cumulative size checks. This exposes the application to memory exhaustion and Denial of Service (DoS) attacks via unbounded fragmented messages. Ensure that a size limit check is performed when accumulating payload chunks.
The parser cursor is advanced by only a small offset (`start+2`) rather than the entire parsed token length (`end`) when an error occurs. This causes overlapping reparsing of the input string, leading to O(N^2) complexity and potential Denial of Service (DoS).
Generating a SCRAM client final message without validating the PBKDF2 iteration count allows a malicious server to cause a client-side Denial of Service (DoS). Retrieve the iteration count using getIterationCount() and enforce a maximum limit before proceeding.
Unbounded calculation of image dimensions or buffers is used without a limit check. This can lead to out-of-memory errors and Denial-of-Service if the inputs are derived from externally crafted files (e.g. parameter inflation in a PDF).
