Skip to main content

Temporal Server CVE-2026-120091

| EUVDEUVD-2026-115641 HIGH
OS Command Injection (CWE-78)
2026-11-02 Temporal GHSA-r7j7-m32j-h8w5
8.7
CVSS 4.0 · Vendor: Temporal
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate with single-namespace read role
  2. Delivery
    Submit crafted k8s compute config to ValidateWorkerDeploymentVersionComputeConfig
  3. Exploit
    Kubernetes client build runs attacker command
  4. Execution
    Execute code as Worker Service account
  5. Impact
    Harvest cluster-wide persistence credentials and TLS material

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK

2 techniques across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Preconditions are concrete and layered. (1) Version: Temporal Server 1.31.0-1.31.2 are exposed in a stock deployment because workercontroller.compute_providers.enabled does not deny by default - when unset the allowlist check is skipped and the k8s provider is permitted; on 1.31.3+ and 1.32.0+ the allowlist denies by default and exposure exists only where k8s was explicitly added to that setting, checking both the global value and every namespace-constrained override. The 1.30 line lacks the Worker Controller Instance module and is not vulnerable. (2) The Worker Service must be running, which it is in the default service set. (3) Authorization must be configured with a real authorizer and claim mapper - a deployment with no authorizer already grants unrestricted cross-namespace access and has no boundary for this to cross. (4) The attacker needs an authenticated identity with at least a read role in one namespace, reaching the provider through ValidateWorkerDeploymentVersionComputeConfig; deployments with a custom authorizer should verify it does not permit that operation to callers lacking namespace write access. Limiting factors: exposure is gated by version and the compute-provider allowlist, and the separate workercontroller.enabled per-namespace setting does NOT gate this path on any affected release.

Impact

Multiple signals converge on genuine priority despite the absence of exploitation telemetry. The CWE-78 OS command-injection flaw yields code execution on the Worker Service host under the server account, and the input CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H) with score 8.7 matches the described mechanics: network-reachable, low attacker-supplied complexity, and only a low privilege level. The PR:L is the critical nuance - the ValidateWorkerDeploymentVersionComputeConfig route is registered as a read-only namespace operation, so a caller holding only a read role in a single namespace reaches the provider, which is a far weaker precondition than the write role CreateWorkerDeploymentVersion demands. Blast radius is cluster-wide: the Worker Service holds persistence credentials for every namespace and the cluster TLS material, so impact crosses the caller's namespace boundary even though the input vector marks SC/SI/SA:N. Exposure, however, is version- and configuration-dependent - stock 1.31.0 through 1.31.2 are exposed by default (allowlist skips the check when unset), whereas 1.31.3+/1.32.0+ are exposed only where k8s was explicitly added to workercontroller.compute_providers.enabled, and 1.30 is unaffected entirely. EPSS score is not provided in the input and the CVE is not listed in CISA KEV, so widespread or active exploitation cannot be asserted; the vuln.today decision label is this_week rather than act_now/emergency. Net: a high-severity, low-privilege RCE with cluster-wide consequences that warrants prompt patching, with real-world exposure gated by version and the compute-provider allowlist.

Exploit ScenarioDerived

An authenticated user who holds only a read-only role in a single namespace submits a crafted Kubernetes client configuration to the read-only ValidateWorkerDeploymentVersionComputeConfig operation; building that client from the caller-supplied config executes an attacker-chosen command on the Worker Service host during validation, with no pre-existing worker deployment required. Because execution happens under the server process account, the attacker can reach the cluster-wide persistence credentials and TLS material. No public exploit identified at time of analysis; the trigger requires only a single validation request, not any scaling decision or task arrival.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Nov 02, 2026

Authenticated command injection in Temporal Server 1.31.0 through 1.31.2 allows a caller holding only a read role in a single namespace to execute commands of their choosing on the Worker Service host under the account the server process runs as. The bundled auto-scaled-workers module's k8s compute provider builds its Kubernetes client from client configuration supplied in the caller's request, and the reachable route (ValidateWorkerDeploymentVersionComputeConfig, registered as a read-only namespace operation) exercises that code during configuration validation, so no worker deployment, scaling decision, or unusual request sequence is required. Vendor fixes are available in v1.31.5 and v1.32.2; no public exploit identified at time of analysis, and the priority comes from stock 1.31.0-1.31.2 deployments permitting every registered compute provider by default when workercontroller.compute_providers.enabled is unset, not from observed exploitation.

RemediationAI

Vendor-released patch: upgrade to Temporal Server v1.31.5 (for the 1.31 line) or v1.32.2 (for the 1.32 line), which carry both the k8s compute provider being restricted to dev/test builds and the change requiring write access to validate worker deployment version compute configs. Where an upgrade cannot be applied immediately, the effective control is the compute provider allowlist: set workercontroller.compute_providers.enabled to an explicit list that excludes k8s, and check both the global value and every namespace-constrained override, since an override can re-add k8s for a single namespace; on 1.31.0 through 1.31.2 leaving the setting unset is not safe because the check is skipped, whereas on 1.31.3+ and 1.32.0+ the default already denies unless k8s was added. The trade-off of excluding k8s is loss of Worker Controller Instance scaling into Kubernetes via that provider until the upgrade is completed. Note that the per-namespace workercontroller.enabled setting does not gate the affected path on any affected release, so disabling it provides no protection. Deployments using a custom authorizer should also verify it does not permit ValidateWorkerDeploymentVersionComputeConfig to callers lacking namespace write access, and the 1.30 release line requires no action because it does not include the Worker Controller Instance module.

