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 mail auto-reply recipient is adopted from the legacy-compatibility entity properties 'email' / 'email_1' of a visitor-controlled mail-message entity (properties that can be populated from POST keys with no backing type='email' form field and that therefore never receive an e-mail-format check) and the value is returned as the outbound auto-reply destinat
A process argument list is flattened into a single shell command string with implode(' ', ...) and handed to $FUNCTION without escapeshellarg()/escapeshellcmd(). On Windows, PHP's shell-execution functions run the whole string through cmd.exe, so unescaped metacharacters (e.g. '&') inside any joined element -- such as a user-supplied URL -- are parsed as com
Dynamic shell variable assignment with an unquoted name: `declare` receives a `$var` expansion in the variable-name position, so whatever the expansion contains becomes the name of a new shell variable. When the name/value pair is parsed from a configuration file that a less-privileged user can influence (KEY='value' conf lines), a forged field such as PATH=
Request-controlled data reaches process execution without being resolved against a fixed allowlist. A caller (unauthenticated or cross-site/CSRF) supplies a command string that is tokenized into an argv list and executed (CVE-2026-107337 pattern: a raw URL segment is handed to the service() runner, split on spaces, joined under scripts/ and executed with sub
An entry of a JSON-decoded map[string]string is selected and concatenated into a "key=value" option string appended to an option list without first validating every entry of the map. If this list is later joined with the delimiter of a single option/flag argument (e.g. mount -o opt1,opt2), a value containing the delimiter injects arbitrary options (argument/
The value $ARG reaches a git command line before the `--` end-of-options separator without validation. Git parses any value whose first character is `-` as an option rather than a revision, so an attacker-controlled ref (e.g. `--output=/etc/cron.d/x`) can make git create, overwrite, or truncate an arbitrary file outside the intended workspace directory. Vali
Using a Unix-only regex backslash escaping routine for shell command arguments fails to neutralize metacharacters when the command runs on Windows shells (such as PowerShell or cmd.exe). This can allow command or argument injection. Use shell-specific quoting and escaping based on the target shell environment.
GitPython unsafe_git_diff_options is missing '--no-index', allowing arbitrary filesystem diffs without opt-in.
Client-controlled request data is placed into a child-process argument vector as a bare positional argument (the element following the "--" end-of-options marker). Utilities that parse argv with getopt_long permute arguments, so a value beginning with "-" is re-interpreted as an option and can override flags the application built itself (e.g. a storage-confi
A request-controlled database name is placed into the --dbname/-d option of a libpq-based utility (psql, pg_restore, pg_dump). libpq expands any value containing "=" into a full connection string whose keywords (host, port, user, sslmode, ...) override the --host/--port/--username arguments the application supplies, so an attacker can redirect the connection
Unescaped dynamic value $VAL is emitted as an rrdtool graph option $FLAG. rrdtool options are space-joined into a single command line/stdin stream, so a double quote in $VAL terminates the option token and a CR/LF starts a new rrdtool command. An attacker controlling this free-form string (e.g. the graph_title request parameter stored in user_title and re-em
Command-line argument validation treats flags containing '=' as safe or allows unvalidated flags, enabling argument injection (CWE-88). All option flags must be strictly validated against an allowlist.
Detected use of `cmdAsSingleString` with a dynamic command string in Jenkins `ProcStarter`. Passing dynamic or macro-expanded strings to `cmdAsSingleString` can lead to command injection or argument injection vulnerabilities. Use `ArgumentListBuilder` with `.cmds(...)` instead.
Unvalidated Perforce port or URL passed to `p4` via `-p` argument. The Perforce client interprets `rsh:` and `jsh:` prefixes in P4PORT as local commands to execute. Validate the port format (e.g. ensure it matches network endpoints like `[tcp|ssl:][host:]port` and reject `rsh:`/`jsh:`) before passing it to `p4`.
Invoking the native 'zip' command without a '--' delimiter before dynamic file sources can lead to argument injection and command execution via crafted file names or options such as '-T' and '-TT'.
Detected command execution with a shell wrapper (`/bin/sh -c` or `bash -c`) where arguments are interpolated via format specifiers without shell quoting or sanitization. This can lead to OS command injection.
Docker `--filter` argument is constructed using double quotes inside a format string without shell quoting. If executed in a shell, this allows command injection via unescaped quotes or shell metacharacters.
Caller-controlled JVM options are passed to a Java subprocess without validation. Unvalidated Java options such as `-javaagent`, `-agentpath`, `-XX:OnError=`, or `@argfile` can allow argument injection and arbitrary code execution (CWE-88).
The blame argument guard polices Repo.blame()/Repo.blame_incremental() with the generic revision denylist (Repo.unsafe_git_revision_options), which only contains the file-WRITE options --output/-o. git-blame's file-READING options -- --contents=<file>, -S <file> and --ignore-revs-file <file>, plus clustered short-option spellings such as -wS<file> -- are the
Calling `Repo.clone` or `Repo.clone_from` with `allow_unsafe_options=True` disables validation against dangerous git clone options (such as `--config`, `--template`, and `--separate-git-dir`). If arguments or options are derived from untrusted input, this can lead to argument injection, arbitrary file overwrite, or remote code execution.
Incomplete unsafe-option guard candidates: value spellings for single-character options are added to the validated candidate list only when short-option splitting is enabled. When splitting is disabled, the command builder emits one joined token '-{key}{value}' (e.g. '-nuhelper' or '-n--upload-pack=helper') that the guard never inspects, so an embedded '-u'
A `git read-tree` command is built through GitPython's Git wrapper without the unsafe-option screening that must guard the argv boundary: the enclosing function never calls check_unsafe_options() (the unsafe_git_read_tree_options denylist) and neither forwards an allow_unsafe_options opt-out nor terminates option parsing with a `--` separator. Caller-supplie
Repo.init() forwards its keyword arguments to the underlying `git init` command as command-line options without validation. GitPython renders each kwarg as a `--long-option[=value]` argument, so caller-influenced kwargs become arbitrary git-init(1) options: --template=<dir> makes git copy an attacker-planted template directory (including executable hooks/) i
Keyword arguments (and option-shaped positional strings) reach the git subcommand `git rm` / `git checkout` / `git reset` unvalidated: the command facade converts every kwarg into a CLI flag, so a caller-controlled kwarg such as `pathspec_from_file=/etc/passwd` (or the unambiguous abbreviation `pathspec_from=/etc/passwd`) injects `--pathspec-from-file=/etc/p
