CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-75506

CVE-2026-75506: Second-Order OS Command Injection in OliveTin shellAfterCompleted Hook

Alon Barad
Alon Barad
Software Engineer

Nov 18, 2026·10 min read·3 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis and Patch Evaluation

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.

Exploitation Methodology

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.

Impact Assessment

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.

Remediation and Mitigation

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:

  1. Audit config.yaml for shellAfterCompleted: Locate all actions utilizing the post-completion hook:
    grep -rn "shellAfterCompleted" /etc/OliveTin/
  2. Remove Output Interpolation: Modify any 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.
  3. Disable Webhook Access to Affected Actions: Ensure that no webhook-triggered action is bound to a configuration that uses shellAfterCompleted.

Official Patches

OliveTinOliveTin 3000.18.1 patched release
OliveTinOfficial GitHub Security Advisory GHSA-vc6p-m6vx-6cwq
OliveTinGitHub Pull Request #1088 implementing complete template scrubbing for shellAfterCompleted
OliveTinGitHub Pull Request #1070 introducing environment variable substitution and webhook restrictions

Fix Analysis (2)

Technical Appendix

CVSS Score
6.6/ 10
CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H

Affected Systems

OliveTin >= 3000.0.0, < 3000.18.1

Affected Versions Detail

Product
Affected Versions
Fixed Version
OliveTin
OliveTin
>= 3000.0.0, < 3000.18.13000.18.1
AttributeDetail
Vulnerability TypeSecond-Order OS Command Injection (CWE-78 / CWE-74)
Affected ComponentbuildShellAfterCommand in service/internal/executor/executor.go
CVSS v3.1 Score6.6 Medium (CVSS:3.1/AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H)
Affected VersionsOliveTin >= 3000.0.0 and < 3000.18.1
Patched VersionOliveTin 3000.18.1
Attack VectorNetwork (Untrusted command output or metadata interpolated into sh -c)
Exploit StatusFunctional PoC in official commit unit tests
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1059.004Unix Shell
Execution
CWE-78
Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection')

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.

Known Exploits & Detection

GitHubOfficial regression unit test in service/internal/executor/executor_test.go demonstrating shell breakout via '{{ output }}' and '{{ .Arguments.output }}'.

Vulnerability Timeline

CVE-2026-75506 and GitHub Security Advisory GHSA-vc6p-m6vx-6cwq published; OliveTin 3000.18.1 released with complete fix.
2026-11-18

References & Sources

  • [1]NVD Vulnerability Detail: CVE-2026-75506
  • [2]CVE.org Record: CVE-2026-75506
  • [3]GitHub Security Advisory: GHSA-vc6p-m6vx-6cwq
  • [4]GitHub Pull Request #1070
  • [5]GitHub Pull Request #1088
  • [6]GitHub Fix Commit 1 (4ef86abee7aac4e4ec4a3200c7ca491ca3501065)
  • [7]GitHub Fix Commit 2 (e5d29b68da66fd7f99072d6afd336dee2c28876c)
  • [8]OliveTin Release 3000.17.0
  • [9]OliveTin Release 3000.18.1
  • [10]CVEList V5 Repository Source: CVE-2026-75506.json

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•5 minutes ago•CVE-2026-69131
4.3

CVE-2026-69131: Missing Authorization in django-filer Bulk Deletion Admin Action

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.

Alon Barad
Alon Barad
0 views•9 min read
•about 2 hours ago•CVE-2026-71481
7.5

CVE-2026-71481: Cryptographic Signature Verification Bypass in ALTCHA PHP Library

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.

Alon Barad
Alon Barad
4 views•10 min read
•about 5 hours ago•CVE-2026-61618
6.9

CVE-2026-61618: Improper Input Validation of KZG Accumulator Limbs in snark-verifier

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.

Amit Schendel
Amit Schendel
4 views•12 min read
•about 6 hours ago•CVE-2026-63496
7.8

CVE-2026-63496: OS Command Injection in @augment-vir/node grep() Helper

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.

Alon Barad
Alon Barad
4 views•8 min read
•about 18 hours ago•CVE-2026-53998
10.0

CVE-2026-53998: Format String Injection and Information Disclosure in Arize Phoenix applyChatTemplate

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.

Amit Schendel
Amit Schendel
9 views•9 min read
•about 19 hours ago•CVE-2026-63634
6.9

CVE-2026-63634: EVM Calldata Padding Gas Drainage in pympp Fee-Payer Verification

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.

Amit Schendel
Amit Schendel
5 views•11 min read