/

CVE-2026-32692

Severity:

HIGH RISK

(7.6)

Authorization Bypass in Juju Vault Secrets Back-end

CVE-2026-32692

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-285

Impact:

Unauthorized Secret Modification / Data Integrity Compromise

Severity:

HIGH RISK

(7.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

An authorization bypass in Juju's Vault secrets back-end allows an authenticated unit agent to update secret revisions it is not authorized to modify.

With sufficient knowledge of target secret metadata, an attacker can poison existing secret revisions within the same Vault back-end, potentially impacting any workloads that consume those secrets.

Affected context

This vulnerability occurs in Juju environments using the Vault secrets back-end in versions 3.1.6 through 3.6.18.

It affects scenarios where:

  • Unit agents are authenticated and can interact with the Vault back-end
  • Multiple secrets and revisions are stored under a shared Vault secret back-end scope
  • Access control relies on Juju's internal authorization rather than strict, per-secret policy enforcement

In such setups, insufficient authorization checks on update operations allow a unit agent to target secrets beyond its intended permissions.

Exploit preconditions

  • Attack surface: Juju controller / model API via the Vault secrets back-end interface.
  • Required access: Authenticated unit agent credentials within the affected Juju deployment.
  • Scope of action: Secrets and revisions stored under the same Vault secret back-end that the compromised or malicious unit can reach.
  • Trigger point: Performing an update operation on a secret revision where the platform fails to fully verify that the caller is authorized for that specific secret.
  • Why exploitation is possible: Authorization logic does not sufficiently bind update operations to the caller's intended secret set, allowing crafted requests that reference other existing secret revisions.

Why this happens

The underlying issue is a broken authorization check (CWE-285) in the Vault secrets back-end implementation.

Instead of enforcing strict, per-secret and per-revision access control based on the identity and role of the unit agent, the system permits updates when broader or incomplete authorization conditions are met.

This weak binding between caller identity, secret identity, and allowed operations enables a unit agent to update any secret revision within the back-end scope, provided it can reference or infer the relevant identifiers.

Potential impact

  • Secrets consumed by other units may be poisoned with attacker-controlled values.
  • Application behavior can be altered by replacing configuration, credentials, or tokens stored as secrets.
  • Downstream services may experience authentication failures, data corruption, or unexpected outages.
  • Lateral movement opportunities may arise if compromised secrets are used to access other systems.
  • Audit trails and operational debugging may be misled by tampered secret data.

General mitigation guidance

Effective mitigation generally focuses on strengthening authorization and reducing the blast radius of any single unit:

  • Enforce strict, per-secret authorization checks that bind specific identities or roles to particular secret IDs and operations.
  • Apply least-privilege principles so that unit agents only have access to the secrets they strictly need.
  • Segment secrets across multiple back-ends or namespaces to limit cross-application and cross-unit impact.
  • Introduce server-side validation of secret ownership and tenancy before allowing updates to any revision.
  • Implement defense-in-depth by having consuming applications validate secrets (e.g., format, ranges, or secondary trust anchors) to detect obvious poisoning attempts.
  • Enhance operational processes such as regular secret rotation and verification to limit the window of abuse.

How teams detect issues like this

Organizations can pursue several high-level approaches to detect or monitor for this class of issue:

  • Authorization logic review: Manually inspect the secrets back-end code path to ensure that all update operations perform explicit, per-secret authorization checks tying identity to secret ID and revision.
  • Policy enforcement checks: Use configuration and policy reviews to verify that unit agents are not granted overly broad secret-backend privileges.
  • Audit log analysis: Enable and regularly review logs for secret access and update operations, flagging patterns such as:
  • Units updating secrets they do not usually consume
  • Frequent updates across many unrelated secrets by the same unit
  • Behavioral monitoring: Correlate application anomalies (authentication failures, configuration changes) with secret updates from unexpected units.
  • Automated review tools: Integrate security scanning or policy-as-code tools into CI/CD pipelines to detect insecure authorization patterns in secrets management integrations.

Sources

SourceLink
github.comgithub.com/juju/juju/security/advisories/GHSA-89x7-5m5m-mcmm

Frequently asked

questions

Not directly. Exploitation requires authenticated access as a Juju unit agent within the affected environment, rather than anonymous or unauthenticated external access.

The attacker must control or impersonate an authenticated unit agent that can interact with the Vault secrets back-end. With that access and some knowledge of existing secrets, they can attempt to update secret revisions outside their intended scope.

The safest pattern is to enforce strict, per-secret authorization checks on all update operations, ensuring that a unit agent can modify only those secrets it is explicitly permitted to access. This should be combined with least-privilege role design and isolation of secrets across back-ends or namespaces.

Prevention typically involves designing secrets management with strong access control boundaries, consistently binding operations to identity and resource, regularly reviewing authorization logic, and using security testing (code review, threat modeling, and automated checks) to catch places where update or read operations do not fully validate permissions.

Find out what's already
exploitable in your codebase.