Summary
OpenChoreo incorrectly authorizes component command execution and wire-log access using a caller-supplied project query parameter rather than the component's actual owning project. A user with a project-scoped grant may therefore execute commands in, or read wirelogs from, components owned by other projects in the same namespace.
Affected context
The issue affects OpenChoreo deployments using the vulnerable API handlers for component execution and wire-log retrieval. It becomes risky when components from multiple projects share a namespace and authorization decisions rely on the request's project parameter instead of the component's authoritative project ownership value. The affected release range is 1.2.0-rc.1 through 1.2.0.
Exploit preconditions
- Attack surface: OpenChoreo API endpoints for component command execution and wire-log access
- Required access: An authenticated user with a project-scoped grant for the relevant operation
- Trigger point: A request targeting a component while supplying a project query parameter
- Why exploitation is possible: The authorization check uses caller-controlled project context rather than verifying the component's actual owner project, allowing authorization to cross project boundaries within the namespace
Why this happens
The underlying bug is an authorization binding failure. The API derives the security decision from a caller-supplied project identifier instead of the trusted project ownership recorded in the component specification.
This pattern maps primarily to CWE-639: Authorization Bypass Through User-Controlled Key and also relates to CWE-863: Incorrect Authorization, because the request is authorized against the wrong security object. Resource ownership and permission checks should be evaluated using server-resolved relationships rather than mutable request parameters.
Potential impact
- An authorized user may execute commands in components owned by another project
- Sensitive wirelogs may be disclosed across project boundaries
- Application data or runtime state could be modified
- Project isolation guarantees may be weakened
- An attacker could use command execution to affect workloads according to the component's available privileges
General mitigation guidance
Mitigation centers on binding authorization decisions to server-side resource ownership and enforcing project isolation consistently.
Common defensive patterns include:
- Resolve the component from a trusted identifier before performing authorization
- Compare the component's authoritative owner project with the caller's granted project scope
- Treat project query parameters as selectors, not proof of ownership or authorization
- Apply the same ownership checks to command execution, wirelogs, and related component operations
- Use least-privilege service accounts and runtime permissions for component workloads
- Add deny-by-default behavior when ownership or project membership cannot be established
How teams detect issues like this
Organizations can look for authorization checks that use request query parameters without reconciling them with server-side resource metadata.
Useful approaches include:
- Static analysis for permission checks based directly on caller-controlled project, tenant, or owner fields
- Code review checks requiring resource ownership resolution before privileged operations
- Integration tests that attempt cross-project access within the same namespace
- Policy checks ensuring every component action validates the component's actual owner and the caller's scope
- Audit-log monitoring for command execution or wire-log access where the requested project differs from the resource owner
- Neutral automated review tools that flag inconsistent object-level authorization patterns

