If you rely solely on CVSS scores to prioritize your enterprise patch cycle, CVE-2026-56164 will eventually catch you off guard. Microsoft stamped this SharePoint Server vulnerability with a deceptively mild 5.3 base score during their July 2026 release cycle. Yet, within hours of its disclosure, the Cybersecurity and Infrastructure Security Agency (CISA) added it to the Known Exploited Vulnerabilities (KEV) catalog, confirming active, in-the-wild exploitation by advanced threat actors.
A 5.3 rating usually implies significant caveats—perhaps the attacker requires prior authentication, localized network access, or complex user interaction. That is simply not the case here. This is a network-based, unauthenticated, zero-click privilege escalation flaw. Attackers are currently chaining it with secondary techniques to seize complete administrative control over on-premises SharePoint farms.
This post dissects exactly what happened, how the underlying exploit chain bypasses your perimeter controls, and why your Active Directory exploitation threat models just became a bit more complicated. We will look past the sanitized vendor advisories to understand the mechanics of the attack, focusing heavily on how threat actors translate a missing authentication check into persistent remote code execution (RCE).
Why a "Moderate" Flaw is Actually Critical
The jarring discrepancy between the assigned CVSS score and the real-world threat stems from how severity metrics are fundamentally calculated. Evaluators scored the isolated, theoretical impact of the privilege escalation vulnerability on its own. They did not score the entire exploit chain that attackers deploy in practice. But attackers do not exploit bugs in a vacuum.
By abusing CVE-2026-56164 (NVD), an unauthenticated adversary can bypass critical access controls on exposed SharePoint Server endpoints. Once they elevate their privileges to a farm administrator level, they immediately pivot to their actual goal.
Their primary target? The underlying IIS machine keys.
A high-level network flow showing how an unauthenticated attacker bypasses access controls to extract IIS machine keys and escalate to RCE.
If an attacker successfully extracts the IIS machine keys, they hold the cryptographic secrets required to forge ViewState payloads and authentication tokens. This leads directly to remote code execution via insecure deserialization. We saw identical post-exploitation tactics during the recent incidents, where attackers turned localized configuration bugs into enterprise-wide persistence. A 5.3 bug that reliably chains into complete domain compromise is a critical threat, regardless of what the metric suggests.
P
Written by
pranay
Ethical Hacker & Cybersecurity Educator
Cybersecurity enthusiast focused on ethical hacking, penetration testing, bug bounty hunting, and security education. Founder of CyberBlockz, sharing practical cybersecurity knowledge, CTF challenges, and hands-on training to help learners develop real-world security skills and stay updated with the latest threats and vulnerabilities.
The Historical Context: SharePoint's Deserialization Demons
To understand why this specific privilege escalation is so dangerous, you have to look at SharePoint's architectural history. Microsoft SharePoint is a massive, complex application built heavily on the .NET framework. For years, the platform has battled a notorious class of vulnerabilities related to insecure deserialization.
Historically, bugs like CVE-2019-0604 and CVE-2020-1147 terrorized defenders because they allowed unauthenticated attackers to execute arbitrary code by passing malicious XML or ViewState data to the server. Microsoft aggressively patched these attack vectors, primarily by hardening the endpoints and requiring strict authentication before the server would deserialize complex objects.
Defenders felt a false sense of security. The deserialization gadgets (often generated by tools like YsoSerial.net) still existed deep within the application's dependencies, but attackers supposedly could not reach them without authenticating first.
CVE-2026-56164 shatters that barrier. It provides the exact authentication bypass needed to reach the guarded deserialization sinks. Threat actors no longer need to phish an employee for credentials; they simply abuse this logic flaw to impersonate a trusted administrator and deliver their payload.
The Technical Breakdown: Missing Authentication
Under the hood, the root cause of this vulnerability maps to CWE-306: Missing Authentication for Critical Function. Specific API routing components in SharePoint Server 2016, SharePoint Server 2019, and SharePoint Server Subscription Edition fail to properly validate authorization headers before processing requests bound for sensitive administrative interfaces.
An attacker simply crafts a malicious HTTP GET or POST request directed at a vulnerable legacy endpoint—frequently paths living under /_vti_bin/ or /_api/. Because the authentication middleware drops the ball, the backend worker process executes the request under the context of the IIS application pool identity, which inherently possesses excessive permissions over the farm configuration.
To illustrate how researchers and authorized pentesters identify these exposed endpoints during an authorized engagement, consider the following Python snippet. This is a benign, non-exploitative script designed solely to check if an endpoint enforces authentication correctly. It simply requests the path and analyzes the HTTP response codes, serving as a rapid auditing mechanism for internal security teams.
#!/usr/bin/env python3import requests
import urllib3
import sys
# Suppress insecure request warnings for lab environmentsurllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)defaudit_endpoint(target_url, endpoint):"""
Checks if a specific SharePoint endpoint enforces authentication.
Returns True if exposed (200 OK), False if protected (401/403).
""" url =f"{target_url.rstrip('/')}/{endpoint.lstrip('/')}" headers ={"User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AuthAuditor/1.0","Accept":"application/json"}try:# We are intentionally sending a request with NO auth headers response = requests.get(url, headers=headers, verify=False, timeout=10)if response.status_code ==200:print(f"[!] WARNING: Endpoint exposed without authentication: {url}")returnTrueelif response.status_code in[401,403]:print(f"[*] Secure: Endpoint properly requires authentication ({response.status_code}).")returnFalseelse:print(f"[-] Info: Unexpected status {response.status_code} for {url}")returnFalseexcept requests.exceptions.RequestException as e:print(f"[-] Error connecting to {url}: {e}")returnFalseif __name__ =="__main__":iflen(sys.argv)!=2:print("Usage: python3 audit_sharepoint.py https://sharepoint.lab.local") sys.exit(1) target = sys.argv[1]# A list of common legacy endpoints often targeted in these bypasses test_endpoints =["/_vti_bin/shtml.exe","/_vti_bin/lists.asmx","/_api/web/siteusers"]print(f"Starting unauthenticated audit against {target}...\n")for ep in test_endpoints: audit_endpoint(target, ep)
If your infrastructure returns a 200 OK for administrative APIs when queried without credentials, you possess a structural routing issue that attackers will inevitably find.
The Exploit Chain: From IIS Keys to RCE
Once the authentication bypass succeeds, the threat actor enters the second phase of the attack. They leverage their unauthenticated access to query internal administrative functions. Specifically, they aim to extract the validationKey and decryptionKey from the IIS web.config memory space.
These keys are the cryptographic backbone of ASP.NET's ViewState mechanism. ViewState is used to persist page state across postbacks. To prevent tampering, the server signs and encrypts the ViewState data using these machine keys.
When an attacker possesses these keys, they can use offensive tooling to forge a malicious ViewState payload. They embed a serialized object—such as an instance of TypeConfuseDelegate or a similar gadget—into the payload, sign it with the stolen keys, and send it back to any standard SharePoint page (like default.aspx).
Because the signature is cryptographically valid, the server trusts the payload. It deserializes the object, which instantly triggers the execution of arbitrary system commands. At this stage, the attacker usually drops a lightweight web shell or initiates a reverse connection to their command and control infrastructure. The privilege escalation effectively served as a quiet, zero-click doorway to a catastrophic remote code execution event.
Hunting the Threat: Detection Engineering
Detecting this attack requires looking at the very beginning of the kill chain. By the time the attacker is forging ViewState payloads, the damage is largely done. Defenders must identify the initial unauthenticated probing against the vulnerable endpoints.
This requires analyzing your IIS web server logs. You are looking for a highly specific pattern: requests to sensitive API directories returning a 200 OK status code, but containing no authenticated username in the cs-username field.
Here is a baseline Sigma rule you can ingest into your SIEM to catch this behavior:
title: Detect Suspicious SharePoint IIS Activity (CVE-2026-56164)
description: Detects potential unauthenticated privilege escalation attempts targeting sensitive SharePoint endpoints without valid authorization headers.
status: experimental
author: CyberBlockz
date:2026-07-17logsource:category: webserver
product: iis
detection:selection:# Attackers target legacy VTI bin paths to bypass routing authc-uri-stem|contains:-'/_vti_bin/'-'/_api/web/'-'/_layouts/15/'sc-status:'200'# Crucial indicator: Look for missing authentication cs-username:'-'condition: selection
falsepositives:- Legitimate unauthenticated API calls to specific public-facing endpoints (requires tuning per environment)
level: high
If your Security Operations Center flags repeated unauthenticated 200 OK responses matching this criteria, you must assume the threat actor is already attempting to extract machine keys. Incident responders should immediately pivot to checking process creation logs (Event ID 4688) for the w3wp.exe (IIS Worker Process) spawning suspicious child processes.
# Hunt for suspicious child processes spawned by IIS (Event ID 4688)# This indicates successful RCE post-exploitation$StartTime = (Get-Date).AddDays(-7)Write-Host"[*] Hunting for suspicious IIS worker process activity..."-ForegroundColor Cyan
Get-WinEvent-FilterHashtable @{ LogName = 'Security' ID = 4688
StartTime = $StartTime}-ErrorAction SilentlyContinue |Where-Object{$_.Properties[5].Value -match"w3wp\.exe"-and$_.Properties[13].Value -match"(cmd\.exe|powershell\.exe|certutil\.exe|whoami\.exe)"}|Select-Object TimeCreated, @{Name="ParentProcess";Expression={$_.Properties[5].Value}}, @{Name="ChildProcess";Expression={$_.Properties[13].Value}}, @{Name="CommandLine";Expression={$_.Properties[8].Value}}|Format-Table-AutoSize
A PowerShell script snippet that incident responders can use to quickly scan local Security event logs for evidence that the IIS worker process was forced to execute arbitrary commands following a successful deserialization attack.
What This Means for Defenders
Your immediate, non-negotiable action is straightforward: apply the July 2026 Microsoft security updates. However, patching massive, legacy SharePoint environments is rarely simple. It often requires careful coordination, testing, and negotiated downtime with business units. While you schedule the emergency maintenance window, you must implement compensating controls.
The most effective stopgap measure is enforcing Antimalware Scan Interface (AMSI) integration aggressively across your entire SharePoint infrastructure. AMSI acts as a deep inspection interception layer. It evaluates incoming request bodies and blocks recognized malicious patterns—such as the signatures of known deserialization gadgets or webshells—before the server's application logic ever processes them.
By routing incoming requests through the Antimalware Scan Interface (AMSI), defenders can block malicious payloads before deserialization.
Many organizations assume AMSI is enabled by default, but configuration drift and legacy upgrades frequently leave it disabled on specific web applications. Imagine you're the on-call engineer tasked with locking this infrastructure down at 2 AM; you cannot afford to manually click through the Central Administration GUI hoping you didn't miss a virtual host.
You can programmatically force AMSI enabled across the entire farm using this concise PowerShell script:
# Enforce AMSI integration for all SharePoint web applications in the farm# Run this from the SharePoint Management Shell as a Farm AdministratorAdd-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue
Write-Host"[*] Auditing AMSI status across all Web Applications..."-ForegroundColor Cyan
$webApps = Get-SPWebApplication$updateCount = 0
foreach($app in $webApps){if($app.AmsiEnabled -ne$true){Write-Host"[!] Found vulnerable application: $($app.DisplayName). Applying AMSI enforcement."-ForegroundColor Yellow
$app.AmsiEnabled = $true# Commit the changes to the farm configuration database$app.Update()Write-Host"[+] AMSI enforcement successfully applied to: $($app.DisplayName)"-ForegroundColor Green
$updateCount++}else{Write-Host"[-] AMSI is already active and protecting: $($app.DisplayName)"-ForegroundColor Gray
}}Write-Host"[*] Audit complete. Updated $updateCount web applications."-ForegroundColor Cyan
Alongside enforcing AMSI, verify that your "Request Body Scan Mode" is set to Full Mode where performance constraints permit.
If your organization relies heavily on on-premises SharePoint Server deployments, treat any unauthenticated network exposure as an immediate, critical risk. This is not a drill, and this is not a vulnerability you can deprioritize. Don't let a deceptive 5.3 CVSS score lull you into waiting for next month's routine patch cycle. The threat actors certainly aren't waiting.