Skip to main content

AshOban CVE-2026-78038

| EUVDEUVD-2026-68185 MEDIUM
Improperly Controlled Modification of Dynamically-Determined Object Attributes (CWE-915)
2026-08-30 EEF
5.9
CVSS 4.0 · Vendor: EEF
View

Attack ChainAIDerived

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

  1. Recon
    Supply crafted :args payload with reserved string keys
  2. Delivery
    Application forwards user input to build_trigger/3 :args
  3. Exploit
    Map.merge passes both atom and string keys without collision
  4. Install
    JSON serialization preserves attacker string keys over trusted atom keys
  5. C2
    Oban worker reads attacker-controlled primary_key and tenant values
  6. Execute
    Background job executes update or destroy against victim record
  7. Impact
    Cross-tenant authorization bypass achieved

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V4 - API and Web Service Object attribute protection
Exploitation Conditions

Exploitation requires two specific preconditions: first, the application must pass user-controlled data into the :args option of AshOban.build_trigger/3 - deployments that construct :args exclusively from server-side trusted data are not vulnerable; second, the trigger must be an update or destroy trigger (not a create trigger), as the primary_key routing only applies to record-targeted operations. The CVSS 4.0 AT:P (Attack Requirements: Present) designation confirms these preconditions must be satisfied. The vulnerability was latent in applications where developers trusted the documentation's statement that :args 'cannot affect the action' and used it for user-supplied uniqueness scoping or similar patterns. What limits exploitation: the attacker must have application-level access sufficient to trigger background job creation; the application code path must route user input to :args without prior sanitization; and the target must be a multi-tenant deployment for the cross-tenant impact to materialize. Single-tenant deployments can still suffer cross-record authorization bypass within the same tenant.

Impact

The CVSS 4.0 score of 5.9 with AV:L and AT:P correctly signals that this is not a default-exploit-all-instances vulnerability - exploitation requires a specific application design flaw where user-controlled input flows into the :args parameter of build_trigger/3. The VI:H (vulnerable system integrity: High) reflects that when the precondition is met, attackers can redirect update or destroy actions at arbitrary records, which is a categorical authorization failure. The VC:L component captures incidental data exposure from cross-tenant job retargeting. No EPSS data was provided and KEV status is absent, indicating no confirmed active exploitation at time of analysis. For single-tenant deployments that do not forward user input into :args, practical risk is negligible. For multi-tenant Ash Framework applications that do expose :args to user input - a pattern the library's own documentation implicitly encouraged by describing :args as unable to affect the action - this is a high-priority issue regardless of the moderate overall score, because tenant isolation is a foundational security boundary whose breach can expose entire customer datasets.

Exploit ScenarioDerived

An attacker authenticated to a multi-tenant web application built on Ash Framework sends a request that causes the application to call AshOban.build_trigger/3 with the attacker's payload in the :args option, including the string key 'primary_key' pointing to a victim record's ID in another tenant and a 'tenant' key targeting that tenant's identifier. When the background job is persisted and the Oban worker processes it, it reads the attacker-supplied string-keyed values, executing an update or destroy action against the victim record in the other tenant - bypassing all tenant isolation and record-level authorization checks. No public exploit code exists, but the exploit mechanism requires only crafting a JSON object with the reserved string keys, making it trivially reproducible once the vulnerability is understood.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAI

AshOban versions 0.2.5 through 0.8.13 expose an authorization bypass and tenant isolation break in the build_trigger/3 function, allowing any user whose input reaches the :args option to retarget update or destroy background jobs at arbitrary records - including records belonging to other tenants. The root cause is an Elixir atom-vs-string key collision: trusted job fields are stored as atom keys, user-supplied :args arrive as string keys after JSON round-tripping, Map.merge sees no collision and both survive, and JSON serialization then keeps the last (string) key when the job is persisted, causing the worker to read attacker-controlled values. No public exploit has been identified at time of analysis, though the mechanism is straightforward and fully documented by the vendor advisory GHSA-gj9p-x393-rf9h.

