Skip to main content

Ansible Automation Platform CVE-2026-76648

| EUVDEUVD-2026-85533 HIGH
Missing Authorization (CWE-862)
2026-09-23 redhat GHSA-26cj-h793-xx7v
8.5
CVSS 3.1 · Vendor: redhat
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate as low-privilege AWX user
  2. Delivery
    Hold required use_role/read_role on related resources
  3. Exploit
    POST to CopyAPIView for target JobTemplate
  4. Execution
    Server skips source read RBAC check
  5. Persist
    Clone created readable by attacker
  6. Impact
    Read disclosed JobTemplate configuration

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization checks on every request
MITRE ATT&CK

1 technique across 1 tactic: Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires an authenticated AWX/Red Hat Ansible Automation Platform 2 account (PR:L) that already holds the resource-level roles gating the copy: inventory.use_role, project.use_role, and execution_environment.read_role (checked by can_add), plus credentials.use_role (checked by can_copy_related). The attacker must NOT need - and specifically lacks - read access on the source JobTemplate, which is exactly the missing check. Exploitation is via a network POST to the CopyAPIView endpoint (awx/awx/api/generics.py) against a default configuration; the GET path is unaffected because it correctly enforces the read guard. Limiting factors: valid credentials and the above use/read roles are prerequisites, so this is an insider/multi-tenant privilege-boundary flaw rather than unauthenticated remote compromise; no user interaction is needed.

Impact

This is a credible but non-critical priority. The CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N, 8.5) describes a network-reachable, low-complexity flaw exploitable by any authenticated low-privilege user who already holds resource-level roles (inventory.use_role, project.use_role, execution_environment.read_role, and credentials.use_role). The core weakness is CWE-862: CopyAPIView's post() handler omits the request.user.can_access(obj._class_, 'read', obj) guard that its own get() handler enforces, so a user who can 'add' and 'copy_related' a JobTemplate can duplicate - and thereby read - a source JobTemplate they have no read permission on. I assess the vendor's S:C and resulting 8.5 as slightly generous: the impact stays inside AWX's single RBAC authority, so S:U (~7.1) is more defensible, though a cross-organization read is a reasonable argument for S:C. Impact is primarily confidentiality (C:H - disclosure of another org/user's JobTemplate configuration via the copy) with minor integrity (I:L - a new object is created) and no availability impact. No EPSS score, no CISA KEV listing, and no public POC were provided, so exploitation status is 'no public exploit identified at time of analysis' - this is a Red Hat self-reported code-audit finding (Bugzilla 2519720), not an observed-in-the-wild issue. The requirement for pre-existing valid credentials and specific resource roles meaningfully limits real-world exposure to insider/multi-tenant abuse rather than opportunistic external attack.

Exploit ScenarioDerived

A low-privilege AWX/AAP user who has been granted use_role on an inventory, project, execution environment, and the relevant credentials - but no read access to a sensitive JobTemplate owned by another team - sends a crafted POST to the CopyAPIView endpoint for that JobTemplate. Because post() only checks 'add' and 'copy_related' roles and never verifies 'read' on the source object, the server clones the JobTemplate into a template the attacker can read, disclosing its configuration. No public exploit code was identified; this is a vendor code-audit finding.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Sep 23, 2026

Missing object-level authorization in the JobTemplate copy endpoint (CopyAPIView) of AWX and Red Hat Ansible Automation Platform 2 lets an authenticated user duplicate a JobTemplate they are not permitted to read, disclosing the template's configuration - playbook reference, associated credentials, inventory and extra variables - that RBAC was intended to protect. The root cause is CWE-862 (Missing Authorization): the copy view's GET path enforces a read check on the source object, but the POST path that performs the copy only validates add and copy-related permissions, none of which imply read access on the source template. Per the independent assessment (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N; vendor score 8.5), exploitation requires an authenticated account already holding inventory.use_role, project.use_role, execution_environment.read_role and credentials.use_role, so this is an insider/multi-tenant privilege-boundary flaw rather than unauthenticated remote compromise; no public exploit code was identified at time of analysis.

