Nov 18, 2026·10 min read·3 visits
OliveTin versions 3000.0.0 through 3000.18.0 interpolate unsanitized command output into the shellAfterCompleted hook prior to executing it via sh -c. Attackers who can influence the output of a primary action or inject metacharacters into runtime variables can achieve arbitrary command execution. Upgrade to OliveTin 3000.18.1 to remediate the flaw.
CVE-2026-75506 (GHSA-vc6p-m6vx-6cwq) is a second-order OS command injection vulnerability in OliveTin affecting versions 3000.0.0 prior to 3000.18.1. The post-execution hook mechanism, shellAfterCompleted, interpolates runtime execution outputs and username variables directly into a shell command string passed to sh -c without validation. When an action emits untrusted output containing shell metacharacters, those metacharacters break out of the intended syntax and execute arbitrary OS commands under the context of the OliveTin service process.
OliveTin is an open-source web interface written in Go that allows administrators to expose predefined shell commands and operational actions via a browser UI or REST API. To mitigate command injection risks during standard operations, OliveTin supports two primary execution modes: shell and exec. The shell mode invokes /bin/sh -c on Unix or cmd /C on Windows while applying strict input validation through checkShellArgumentSafety, whereas the exec mode passes an argument array directly to the OS execve system call to bypass shell interpretation altogether.
In addition to primary action execution, OliveTin provides a post-execution hook configured via the shellAfterCompleted attribute. Administrators commonly configure this attribute to dispatch completion notifications through utilities like apprise, curl, or custom logging scripts. The shellAfterCompleted template permits dynamic interpolation of execution metadata, including the standard output of the primary command ({{ output }}), the exit status ({{ exitCode }}), and the authenticated username ({{ ot_username }}).
In OliveTin versions 3000.0.0 prior to 3000.18.1, the template processing pipeline for shellAfterCompleted fails to enforce argument sanitization or escape shell metacharacters within these runtime variables. Instead, the raw text expanded from {{ output }} and other execution parameters is concatenated directly into the command string before being passed to sh -c.
This design flaw results in a second-order OS command injection vulnerability tracked as CVE-2026-75506 (and GHSA-vc6p-m6vx-6cwq), classified under CWE-78 and CWE-74. Even when an administrator configures the primary action using the secure exec vector mode to safely process untrusted input, any data emitted to standard output or standard error by that primary action is subsequently evaluated as live shell syntax if referenced within shellAfterCompleted.
The root cause of CVE-2026-75506 resides in service/internal/executor/executor.go within the buildShellAfterCommand and buildShellAfterArgs functions. When a primary action finishes executing, OliveTin captures its combined standard output and standard error streams into a memory buffer. The executor then invokes buildShellAfterArgs(req) to construct a map[string]string dictionary containing runtime variables for the post-execution phase.
Within buildShellAfterArgs, the executor populates four key entries in the argument map: output (the raw captured stdout/stderr string), exitCode (the numeric exit status formatted as a string), ot_username (the requester's username, which may originate from reverse-proxy HTTP headers), and ot_executionTrackingId. Unlike user-supplied action arguments in primary shell commands—which must pass strict type and regex validation in checkShellArgumentSafety—the values inserted into the shellAfterCompleted argument map undergo no character filtering.
Following argument map construction, buildShellAfterCommand calls tpl.ParseTemplateWithActionContext(action.ShellAfterCompleted, req.Binding.Entity, args). This function evaluates the Go template string configured in shellAfterCompleted and replaces placeholders such as {{ output }} or {{ .Arguments.output }} directly with their literal string values from the args map. The resulting string, finalParsedCommand, is then passed directly to exec.Command("sh", "-c", finalParsedCommand).
Because the template engine performs raw text substitution without shell-quoting or escaping, any shell control operators (;, |, &, $(), or backticks) present in the primary command's output alter the abstract syntax tree parsed by /bin/sh. If the primary command queries an external HTTP endpoint, lists directory contents containing attacker-controlled filenames, echoes user input, or outputs log records, an attacker can embed shell metacharacters that break out of surrounding quotes in the shellAfterCompleted template and execute arbitrary commands.
Before remediation, buildShellAfterCommand in service/internal/executor/executor.go passed the full args map directly into the Go template parser. The vulnerable implementation followed this pattern:
func buildShellAfterCommand(ctx context.Context, req *ExecutionRequest, stdout, stderr *bytes.Buffer) (*exec.Cmd, map[string]string, error) {
action, ok := shellAfterCompletedAction(req)
if !ok {
return nil, nil, nil
}
args, err := buildShellAfterArgs(req)
if err != nil {
return nil, nil, err
}
// VULNERABLE: args["output"] contains raw stdout/stderr and is interpolated directly into the command string
finalParsedCommand, err := tpl.ParseTemplateWithActionContext(action.ShellAfterCompleted, req.Binding.Entity, args)
if err != nil {
return nil, nil, err
}
// finalParsedCommand is passed to sh -c
}The maintainers initially attempted to address the issue in commit 4ef86abee7aac4e4ec4a3200c7ca491ca3501065 (released in 3000.17.0). That initial commit introduced static string replacements for four exact literals ({{ output }}, {{output}}, {{ exitCode }}, and {{exitCode}}), converting them into environment variable references ("$OUTPUT" and "$EXITCODE"). It also restricted shellAfterCompleted from executing on webhook-triggered actions:
// Incomplete fix in commit 4ef86abee7aac4e4ec4a3200c7ca491ca3501065
replacements := []struct{ old, new string }{
{"{{ output }}", `"$OUTPUT"`},
{"{{output}}", `"$OUTPUT"`},
{"{{ exitCode }}", `"$EXITCODE"`},
{"{{exitCode}}", `"$EXITCODE"`},
}
for _, r := range replacements {
command = strings.ReplaceAll(command, r.old, r.new)
}> [!WARNING]
> The initial patch in commit 4ef86abee7aac4e4ec4a3200c7ca491ca3501065 was incomplete. Because output and exitCode remained inside the args map passed to ParseTemplateWithActionContext, any template variation that did not match the four hardcoded strings bypassed the replacement and expanded raw output directly into the shell command.
Specifically, OliveTin's template engine supports both legacy bare syntax with arbitrary internal whitespace (such as {{ output }}) and modern dot-prefixed argument syntax ({{ .Arguments.output }} or {{.Arguments.output}}). In version 3000.17.0, an action configured with {{ .Arguments.output }} bypassed strings.ReplaceAll and remained vulnerable to OS command injection.
To make the fix complete, commit e5d29b68da66fd7f99072d6afd336dee2c28876c (released in 3000.18.1) introduced a two-layer defense in service/internal/executor/executor.go:
var (
// Matches both {{ output }} and {{ .Arguments.output }} with arbitrary whitespace
shellAfterOutputRef = regexp.MustCompile(`\{\{\s*(?:\.Arguments\.)?output\s*\}\}`)
shellAfterExitCodeRef = regexp.MustCompile(`\{\{\s*(?:\.Arguments\.)?exitCode\s*\}\}`)
)
func substituteShellAfterCompletedEnvRefs(command string) string {
// Rewrites template placeholders into double-quoted shell environment variables
command = shellAfterOutputRef.ReplaceAllString(command, `"$$OUTPUT"`)
command = shellAfterExitCodeRef.ReplaceAllString(command, `"$$EXITCODE"`)
return command
}
func shellAfterTemplateArgs(args map[string]string) map[string]string {
// Completely strips output and exitCode from the Go template context
templateArgs := make(map[string]string, len(args))
for name, value := range args {
if name == "output" || name == "exitCode" {
continue
}
templateArgs[name] = value
}
return templateArgs
}This complete patch ensures that output and exitCode are passed to the child sh -c process exclusively via OS environment variables (OUTPUT and EXITCODE) and are scrubbed from the template map prior to template rendering. When the POSIX shell expands "$OUTPUT", it treats the variable contents purely as a string literal rather than re-evaluating tokens as shell commands or pipeline operators.
Exploiting CVE-2026-75506 requires two primary conditions: a target OliveTin action must have shellAfterCompleted configured to reference the primary command's output (or untrusted username metadata), and the attacker must be able to trigger the action while influencing the standard output stream. Because OliveTin is frequently deployed to run diagnostic scripts, fetch remote status endpoints, or process files, attackers can often influence stdout even when direct command arguments are restricted.
Consider a production configuration where an administrator defines an action using the exec array to prevent direct argument injection, followed by a shellAfterCompleted notification command:
actions:
- title: Check Service Endpoint
exec:
- /usr/bin/curl
- -s
- https://internal-status.example.com/api/health
shellAfterCompleted: "apprise -t 'Health Check' -b 'Response: {{ output }}'"If an attacker controls the HTTP response returned by the target endpoint (or can inject arbitrary strings into the stdout of a local script), they can return a payload structured to close the single quote in the apprise command, inject an arbitrary shell command, and comment out or re-open the trailing quote:
'; id > /tmp/pwned; echo 'When OliveTin finishes running /usr/bin/curl, it captures the payload in stdout and invokes buildShellAfterCommand. The template engine substitutes {{ output }} with the literal string, producing the following command line for /bin/sh -c:
apprise -t 'Health Check' -b 'Response: '; id > /tmp/pwned; echo ''The official regression test suite in service/internal/executor/executor_test.go demonstrates this exact exploitation vector across multiple template syntaxes:
injectedPath := filepath.Join(t.TempDir(), "olivetin-injected")
a1 := &config.Action{
Title: "After completion escape",
Shell: "printf %s \"'; touch " + injectedPath + "; echo '\"",
ShellAfterCompleted: "printf %s '{{ .Arguments.output }}'",
}In versions prior to 3000.18.1, executing this action causes /bin/sh to sequentially execute printf %s '', followed by touch <tempdir>/olivetin-injected, and finally echo ''. On version 3000.18.1, the template tag is rewritten to "$OUTPUT", causing the shell to pass the entire literal payload as a single argument to printf without executing the embedded touch command.
Successful exploitation of CVE-2026-75506 grants an attacker arbitrary OS command execution with the privileges of the system user running the OliveTin daemon or container process. Because OliveTin is specifically designed as a systems administration and automation gateway, its runtime environment frequently holds elevated privileges, such as root execution rights, sudo capabilities, SSH private keys for remote hosts, cloud provider API tokens, or access to the host Docker socket.
The vulnerability is assigned a CVSS v3.1 base score of 6.6 (Medium) with the vector CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H. The High (H) Attack Complexity metric reflects that shellAfterCompleted is not enabled by default on actions and must be explicitly configured by an administrator in config.yaml with variable interpolation. The High (H) Privileges Required metric reflects deployments where only authenticated users with action-execution permissions can trigger the vulnerable workflow.
However, the effective risk is substantially higher in environments where OliveTin actions are exposed to low-privileged internal users, unauthenticated guests, or automated webhooks (in versions prior to 3000.17.0). In those deployments, a user who is only authorized to run a benign read-only diagnostic command (such as ping, dig, or a log viewer) can escalate their access to full shell execution on the OliveTin host.
Once arbitrary code execution is achieved, confidentiality, integrity, and availability impacts are all rated High (H). An attacker can read config.yaml and environment variables to harvest secrets, modify scripts executed by other OliveTin actions to establish persistence, or pivot laterally across the internal management network connected to the OliveTin server.
The definitive remediation for CVE-2026-75506 is to upgrade OliveTin to version 3000.18.1 or later. Note that version 3000.17.0 contains only a partial fix that can be bypassed using {{ .Arguments.output }} or non-standard whitespace formatting within template directives.
In version 3000.18.1, OliveTin automatically rewrites {{ output }}, {{ .Arguments.output }}, {{ exitCode }}, and {{ .Arguments.exitCode }} into double-quoted environment variable expansions ("$OUTPUT" and "$EXITCODE") and removes those keys from the Go template argument map. Furthermore, actions triggered via webhooks are explicitly blocked from executing shellAfterCompleted hooks and will return an error advising the administrator to use exec scripts directly.
> [!NOTE]
> When upgrading to 3000.18.1, inspect existing shellAfterCompleted configurations in config.yaml for redundant single quotes around {{ output }}. Because OliveTin now substitutes {{ output }} with "$OUTPUT" (including double quotes), wrapping the placeholder in single quotes (e.g., '{{ output }}') will result in '"$OUTPUT"', which prevents the shell from expanding the $OUTPUT variable inside single quotes. Update your configuration to reference $OUTPUT directly or allow OliveTin's double-quoted replacement to stand unquoted.
For environments that cannot immediately upgrade to 3000.18.1, administrators should apply the following workarounds:
config.yaml for shellAfterCompleted: Locate all actions utilizing the post-completion hook:
grep -rn "shellAfterCompleted" /etc/OliveTin/shellAfterCompleted command that references {{ output }}, {{ .Arguments.output }}, or {{ ot_username }}. Instead of using shellAfterCompleted to send output notifications, wrap the primary command and the notification logic inside a standalone shell script invoked via exec, where standard output can be captured directly into a local variable or temporary file without double shell evaluation.shellAfterCompleted.CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
OliveTin OliveTin | >= 3000.0.0, < 3000.18.1 | 3000.18.1 |
| Attribute | Detail |
|---|---|
| Vulnerability Type | Second-Order OS Command Injection (CWE-78 / CWE-74) |
| Affected Component | buildShellAfterCommand in service/internal/executor/executor.go |
| CVSS v3.1 Score | 6.6 Medium (CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H) |
| Affected Versions | OliveTin >= 3000.0.0 and < 3000.18.1 |
| Patched Version | OliveTin 3000.18.1 |
| Attack Vector | Network (Untrusted command output or metadata interpolated into sh -c) |
| Exploit Status | Functional PoC in official commit unit tests |
| CISA KEV Status | Not Listed |
The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component.
A missing authorization vulnerability exists in django-filer versions prior to 3.5.0 when the optional per-folder permission system (FILER_ENABLE_PERMISSIONS) is enabled. The bulk delete admin action (delete_files_or_folders) verifies global Django model-level deletion permissions but fails to enforce object-level FolderPermission edit checks. Consequently, an authenticated staff user holding model-level delete rights can delete files, folders, and directory trees from folders where their access has been explicitly restricted to read-only via FolderPermission.
CVE-2026-71481 (GHSA-82w8-65qw-gch6) is a cryptographic signature verification bypass (CWE-347) in the altcha-org/altcha PHP library affecting versions 2.0.0 through 2.0.2. Due to a flawed conditional check in the verifySolution method, omitting the signature field from a submitted challenge payload causes the server to skip HMAC verification entirely, even when a server-side HMAC secret is configured. Unauthenticated remote attackers can exploit this flaw to self-issue low-difficulty Proof-of-Work challenges, solve them with trivial effort, and bypass CAPTCHA controls.
CVE-2026-61618 (GHSA-265x-v3qf-ff6p) is an improper input validation vulnerability (CWE-20) in Axiom Crypto's snark-verifier library prior to version 0.2.5. The library decodes KZG accumulator public-instance limbs without enforcing canonical bit-width bounds prior to elliptic curve coordinate reconstruction. In the Ethereum Virtual Machine (EVM) loader path, the generated Yul bytecode validates that reconstructed affine coordinates lie on the elliptic curve, but fails to verify that the constituent limbs respect their allocated bit-widths, allowing non-canonical proof representations. In the native Rust execution path, accumulator decoding relies on unchecked assertions and unwraps, allowing malformed public instances to trigger an unhandled process panic.
An OS command injection vulnerability (CWE-78) exists in the @augment-vir/node package prior to version 31.73.5. The grep() utility function builds a shell command string by interpolating caller-supplied search patterns inside double quotes and executes the string through bash via runShellCommand(). Because bash evaluates command substitution expressions inside double-quoted strings, an attacker controlling the search pattern input can execute arbitrary OS commands with the privileges of the Node.js runtime.
CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.
CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.