RemediationAI

Upgrade ash_oban to version 0.8.14 or later, which introduces the remove_reserved_args/1 function that strips the reserved keys 'primary_key', 'metadata', 'action_arguments', 'tenant', and 'actor' from both the extra_args map and the caller-supplied :args map before any merging occurs, closing the atom/string collision bypass. The fix commit is confirmed at https://github.com/ash-project/ash_oban/commit/da2d81e1e8e1dcc3e6ec8587cdb4f273575ffca3. Prior to upgrading, applications can apply a workaround by sanitizing user input before passing it to :args - specifically, dropping any map keys that match the reserved set in both atom and string form (primary_key, metadata, action_arguments, tenant, actor) before they reach build_trigger/3. This workaround requires per-callsite application changes and is error-prone if new reserved keys are added in future versions; upgrading to 0.8.14 is strongly preferred. The vendor advisory at https://github.com/ash-project/ash_oban/security/advisories/GHSA-gj9p-x393-rf9h should be consulted for any additional guidance.

Affected VersionsENISA

ash_oban 0.2.5 <0.8.14
ash_oban ce079229ecdf0d323da2b554f30fc569e54660f0 <da2d81e1e8e1dcc3e6ec8587cdb4f273575ffca3

Affected Packages

euvd ash_oban fix: 0.8.14

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

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

Technical ContextAI · show details

AshOban is an Elixir library integrating the Ash Framework with the Oban background job processor (CPE: cpe:2.3:a:ash-project:ash_oban:*:*:*:*:*:*:*:*). The vulnerability lives in AshOban.build_trigger/3 (lib/ash_oban.ex), which constructs the trusted Oban job argument map using Elixir atom keys - :primary_key, :tenant, :action_arguments, :actor, :metadata. The caller's :args are merged beneath these trusted values via Map.merge/2 with the intent that trusted keys win on collision. However, Oban serializes job arguments to JSON and back, converting all atom keys to string keys upon deserialization. When the caller supplies string keys such as 'primary_key', Map.merge sees ':primary_key' (atom) and 'primary_key' (string) as distinct keys and allows both into the map. JSON serialization then de-duplicates by keeping the last occurrence of each string key, which is the caller-supplied value. The Oban worker subsequently reads the string-keyed value, bypassing the trusted atom-keyed assignment entirely. CWE-915 (Improperly Controlled Modification of Dynamically-Determined Object Attributes) precisely describes this root cause: the library fails to sanitize caller-controlled attributes that can shadow or override trusted runtime-determined object fields.

Know when Ash Oban 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 (EEF) PRIMARY 5.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Network-reachable via web app input but requires specific application design flaw (AC:H); cross-tenant record manipulation yields scope change with high integrity impact.

3.1 AV:N/AC:H/PR:N/UI:N/S:C/C:L/I:H/A:N
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:L/SI:H/SA:N

Primary rating from Vendor (EEF).

CVSS VectorVendor: EEF

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
High
Vulnerable system: Availability
None
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

Improperly Controlled Modification of Dynamically-Determined Object Attributes vulnerability in ash-project ash_oban allows a user whose input reaches the :args option of AshOban.build_trigger/3 to retarget an update or destroy trigger at another record, including across tenants.

build_trigger/3 builds the trusted job arguments with atom keys (:primary_key, :tenant, :action_arguments) and merges the caller's :args underneath so the trusted values win on collision. Because Oban job arguments round-trip through JSON, the caller's keys arrive as strings, so Map.merge sees no collision and both keys survive. When the job is persisted the JSON object is de-duplicated keeping the last (string) key, and the worker reads the caller's value. The documentation describes :args as unable to affect the action, so an application that forwards user input into it for uniqueness scoping is exposed to authorization bypass and tenant isolation breaks.

This issue affects ash_oban: from 0.2.5 before 0.8.14.

Threat Intelligence Overview

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Low
niche Elixir/Ash Framework background job library
Data Quality
6 sources
Confidence: High

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

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

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

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