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.
An incomplete blocklist of unsafe modules for pickle deserialization was found. The blocklist misses stdlib modules such as `uuid`, `pkgutil`, `imaplib`, or insufficiently blocks `cProfile` and `profile`. Attackers can exploit these unblocked functions to bypass the scanner and achieve arbitrary code execution.
A module blocklist meant for Python deserialization scanning appears to be incomplete. Omitting dangerous modules like `pkgutil` (which can resolve any module dynamically, bypassing blocklists) or command-execution vectors in `uuid`, `test`, and `imaplib` allows attackers to bypass inspection. Ensure the blocklist maps modules such as `pkgutil`, `uuid`, `tes
The Admin API routes are instantiated unconditionally if `enable_admin` is true, without verifying the YAML config provider setting. This exposes potentially unintended ETCD-related management endpoints if CLI startup checks are bypassed (e.g., direct binary execution or reload). Always restrict routes based on the deployment config provider.
Unconditional binding of Admin API routes directly from core configuration detected. In Apache APISIX, this may inadvertently expose ETCD-backed routes when running in standalone (YAML) mode, leading to authentication bypass or deserialization exploits if default unauthenticated states are triggered. Ensure that routes enforce configuration provider segregat
Calling `:erlang.binary_to_term/1` or `/2` without the `:safe` option allows deserialization of untrusted data. This can lead to atom table exhaustion (DoS) or Remote Code Execution (RCE) if an encoded payload constructs malicious function terms. Always pass the `[:safe]` option. Furthermore, since `:safe` alone might not block all function materialization a
Extracting a file path from a user-supplied URL and verifying only its existence allows path traversal and arbitrary local file reads. Path input extracted from untrusted URLs must be defensively normalized using `os.path.abspath` and verified against an explicit allowlist before being trusted.
ETCD administrative routes are instantiated unconditionally when `enable_admin` is true, bypassing `yaml` standalone mode restrictions.
The application configures Celery to accept and deserialize 'pickle' data. Pickle is inherently insecure and can result in arbitrary Remote Code Execution (RCE) if an attacker can send messages to the broker. Use a secure data serialization format like 'json' instead.
An arbitrary file read or path traversal may occur when a dynamically fetched value is passed to `Path::join` and subsequently read. Rust's `Path::join` ignores and replaces the base path if the right-hand argument is an absolute path. When fed untrusted object properties or configurations, this allows path bounds to be escaped.
Multimodal tool results (e.g., URLs) are incorrectly extracted and added to user prompts. This can allow attackers to bypass tool-specific security validations (such as SSRF blocklists on URLs) because the contents are evaluated as standard user strings/comments rather than structured tool returns.
Deserializing data from a file using `pickle` allows arbitrary code execution if the file can be tampered with by an attacker. Attackers with write access to predictable file paths (like cache files) can deploy malicious pickle payloads. Use a safer data format like JSON.
JMXAuthenticator implementation inappropriately casts credentials to generic `Object[]`. When paired with missing JEP 290 deserialization filters (`jmx.remote.rmi.server.credentials.filter.pattern`), this permits unauthenticated attackers to supply a malicious gadget chain array, leading to Remote Code Execution. Explicitly enforce strong types (e.g., `insta
Using `yaml:",inline"` on a map field acts as a catch-all during YAML deserialization. This neutralizes `Strict` mode unmarshaling, allowing configuration files with typos or misspelled properties to fail silently rather than producing errors. If strict validation is required, remove the inline map or perform manual validation of the unmarshaled data.
APISIX unconditional admin route initialization bypasses standalone YAML configuration checks, potentially exposing unsupported ETCD endpoints.
Method '$METHOD' accepts ByteBuffer but declares 'throws IOException'. ByteBuffer operations never throw IOException; this incorrect checked-exception declaration forces callers to wrap deserialization of untrusted network data in catch(IOException) blocks, causing protocol parse errors to be misclassified as I/O failures and potentially swallowed silently.
Environment variables are iterated and parsed with `yaml.safe_load` or `yaml.load` without structural type validation. If this unvalidated parsed structure is passed into downstream consumers (such as Jinja2 rendered YAML manifests), it allows attackers who control runtime environment variables to achieve configuration or manifest injection. Validate the par
Dynamically applying `yaml.safe_load` to environment variables matched merely by a prefix opens the door to YAML injection vulnerabilities if the results are later used in structural configurations downstream. Restrict `yaml.safe_load` to an explicit allowlist of variables.
Validation bypass vulnerability. By checking the truthiness of a dictionary value retrieved via `.get()` before running it through a validation function, falsy values (like empty strings) can bypass the validation logic completely. If the dictionary containing these unvalidated falsy values is later processed, it could lead to security issues. Use explicit p
Unconditionally merging user-controlled data from HTTP requests (e.g., via `flask.request.get_json()`) into dictionaries using `update()` can lead to Mass Assignment vulnerabilities. If the dictionary is used for policy enforcement, authorization, or business logic state, attackers may overwrite trusted keys (e.g., `user_id` or `target`) resulting in privile
An arbitrary file read and path traversal vulnerability was found. The code resolves a user-supplied path using a stream locator but fails to validate that the resulting path is within the expected root directory using `realpath()`. An attacker can pass directory traversal sequences or absolute paths to read sensitive files.
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
Eagerly allocating arrays with untrusted lengths derived from input structures can cause a Denial of Service via memory exhaustion (e.g. V8 contiguous backing store allocation). Avoid using `new Array(untrusted_len)` and instead initialize an empty array, assign properties sparsely or force dictionary-elements mode, and set `.length` accordingly.
This function checks only operation-level Security and returns with auth not required when that field is absent or empty, ignoring any API-level global security configuration. Any endpoint registered without an explicit Security block silently bypasses authentication (auth-bypass-by-omission). Add the huma.API as a parameter and fall back to api.OpenAPI().Se
Extracting and unescaping a raw HTTP path without first normalizing dot-segments (`../`) can cause path traversal or authorization bypasses when a downstream server normalizes the path. Apply path normalization (e.g., `path.Clean` or a custom dot-segment remover) before unescaping.
