Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate with workflowrun:update in shared namespace
-
DeliverySend PUT to victim run path with attacker-owned labels
-
ExploitServer authorizes on body labels, loads run by path
-
ExecutionRewrite victim run ownership labels
-
ImpactRead logs, delete, or sabotage victim run
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Object-level authorization, IDOR prevention
|
| Exploitation Conditions | Requires a multi-tenant deployment pattern where more than one project or component shares a single Kubernetes namespace, and the attacker must be an authenticated caller already holding the workflowrun:update permission for at least one project or component in that namespace. The specific trigger is the PUT .../workflowruns/{runName} update route, which authorizes using the openchoreo.dev/project and openchoreo.dev/component labels supplied in the request body while selecting the stored WorkflowRun by the URL path; the attacker must also know (or enumerate) the name of a victim run in the same namespace. Limiting factors that reduce real-world risk: it is NOT anonymously reachable (valid credentials required), NOT cross-tenant (confined to one namespace per the URL-derived namespace), and a single-project-per-namespace deployment is not meaningfully exposed. Fixed by making the project/component ownership labels immutable on update and re-deriving authorization from the stored run. |
| Impact | This is a genuine but moderate-priority authorization flaw (CWE-639, IDOR/authorization bypass through a user-controlled key). The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:L, base 7.4) is internally consistent with the description: network-reachable, low complexity, but requiring an already-authenticated caller (PR:L) who holds workflowrun:update on at least one project or component in the target namespace. The scope change (S:C) is justified because the attacker crosses the project/component authorization boundary to affect resources they do not own. No EPSS score, no CISA KEV listing, and no public exploit code are provided in the input, so there is no signal of active or widespread exploitation - the risk is driven by the structural authorization defect, not by observed attacks. SSVC framing: exploitation status is 'none' (no POC/KEV), automatable is likely 'no' because it requires valid credentials and knowledge of a victim run name within the same namespace, and technical impact is 'partial' (consistent with the L/L/L impacts). The strongest mitigating factor is the explicit non-anonymous, non-cross-tenant boundary stated by the vendor: the attacker must already be an authenticated tenant with update rights inside the shared namespace. Net assessment: a legitimate internal/multi-project privilege-escalation issue worth patching promptly in multi-tenant OpenChoreo deployments, but not an emergency for single-project or single-team installations, and not a mass-exploitation candidate. |
| Exploit ScenarioDerived | In a shared namespace hosting multiple projects, an authenticated developer who legitimately holds workflowrun:update on their own project sends a PUT to .../workflowruns/{victimRunName} with their own openchoreo.dev/project and openchoreo.dev/component labels in the body. The server authorizes against the attacker-supplied labels while loading the run named in the URL path, letting the attacker rewrite the victim run's ownership labels and subsequently read its build logs/events, delete it, alter pending workflow parameters, or force it into a permanent ComponentValidationFailed state. No public exploit is identified at time of analysis, and exploitation requires valid credentials plus knowledge of a victim run name in the same namespace. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 21, 2026
Authorization bypass in OpenChoreo (1.0.0 through 1.0.5, 1.1.0 through 1.1.6, and 1.2.0 through 1.2.4) lets an authenticated user holding workflowrun:update on one project or component rewrite the ownership labels of a different WorkflowRun in the same namespace. Because the PUT .../workflowruns/{runName} handler derives its authorization hierarchy from the openchoreo.dev/project and openchoreo.dev/component labels in the request body while loading the target run from the URL path, an attacker who names a victim run in the path and submits labels for a scope they control is subsequently treated as authorized to read build logs and Kubernetes events, delete the run, modify pending spec.workflow.parameters, or drive the run into a permanent ComponentValidationFailed state. CVSS 3.1 scores this 7.4 with scope change (AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:L), but exposure is limited to deployments where multiple projects or components share a single namespace; it is not anonymously reachable and not cross-tenant, and no public exploit code was identified at time of analysis. Vendor-released patches exist in 1.0.6, 1.1.7, and 1.2.5.
RemediationAI
Upgrade to OpenChoreo 1.0.6, 1.1.7, or 1.2.5 depending on your release line - these versions make the openchoreo.dev/project and openchoreo.dev/component ownership labels immutable on update and re-derive authorization from the stored WorkflowRun instead of the submitted body; details are in the vendor advisory at https://github.com/openchoreo/openchoreo/security/advisories/GHSA-46r4-q7wv-32fc. If an immediate upgrade is not possible, the highest-value compensating control is to reduce the blast radius of the confused-deputy path by enforcing a one-project-per-namespace (or one-component-per-namespace) tenancy model, which removes the precondition that an attacker's authorized scope and the victim run share a namespace - the trade-off is coarser namespace sprawl and more namespaces to manage. Additionally, audit and tighten RBAC so workflowrun:update is granted only to principals who genuinely need to mutate runs, since the flaw requires that permission as a starting point; this does not fix the label-rewrite primitive but shrinks the attacker pool. Restricting network access to the openchoreo-api service (API server allow-listing, mTLS, or gateway-level authn) limits reachability of the PUT .../workflowruns/{runName} route to trusted clients, at the cost of making legitimate CI and developer tooling dependent on that chokepoint. Finally, enable Kubernetes audit logging and alert on Update events that modify openchoreo.dev/project or openchoreo.dev/component on existing WorkflowRun objects, and on the downstream actions the bug enables (log/event reads, deletions, spec.workflow.parameters changes, transitions to ComponentValidationFailed); this is detection-only and produces alert volume that must be tuned, but it catches exploitation attempts during the upgrade window. No vendor-released patch is required beyond the fixed tags, and there is no indication in the source data that a configuration toggle disables the vulnerable route.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in go, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
OpenChoreo is a Go-based developer platform for Kubernetes that exposes an HTTP API service (internal/openchoreo-api) layered over Kubernetes custom resources such as WorkflowRun (openchoreov1alpha1), with authorization delegated to a policy decision point through a service_authz.go wrapper. The ownership of a WorkflowRun is encoded entirely in two Kubernetes labels, openchoreo.dev/project and openchoreo.dev/component, and the authz layer builds its resource hierarchy for the PDP check from those labels (constructHierarchyForAuthzCheck) plus a workflow attribute from spec.workflow.kind/name. CWE-639 (Authorization Bypass Through User-Controlled Key) manifests here as an IDOR-style confused-deputy: the create path in the original code passed the caller-supplied object straight into the authorization check, and the update path selected the stored run by the URL path segment while evaluating authorization against labels taken from the submitted body, so the key used for the lookup and the key used for the decision could disagree. The upstream fix (commit 0e311468bb704b0dce7753b89c9d0204009285ca and related PRs 4596, 4618, 4626, 4627) fetches the existing WorkflowRun first and derives ResourceID, hierarchy labels, and the workflow attribute from the stored object, then makes the project/component ownership labels immutable in UpdateWorkflowRun - omitted labels are carried over from the stored record rather than treated as a clear, and an explicitly different value returns a ValidationError ('label ... is immutable'). The same change rejects mutation of spec.workflow.kind/name, normalizing an empty kind to ClusterWorkflow so an omitted kind is not silently cleared, and adds a nil-object guard that errors before the internal service or PDP is invoked. Test coverage was extended to assert not-found short-circuits before authorization and that nil input fails without side effects.
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
AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:L/A:L
Authenticated caller with partial privilege (PR:L) over network (AV:N); crossing the project/component authorization boundary justifies S:C, with limited confidentiality, integrity and availability impact on the victim run.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
2DescriptionCVE.org
OpenChoreo is a developer platform for Kubernetes. From 1.0.0 until 1.0.6, 1.1.7, and 1.2.5, the PUT .../workflowruns/{runName} update route authorizes a request using the openchoreo.dev/project and openchoreo.dev/component labels in the submitted body while selecting the stored WorkflowRun by the URL path. An authenticated caller with workflowrun:update for one project or component in the same namespace can name another run in the path, submit ownership labels for a scope they control, and rewrite the victim run's ownership labels. Subsequent authorization then treats the attacker as authorized to read build logs and Kubernetes events, delete the run, modify pending spec.workflow.parameters, or place the run into a permanent ComponentValidationFailed state. The namespace comes from the URL, so the issue is cross-project or cross-component within one namespace and is not anonymously reachable or cross-tenant. This issue is fixed in 1.0.6, 1.1.7, and 1.2.5.
Technical POC Analysis
CWE-639 (Authorization Bypass Through User-Controlled Key), realized here as an identifier mismatch rather than a classic IDOR: the authorization decision and the object mutation are keyed on two dif…
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
OpenChoreo releases 1.0.0 through 1.2.4 contain an authorization bypass that lets any authenticated user with workflowrun:update in one project or component reach into a different WorkflowRun sharing the same namespace - exposing build logs, Kubernetes events, and the ability to delete runs or alter workflow parameters before execution. Engineering and platform teams operating shared or multi-tenant OpenChoreo namespaces are directly affected, and because the abuse relies on ordinary low-privilege credentials it can blend into normal CI/CD activity. Leadership should prioritize remediation because the flaw undermines namespace-level tenant isolation across the software supply chain, not just a single application.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
More in Kubernetes
View allA critical vulnerability in Kubernetes ingress-nginx controller allows unauthenticated attackers with pod network access
Credential-harvesting malware compromised 84 versions of 42 TanStack npm packages on 2026-05-11 via chained GitHub Actio
Kubernetes ingress-nginx contains a configuration injection vulnerability via the mirror-target and mirror-host Ingress
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-url` Ingres
A security issue was discovered in ingress-nginx https://github.com/kubernetes/ingress-nginx where the `auth-tls-match-c
Kubernetes API server in all versions allow an attacker who is able to create a ClusterIP service and set the spec.exter
A security issue was discovered in Kubernetes where a user that can create pods on Windows nodes may be able to escalate
Argo CD is a declarative, GitOps continuous delivery tool for Kubernetes. Rated critical severity (CVSS 9.9), this vulne
Unauthenticated remote attackers can trigger complete database overwrites, server-side file reads, and SSRF attacks agai
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
Fluentd configuration injection in the kube-logging Logging operator before 6.6.0 allows a namespace-scoped user who can
Authenticated Typebot users can abuse the webhook block (HTTP Request component) in versions prior to 3.13.1 to issue ar
EUVD-2026-105772
GHSA-46r4-q7wv-32fc
NVD
CVE.org
EPSS
Exploit-DB