CVE-2026-105895

Executive Summary

CVE-2026-105895 is a critical Improper Input Validation vulnerability (CWE-20) in Adobe Experience Manager (AEM) that allows an authenticated attacker with low privileges to achieve arbitrary code execution in the context of the current user, with a scope change that can yield elevated access or full control over a victim's account or session. The flaw is network-reachable, requires no user interaction, and carries a CVSS v3.1 base score of 9.9, placing it among the highest-severity classes of web application defects. No public proof-of-concept, exploit code, or Nuclei template has been observed, and no patch or vendor workaround has been identified through tracked sources, leaving affected AEM deployments wholly reliant on compensating controls until Adobe publishes remediation.

Technical Analysis

The vulnerability is classified under CWE-20 (Improper Input Validation). In the context of Adobe Experience Manager — a Java-based content management and digital experience platform typically exposed on enterprise networks and frequently reachable from the public internet — improper input validation occurs when user-supplied input is accepted and processed without adequate verification of type, format, length, range, or structure before being used in a security-sensitive operation. Because the NVD description states the outcome is "arbitrary code execution in the context of the current user," the validated attack surface is one where attacker-controlled input reaches a code-execution sink (for example, dynamic evaluation, template rendering, script interpretation, or deserialization) that does not neutralise hostile content.

Several properties distinguish this issue:

• Attack vector is network (AV:N): the vulnerable component is reachable over a network protocol, consistent with AEM's HTTP-based interfaces and content delivery endpoints.
• Low privileges required (PR:L): the attacker must possess at least a baseline authenticated foothold. This is significant for AEM, where self-registration, author-tier accounts, or low-privileged service accounts may be attainable, and where privilege boundaries are frequently misconfigured.
• No user interaction (UI:N): exploitation does not depend on a victim clicking a link or opening a file, meaning the attack can be automated against exposed instances.
• Scope is changed (S:C): the vulnerable component's exploitation affects resources beyond its original security authority. This is the critical escalation indicator — successful input validation bypass does not merely compromise the invoking user's own resources, but can cross into other accounts, sessions, or security domains, consistent with the described "gaining elevated access or control over the victim's account or session."
• High confidentiality, integrity, and availability impact (C:H/I:H/A:H): the outcome permits reading sensitive content, modifying data, and disrupting service.

The combination of S:C with C:H/I:H/A:H is what drives the 9.9 score despite the PR:L requirement: the scope change effectively converts a low-privileged foothold into a cross-boundary compromise. The mechanism therefore involves validation logic that fails to constrain input before it is interpreted by a component operating under a different security context, allowing attacker-controlled data to influence execution outside the originally granted authority.

Attack surface. AEM exposes multiple request-handling tiers (author, publish, dispatcher-fronted endpoints, and administrative APIs on default ports 4502/4503). Any of these that performs input validation inadequately could serve as the entry point. No specific endpoint, servlet path, parameter name, or affected package is disclosed in the available data, and this report will not invent them. The reliable, data-supported statement is: an authenticated actor submits crafted input to a network-reachable AEM interface, the interface fails to validate that input, and the input is subsequently interpreted in a manner that executes attacker-influenced code under the current user's context with the potential to escape into other accounts or sessions.

Absence of specifics. The CNA title is empty, the affected version range is unavailable, and no OSV package mapping exists. Consequently, code-level detail (specific class, method, parser, or sink) cannot be stated without fabrication. Analysts should treat the absence of an affected-version list as a signal to inventory all AEM instances and treat any release not explicitly confirmed fixed as potentially vulnerable.

Exploitation Scenarios

No public proof-of-concept is available; the attack chain below is inferred strictly from the vulnerability class (CWE-20) and the CVSS profile in the provided data. No specific function names, endpoints, or parameters are asserted.

1. Reconnaissance / target identification. The attacker enumerates internet- and intranet-facing Adobe Experience Manager deployments, typically via HTTP fingerprinting of AEM-specific responses, default administrative login surfaces, and publish-tier endpoints. Targets of interest are instances where the attacker can obtain or self-provision a low-privileged authenticated account (justifying PR:L). Because UI:N applies, no victim participation is required to arm or deliver the attack.

2. Triggering the flaw class. Holding a low-privileged session, the attacker submits crafted input to a network-reachable interface whose validation is insufficient. The input is malformed or semantically hostile relative to what the receiving component expects — the defining condition of CWE-20. The component accepts the input and passes it toward a security-sensitive operation rather than rejecting or sanitising it.

3. Payload/execution at the vulnerability-class level. The improperly validated input reaches a code-execution sink and is interpreted, resulting in arbitrary code execution under the context of the current user. Because scope is changed (S:C), the execution context is not confined to the attacker's own authority; the attacker can influence resources and security domains belonging to other users — consistent with gaining elevated access or control over a victim's account or session. At the class level, this may manifest as session or account takeover, cross-user data exposure, or execution of attacker-supplied logic within the platform's runtime.

4. Post-exploitation impact. With code execution in the current user's context plus a scope change, the attacker can: escalate from low-privileged to elevated platform access; assume or hijack other users' sessions and accounts; expose confidential content (C:H); tamper with or inject content, code, and configuration (I:H); and degrade or disable services (A:H). On AEM, such access frequently enables content poisoning, lateral movement into integrated systems, and persistence via platform extension mechanisms.

Caveats. Exploitability in any specific environment depends on reachability, the attacker's ability to obtain the required low-privileged account, and whether compensating controls (dispatcher rules, WAF, network segmentation, authentication hardening) interrupt the chain.

Impact Assessment

The CVSS v3.1 subscores frame a severe, cross-boundary compromise:

• AV:N — exploitable remotely over a network, broadening the exposed population to any reachable AEM instance, including internet-facing publish tiers.
• AC:L — no special conditions or timing are required; the attack is repeatable and automatable.
• PR:L — a low-privileged authenticated foothold suffices, which is materially easier to obtain than administrative access.
• UI:N — no victim action is needed, removing the primary human-defence barrier and enabling large-scale automated attempts.
• S:C — exploitation crosses a security-authority boundary, the most impactful subscore driver.
• C:H / I:H / A:H — full loss of confidentiality, integrity, and availability is possible.

Business impact. Adobe Experience Manager commonly underpins customer-facing web properties, marketing content, authenticated portals, and integrated digital asset and personalisation workflows. Successful exploitation can lead to: unauthorised disclosure of proprietary content and customer data (regulatory and privacy exposure under GDPR, CCPA and similar regimes); defacement or malicious content injection on public sites; account and session takeover enabling further abuse; and service interruption to revenue-generating digital channels.

Affected systems and blast radius. All AEM deployments that expose the vulnerable interface to network-reachable actors and that cannot prevent attainment of a low-privileged account are at risk. Because the affected version range is unavailable, the safe operating assumption is that any AEM release not explicitly confirmed fixed is potentially in scope. The scope-change property means the blast radius extends beyond the attacker's own principal to other users, sessions, and connected systems (CDNs, personalisation engines, asset stores, and downstream integrations). The CVSS base score of 9.9 classifies this as Critical; however, the EPSS score is not yet available from FIRST.org, and there is no CISA KEV listing, so no observed exploitation is assumed at this time.

Detection Guidance

Sigma Rule

title: Potential CVE-2026-105895 Adobe Experience Manager Improper Input Validation Exploitation
id: 8f2c1a44-6b7e-4d91-9c3a-aem1058950001
status: experimental
description: Detects anomalous authenticated requests to Adobe Experience Manager interfaces exhibiting patterns consistent with improper input validation abuse (CWE-20) leading to code execution.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-105895
author: Threat Intelligence
date: 2026/01/01
logsource:
  category: webserver
  product: adobe_experience_manager
detection:
  selection_methods:
    - cs-method: 'POST'
    - cs-method: 'GET'
  selection_paths:
    - cs-uri-stem|contains: '/content/'
    - cs-uri-stem|contains: '/libs/'
    - cs-uri-stem|contains: '/apps/'
    - cs-uri-stem|contains: '/bin/'
  selection_payload_indicators:
    - cs-uri-query|contains: '${'
    - cs-uri-query|contains: 'Runtime'
    - cs-uri-query|contains: 'exec'
    - cs-uri-query|contains: '../'
  condition: selection_methods and selection_paths and selection_payload_indicators
fields:
  - c-ip
  - cs-username
  - cs-uri-stem
  - cs-uri-query
  - sc-status
falsepositives:
  - Legitimate administrative content operations referencing these tokens
level: high
tags:
  - attack.t1190
  - cve.2026-105895

YARA Rule

rule CVE_2026_105895_AEM_InputValidation_Exploit
{
    meta:
        description = "Detects exploit artifacts targeting Adobe Experience Manager improper input validation (CVE-2026-105895, CWE-20)"
        author = "Threat Intelligence"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-105895"
        date = "2026-01-01"
        severity = "critical"

    strings:
        $aem1 = "Adobe Experience Manager" ascii nocase
        $aem2 = "/libs/granite" ascii nocase
        $aem3 = "cq:Page" ascii nocase
        $sink1 = "getRuntime().exec" ascii
        $sink2 = "ProcessBuilder" ascii
        $sink3 = "Class.forName" ascii
        $inject1 = "${" ascii
        $inject2 = "#{" ascii

    condition:
        (any of ($aem*)) and
        (any of ($sink*) or all of ($inject*)) and
        filesize < 2MB
}

Suricata IDS Rule

alert http any any -> any any (msg:"CVE-2026-105895 Adobe Experience Manager Improper Input Validation Attempt"; flow:established,to_server; http.method; content:"POST"; http.uri; content:"/content/"; http.uri; content:"${"; nocase; http.header; content:"Cookie"; reference:cve,2026-105895; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-105895; classtype:web-application-attack; sid:1058950; rev:1;)

Elastic Detection

sequence by source.ip with maxspan=30s
  [network where network.protocol == "http" and http.request.method == "POST" and
    wildcard(http.request.body.content, "*${*") and
    (wildcard(url.path, "*/content/*") or wildcard(url.path, "*/bin/*") or wildcard(url.path, "*/libs/*"))]
  [network where network.protocol == "http" and http.response.status_code >= 500 and
    wildcard(url.path, "*/content/*")]

Splunk SPL Query

index=web sourcetype=access_combined
| eval uri=coalesce(uri, cs_uri_stem, "")
| eval query=coalesce(uri_query, cs_uri_query, "")
| eval method=coalesce(method, cs_method, "")
| where method IN ("POST","GET")
| where (match(uri, "(?i)/(content|libs|apps|bin)/"))
| where (match(query, "(\$\{|Runtime|exec|\.\./)") OR match(uri, "(\$\{|Runtime|exec|\.\./)"))
| stats count min(_time) as first_seen max(_time) as last_seen by src_ip, uri, query, status
| sort - count
| convert ctime(first_seen) ctime(last_seen)

Wazuh OSSEC Rule

<group name="web,adobe,aem,">
  <rule id="105895" level="12">
    <if_sid>31100</if_sid>
    <match>Adobe Experience Manager</match>
    <regex>(?i)(/(content|libs|apps|bin)/).*(\$\{|Runtime|exec)</regex>
    <description>CVE-2026-105895: Possible Adobe Experience Manager improper input validation exploitation attempt</description>
    <mitre>
      <id>T1190</id>
    </mitre>
    <group>web_attack,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). No vendor fix, upgrade target, or workaround is available in the provided data.

1. Immediate mitigations (compensating controls).

   • Restrict network access to AEM author and administrative interfaces; do not expose author-tier instances to the public internet. Front publish instances with the AEM Dispatcher or an equivalent reverse proxy.
   • Enforce strict authentication and least privilege: eliminate anonymous or self-registration paths to any interface that accepts user input, and remove unnecessary low-privileged accounts (directly counters PR:L).
   • Deploy virtual patching at a WAF/reverse proxy targeting anomalous input patterns consistent with the CWE-20 condition (see Detection Guidance), and enable request rate limiting and anomaly alerting.
   • Segment AEM from back-end asset stores, databases, and integrated systems to limit the scope-change blast radius.
   • Enforce HttpOnly, Secure, and SameSite attributes on session cookies and shorten session lifetimes to reduce account/session takeover impact.

2. Patch/upgrade steps.

   • Monitor Adobe's security bulletin channel and the Adobe Product Security Incident Response Team (PSIRT) advisories for the CVE-2026-105895 fix. No patch version or reference is currently identified.
   • Inventory all AEM instances (author, publish, dispatcher) and record exact build versions so the forthcoming vendor fix can be applied precisely.
   • Test the vendor fix in a non-production environment before staged rollout; verify scope-change and privilege-boundary behaviour after upgrading.

3. Long-term hardening.

   • Maintain a continuous vulnerability-management programme covering all AEM tiers and dispatcher configurations.
   • Harden access control: default-deny on administrative paths, enforce role separation, and rotate service credentials.
   • Adopt defense-in-depth: runtime application self-protection (RASP), file integrity monitoring, and centralised logging with the detections above.
   • Track EPSS and CISA KEV for this CVE and reprioritise once exploitation data emerges.

References

• NVD — CVE-2026-105895: https://nvd.nist.gov/vuln/detail/CVE-2026-105895
• MITRE CWE-20 — Improper Input Validation: https://cwe.mitre.org/data/definitions/20.html
• MITRE ATT&CK T1190 — Exploit Public-Facing Application: https://attack.mitre.org/techniques/T1190/
• FIRST EPSS (CVE-2026-105895) — currently unscored: https://api.first.org/data/v1/epss?cve=CVE-2026-105895
• CISA Known Exploited Vulnerabilities Catalog (not currently listed): https://www.cisa.gov/known-exploited-vulnerabilities-catalog
• Adobe Security Bulletins (monitor for the vendor advisory and fix version): https://helpx.adobe.com/security.html

No threat-actor campaigns or exploit-in-the-wild evidence are known for this CVE at the time of writing.