Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as low-privilege AWX user
-
DeliveryHold required use_role/read_role on related resources
-
ExploitPOST to CopyAPIView for target JobTemplate
-
ExecutionServer skips source read RBAC check
-
PersistClone created readable by attacker
-
ImpactRead 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N
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.
Primary rating from Vendor (redhat).
CVSS VectorVendor: redhat
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
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Affected Products (CPE)CVE.org
Missing authorization checks in the Red Hat Ansible Automation Platform 2 automation-controller allow an authenticated o
Authenticated users who hold permission to create or modify a project within a single organization can execute arbitrary
Privilege escalation and remote code execution on managed hosts is possible in Red Hat Ansible Automation Platform 2 bec
Credential disclosure in Red Hat Ansible Automation Platform 2.5 and 2.6 allows any authenticated user to retrieve plain
Server-side request forgery in the Red Hat Ansible Automation Platform 2 Controller's HashiCorp Vault credential plugin
Privilege escalation in Red Hat Ansible Automation Platform 2 (built on the AWX upstream project) lets an authenticated
Arbitrary file write in pulpcore's FilesystemExport feature allows an authenticated administrator to escape the intended
Symlink-following file overwrite on the Ansible control node is possible in ansible-core when a user runs `ansible-galax
Stored cross-site scripting in the automation-controller component of Red Hat Ansible Automation Platform 2 lets an auth
An authenticated automation-controller administrator in Red Hat Ansible Automation Platform 2 can turn the administrator
Jinja2 template injection in Ansible Operator Plugins (CWE-1336) lets an authenticated Kubernetes user who can create or
mTLS authentication bypass in the Red Hat Ansible Automation Platform (AAP) Gateway Envoy proxy allows unauthenticated r
EUVD-2026-85533
GHSA-26cj-h793-xx7v
NVD
CVE.org
EPSS
Exploit-DB