RemediationAI

No vendor-released patch version identified at time of analysis in the supplied data; track the Red Hat CVE record (https://access.redhat.com/security/cve/CVE-2026-76648) and Bugzilla issue 2519720 for the fixed AWX/AAP 2 build and apply it as soon as it is published, then confirm the POST copy path enforces a read check on the source object. Until then, the most effective compensating control is to shrink the set of accounts that can reach the vulnerable code path: audit and remove inventory.use_role, project.use_role, execution_environment.read_role and credentials.use_role from users who do not legitimately need to copy JobTemplates, since all four are simultaneously required to trigger the flaw - this preserves normal job-launch workflows but will break legitimate template-copy scenarios for the affected users. As a stricter measure, restrict network access to the API (for example, limit the JobTemplate copy endpoint to trusted administrative networks or a bastion via reverse proxy rules); the trade-off is that all copy functionality, including legitimate administrative use, becomes unavailable from unrestricted clients. Additionally, monitor and alert on POST requests to the JobTemplate copy endpoint, especially from accounts lacking read_role on the referenced templates, since successful exploitation leaves an audit trail of template duplication events; this detection layer does not prevent the disclosure but supports containment and forensic follow-up. Because exploitation requires valid credentials plus the above role set, rotating credentials and tightening multi-tenant role assignments reduces the insider risk surface while a patch is pending.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The affected component is Django REST Framework's view layer in AWX, the upstream project bundled into Red Hat Ansible Automation Platform 2. CopyAPIView (awx/awx/api/generics.py:873) declares permission_classes = (IsAuthenticated,), which only establishes that the caller is a logged-in user and delegates all object-level authorization to view logic or the queryset returned by get_object(). AWX implements its RBAC through a resource-scoped role model in awx/awx/main/access.py rather than DRF object permissions, and it distinguishes use_role (ability to consume a resource when launching jobs) from read_role (ability to view the resource). The get() handler at lines 988-991 correctly calls request.user.can_access(obj._class_, 'read', obj) before returning the source object, but post() at lines 1001-1010 omits that guard and instead calls can_access(model, 'add', create_kwargs_check) plus can_access(model, 'copy_related', obj). For the JobTemplate model, can_add (access.py:1465-1520) gates on inventory.use_role + project.use_role + execution_environment.read_role, and can_copy_related (1522-1534) checks only credentials.use_role. Because use_role on an inventory or project does not confer read_role on a JobTemplate, a caller can satisfy every POST check while still being denied read on the template being copied - the classic CWE-862 pattern of a missing authorization check on one code path of an otherwise guarded endpoint. The CPE data identifies the affected offering as cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2 (version fields wildcarded), with upstream AWX sharing the same flawed code.

Know when Red Hat Ansible Automation Platform 2 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

Vendor (redhat) PRIMARY 8.5 HIGH
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N
vuln.today AI 7.1 HIGH

Authenticated low-priv user (PR:L) with resource roles reads another party's JobTemplate via copy (C:H); minor object creation (I:L); impact stays within AWX's RBAC authority so S:U over vendor's S:C.

3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:L/VA:N/SC:N/SI:N/SA:N
Red Hat 8.5 HIGH

Primary rating from Vendor (redhat).

CVSS VectorVendor: redhat

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
Low
Availability
None

DescriptionCVE.org

CopyAPIView (awx/awx/api/generics.py:873) sets permission_classes = (IsAuthenticated,), so DRF's get_object() performs no object-level RBAC. The get() handler (lines 988-991) explicitly guards with request.user.can_access(obj._class_, 'read', obj) - but post() (lines 1001-1010) does not. POST only checks:

can_access(model, 'add', create_kwargs_check)

can_access(model, 'copy_related', obj)

For JobTemplate, can_add (awx/awx/main/access.py:1465-1520) gates on

inventory.use_role + project.use_role + execution_environment.read_role - resource-level roles that do not imply read on the source JT - and can_copy_related (1522-1534) checks only credentials.use_role. None of these imply the caller can read the source JT.

Executive ViewAI

Why It Matters

A privilege-boundary flaw in the AWX and Red Hat Ansible Automation Platform 2 JobTemplate copy function allows authenticated tenant users to duplicate templates they are explicitly barred from reading, exposing playbook references, credential associations, inventory definitions, and extra variables that role-based access controls were meant to protect. The exposure is limited to accounts already holding a specific combination of use and read roles, meaning risk is concentrated in multi-tenant or shared-platform deployments where role grants are broad or loosely governed, and where leaked credentials or inventory detail could be chained into follow-on access. Because no vendor fix is currently available, leadership should treat this as a manageable but time-sensitive insider and tenant-isolation risk that must be mitigated through access governance until a patch ships.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: enforce least privilege by removing the standing combination of inventory.use_role, project.use_role, execution_environment.read_role and credentials.use_role from accounts that do not require it; segregate credentials, inventories, and projects across tenants so exposed configuration has limited blast radius; enable API audit logging and alert on JobTemplate copy (CopyAPIView) POST activity; restrict management API access to trusted network segments; rotate any credentials associated with templates that may have been duplicated; and monitor vendor advisories for a fixed AWX or Ansible Automation Platform 2 release and apply it as soon as it is published.

Threat Intelligence Overview

EPSS Score
0.2%
Top 87% exploitable
Prevalence
Medium
Red Hat Ansible Automation Platform / AWX controller, common enterprise automation but not universal
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Affected Products (CPE)CVE.org

cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
cpe:2.3:a:red_hat:red_hat_ansible_automation_platform_2:*:*:*:*:*:*:*:*
CVE-2026-84719 CRITICAL
9.9 Sep 23

Missing authorization checks in the Red Hat Ansible Automation Platform 2 automation-controller allow an authenticated o

CVE-2026-84502 CRITICAL
9.9 Sep 23

Authenticated users who hold permission to create or modify a project within a single organization can execute arbitrary

CVE-2026-84474 CRITICAL
9.9 Sep 23

Privilege escalation and remote code execution on managed hosts is possible in Red Hat Ansible Automation Platform 2 bec

CVE-2026-11807 CRITICAL
9.6 Jun 23

Credential disclosure in Red Hat Ansible Automation Platform 2.5 and 2.6 allows any authenticated user to retrieve plain

CVE-2026-12564 CRITICAL
9.6 Aug 18

Server-side request forgery in the Red Hat Ansible Automation Platform 2 Controller's HashiCorp Vault credential plugin

CVE-2026-75884 CRITICAL
9.1 Sep 23

Privilege escalation in Red Hat Ansible Automation Platform 2 (built on the AWX upstream project) lets an authenticated

CVE-2026-12701 CRITICAL
9.0 Jul 20

Arbitrary file write in pulpcore's FilesystemExport feature allows an authenticated administrator to escape the intended

CVE-2026-89091 HIGH
8.8 Oct 08

Symlink-following file overwrite on the Ansible control node is possible in ansible-core when a user runs `ansible-galax

CVE-2026-84683 HIGH
8.7 Sep 23

Stored cross-site scripting in the automation-controller component of Red Hat Ansible Automation Platform 2 lets an auth

CVE-2026-84691 HIGH
8.7 Sep 23

An authenticated automation-controller administrator in Red Hat Ansible Automation Platform 2 can turn the administrator

CVE-2026-92982 HIGH
8.5 Oct 15

Jinja2 template injection in Ansible Operator Plugins (CWE-1336) lets an authenticated Kubernetes user who can create or

CVE-2026-12382 HIGH
8.2 Jul 15

mTLS authentication bypass in the Red Hat Ansible Automation Platform (AAP) Gateway Envoy proxy allows unauthenticated r

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy