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.
Unrestricted inline remote instantiation in rclone's server allows unauthenticated attackers to execute arbitrary commands by supplying crafted backend connection strings. Validate user-provided backend configuration strings against the active authentication context using 'checkServeRemote()' before calling 'cache.Get()'.
Using `eval STRING` with interpolated or dynamically constructed variables can allow an attacker to execute arbitrary Perl code. If the interpolated variable contains unescaped quotes matching the string boundaries, an attacker can break out of the string encapsulation and execute a payload. Refactor to avoid `eval STRING` or use safer alternatives for dynam
Directly interpolating variables into generated code templates using surrounding quotes (e.g., `"${variable}"`) enables code injection if the input contains unescaped quote or backslash characters. Securely serialize dynamic values into the generated code using robust methods like `JSON.stringify()` or specific compiler-aware escaping functions, and remove t
Evaluating a dynamically built regular expression string using 'Kernel.eval' allows an attacker to break out of the regex literal and execute arbitrary Ruby code. Provide the string directly to 'Regexp.new' instead to safely compile the untrusted input into a regex object.
Detected a fallback to a wildcard ('*') when evaluating a list of CORS origins that has a length greater than 1. This incorrectly exposes the endpoint to Cross-Origin Resource Sharing (CORS) from any domain if multiple origins are provided. Instead of enforcing multi-origin protections, the fallback strips all security by providing an unrestricted wildcard p
Instantiating FactoryFinder without specifying a required type and allowed implementations enables arbitrary class instantiation via reflection if an attacker can control the factory lookup key. Provide a `requiredType` and `allowedImpls` strict allowlist using the updated `FactoryFinder` constructor.
An MCP tool handler passes a user-controlled string parameter to Python's eval()/exec(). Because eval/exec is invoked without an AST allowlist and with __builtins__ reachable, an attacker (directly or via prompt injection of the LLM client) can submit a payload such as `__import__('os').system(...)` to achieve remote code execution (CWE-94, CWE-1427). Replac
JSON.parse() output is merged directly into an options object via Object.assign() without filtering security-sensitive keys. An attacker who controls the JSON input (e.g. via a URL query parameter, deep link, CLI argument, or crafted shortcut) can inject arbitrary keys that downstream code may use in privileged operations—such as spawning a process with an a
Gin middleware function conditionally invokes middleware.AuthRequired() only on one branch and calls ctx.Next() on the other branch, allowing requests to proceed unauthenticated when the condition is false. This is a state- or time-window-dependent authentication bypass (e.g. "auth only after install" or "auth only after a timeout"); attackers can hit the ro
Using `eval()` with an empty dictionary for globals is an incomplete sandbox. Python implicitly injects `__builtins__` into the globals dictionary if it is not explicitly provided, allowing attackers to execute arbitrary system commands via built-in functions like `__import__`. To properly restrict `eval()`, pass a dictionary explicitly limiting or disabling
A string value is embedded into a filter or query expression using String.format with naive single-quote wrapping ("'%s'") and no escaping of special characters. A value containing a single quote will terminate the string literal prematurely and allow injection of arbitrary filter/query syntax (e.g., Milvus filter injection, MariaDB SQL injection via metadat
A DQL predicate is being constructed by concatenating a language tag via `fmt.Sprintf("%v@%v", predicate, lang)` (or `%s@%s`), and the result is later interpolated into a DQL query template. Because `x.PredicateLang()` only splits the JSON mutation key on the last `@` and returns the suffix verbatim, the language tag is attacker-controlled and can contain DQ
Potential DQL injection (CVE-2026-41327): a user-controlled upsert `cond` value is being transformed by `strings.Replace($X, "@if", "@filter", 1)` and concatenated into a DQL query without prior structural validation. The `strings.Replace` call is a cosmetic syntax rewrite, not a security boundary. An attacker can craft a `cond` that closes the `@filter(...)
Dynamically constructing Envoy Lua filter scripts via string interpolation or templates allows Lua code injection. User-controlled values injected into the script source can execute arbitrary code within the proxy. Configure static Lua scripts and pass dynamic variables through Envoy's `FilterContext` or stream data instead.
The protobufjs `Type` constructor forwards the `name` argument to `Namespace.call(this, name, options)` without first stripping non-word characters. The stored name is later interpolated verbatim as a JavaScript identifier in source compiled by `new Function()` (util/codegen in decoder.js / encoder.js / verifier.js / converter.js), allowing an attacker who c
A credential-like field (e.g., password, token, code) destructured from `req.body` via a TypeScript type assertion (`as <Type>`) is passed directly into a Mongoose equality query. TypeScript type assertions are erased at runtime and do not validate input, so an attacker can submit a JSON object such as `{"$ne": ""}` for a field expected to be a string/number
File mutation operation performs path-traversal validation (_validate_path) but does not enforce workspace containment via _require_workspace_access(write=True) before invoking a destructive filesystem operation (shutil.move / shutil.copy2 / os.remove / os.unlink / open(..., 'w')). Path-traversal checks alone allow any absolute host path that does not contai
A SQLite JSON path is built by concatenating a field-name parameter to a '$' / '$.' prefix without escaping single quotes or backslashes. The resulting path is typically interpolated into single-quoted SQL string literals (e.g., json_extract(document, '$.field'), json_each, json_type, json_array_length). An attacker-controlled field name containing a single
Use of PHP's create_function() compiles its second argument via internal eval(). When any value that flows into the body string originates from request data (cookies, query parameters, headers, or config values overrideable by the client), this becomes a code-injection / RCE primitive (CWE-94). Replace create_function() with an anonymous closure (function(..
A value is interpolated into a Ruby string that builds a Gemfile gem-source option (branch:/ref:/tag:). Generated Gemfiles are evaluated as Ruby by Bundler, so any attacker-controlled content in the interpolated value can break out of the string literal and execute arbitrary Ruby code at bundle composition time (see CVE-2026-34060 in ruby-lsp, where the ruby
Compiling user-supplied `jq` expressions without constraints can lead to the execution of dangerous `jq` built-ins. Built-ins like `env` allow leaking process environment variables (such as passwords or API keys), while `import` and `include` allow arbitrary file reads. Ensure dynamic `jq` queries are validated against an allowlist or blocklist before passin
Returning a pre-parsed AST node (e.g., 'Program') directly without structural validation can lead to arbitrary code execution if the input is attacker-controlled. A crafted object can bypass compilation guards and inject arbitrary code. Ensure that dynamically provided ASTs are validated against type confusion and unexpected literals before processing.
Handlebars precompiler concatenates user-controllable options (`opts.handlebarPath`, `opts.commonjs`, `opts.namespace`) directly into generated JavaScript source code without escaping, and emits the result via `SourceNode.add(...)`. CVE-2026-33937: an attacker who controls these options (or, more broadly, who can supply a fake AST whose literal `value` field
Channel/sender ACL check is fail-open: when the configured allow list is empty or missing, the function returns True, granting access to every sender. A remote attacker can deliver messages (e.g. via an unauthenticated email/IMAP poll, webhook, or chat platform) and have them processed as trusted owner input, enabling indirect prompt injection and tool abuse
