Summary
Google Turbinia contains an operating system command injection vulnerability in worker task processing. An attacker who can submit a processing request or influence an evidence path or name may achieve arbitrary command execution on the worker fleet.
Affected context
The issue can occur in Turbinia deployments where worker tasks incorporate attacker-influenced processing parameters, evidence paths, or evidence names into operating system command execution. Risk depends on whether an untrusted party can submit processing requests or otherwise control the values consumed by worker task handlers.
Exploit preconditions
- Attack surface: Turbinia processing requests and worker task execution - Required access: Privileges to submit a processing request, or the ability
to influence an evidence path or name
- Trigger point: Worker handling of a task containing attacker-controlled
command-related values
- Why exploitation is possible: Input is incorporated into an operating
system command without sufficiently separating data from executable syntax
Why this happens
The underlying bug is an OS command injection condition, mapped to CWE-78. Worker task logic treats externally influenced paths, names, or processing parameters as trusted command components. When those values reach a shell or command interpreter without robust argument separation and validation, special input can alter the intended command behavior. This is an insecure composition pattern in which data crosses into an execution context.
Potential impact
- An attacker may execute arbitrary operating system commands on Turbinia workers.
- Worker credentials, queued tasks, and locally accessible evidence may be exposed.
- The attacker could modify, delete, or poison forensic processing results.
- Compromised workers could be used for lateral movement or disruption of the processing fleet.
General mitigation guidance
Mitigation generally focuses on ensuring that untrusted task data never becomes shell syntax. Secure-by-default patterns include invoking processes directly with structured argument arrays rather than shell command strings, applying strict allowlist validation to paths and names, and canonicalizing filesystem inputs before use. Input trust should be minimized across request handlers and worker boundaries, while worker identities, filesystem access, and available operating system privileges should follow least-privilege principles. Isolating task execution and limiting outbound access can reduce impact if a worker is compromised.
How teams detect issues like this
Detection approaches include static analysis for shell execution APIs, string interpolation or concatenation near process-spawning calls, and worker code paths that combine request fields with command strings. Code reviews can flag shell invocation where structured arguments would suffice, insufficient allowlists for evidence names and paths, and missing trust-boundary validation. Runtime monitoring can correlate unusual worker child processes, command-line patterns, filesystem activity, and outbound connections with submitted tasks. Automated code review and security scanning tools may help identify these patterns during development.

