/

CVE-2026-82859

Severity:

CRITICAL RISK

(9.8)

Authorization Bypass (CWE-284) in Hulumi SCP Template

CVE-2026-82859

Deferred

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-284

Impact:

IAM Boundary Bypass and Privilege Escalation

Severity:

CRITICAL RISK

(9.8)

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

A weakened deployment SCP template in hulumi can allow tag-on-create operations to bypass intended hulumi:iac-role protections. An attacker who can influence or initiate a downstream deployment may circumvent IAM boundary restrictions and obtain permissions that should have been denied.

Affected context

The vulnerability occurs in deployments that use the affected hulumi SCP template to enforce IAM restrictions. It becomes risky when tag-on-create behavior is permitted by the template without sufficiently binding resource creation and authorization decisions to the intended hulumi:iac-role protections.

Exploit preconditions

  • Attack surface: Downstream cloud deployments using the hulumi SCP template
  • Required access: Ability to initiate, influence, or supply inputs to a protected deployment
  • Trigger point: Resource creation involving tags and IAM boundary enforcement
  • Why exploitation is possible: The SCP template weakens authorization checks, allowing tag-on-create operations to avoid restrictions intended to apply to the hulumi:iac-role

Why this happens

The underlying issue is an authorization policy design flaw in which the deployment SCP does not consistently associate resource creation with the required IAM role protections. This permits a request that includes creation tags to follow a less-restricted authorization path. The behavior maps to CWE-284, Improper Access Control, because policy conditions fail to enforce the intended permissions boundary across all equivalent creation flows.

Potential impact

  • An attacker may bypass intended IAM boundary restrictions.
  • Unauthorized cloud resources could be created.
  • Excessive permissions could be obtained through downstream deployment roles.
  • Sensitive data or infrastructure may be exposed or modified.
  • Compromised deployments could facilitate lateral movement or persistence.

General mitigation guidance

Mitigation generally focuses on making authorization decisions independent of

attacker-controlled tags and ensuring every resource-creation path is covered

by the same restrictive policy conditions.

Common defensive patterns include:

  • Use deny-by-default SCP and IAM policy rules for protected operations.
  • Require explicit authorization checks for both resource creation and tagging.
  • Avoid treating request tags as sufficient evidence of role or ownership.
  • Apply least privilege to deployment roles and separate provisioning duties.
  • Validate generated policies against a centralized authorization standard.
  • Add preventive guardrails and independent review for downstream deployment

templates.

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis of SCP and IAM policy conditions involving request tags,

resource tags, and create actions.

  • Code review checks for authorization paths that differ between creation and

subsequent tagging.

  • Policy-as-code tests that attempt protected operations with alternate tag

combinations and deployment roles.

  • Cloud audit-log monitoring for resource creation by roles or principals that

should be boundary-restricted.

  • CI enforcement requiring generated policies to pass least-privilege and

deny-by-default checks.

Automated policy analysis tools may help identify overly permissive conditions,

but findings should be validated against the deployment's trust model.

Sources

SourceLink
github.comgithub.com/kerberosmansour/hulumi/security/advisories/GHSA-86q4-r5j3-ff5c
vulncheck.comvulncheck.com/advisories/hulumi-before-1.3.2-scp-template-tag-on-create-bypass

Frequently asked

questions

It can be exploitable through a cloud deployment workflow when an attacker can

initiate or influence a downstream deployment. Exploitability depends on the

permissions exposed by that workflow.

Typically, some authenticated access to a deployment interface, pipeline, or

cloud principal is required. The attacker must also be able to reach a

resource-creation path governed by the weakened policy.

Enforce the same restrictive authorization requirements on resource creation,

tagging, and related follow-up actions. Do not rely on attacker-controlled

tags to establish authorization.

Use deny-by-default policy design, least-privilege deployment roles, policy-as-

code testing, and audit monitoring for unexpected resource creation or

privilege changes.

Find out what's already
exploitable in your codebase.