CVE-2026-92393

Executive Summary

CVE-2026-92393 is an authorization bypass affecting Apache YuniKorn scheduler versions 1.9.0 and earlier. The vulnerability allows any authenticated user to bypass label and user annotation checks during workload UPDATE operations — affecting Kubernetes objects including deployments, replicasets, statefulsets, daemonsets, jobs, and cronjobs — while CREATE operations correctly enforce the same checks. Successful exploitation permits manipulation of user identity annotations and application IDs, enabling cross-queue access, quota evasion, and unauthorized resource consumption.

Technical Analysis

Apache YuniKorn is a light-weight, universal resource scheduler for container orchestrators, commonly deployed alongside Apache Hadoop YARN and Kubernetes clusters to manage multi-tenant workload scheduling and enforce queue-based resource quotas.

The core defect in CVE-2026-92393 is an inconsistent enforcement of authorization controls between CREATE and UPDATE actions on Kubernetes workload objects. The vendor description states that for the CREATE action, label and user annotation checks are correctly enforced for all supported object types. However, for the UPDATE action, these checks are not implemented, allowing them to be bypassed entirely.

Two distinct trust properties are validated at CREATE time but not at UPDATE time:

1. User info annotation — YuniKorn relies on a user identity annotation applied to the workload to determine which user is submitting work. Because UPDATE does not validate this annotation, any user can specify an arbitrary user identity.
2. Application ID — the application ID ties the workload to a scheduling queue. Because UPDATE does not validate application ID changes, a user can reassign their workload to a queue they are not authorized to use.

User-based quota enforcement in YuniKorn derives from the user annotation. Consequently, even if the application remains in the correct queue, an attacker who alters the user annotation can cause user quota tracking to be circumvented. This is a classic object-level authorization failure: the control exists in one code path (CREATE) but is absent in another (UPDATE), creating a state-modification bypass.

The vulnerability maps most directly to CWE-863 (Incorrect Authorization). The absence of public CVSS scoring from NVD at time of writing does not reduce severity — the flaw undermines the multi-tenant isolation guarantees that are the primary reason YuniKorn exists.

No public proof-of-concept, Nuclei template, or exploit code is currently available, and the CVE has not been added to CISA KEV. Patch confidence is rated 0/4 from tracked sources, though the vendor has explicitly recommended version 1.10.0 as the fix release.

Exploitation Scenarios

No public PoC is available; the attack chain below is inferred from the vulnerability class (authorization-bypass via inconsistent action-level enforcement) and the specific details in the NVD description.

1. Reconnaissance / target identification. An attacker first identifies a Kubernetes cluster running Apache YuniKorn 1.9.0 or earlier as its scheduler. Enumeration focuses on confirming the YuniKorn scheduling layer is present and identifying the supported workload types in use (deployments, replicasets, statefulsets, daemonsets, jobs, cronjobs). The attacker needs only a valid account with permission to update one of these workload objects.

2. Triggering the flaw class. The attacker issues an UPDATE operation against an existing workload object they are permitted to modify. Because YuniKorn does not implement label and user annotation checks on the UPDATE path, the modification is accepted without the authorization validation that the CREATE path would have enforced. No privileged token or role escalation is required — the gap is in the action itself, not in the user's credentials.

3. Payload/execution at the vulnerability-class level. Two manipulations enable the bypass, and the description notes they are most impactful when combined in a single UPDATE:

   • Setting an arbitrary user info annotation, spoofing a user identity the attacker does not legitimately hold.
   • Changing the application ID associated with the workload, redirecting the application to a queue the user would not normally be permitted to access. Performing both in one UPDATE lets the workload run in a queue that would otherwise reject the attacker, while the spoofed identity masks the origin of the request.

4. Post-exploitation impact. Once rescheduled into an unauthorized queue, the workload consumes that queue's resources. Quota usage for the target queue may be impacted, degrading service quality for its legitimate tenants (a denial-of-service side effect). If the workload instead remains in the correct queue but carries a forged user annotation, user-based quota enforcement is circumvented and user quota tracking is sidestepped. In both cases, the attacker gains compute resources beyond their entitlement and the integrity of multi-tenant accounting is broken.

Impact Assessment

CVE-2026-92393 primarily impacts the confidentiality of the authorization model and the integrity of YuniKorn's scheduling and quota system. Under a CVSS 3.1 assessment framework consistent with the vulnerability class, the attack vector is network (AV:N), complexity is low (AC:L), privileges required are low (PR:L — a basic account able to update a workload), user interaction is none (UI:N), and scope is unchanged (S:U). Integrity is rated high (I:H) because queue assignment, application identity, and quota accounting can all be altered; confidentiality is low (C:L) because tenant/resource boundaries may be inferred; availability is not directly impacted (A:N), though quota exhaustion on a victim queue can produce secondary resource starvation.

Blast radius. Any multi-tenant YuniKorn deployment at 1.9.0 or earlier is exposed. Environments that rely on queue isolation to guarantee fair-share scheduling or chargeback accounting are most at risk. Because the flaw permits spoofing of the user annotation, audit logs generated by the scheduler may attribute activity to the wrong user, complicating both incident response and forensic attribution.

Business impact. A successful exploit undermines the tenancy model itself, potentially enabling noisy-neighbor resource consumption, evasion of per-user quotas, and cross-queue resource theft. In regulated environments, corrupted quota/chargeback records and misattributed audit trails can create compliance exposure independent of the raw scheduling impact.

Detection Guidance

Sigma Rule

title: Apache YuniKorn Workload UPDATE with User Annotation or Application ID Change
id: b7e1c9a4-3f2d-4a6e-9c81-1d5f2a0b7e33
status: experimental
description: Detects UPDATE operations on YuniKorn-managed Kubernetes workload objects where the user identity annotation or application ID is modified, consistent with CVE-2026-92393 authorization bypass.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-92393
author: valtersit.com
date: 2026/01/01
logsource:
  product: kubernetes
  service: audit
detection:
  selection_action:
    verb: update
  selection_resource:
    objectRef.resource:
      - deployments
      - replicasets
      - statefulsets
      - daemonsets
      - jobs
      - cronjobs
  selection_annotation:
    requestObject.metadata.annotations|contains:
      - 'yunikorn.apache.org/user'
      - 'yunikorn.apache.org/applicationId'
      - 'yunikorn.apache.org/queue'
  condition: selection_action and selection_resource and selection_annotation
falsepositives:
  - Legitimate administrative rescheduling by platform SREs
  - Automated GitOps reconciliation updating annotations
level: medium
tags:
  - attack.t1548
  - cve.2026.92393

YARA Rule

rule CVE_2026_92393_YuniKorn_Update_Bypass
{
    meta:
        description = "Detects YuniKorn user/application annotation manipulation artifacts in request bodies or audit captures related to CVE-2026-92393"
        author = "valtersit.com"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-92393"
        date = "2026-01-01"
        severity = "high"

    strings:
        $ann_user = "yunikorn.apache.org/user" ascii nocase
        $ann_app  = "yunikorn.apache.org/applicationId" ascii nocase
        $ann_queue = "yunikorn.apache.org/queue" ascii nocase
        $verb_upd = "\"verb\":\"update\"" ascii nocase
        $verb_upd2 = "verb=update" ascii nocase
        $obj_dep  = "deployments" ascii nocase
        $obj_sts  = "statefulsets" ascii nocase
        $obj_job  = "jobs" ascii nocase

    condition:
        (2 of ($ann_*)) and (1 of ($verb_upd*)) and (1 of ($obj_*))
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-92393 Apache YuniKorn Workload UPDATE Authorization Bypass Attempt"; flow:to_server,established; http.method; content:"PUT"; http.uri; content:"/apis/"; content:"deployments"|"statefulsets"|"daemonsets"|"jobs"|"cronjobs"; http.request_body; content:"yunikorn.apache.org/user"; http.request_body; content:"yunikorn.apache.org/applicationId"; classtype:attempted-admin; reference:cve,2026-92393; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-92393; sid:202692393; rev:1; metadata:created_at 2026_01_01, updated_at 2026_01_01;)

Elastic Detection

sequence by user.name with maxspan=5m
  [process where event.action == "update" and process.command_line : ("*yunikorn*update*")]
  [file where event.action == "modification" and
    (file.name : ("deployment*.yaml" or "statefulset*.yaml" or "job*.yaml")) and
    wildcard(file.Ext.custom_annotations, "yunikorn.apache.org/user*")]

Splunk SPL Query

index=kubernetes sourcetype="kube:apiserver:audit"
verb=update
objectRef.resource IN ("deployments","replicasets","statefulsets","daemonsets","jobs","cronjobs")
(requestObject.metadata.annotations.yunikorn* OR requestObject.spec*applicationId*)
| stats count min(_time) as first_seen max(_time) as last_seen
        values(requestObject.metadata.annotations) as annotations
        values(user.username) as actor
        values(objectRef.name) as workload
  by user.username objectRef.namespace objectRef.resource
| where count > 0
| table first_seen last_seen actor workload objectRef.namespace objectRef.resource annotations count

Wazuh OSSEC Rule

<group name="kubernetes,apache_yunikorn,">
  <rule id="2026393" level="10">
    <decoded_as>json</decoded_as>
    <field name="verb">update</field>
    <field name="objectRef.resource">deployments|replicasets|statefulsets|daemonsets|jobs|cronjobs</field>
    <field name="requestObject.metadata.annotations">yunikorn.apache.org/(user|applicationId|queue)</field>
    <description>CVE-2026-92393: Possible Apache YuniKorn workload UPDATE authorization bypass via user/application annotation change</description>
    <mitre>
      <id>T1548</id>
    </mitre>
    <group>cve_2026_92393,authorization_bypass,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). The vendor has recommended upgrading to version 1.10.0 as the fix release, but no patch source has been confirmed by tracked repositories, and no workaround is currently published.

1. Immediate mitigations.

   • Restrict Kubernetes RBAC so that only trusted platform administrators hold update/patch verbs on deployments, replicasets, statefulsets, daemonsets, jobs, and cronjobs in YuniKorn-scheduled namespaces. Since the bypass lives in the UPDATE action path, denying the ability to UPDATE these objects removes the attack primitive.
   • Enable and centralize Kubernetes audit logging, and apply the detection rules above to flag UPDATE operations that touch yunikorn.apache.org user/application annotations.
   • Monitor YuniKorn queue utilization and per-user quota dashboards for anomalies that suggest workloads are running under unexpected queue or user identities.

2. Patch/upgrade steps.

   • Upgrade Apache YuniKorn to version 1.10.0, which the vendor states fixes the issue.
   • On upgrade, consider rotating service account credentials for any principal that held broad workload-update permissions, in case the bypass was abused to spoof identities.
   • Verify post-upgrade that label and user annotation checks are enforced on both CREATE and UPDATE actions for all six workload object types.

3. Long-term hardening.

   • Adopt a policy of auditing action-level authorization parity — ensure any check enforced on CREATE is also enforced on UPDATE and PATCH.
   • Enforce least-privilege RBAC for workload mutation and avoid granting broad namespace-level update rights.
   • Introduce admission policy controls (e.g., validating webhooks) that reject changes to reserved YuniKorn scheduling annotations from untrusted principals.
   • Add regression tests covering per-action authorization for all supported workload object types.

References

• NVD — CVE-2026-92393: https://nvd.nist.gov/vuln/detail/CVE-2026-92393
• Apache YuniKorn project: https://yunikorn.apache.org/
• Apache YuniKorn release 1.10.0 (vendor-recommended fix version)
• MITRE ATT&CK — T1548 Abuse Elevation Control Mechanism: https://attack.mitre.org/techniques/T1548/
• CWE-863 Incorrect Authorization: https://cwe.mitre.org/data/definitions/863.html

Exploitation status: No public proof-of-concept, exploit code, or Nuclei template was identified at time of writing, and the CVE is not listed in CISA KEV. No threat actor campaigns have been publicly associated with this vulnerability.