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.
Directly reading the Kubernetes ServiceAccount token from '/var/run/secrets/kubernetes.io/serviceaccount/token' can expose cluster credentials if the token is transmitted in outbound requests. Use a scoped token with a restricted audience instead.
Deserialization of data using ObjectInputStream without an ObjectInputFilter allowlist can allow remote code execution via gadget chains (CWE-502). Configure an ObjectInputFilter via setObjectInputFilter() before calling readObject() or readUnshared().
MCP installation specification uses a mutable git ref instead of an immutable 40-character commit SHA. Compromise of the upstream branch can lead to supply-chain compromise and arbitrary code execution.
Missing replacement document validation. Passing an unvalidated replacement can allow pipeline injection if a BsonArray is supplied.
Equality filter optimization simplifies explicit comparison to implied equality without validating that document values do not contain '$'-prefixed keys. This allows MongoDB to interpret user-supplied keys as query operators, leading to NoSQL query injection.
Unbounded string splitting on '.' when parsing compact JWE/JWS/JWT tokens can allow a remote attacker to trigger excessive memory allocation (MemoryError DoS) by providing numerous delimiter characters. Specify a maxsplit argument to split (e.g., `split('.', 5)`).
Custom `pickle.Unpickler.find_class` delegates to `super().find_class` without validating against dotted names (`.` in `name`). Under pickle protocol 4+, `find_class` resolves dotted names via `getattr` chaining, allowing an attacker to bypass module-level allowlists to access dangerous attributes or submodules.
Detected `Reflect.has` used inside a recursive object merge function. `Reflect.has` traverses the prototype chain, which allows special keys like `__proto__` to be recognized as existing properties and traversed recursively, leading to Prototype Pollution. Use `Object.hasOwn()` and reject keys such as `__proto__`, `constructor`, and `prototype`.
Calling `maybe_unserialize()` on Gravity Forms field input values allows arbitrary PHP Object Injection (CWE-502). Use `unserialize($data, ['allowed_classes' => false])` or validate the data type instead.
Base64-decoded serialized data is re-hashed using `wp_hash()` and assigned to a hash field without validating that the payload does not contain serialized PHP objects. This can allow attackers to bypass WordPress HMAC/hash integrity checks and achieve PHP Object Injection.
Authorization check fails open when permissions list is empty ($permissions is empty -> permitted). This allows unauthenticated or unauthorized access to routes or actions that lack explicit permission definitions.
STIX 2 content is read and parsed without prior input size validation, potentially leading to memory exhaustion and denial of service.
Calling `InetAddress.getByName()` during deserialization without verifying that the input is an IP address literal causes eager DNS resolution of arbitrary hostnames, leading to DNS-based SSRF and internal host enumeration.
The controller's editAction performs HMAC or token-based authorization, but updateAction persists updates to the repository without verifying the token or using a #[Validate] attribute.
ZeroMQ `recv_pyobj()` deserializes messages using `pickle.loads()`, which allows arbitrary code execution if incoming socket data is untrusted. Use safe serialization formats like JSON (`recv_json()`) or Protocol Buffers instead.
Insecure deserialization using nested joblib.load and pickle.loads. Deserializing untrusted files using pickle allows arbitrary code execution.
Detected direct passing of parsed request body to entity edit logic without filtering sensitive backend configuration properties or checking appropriate permissions.
Data read directly from a file or stream is deserialized without cryptographic integrity verification (such as HMAC via hash_hmac/hash_equals). This allows arbitrary PHP object injection if an attacker can tamper with or write cache files.
Insecure classpath resource discovery for serialization filter configuration in fat JAR environments.
ClassLoader resource discovery for serialization configuration files may fail in fat-jar environments.
Insecure classpath resource lookup for serialization configuration may fail to discover all filter definitions in single-JAR or modular deployments, potentially leading to incomplete deserialization filters.
Deserialization filter configuration loaded via ClassLoader.getResources() may fail to discover all filter entries when packaged in single/fat jars. Use MetadataDiscovery instead.
Direct classpath resource lookup for serialization filter configurations can lead to missing or overwritten JEP 290 filter patterns when packaged in single/fat JARs. Use MetadataDiscovery to aggregate module-scoped filter definitions.
Helidon serialization configuration should use MetadataDiscovery rather than direct ClassLoader lookup to ensure complete filter discovery.