Affected VersionsENISA

Temporal Server 1.32.0 <1.32.2
Temporal Server 1.31.0 <1.31.5

Affected Packages

euvd temporal_server fix: 1.31.5, 1.32.2

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Temporal Server compiles the Go module go.temporal.io/auto-scaled-workers into its Worker Service; that module registers a Worker Controller Instance compute provider named k8s for managing workers in a Kubernetes cluster. The defect is CWE-78 (OS command injection): the provider constructed its Kubernetes client from client configuration taken from the caller's request rather than from operator-supplied configuration, so building and using that client could run a caller-chosen command on the Worker Service host. Two frontend operations reach the provider - CreateWorkerDeploymentVersion (requires namespace write) and ValidateWorkerDeploymentVersionComputeConfig (registered read-only) - and the latter executes the code while the submitted configuration is validated, which is why a caller with a read role is sufficient and no pre-existing worker deployment is needed. Because the Worker Service process holds persistence credentials for every namespace and the cluster's TLS material, impact is assessed as high confidentiality, integrity, and availability on the server component (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The gating control is the compute provider allowlist dynamic configuration workercontroller.compute_providers.enabled; on 1.31.0-1.31.2 an unset value skips the check and permits k8s, while 1.31.3+ and 1.32.0+ deny by default. Upstream remediation is twofold: pull request 165 removes the k8s provider from release builds behind the build tag computeprovider_k8s && !release (marking it dev/test only), and pull request 12843 requires write access to validate worker deployment version compute configs. The 1.30 release line does not include the Worker Controller Instance module.

Know when Temporal Server gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (Temporal) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.8 HIGH

Network-reachable validation route exploitable by a low-privilege read-role caller with no user interaction or special conditions (AC:L, PR:L); command execution as the server account yields full C/I/A loss.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (Temporal).

CVSS VectorVendor: Temporal

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Temporal Server compiles a Worker Controller Instance module, go.temporal.io/auto-scaled-workers, into its Worker Service, and that module registers a compute provider named k8s whose function is to manage workers running in a Kubernetes cluster. The k8s provider built its Kubernetes client from the client configuration supplied in the caller's request rather than from operator configuration, and building and using that client could run a command of the caller's choosing on the Worker Service host, under the account the server process runs as. Two frontend operations reach the provider. CreateWorkerDeploymentVersion requires a namespace write role. ValidateWorkerDeploymentVersionComputeConfig is registered as a read-only namespace operation, so an authenticated caller holding only a read role in a single namespace can reach the provider through it, and that route does not require a worker deployment to already exist. Execution happens while the submitted configuration is validated, so no scaling decision, task arrival, or unusual request sequence is required. Because the Worker Service process holds the persistence credentials for every namespace in the cluster and the cluster's TLS material, the consequence reaches beyond the caller's namespace to the cluster as a whole. The provider is present in the official temporal-server binaries and container images for the affected releases. The control that keeps it unreachable is the compute provider allowlist, the dynamic configuration setting workercontroller.compute_providers.enabled. On Temporal Server 1.31.0 through 1.31.2 that allowlist does not deny by default: when the setting is unset the check is skipped and every registered compute provider is permitted, k8s included, so a stock deployment of those releases is exposed. On 1.31.3 and later 1.31 releases, and on 1.32.0 and later 1.32 releases, the allowlist denies by default, and a deployment is exposed only where k8s has been added to it. The 1.30 release line does not include the Worker Controller Instance module and is unaffected. To determine whether a deployment is affected, check the following together. The deployed Temporal Server version is in an affected range. The Worker Service is running, which it is in the default service set and therefore in a stock deployment. The effective value of workercontroller.compute_providers.enabled contains k8s, or, on 1.31.0 through 1.31.2 only, is unset; check both the global value and every namespace-constrained override, because an override can add k8s for a single namespace. And authorization is configured, meaning a real authorizer and claim mapper are in place; a deployment running with no authorizer already grants every caller unrestricted access to every namespace, so it has no namespace boundary for this to cross. Deployments that use a custom authorizer should also check whether it permits ValidateWorkerDeploymentVersionComputeConfig to callers without namespace write access. The separate per-namespace dynamic configuration setting workercontroller.enabled does not gate the affected path on any affected release.

Executive ViewAI

Why It Matters

CVE-2026-120091 is a high-severity authenticated command injection in Temporal Server versions 1.31.0 through 1.31.2 that allows any user with read-only access to a single namespace to execute arbitrary commands on the Worker Service host. This compromises the confidentiality, integrity, and availability of the Worker Service and potentially other systems reachable from that host, affecting all organizations running these versions in production. Leadership should care because the vulnerability requires no special privileges, is trivial to exploit, and the fix is available but must be deployed promptly.

Business Impact: High
Compensating Controls

Apply vendor patch. If patching is delayed, set workercontroller.compute_providers.enabled to an empty list or disable the auto-scaled-workers module to prevent exploitation.

Threat Intelligence Overview

EPSS Score
0.5%
Top 59% exploitable
Prevalence
Medium
popular workflow-orchestration engine; only specific recent 1.31/1.32 releases affected
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

OS command injection occurs when an application passes unsanitized user input directly into system shell commands.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy