Back to Intelligence

Microsoft's Record 974-Vulnerability Patch Tuesday (September 2026): Two Actively Exploited Windows Zero-Days — Prioritization, Detection, and Remediation Guide

SA
Security Arsenal Team
September 9, 2026
13 min read

Microsoft's September 2026 Patch Tuesday is the largest security update release in the company's history: 974 vulnerabilities addressed in a single cycle, spanning Windows (723 flaws), Office and Office 2016 (111), SQL Server (62), and Developer Tools (22). More than 110 of these carry a Critical severity rating, and — most urgently — two Windows vulnerabilities are confirmed as actively exploited zero-days in the wild.

If you manage a Windows estate of any meaningful size, this is not a routine patch cycle. The combination of record volume, a heavy Critical-severity concentration, and confirmed in-the-wild exploitation means your standard 30-day patching cadence is a liability this month. The two exploited zero-days need emergency-change treatment; the Critical remote code execution (RCE) and elevation of privilege (EoP) flaws need an accelerated ring deployment. Everything else still needs to land before the exploit kits catch up — and with 974 patched flaws, the differential analysis ("patch diffing") community has an enormous attack surface to reverse-engineer.

This post breaks down what we know, how to prioritize remediation under pressure, and how to hunt for evidence that the zero-days were used against you before you patched.

Technical Analysis

Scope of the Release

Product FamilyVulnerability CountDefensive Significance
Windows723Core OS, kernel, drivers, and services — the bulk of the attack surface and home of both exploited zero-days
Office / Office 2016111Document-borne RCE and preview-pane attack vectors; the continued patching of Office 2016 confirms legacy versions remain in the exploitation crosshairs
SQL Server62Database-tier RCE and privilege escalation; high value in ransomware and data-extortion chains
Developer Tools22Visual Studio and related tooling — supply-chain and build-pipeline risk

Over 110 flaws are rated Critical. In Microsoft's severity model, Critical ratings are typically reserved for vulnerabilities that are remotely exploitable without user interaction (or with minimal interaction, such as previewing a malicious file) — the class of bugs that wormable malware and hands-on-keyboard intrusions are built from.

The Two Actively Exploited Windows Zero-Days

Microsoft has confirmed that two of the Windows flaws patched this cycle were exploited in the wild before patches were available — the definition of a zero-day. Per Microsoft's standard disclosure practice, full technical details on these two flaws are being withheld to give defenders a patching window; specific CVE identifiers and component details were not included in initial reporting.

What we can state with confidence based on historical patterns for in-the-wild Windows zero-days:

  • Elevation of Privilege is the most common zero-day class. The majority of Windows zero-days exploited in the wild in recent years have been EoP flaws in the kernel, the Common Log File System (CLFS) driver, Win32k, or Windows services. Attackers chain them with an initial-access vector (phishing, browser exploit, or a separate RCE) to escape sandboxes and gain SYSTEM.
  • Exploitation is typically targeted first, commodity later. The actors exploiting these flaws today are likely APT or financially motivated groups with specific targets. Once the patch diffs circulate, working exploits proliferate to ransomware affiliates within days to weeks.
  • Patching closes the hole but doesn't evict the intruder. If exploitation predates your patch, assume the possibility of established persistence and hunt accordingly — the detection content below is built for exactly this scenario.

Given the volume of Windows fixes (723), defenders should also assume that several of the Critical-rated Windows RCE flaws — particularly any affecting network-facing services, the Windows TCP/IP stack, or authentication components — are candidates for rapid reverse engineering. The "patch gap" (time between patch release and broad deployment) is the window attackers race to exploit.

Exploitation Status

  • Two Windows vulnerabilities: Confirmed active exploitation in the wild as zero-days. These should be treated as CISA KEV-equivalent priority regardless of when formal KEV listing is published — Microsoft's "exploited: yes" designation is sufficient trigger for emergency change.
  • ~110 Critical flaws: No confirmed exploitation at disclosure time, but Critical RCEs in Windows and Office are historically the first targets of exploit developers performing patch-diffing.
  • Remaining flaws: Important/Moderate severity — still require patching on normal-to-accelerated cadence; EoP and security feature bypass bugs in this tier are routinely chained with Critical RCEs.

Detection & Response

Patching is the primary remediation, but it answers only half the question. The other half: were you exploited before you patched? Since Microsoft has not released component-level detail on the two zero-days, detection must be behavioral — focused on the post-exploitation patterns common to Windows EoP zero-day abuse (unexpected SYSTEM-level process trees, suspicious child processes of Office applications, anomalous activity on SQL Server hosts) and on patch-verification hygiene.

The following content is designed for high signal. Tune thresholds to your environment's baseline before production deployment.

Sigma Rules

YAML
---
title: Office Application Spawning Script Interpreter or Shell
id: 3f8c2a91-6b4d-4e1a-9c57-2d8f4b6a1e90
status: experimental
description: Detects Microsoft Office processes spawning command shells, script interpreters, or LOLBins. Consistent with post-exploitation behavior following document-borne exploitation of Office RCE flaws patched in the September 2026 record Patch Tuesday (111 Office flaws addressed).
references:
  - https://thehackernews.com/2026/09/microsoft-patches-record-974-flaws.html
  - https://attack.mitre.org/techniques/T1203/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/10
tags:
  - attack.exploitation_for_client_execution
  - attack.t1203
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\winword.exe'
      - '\excel.exe'
      - '\powerpnt.exe'
      - '\outlook.exe'
      - '\onenote.exe'
      - '\mspub.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\certutil.exe'
      - '\bitsadmin.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Rare legitimate Office add-ins or macros in controlled development environments
level: high
---
title: SQL Server Process Spawning Command Shell or Script Interpreter
id: 7d1e5b42-9a3c-4f68-b812-4c6d9e2a7f35
status: experimental
description: Detects sqlservr.exe or SQL Server Agent spawning command shells, PowerShell, or script interpreters. Behavioral indicator of post-exploitation following SQL Server vulnerability abuse; 62 SQL flaws were patched in the September 2026 Microsoft release.
references:
  - https://thehackernews.com/2026/09/microsoft-patches-record-974-flaws.html
  - https://attack.mitre.org/techniques/T1190/
  - https://attack.mitre.org/techniques/T1059.001/
author: Security Arsenal
date: 2026/09/10
tags:
  - attack.exploit_public_facing_application
  - attack.t1190
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\sqlservr.exe'
      - '\sqlagent.exe'
      - '\sqlps.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\whoami.exe'
      - '\net.exe'
      - '\net1.exe'
  condition: selection_parent and selection_child
falsepositives:
  - xp_cmdshell legitimately enabled and used by database administrators (should be disabled; treat any hit as review-worthy)
  - SQL Agent jobs executing scripts (validate against documented job schedules)
level: high
---
title: Suspicious SYSTEM-Level Process Tree Following Service or Kernel Exploitation
id: 9c4a7d16-2e5b-4a89-8f31-6b3e1c9d4a72
status: experimental
description: Detects interactive shells, download cradles, or discovery tooling running as NT AUTHORITY\SYSTEM spawned by services or unusual parents. Consistent with post-exploitation after Windows elevation-of-privilege zero-day abuse, the class of the two actively exploited flaws patched September 2026.
references:
  - https://thehackernews.com/2026/09/microsoft-patches-record-974-flaws.html
  - https://attack.mitre.org/techniques/T1068/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/09/10
tags:
  - attack.privilege_escalation
  - attack.t1068
  - attack.discovery
logsource:
  category: process_creation
  product: windows
detection:
  selection_user:
    User|contains: 'SYSTEM'
  selection_cmd:
    CommandLine|contains:
      - 'whoami'
      - 'net user'
      - 'net localgroup'
      - 'quser'
      - 'systeminfo'
      - 'Invoke-'
      - 'IEX'
      - 'DownloadString'
      - 'certutil -urlcache'
      - 'bitsadmin /transfer'
  filter_parents:
    ParentImage|endswith:
      - '\wmiprvse.exe'
      - '\services.exe'
      - '\svchost.exe'
      - '\spoolsv.exe'
      - '\MsMpEng.exe'
      - '\sqlservr.exe'
  condition: selection_user and selection_cmd and not filter_parents
falsepositives:
  - Legitimate system management agents (SCCM, Tanium, RMM tooling) — baseline and allowlist known tooling by full path and signer
  - Backup and monitoring software executing SYSTEM-context scripts
level: medium

KQL — Microsoft Sentinel / Defender

This query hunts for the highest-fidelity post-exploitation behaviors relevant to this Patch Tuesday: Office and SQL Server processes spawning shells (document-borne RCE and SQL abuse) combined with SYSTEM-context discovery activity on endpoints that are pending the September 2026 updates. Run it across the pre-patch window to assess whether exploitation preceded remediation.

KQL — Microsoft Sentinel / Defender
let PatchWindowStart = ago(14d);
let SuspiciousChildren = dynamic(["cmd.exe","powershell.exe","pwsh.exe","wscript.exe","cscript.exe","mshta.exe","rundll32.exe","regsvr32.exe","certutil.exe","bitsadmin.exe"]);
let OfficeParents = dynamic(["winword.exe","excel.exe","powerpnt.exe","outlook.exe","onenote.exe","mspub.exe"]);
let SqlParents = dynamic(["sqlservr.exe","sqlagent.exe","sqlps.exe"]);
DeviceProcessEvents
| where TimeGenerated >= PatchWindowStart
| extend ParentName = tolower(tostring(split(InitiatingProcessFileName, "\\")[-1])), ChildName = tolower(FileName)
| where (ParentName in~ (OfficeParents) or ParentName in~ (SqlParents))
    and ChildName in~ (SuspiciousChildren)
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName,
    InitiatingProcessCommandLine, FileName, ProcessCommandLine, SHA256, ReportId
| join kind=leftouter (
    DeviceProcessEvents
    | where TimeGenerated >= PatchWindowStart
    | where AccountName =~ "SYSTEM"
    | where ProcessCommandLine has_any ("whoami","net user","net localgroup","systeminfo","DownloadString","IEX","certutil -urlcache")
    | project SystemActivityTime = TimeGenerated, DeviceName, SystemCmd = ProcessCommandLine
) on DeviceName
| summarize OfficeOrSqlHits = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated),
    SampleCommands = make_set(ProcessCommandLine, 5), SystemDiscoveryCmds = make_set(SystemCmd, 5)
    by DeviceName, AccountName
| order by FirstSeen asc

For patch-compliance hunting via Defender TVM data (where available), correlate exposed devices:

KQL — Microsoft Sentinel / Defender
DeviceInfo
| where TimeGenerated >= ago(1d)
| join kind=inner (
    DeviceProcessEvents
    | where TimeGenerated >= ago(7d)
    | summarize LastActivity = max(TimeGenerated) by DeviceId
) on DeviceId
| summarize arg_max(TimeGenerated, *) by DeviceId
| project DeviceName, OSPlatform, OSVersion, OSBuild, LastActivity
| order by OSBuild asc

Velociraptor VQL

Use this hunt artifact to sweep endpoints for Office/SQL-spawned shells and SYSTEM-context tooling execution in the pre-patch window — the artifacts most likely to survive after a zero-day operator moves on.

VQL — Velociraptor
-- Hunt: Post-exploitation indicators relevant to September 2026 Patch Tuesday zero-day abuse
-- Looks for Office/SQL-spawned shells and SYSTEM-context execution of discovery/cradle tooling
SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime,
       dict(Ppid=Ppid) as _ParentLookup
FROM pslist()
WHERE (
    -- Child of Office or SQL processes
    Ppid IN (
        SELECT Pid FROM pslist()
        WHERE Name =~ '(?i)(winword|excel|powerpnt|outlook|onenote|mspub|sqlservr|sqlagent)'
    )
    AND Name =~ '(?i)(cmd|powershell|pwsh|wscript|cscript|mshta|rundll32|regsvr32|certutil|bitsadmin)'
)
OR (
    -- SYSTEM-context discovery or download cradle execution
    Username =~ '(?i)SYSTEM'
    AND CommandLine =~ '(?i)(whoami|net user|net localgroup|systeminfo|DownloadString|IEX|certutil -urlcache|bitsadmin /transfer)'
)

Remediation & Verification Script

The following PowerShell script (run elevated, per-host or via your RMM/Intune/GPO tooling) checks build/patch status, inventories recently installed September 2026 hotfixes, forces a Windows Update scan, and flags Office 2016 installations that require manual attention given their continued exposure.

PowerShell
#requires -RunAsAdministrator
# Security Arsenal — September 2026 Patch Tuesday verification & enforcement helper
# Validates OS build recency, lists installed Sept-2026 hotfixes, triggers update scan, flags legacy Office

$ErrorActionPreference = 'Continue'
$report = [ordered]@{}

# --- 1. OS build and last boot (long uptime = updates likely not applied) ---
$os = Get-CimInstance Win32_OperatingSystem
$report['OSBuild'] = $os.BuildNumber
$report['OSVersion'] = $os.Version
$report['LastBoot'] = $os.LastBootUpTime
$report['UptimeDays'] = [math]::Round(((Get-Date) - $os.LastBootUpTime).TotalDays, 1)

# --- 2. Installed hotfixes from September 2026 forward ---
$septPatches = Get-HotFix | Where-Object { $_.InstalledOn -ge (Get-Date '2026-09-08') } |
    Sort-Object InstalledOn -Descending
$report['Sept2026HotfixCount'] = ($septPatches | Measure-Object).Count
$report['Sept2026Hotfixes'] = ($septPatches | Select-Object -ExpandProperty HotFixID) -join ', '

# --- 3. Pending reboot check (patch applied but not effective until reboot) ---
$rebootPending = $false
$paths = @(
    'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootPending',
    'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired'
)
foreach ($p in $paths) { if (Test-Path $p) { $rebootPending = $true } }
$report['RebootPending'] = $rebootPending

# --- 4. Detect legacy Office 2016 installs (111 Office/Office 2016 flaws patched this cycle) ---
$officeKeys = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*',
    'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*' -ErrorAction SilentlyContinue |
    Where-Object { $_.DisplayName -match 'Microsoft Office' } |
    Select-Object DisplayName, DisplayVersion
$report['OfficeInstalls'] = ($officeKeys | ForEach-Object { "$($_.DisplayName) $($_.DisplayVersion)" }) -join '; '
$report['Office2016Present'] = [bool]($officeKeys | Where-Object { $_.DisplayVersion -like '16.*' -and $_.DisplayName -notmatch '365' })

# --- 5. Force a Windows Update scan against configured source (WSUS/WUfB/Intune) ---
try {
    $updateSession = New-Object -ComObject Microsoft.Update.Session
    $searcher = $updateSession.CreateUpdateSearcher()
    $result = $searcher.Search("IsInstalled=0 and Type='Software'")
    $report['UpdatesPending'] = $result.Updates.Count
    $report['PendingCritical'] = @($result.Updates | Where-Object { $_.MsrcSeverity -eq 'Critical' }).Count
} catch {
    $report['UpdateScanError'] = $_.Exception.Message
}

# --- 6. Verdict ---
if ($report['Sept2026HotfixCount'] -gt 0 -and -not $rebootPending) {
    $report['Status'] = 'PATCHED - September 2026 updates installed, no reboot pending'
} elseif ($rebootPending) {
    $report['Status'] = 'ACTION REQUIRED - Updates installed, REBOOT PENDING (system still vulnerable until restart)'
} else {
    $report['Status'] = 'ACTION REQUIRED - No September 2026 hotfixes detected'
}

$report.GetEnumerator() | ForEach-Object { "{0,-22}: {1}" -f $_.Key, $_.Value }

# Exit code for RMM/SCCM compliance rules: 0 = patched, 1 = action required
if ($report['Status'] -like 'PATCHED*') { exit 0 } else { exit 1 }

Remediation

Priority 1 — Emergency change (24–48 hours):

  1. Deploy the September 2026 Windows cumulative updates across all supported Windows client and server versions. These contain the fixes for the two actively exploited zero-days. Treat Microsoft's "exploited: yes" designation as KEV-equivalent — do not wait for formal CISA KEV publication or the associated federal remediation deadline before acting. If and when CISA adds these CVEs to the KEV catalog, the Binding Operational Directive 22-01 clock will start for federal civilian agencies; private-sector organizations should hold themselves to the same timeline.
  2. Reboot matters. A meaningful share of "we patched but still got hit" incidents trace to pending reboots. Build reboot completion into your compliance gate — the verification script above flags exactly this condition.

Priority 2 — Accelerated ring (7 days):

  1. Patch the ~110 Critical-rated flaws, with sequencing driven by exposure: internet-facing systems, Remote Desktop Services, VPN gateways, and any Windows component reachable from untrusted networks first; Office on endpoints that receive external email second; SQL Server hosts third — prioritizing any instance reachable outside its application tier.
  2. Address Office 2016 specifically. The 111 Office flaws explicitly include Office 2016, a product approaching or past end of mainstream support. If you still run Office 2016, this release is your migration business case: inventory every install, patch what you must keep, and accelerate the move to Microsoft 365 Apps or a supported perpetual version. Legacy Office is a recurring zero-day delivery vehicle.

Priority 3 — Standard ring (30 days):

  1. Complete the remaining fleet, including the 62 SQL Server fixes and 22 Developer Tools fixes. For SQL Server: confirm cumulative update/GDR applicability per build, test against your availability groups before rolling, and audit xp_cmdshell status (EXEC sp_configure 'xp_cmdshell'; — it should be 0). For Developer Tools: build servers and CI/CD runners are supply-chain chokepoints; do not treat them as low priority.

Compensating controls while patching:

  • Enforce attack surface reduction (ASR) rules blocking Office child processes — this directly blunts the most likely document-borne delivery chain for the Office RCE flaws.
  • Disable Office macros from the internet (Mark-of-the-Web enforcement) if not already done.
  • Restrict SQL Server network exposure to application tiers only; verify no instance answers on untrusted segments.
  • Enable credential guard and LSASS protection to limit post-EoP credential theft — the typical follow-on after a Windows privilege-escalation zero-day lands.

Verification and accountability:

  • Authoritative sources: the Microsoft Security Update Guide for per-CVE applicability and KB numbers, and the CISA Known Exploited Vulnerabilities catalog for formal KEV additions and federal deadlines.
  • Measure the patch gap, not just patch state: track days-to-remediate for the two zero-day fixes separately from the rest of the cycle. If your mean time to remediate exploited vulnerabilities exceeds 72 hours, this cycle — 974 flaws with two under active attack — is the forcing function to fix that process.

Hunt before you close the ticket. Because the two zero-days were exploited before patches existed, any system patched after the public disclosure date was potentially exposed during that window. Run the Sigma, KQL, and VQL content above across the pre-patch period on high-value assets — domain controllers, executive endpoints, SQL hosts, and internet-facing systems — before declaring this cycle complete.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.