Skip to main content
View

Attack ChainAIDerived

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

  1. Access
    Authenticate as low-privileged Kubernetes user
  2. Delivery
    Craft custom resource with malicious Jinja2 payload
  3. Exploit
    Operator processes CR spec values unsanitized
  4. Execution
    Code executes in operator pod
  5. Impact
    Abuse operator service account for cluster-wide control

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V1 - Encoding and Sanitization Template injection prevention
Exploitation Conditions

Requires an authenticated Kubernetes user (PR:L) who holds permission to create or modify a custom resource reconciled by an affected Ansible-based operator (e.g., components shipped in Red Hat Ansible Automation Platform 2, Advanced Cluster Management for Kubernetes 2, or the Migration Toolkit operators). The specific condition is that the operator passes attacker-controllable CR spec values into Ansible/Jinja2 template evaluation without sanitization, so exploitation depends on the operator consuming those fields - this aligns with the vendor's AC:H rating. Limiting factors: the attacker must already possess valid cluster credentials with CR write access in a managed namespace; purely anonymous or read-only users cannot trigger it, and operators that do not expose user-controlled values to templating are not affected.

Impact

This is a genuinely high-priority flaw rather than a CVSS-inflated one, but with an important authentication caveat. The CVSS vector (AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H, score 8.5) confirms a network-reachable, authenticated (PR:L) attack requiring no user interaction, with a scope change (S:C) and full confidentiality/integrity/availability impact - consistent with the description's claim that a low-privileged Kubernetes user can escalate to the operator's cluster-wide service account. The high value comes from the scope change plus the privilege-escalation outcome: a minor tenant foothold converts into cluster-admin-equivalent control. However, no EPSS score, no CISA KEV listing, and no public POC are present in the input, so there is no evidence of active exploitation or mass-scanning pressure; this currently reads as a serious-but-not-yet-weaponized issue. The vendor's AC:H rating tempers the picture - it implies exploitation is not trivially reliable (likely depending on which CR fields the operator passes unsanitized into Jinja2). The one signal to reconcile: AV:N is accurate in that the Kubernetes API is network-facing, but exploitation still requires authenticated API access with permission to create or modify the relevant custom resources, so realistic exposure is to users/tenants who already hold some cluster credentials, not the anonymous internet. No SSVC decision data was supplied.

Exploit ScenarioDerived

A low-privileged tenant with permission to create or edit a custom resource in a namespace managed by a vulnerable Ansible-based operator submits a CR whose spec values embed a Jinja2 expression. The operator processes those values without sanitization, evaluating the expression inside the operator pod and running attacker-controlled code under the operator's service account, which holds cluster-wide permissions. No public exploit was identified at time of analysis, and the vendor-assigned AC:H suggests exploitation reliability depends on which CR fields reach the template engine.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 15, 2026

Jinja2 template injection in Ansible Operator Plugins (CWE-1336) lets an authenticated Kubernetes user who can create or modify a custom resource reconciled by an affected Ansible-based operator execute embedded Jinja2 expressions inside the operator pod, achieving remote code execution and escalating to the operator's service account. Because these operators typically hold cluster-wide RBAC, successful exploitation crosses a privilege boundary (CVSS 3.1 base 8.5, AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H), affecting components of Red Hat Ansible Automation Platform 2, Red Hat Advanced Cluster Management for Kubernetes 2, the Migration Toolkit for Applications/Containers/Virtualization, OpenShift Service Mesh 3 and related Red Hat OpenShift and OpenStack streams. No public exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis; the high attack complexity reflects the prerequisite that the targeted operator must pass attacker-controllable CR spec values into Jinja2 templating without sanitization. This is a genuinely high-priority flaw rather than a CVSS-inflated one, but with an important authentication caveat: purely anonymous or read-only users cannot trigger it.

RemediationAI

Patch status for CVE-2026-92982 was not confirmed in the available data, so treat this as no vendor-released patch identified at time of analysis and monitor https://access.redhat.com/security/cve/CVE-2026-92982 and https://bugzilla.redhat.com/show_bug.cgi?id=2522227 for updated Ansible operator/Operator SDK builds, then roll them out via OperatorHub or subscription-manager once Red Hat publishes errata. Until an updated operator image is available, the most effective control is to cut off the input path: use Kubernetes RBAC and admission policy to restrict create, update and patch rights on the custom resources reconciled by Ansible-based operators (for example the Migration Toolkit, ACM, AAP and Service Mesh CRDs) to trusted, privileged principals only, accepting the trade-off that this curtails the self-service multi-tenant workflows these operators are often deployed for. A narrower compensating control is a ValidatingAdmissionPolicy, OPA/Gatekeeper or Kyverno rule that rejects CR spec values containing Jinja2 delimiters such as double braces or percent braces for the affected CRDs; this blocks naive payloads but can break legitimate templating and is bypassable through alternative Jinja2 expression syntax, so it should be paired with server-side validation in the operator. Finally, reduce blast radius by auditing and trimming the ClusterRole/ClusterRoleBinding granted to each operator's service account, removing wildcard verbs and resources where feasible and running operators with least-privilege service accounts in dedicated namespaces, with the operational cost that some cross-namespace reconciliation will require manual intervention.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

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

Technical ContextAI · show details

