/

CVE-2026-22781

Severity:

CRITICAL RISK

(9.8)

OS Command Injection in TinyWeb HTTP Server CGI Parameter

CVE-2026-22781

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

TinyWeb HTTP Server versions before 1.98 contain an OS command injection vulnerability in their CGI handling logic, where ISINDEX-style query parameters are passed directly as command-line arguments to CGI executables.

An unauthenticated remote attacker can inject Windows shell metacharacters into crafted HTTP requests, potentially resulting in arbitrary command execution with the privileges of the TinyWeb process.

Affected context

This vulnerability affects deployments of TinyWeb HTTP Server (pre-1.98) that:

  • Have CGI support enabled
  • Process ISINDEX-style queries (e.g., /script.cgi?param) and forward query parameters to CGI programs
  • Execute CGI programs via CreateProcess() on Windows

The risk is highest where CGI scripts run with elevated privileges or have access to sensitive resources on the underlying Windows host.

Exploit preconditions

  • Attack surface: Network-exposed HTTP/HTTPS endpoints on the TinyWeb server.
  • Required access: None; exploitation can be performed by an unauthenticated remote client able to send HTTP requests.
  • Trigger point: CGI invocations where ISINDEX-style query parameters are mapped to process command-line arguments without proper sanitization or encoding.
  • Why exploitation is possible: User-controlled query parameter values are incorporated into the CGI process command line in a way that allows interpretation of shell metacharacters or arguments leading to unintended command execution on Windows.

Why this happens

The root cause aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

TinyWeb forwards CGI ISINDEX-style query parameters directly into the command line used by CreateProcess() without robust validation, escaping, or argument separation. This conflation of untrusted HTTP input with process invocation strings allows an attacker to introduce special characters or additional arguments that the operating system interprets as separate commands or altered execution context. The underlying pattern is treating text from remote requests as part of an executable command instead of as data-only arguments.

Potential impact

  • Remote execution of arbitrary commands with the privileges of the TinyWeb server process
  • Installation or execution of malware on the underlying Windows host
  • Reading, modifying, or deleting files accessible to the TinyWeb process
  • Use of the compromised server as a pivot point for lateral movement inside the network
  • Service disruption or denial of service by terminating critical processes or altering configuration

General mitigation guidance

Mitigation focuses on separating untrusted input from OS-level command execution and hardening CGI invocation:

  • Avoid constructing command lines from raw query parameters; use APIs that pass arguments as structured arrays rather than concatenated strings.
  • Enforce strict whitelisting for CGI parameters: limit allowed characters, length, and value patterns, and reject or normalize anything outside the expected set.
  • Apply rigorous input validation for all CGI inputs, neutralizing or rejecting shell and metacharacter sequences that could alter process invocation semantics.
  • Run the TinyWeb service and CGI processes with least-privilege Windows accounts and constrained file/system permissions to reduce impact if exploitation occurs.
  • Where possible, replace shell-based or argument-driven wrappers with safer application-level logic (e.g., libraries or internal APIs) that do not rely on external command execution.
  • Isolate the web server environment using OS-level hardening (e.g., job objects, restricted tokens, desktop/window station isolation) to limit damage from a compromised CGI process.

How teams detect issues like this

Detection strategies generally focus on both code-level and operational signals:

  • Static analysis and code review:
  • Flag locations where HTTP query parameters are concatenated into command strings passed to CreateProcess(), ShellExecute(), or similar APIs.
  • Look for CGI dispatch code that builds a single command line from user-controlled input rather than using argument arrays or robust escaping.
  • Review CGI-related configuration and dispatcher code for missing input validation or character whitelisting on query parameters.
  • Runtime and logging-based detection:
  • Monitor web server logs for unusual CGI requests containing shell-like metacharacters, suspicious argument patterns, or encoded payloads.
  • Correlate HTTP request patterns with Windows event logs and process creation logs (e.g., Sysmon) to detect unexpected child process trees spawned from TinyWeb.
  • Policy enforcement:
  • Enforce secure coding standards that prohibit direct passing of untrusted input into OS command execution.
  • Integrate automated review tools or SAST solutions into CI/CD pipelines to detect OS command injection patterns before deployment.

Sources

SourceLink
github.comgithub.com/maximmasiutin/TinyWeb/commit/876b7e2887f4ea5be3e18bb2af7313f23a283c96
github.comgithub.com/maximmasiutin/TinyWeb/security/advisories/GHSA-m779-84h5-72q2
masiutin.netmasiutin.net/tinyweb-cve-2025-cgi-command-injection.html

Frequently asked

questions

Yes. Any attacker who can reach the TinyWeb HTTP/HTTPS interface and trigger a vulnerable CGI endpoint can attempt exploitation without prior authentication.

No local or authenticated access is required. The attacker only needs the ability to send crafted HTTP requests to a CGI-enabled TinyWeb instance that is running a vulnerable version.

The safest pattern is to eliminate direct command-line construction from user input and instead use APIs that treat user data strictly as arguments, combined with strict input validation and whitelisting for all CGI parameters. Avoid invoking shells or wrappers that interpret special characters whenever possible.

Adopt a defensive design that never treats user input as part of an executable command, enforce strong input validation and encoding, run services with minimal privileges, and include explicit checks for command injection patterns in code review guidelines and automated security testing.

Find out what's already
exploitable in your codebase.