/

CVE-2026-33211

Severity:

CRITICAL RISK

(9.6)

Path Traversal in Tekton Pipelines Git Resolver pathInRepo

CVE-2026-33211

Modified

Vulnerability type

Category:

Path Traversal

CWE:

CWE-22

Impact:

Sensitive File Disclosure and Potential Cluster Compromise

Severity:

CRITICAL RISK

(9.6)

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

Tekton Pipelines' git resolver improperly handles the pathInRepo parameter, allowing crafted paths to escape the intended repository directory and read arbitrary files from the resolver pod's filesystem.

A tenant who can create ResolutionRequests (directly or via TaskRuns/PipelineRuns using the git resolver) can exfiltrate sensitive files such as ServiceAccount tokens, whose contents are returned base64-encoded in resolutionrequest.status.data.

Affected context

This vulnerability affects Kubernetes environments running Tekton Pipelines where:

  • The git resolver is enabled and used to fetch Tasks or Pipelines from Git repositories.
  • Tenants are allowed to create TaskRuns/PipelineRuns or ResolutionRequests that reference the git resolver.
  • The resolver pod has access to sensitive files on its filesystem, such as mounted ServiceAccount tokens, configuration files, or secrets.

In such multi-tenant setups, the isolation boundary may be weaker than expected because resolver pods process parameters provided by tenants without adequately constraining filesystem access.

Exploit preconditions

  • Attack surface: Tekton git resolver within the Kubernetes cluster.
  • Required access: Ability to create ResolutionRequests, or to create TaskRuns/PipelineRuns that indirectly create ResolutionRequests using the git resolver.
  • Trigger point: Supplying a malicious pathInRepo value that includes traversal sequences (e.g., ../) or equivalent constructs when requesting resolution of a remote resource.
  • Why exploitation is possible: The pathInRepo parameter is not normalized and constrained to a safe base directory before being used for filesystem access, allowing escape from the expected repository path and access to arbitrary files visible inside the resolver pod.

Why this happens

The core issue is a lack of robust path canonicalization and validation before using user-controlled input as part of a filesystem path.

The git resolver treats the pathInRepo parameter as trusted, concatenating it with a base directory (or otherwise using it directly) without eliminating traversal components or verifying that the final resolved path stays within an allowed directory tree.

This aligns with CWE-22: Improper Limitation of a Pathname to a Restricted Directory, where an application fails to enforce directory boundaries, enabling attackers to read files they should not be able to access.

Potential impact

  • Unauthorized reading of ServiceAccount token files from the resolver pod.
  • Access to cluster credentials that can be used to impersonate the resolver's identity against the Kubernetes API.
  • Exposure of configuration files, logs, or secrets mounted into the resolver pod.
  • Lateral movement within the cluster using the compromised token or sensitive data.
  • Escalation from tenant-level isolation to broader namespace or cluster-level compromise, depending on the permissions associated with the stolen credentials.

General mitigation guidance

Effective mitigation focuses on constraining filesystem access and tightening multi-tenant boundaries:

  • Normalize and canonicalize all user-provided paths, rejecting any that resolve outside a predefined, strict base directory for checked-out repositories.
  • Use allowlists or exact mappings of valid resource paths instead of passing arbitrary path fragments from users to filesystem APIs.
  • Run resolver pods with minimal privileges and limited filesystem visibility (e.g., avoid mounting high-privilege ServiceAccount tokens; use dedicated, least-privilege ServiceAccounts).
  • Isolate resolvers used by untrusted or less-trusted tenants into separate namespaces or workloads with strong RBAC boundaries.
  • Apply defense-in-depth Kubernetes controls such as read-only root filesystems and restricted volume mounts where practical.

How teams detect issues like this

Teams can detect and monitor for this pattern at both code and operations levels:

  • Static analysis & code review:
  • Search for direct or indirect use of user-controllable inputs (pathInRepo, similar path parameters) in filesystem operations without normalization and boundary checks.
  • Flag path concatenations that do not verify the canonical path remains under a known safe root.
  • Enforce secure coding guidelines for path construction and file access through linting rules or code review templates.
  • Runtime and logging:
  • Log all ResolutionRequests and include the requested pathInRepo for anomaly detection (e.g., presence of ../ or unusual absolute paths).
  • Monitor resolver pod logs and audit events for repeated or suspicious resolution failures involving traversal patterns.
  • Security tooling:
  • Incorporate container security scanners and policy engines (e.g., admission controllers, OPA/Gatekeeper, Kyverno) to enforce that resolver pods run with least privilege and do not mount overly powerful ServiceAccounts.

Sources

SourceLink
github.comgithub.com/tektoncd/pipeline/commit/10fa538f9a2b6d01c75138f1ed7ba3da0e34687c
github.comgithub.com/tektoncd/pipeline/commit/318006c4e3a5
github.comgithub.com/tektoncd/pipeline/commit/3ca7bc6e6dd1d97f80b84f78370d91edaf023cbd
github.comgithub.com/tektoncd/pipeline/commit/961388fcf3374bc7656d28ab58ca84987e0a75ae
github.comgithub.com/tektoncd/pipeline/commit/b1fee65b88aa969069c14c120045e97c37d9ee5e
github.comgithub.com/tektoncd/pipeline/commit/cdb4e1e97a4f3170f9bc2cbfff83a6c8107bc3db
github.comgithub.com/tektoncd/pipeline/commit/ec7755031a183b345cf9e64bea0e0505c1b9cb78
github.comgithub.com/tektoncd/pipeline/security/advisories/GHSA-j5q5-j9gm-2w5c
access.redhat.comaccess.redhat.com/errata/RHSA-2026:10026
access.redhat.comaccess.redhat.com/errata/RHSA-2026:10066
access.redhat.comaccess.redhat.com/errata/RHSA-2026:10125
access.redhat.comaccess.redhat.com/errata/RHSA-2026:10155
access.redhat.comaccess.redhat.com/errata/RHSA-2026:10158
access.redhat.comaccess.redhat.com/errata/RHSA-2026:21931
access.redhat.comaccess.redhat.com/errata/RHSA-2026:21932
access.redhat.comaccess.redhat.com/errata/RHSA-2026:24484
access.redhat.comaccess.redhat.com/errata/RHSA-2026:6166
access.redhat.comaccess.redhat.com/errata/RHSA-2026:6170
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-33211
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2450554
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-33211.json

Frequently asked

questions

Typically, exploitation requires logical access inside the cluster to create TaskRuns, PipelineRuns, or ResolutionRequests. In many setups this means an attacker must already have some authenticated tenant-level access to the Tekton installation, although that access may be obtained through other means.

The attacker must be able to submit Tekton resources that use the git resolver, such as ResolutionRequests directly or TaskRuns/PipelineRuns that reference it. No direct shell access to the resolver pod is needed; the exploit leverages normal resolver behavior.

Always treat path parameters as untrusted: canonicalize them, strip traversal components, and enforce that the resulting path lies within a predefined repository directory. Combine this with least-privilege design for resolver pods and their associated identities so that even if a path bug appears, the damage is limited.

Standardize a secure path-handling utility for all components to use, mandate its use via code review and tooling, and document clear guidelines that no user-controlled path fragments may be passed directly to filesystem APIs. In addition, design multi-tenant features under the assumption that tenant-controlled parameters may be malicious, and isolate sensitive credentials away from components that process such input.

Find out what's already
exploitable in your codebase.