GHSA-5cj2-rqqf-hx9p is a medium-severity (CVSS 6.6) CWE-343 vulnerability in github.com/juju/juju. A fix is available for github.com/juju/juju — see the affected versions and patch details below.
Juju affected by Confused Deputy IDOR attack via Predictable user specified ID in Juju Secrets
Exploitation Status
Proof-of-concept exploit code exists
- CISA’s SSVC triage found public proof-of-concept exploit code for this CVE, though no confirmed active exploitation.
- A successful exploit gives an attacker total control of the affected component, not partial access.
Exploitation and automatability from CISA’s SSVC triage for GHSA-5cj2-rqqf-hx9p.
EPSS Exploitation Probability
EPSS (Exploit Prediction Scoring System) is a daily probability model maintained by FIRST.org. It estimates the likelihood a CVE will be exploited in production environments within the next 30 days, derived from real-world threat intelligence signals.
How urgent is this, really
GHSA-5cj2-rqqf-hx9p plotted by exploitation likelihood (EPSS) against impact (CVSS). The shaded corner — EPSS 50%+ and CVSS 7.0+ — is where this CVE doesn't sit, though severity or exploitability alone can still warrant action.
Where this sits among everything scored
Of 378,567 CVEs with a current EPSS score, this one falls in the < 10% band (highlighted). Real counts from FIRST.org, not a sample — log-scaled since the landscape is heavily right-skewed.
Real-World Exposure
github.com/juju/jujuReal-time download stats are indexed for npm and PyPI packages. This vulnerability affects Go packages — download data is not available via public APIs for these ecosystems.
Description
Summary
Predictable secret ID and lack of secret origin API enable confused deputy attacks on Juju workloads.
Details
A Juju application can create a secret and grant it to another integrated application (grantee).
When they do so, the secret owner has to communicate the secret id to the grantee.
The grantee, having received the secret id can load the secret content and perform operations on behalf of the secret owner.
However, today the grantee has no way to determine which granted secret belongs to which owner.
Instead the grantee relies on:
- being able to read the secret by id (secret was in fact granted, by some entity)
- secret id was received over a relation (the remote end of the relation is presumed to be secret owner)
Additionally, secret IDs are XID, which are predictable, here two secrets created by two distinct apps in the same K8s model close in time:
d34vsl7mp25c76301hs0
time (UTC): 2025-09-17 00:18:28 (Unix 1758068308)
machine: f6c88a
pid: 50072
counter: 6294648
d34vslfmp25c76301hsg
time (UTC): 2025-09-17 00:18:29 (Unix 1758068309)
machine: f6c88a
pid: 50072
counter: 6294649
PoC
This allows for an IDOR attack where:
- actors:
- a Good application (the owner of the Victim),
- an Evil application, and
- a Provider application (the Confused Deputy)
- relations: Good --- Provider, Evil --- Provider
- secrets: Good and Evil create Secrets, granting them to the Provider and communicate Secret IDs with the Provider.
- semantics: the Provider performs some operation on behalf of the Good/Evil using the Secret.
- weakness 1: Evil can guess the Secret ID that Good granted and communicated to Provider.
- weakness 2: Juju doesn't provide the Provider application the facility to verify the provenance of the Secret IDs.
- exploit: Evil passes Good's secret id to Provider.
- bypass: Provider performs evil operation with Good's Secret ID on behalf of Evil.
Evil could benefit by:
- exfiltrating Good's Secret via reflection.
- reading or mutating Good's resources accessible via *Good's Secret.
Impact
This requires a complex setup.
Not all shared secrets are used like above, so an actual exploit requires a very specific relation interface, specific semantics of the data in the databag, and an administrator having a reasonable need to deploy two apps (one evil, one good) related to the same (third) provider app.
If exploited, it can be very hard to determine what went wrong after the fact.
Suggested remediation
1. Longer, random secret IDs
For example, if the secret id was extended with a 128-bit nonce, guessing a sibling secret ID would be infeasible, and an attack of this style would require another weakness (e.g. secret IDs exposed in logs)
2. Grantee secret API
Today, an app is not allowed to call secret-info-get on the granted secret.
Additionally, granted secrets are not included in the secret-ids output.
Suppose that the Provider could run these hook tools:
(provider/0)> secret-ids
my-own-secret-123
(provider/0)> secret-ids --grants
good-secret-id-42
evil-secret-id-43
(provider/0)> secret-info-get good-secret-id-42
good-secret-id-42:
revision: 1
label: ""
owner: good
grant-relation-id: 12
rotation: never
The Provider would then able to validate the secret ID it's about to use against:
- the relation in which the secret ID has been passed (good relation 12 or evil relation 14)
- the application or unit name of the secret owner (good or evil)
Affected Packages
| Ecosystem | Package | Vulnerable range | Fix |
|---|---|---|---|
| 🐹Go | github.com/juju/juju | ≥ 0.0.0-20221021155847-35c560704ee2&&< 0.0.0-20260319091847-d06919eb03ec | 0.0.0-20260319091847-d06919eb03ecgo get github.com/juju/juju@v0.0.0-20260319091847-d06919eb03ec |
Detection & mitigation playbook
Open-source dependencyDetect
Scan your dependency tree (package-lock.json, pnpm-lock.yaml, requirements.txt, go.sum, etc.) for github.com/juju/juju, including transitive dependencies — a direct dependency you never call can still pull in a vulnerable version.
Fix
Update github.com/juju/juju to 0.0.0-20260319091847-d06919eb03ec or later, then make sure no transitive (indirect) dependency still pins the vulnerable range — O3 confirms GHSA-5cj2-rqqf-hx9p is resolved across your whole dependency graph.
Workarounds
If you can't upgrade right away: gate or disable the affected feature, validate untrusted input at the boundary, and avoid passing attacker-controlled data into the vulnerable path. O3's runtime protection blocks exploitation in production as an interim safeguard until the upgrade lands.
How O3 protects you
O3 Security's impact-aware SCA analyses which vulnerable code paths your application actually calls, so a match like GHSA-5cj2-rqqf-hx9p can be triaged on real exposure rather than presence alone.
Tailored to GHSA-5cj2-rqqf-hx9p. Runtime protection reduces exposure until a permanent patch is applied and verified — it complements patching, it doesn't replace it.
Frequently Asked Questions
Is GHSA-5cj2-rqqf-hx9p in your dependencies?
O3 Security finds GHSA-5cj2-rqqf-hx9p across Go dependencies, including transitive ones, and its impact-aware SCA ranks findings by whether your code actually calls the vulnerable path.