Ansible Operator Plugins are the part of the Ansible-based Operator SDK that reconciles Kubernetes custom resources by rendering Jinja2 templates and Ansible tasks using values taken from the CR spec. CWE-1336, Improper Neutralization of Special Elements Used in a Template Engine, describes the root cause: CR fields that an attacker controls are interpolated into Jinja2 templates without escaping, so a value containing Jinja2 delimiters such as double-brace or percent-brace expressions is evaluated as template code by the Ansible runner inside the operator pod instead of being treated as a literal string. That evaluation happens in the operator's own process, with its mounted service account token and whatever RBAC the operator was granted, which is exactly why the scope-changed (S:C) rating is accurate: the attacker's security authority and the vulnerable component's are different, and the impact propagates beyond the operator to anything its service account can reach. The AC:H rating is consistent with the requirement that the target operator must actually consume an attacker-influenced field in a templated context; operators that never expose user-controlled values to templating are not exploitable. This server-side template injection class is closely related to sandbox-escape and code-injection issues in Jinja2 and other template engines, and mitigations generally rely on treating CR values as data rather than code.

Know when Kubernetes 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 (redhat) PRIMARY 8.5 HIGH
AV:N/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H
vuln.today AI 8.5 HIGH

Kubernetes API is network-reachable (AV:N) but needs authenticated CR-write access (PR:L); AC:H retained because success depends on the operator passing specific CR fields into Jinja2; escape to the cluster-scoped service account is a scope change (S:C) with full C/I/A impact.

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

Primary rating from Vendor (redhat).

CVSS VectorVendor: redhat

Attack Vector
Network
Attack Complexity
High
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

A flaw was found in Ansible Operator Plugins. A low-privileged Kubernetes user can exploit a Jinja2 template injection vulnerability by crafting malicious custom resource (CR) specification values. These values are processed by Ansible without proper sanitization, allowing embedded Jinja2 expressions to be executed within the operator pod. This can lead to arbitrary code execution and privilege escalation, granting the attacker control over the operator's service account with cluster-wide permissions.

Executive ViewAI

Why It Matters

A high-severity flaw in Ansible-based operator plugins affects Red Hat Ansible Automation Platform 2, Red Hat Advanced Cluster Management for Kubernetes 2, Migration Toolkit for Applications/Containers/Virtualization, OpenShift Service Mesh 3, and related OpenShift/OpenStack streams, allowing an authenticated Kubernetes user with custom-resource write access to run code in the operator pod and assume its service-account privileges. Because affected operators often hold cluster-wide RBAC, this can cross a privilege boundary and expose broad cluster workloads, secrets, and management capabilities. Leadership should care because exploitation could turn limited Kubernetes access into cluster-level control; no public exploit identified at time of analysis and no vendor-released patch identified at time of analysis.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: restrict custom-resource create/update/patch permissions to trusted administrators; reduce or eliminate cluster-wide RBAC for affected operator service accounts; deploy admission control (OPA Gatekeeper, Kyverno) to validate CR specs; isolate operators in dedicated namespaces with network policies; enable Kubernetes audit logging and alert on anomalous Jinja2/Ansible reconciliation activity; disable unused Ansible-based operators; and upgrade to vendor-fixed versions when released.

Threat Intelligence Overview

EPSS Score
0.4%
Top 69% exploitable
Prevalence
Medium
enterprise Kubernetes/OpenShift operators, common but not in every environment
Social Media
2
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.4%
Patch available No
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

Affected Products (CPE)CVE.org

cpe:2.3:a:red_hat:migration_toolkit_for_applications_8:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:migration_toolkit_for_containers:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:migration_toolkit_for_virtualization:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:openshift_service_mesh_3:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_advanced_cluster_management_for_kubernetes_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_advanced_cluster_management_for_kubernetes_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
+ 11 more
CVE-2025-1974 CRITICAL POC
9.8 Mar 25

A critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access

CVE-2026-45321 CRITICAL POC
9.6 May 12

Credential-harvesting malware compromised 84 versions of 42 TanStack npm packages on 2026-05-11 via chained GitHub Actio

CVE-2025-1098 HIGH POC
8.8 Mar 25

Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress

CVE-2025-24514 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres

CVE-2025-1097 HIGH POC
8.8 Mar 25

A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c

CVE-2020-8554 MEDIUM POC
6.3 Jan 21

Kubernetes API server in all versions allow an attacker who is able to create a ClusterIP service and set the spec.exter

CVE-2023-3676 HIGH POC
8.8 Oct 31

A security issue was discovered in Kubernetes where a user that can create pods on Windows nodes may be able to escalate

CVE-2025-55190 CRITICAL POC
9.9 Sep 04

Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. Rated critical severity (CVSS 9.9), this vulne

CVE-2026-34976 CRITICAL POC
10.0 Apr 02

Unauthenticated remote attackers can trigger complete database overwrites, server-side file reads, and SSRF attacks agai

CVE-2018-18843 CRITICAL POC
10.0 Dec 04

The Kubernetes integration in GitLab Enterprise Edition 11.x before 11.2.8, 11.3.x before 11.3.9, and 11.4.x before 11.4

CVE-2026-54680 CRITICAL POC
9.9 Jul 29

Fluentd configuration injection in the kube-logging Logging operator before 6.6.0 allows a namespace-scoped user who can

CVE-2026-22039 CRITICAL POC
9.9 Jan 27

Kyverno Kubernetes policy engine prior to 1.x has a privilege escalation vulnerability (CVSS 9.9) allowing policy bypass

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