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 extracting the exact 'd' closest peers from the routing table for Kademlia DHT disjoint paths leaves the lookup vulnerable to Sybil/Eclipse attacks. If an attacker controls the 'd' closest node IDs, they will intercept and control all query paths. Fix this by retrieving a wider pool of closest peers (e.g., `kBucketSize`) and drawing from it probabil
Starting a DHT lookup by selecting exactly the `d` (`disjointPaths`) closest peers from the routing table makes the network vulnerable to an eclipse attack (CVE-2026-45783). An attacker controlling the `d` closest nodes will compromise all disjoint lookup paths. Instead, fetch up to a larger threshold (e.g., `kBucketSize`) of closest peers and randomly parti
Generating a session token or credentials directly from a process ID (PID) makes the token highly predictable. Attackers can guess valid tokens to hijack sessions or trigger unauthorized actions. Use a cryptographically secure random number generator (CSPRNG) to generate session identifiers.
Cryptographic operations from underlying libraries are returned directly without checking for failure (e.g., null returns from JNI wrappers or uncaught exceptions). This can cause fallbacks to all-zero keys, leading to deterministic and predictable key material. Properly handle failures by checking for null or catching exceptions and throwing a dedicated Cry
A potentially hardcoded or static seed is used for MurmurHash3 initialization. This makes the hash function predictable and vulnerable to hash collision Denial of Service (DoS) attacks. An attacker can precompute keys that hash to the same bucket, degrading performance to O(n²). Randomize the hash seed using a cryptographically secure pseudo-random number ge
Generating bytes with Perl's built-in rand() (e.g. `chr rand 256`) is insecure for any cryptographic purpose. Perl's rand() is a non-CSPRNG with a small, predictable internal state; bytes derived from it can be reproduced or brute-forced by an attacker. Use an OS CSPRNG such as Crypt::SysRandom::random_bytes(), Crypt::URandom, or Crypt::PRNG instead.
Authentication/API token is generated using itsdangerous.URLSafeTimedSerializer keyed by a non-secret value (e.g. tenant_id) and/or signing a predictable payload such as a UUID, with the output being sliced. This treats the serializer as a randomness source instead of a verifiable signed token. URLSafeTimedSerializer produces deterministic base64(payload).ti
A user/session/API token is generated using `:base62.encode/1` without sourcing entropy from `:crypto.strong_rand_bytes/1`. This pattern produces structurally-predictable tokens (especially when combined with HMAC over user-identifiable inputs) that are brute-forceable or enumerable (CVE-2025-64097, CWE-330). Replace the token body with `:crypto.strong_rand_
Session/token identifier is derived by hashing the output of Perl's built-in rand(), which is a non-cryptographic PRNG seeded with only ~32 bits and is therefore predictable. Combining it with $$ (PID), time, or stringified references (memory addresses) does not add meaningful entropy, and wrapping the result in a digest (sha1_hex/md5_hex/sha256_hex/...) doe
Generating session seeds or cryptographic tokens using weak sources of entropy like `time` and `rand` leads to highly predictable values. An attacker can brute-force or correlate these inputs to guess the final output, leading to session hijacking. Use a true CSPRNG (e.g., Crypt::SysRandom or Math::Random::Secure) instead.
Perl's built-in rand() is being fed into a cryptographic hash (SHA-1/SHA-256/SHA-512/MD5) to derive bytes. rand() is seeded with at most 32 bits and is not a CSPRNG, so hashing it (optionally with $$, Time::HiRes::time, or other low-entropy values) does not produce cryptographically strong output. This pattern produces predictable session IDs, CSRF tokens, a
Mojolicious applications and framework code should not use the predictable application moniker or insecure PRNGs like `rand` to generate session secrets or CSRF tokens. This allows an attacker to compute valid HMAC signatures and forge session cookies. Replace predictable secrets with strong cryptographic random strings (e.g. `Mojo::Util::urandom_urlsafe`).
Predictable TCP Initial Sequence Number (ISN) generation detected. Generate ISNs using a cryptographically secure pseudo-random number generator (CSPRNG) or a secure hash that incorporates connection parameters and a secret key, as recommended by RFC 9293. Incrementing a variable to compute the ISN makes it predictable, rendering the stack susceptible to TCP
