Back to Intelligence

CVE-2026-108186: Critical Zoom Workplace for Windows Vulnerability — Detection and Remediation Guide

SA
Security Arsenal Team
November 11, 2026
12 min read

Zoom has released emergency software updates to address two significant security vulnerabilities in Zoom Workplace for Windows. The most severe flaw, CVE-2026-108186, carries a CVSS score of 9.6 (Critical) and stems from improper input validation within the Zoom client. This vulnerability allows an unauthenticated remote attacker to escalate privileges on affected systems—effectively granting them elevated access without requiring valid credentials or user interaction beyond the presence of a vulnerable client.

For enterprise environments, this represents a high-risk attack vector. Zoom Workplace is ubiquitous across corporate fleets, often installed with elevated privileges or running in the context of users with administrative rights. A successful exploit chain could serve as an initial access point for ransomware operators, nation-state actors, or supply-chain adversaries looking to pivot from a collaboration tool into broader network compromise.

Given the critical severity, the unauthenticated nature of the exploit, and the widespread deployment of Zoom in Windows environments, defenders must treat this as a drop-everything patch event. If you cannot patch immediately, you must hunt for signs of active exploitation and apply compensating controls.


Technical Analysis

Affected Products

  • Product: Zoom Workplace for Windows
  • Platform: Microsoft Windows (specific versions not disclosed in initial advisory; assume all supported versions prior to the patch release are vulnerable)
  • CVE Identifiers:
    • CVE-2026-108186 (CVSS 9.6) — Improper Input Validation leading to Privilege Escalation
    • CVE-2026-108187 (CVSS score not disclosed) — Additional security flaw addressed in the same update

Vulnerability Mechanics

CVE-2026-108186 is classified as an Improper Input Validation (CWE-20) vulnerability. From a defensive perspective, this class of bug typically manifests when the application fails to properly sanitize, bounds-check, or validate data received from an untrusted source—often over the network—before passing it to privileged components or parsing routines.

In the context of Zoom Workplace, the attack surface is significant:

  1. Attack Vector: Network-based (remote). The attacker does not require local access.
  2. Authentication: None required (unauthenticated). The vulnerability can be triggered before any user authentication or session establishment.
  3. User Interaction: Likely none or minimal. Improper input validation flaws in client-side software often trigger during meeting join attempts, chat message processing, or handling of malicious payloads embedded in shared content.
  4. Impact: Privilege Escalation. Successful exploitation allows the attacker to execute code or commands with elevated privileges—potentially SYSTEM or Administrator-level access depending on the Zoom service context.

While Zoom has not disclosed the exact technical mechanism (to prevent weaponization), the CWE-20 classification combined with the privilege escalation impact suggests the vulnerability likely exists in a service component or IPC handler that processes untrusted input without adequate validation, allowing an attacker to manipulate memory structures, inject malicious commands, or overwrite security tokens.

Exploitation Status

At the time of this writing, no public proof-of-concept (PoC) exploit code has been released, and there are no confirmed reports of in-the-wild exploitation. However, the window between patch release and exploit development for critical, unauthenticated vulnerabilities in ubiquitous software like Zoom is typically measured in days or weeks—not months. Threat actors reverse-engineer patches rapidly to identify the vulnerable code path.

Given the CVSS 9.6 score and the potential for remote privilege escalation without authentication, this vulnerability should be treated as exploitable in the near-term. It has not yet been added to the CISA Known Exploited Vulnerabilities (KEV) catalog, but organizations should monitor KEV and Zoom’s security bulletin for updates.


Detection & Response

SIGMA Rules

The following Sigma rules are designed to detect post-exploitation behaviors commonly associated with privilege escalation attacks leveraging CVE-2026-108186. These focus on detecting anomalous process relationships involving Zoom binaries and suspicious child process creation indicative of privilege escalation attempts.

YAML
---
title: Zoom Workplace Suspicious Child Process Execution
id: 8a7b9c1d-2e3f-4a5b-8c9d-1e2f3a4b5c6d
status: experimental
description: Detects suspicious child processes spawned by Zoom Workplace for Windows, potentially indicating exploitation of CVE-2026-108186 leading to privilege escalation.
references:
  - https://thehackernews.com/2026/11/critical-zoom-workplace-flaw-could.html
  - https://attack.mitre.org/techniques/T1068/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.privilege_escalation
  - attack.t1068
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    ParentImage|endswith:
      - '\Zoom.exe'
      - '\Zoom.exe.tmp'
      - '\CptHost.exe'
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\mshta.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\wmic.exe'
      - '\sc.exe'
      - '\net.exe'
      - '\net1.exe'
      - '\whoami.exe'
      - '\systeminfo.exe'
  condition: selection
falsepositives:
  - Legitimate Zoom updates may spawn installer processes
  - IT administrative scripts executed via Zoom chat (rare)
level: high
---
title: Zoom Process Execution from Unusual Directory
id: 9b8c7d6e-5f4a-3b2c-1d9e-8f7a6b5c4d3e
status: experimental
description: Detects execution of Zoom binaries from non-standard installation directories, which may indicate a malicious payload masquerading as Zoom or an attempt to execute a compromised binary from a temp location.
references:
  - https://thehackernews.com/2026/11/critical-zoom-workplace-flaw-could.html
  - https://attack.mitre.org/techniques/T1036/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.defense_evasion
  - attack.t1036
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    Image|contains:
      - 'Zoom.exe'
      - 'CptHost.exe'
    Image|not_contains:
      - ':\\Program Files\\Zoom\\'
      - ':\\Program Files (x86)\\Zoom\\'
      - ':\\Users\\*\\AppData\\Roaming\\Zoom\\'
  condition: selection
falsepositives:
  - Portable installations (rare in enterprise)
  - Developer testing environments
level: medium
---
title: Zoom Network Connection to Suspicious External IP
id: 7c6d5e4f-3a2b-1c9d-8e7f-6a5b4c3d2e1f
status: experimental
description: Detects Zoom processes establishing network connections to rare or known-bad external IP addresses, potentially indicating C2 communication following exploitation.
references:
  - https://thehackernews.com/2026/11/critical-zoom-workplace-flaw-could.html
  - https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/11/15
tags:
  - attack.command_and_control
  - attack.t1071
logsource:
  category: network_connection
  product: windows
detection:
  selection:
    Image|endswith:
      - '\Zoom.exe'
      - '\CptHost.exe'
    DestinationIp|cidr:
      - '10.0.0.0/8'
      - '172.16.0.0/12'
      - '192.168.0.0/16'
    DestinationIp|not_cidr:
      - '224.0.0.0/4'
      - '239.0.0.0/8'
  condition: selection
falsepositives:
  - Zoom traffic to private relay servers (verify internal Zoom infrastructure)
  - Split-tunnel VPN configurations
level: medium

Microsoft Sentinel / Defender KQL

The following KQL queries are designed for Microsoft Sentinel and Defender for Endpoint to hunt for exploitation attempts and post-exploitation activity related to Zoom Workplace vulnerabilities.

Query 1: Hunt for Zoom spawning suspicious child processes (indicative of privilege escalation post-exploitation)

KQL — Microsoft Sentinel / Defender
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName =~ "Zoom.exe" or InitiatingProcessFileName =~ "CptHost.exe"
| where FileName in~ (
    "cmd.exe", "powershell.exe", "pwsh.exe", "rundll32.exe", 
    "regsvr32.exe", "mshta.exe", "wscript.exe", "cscript.exe",
    "wmic.exe", "sc.exe", "net.exe", "net1.exe", "whoami.exe",
    "systeminfo.exe", "nltest.exe", "dsquery.exe"
)
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, 
          FileName, ProcessCommandLine, SHA256, FolderPath
| order by TimeGenerated desc

Query 2: Hunt for Zoom processes executing from anomalous paths (potential masquerading)

KQL — Microsoft Sentinel / Defender
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where FileName =~ "Zoom.exe" or FileName =~ "CptHost.exe"
| where FolderPath !contains "Program Files" 
    and FolderPath !contains "AppData\\Roaming\\Zoom"
    and FolderPath !contains "Downloads"
| project TimeGenerated, DeviceName, AccountName, FileName, 
          FolderPath, ProcessCommandLine, SHA256
| order by TimeGenerated desc

Query 3: Network connections from Zoom to non-Microsoft/Zoom infrastructure (C2 detection)

KQL — Microsoft Sentinel / Defender
DeviceNetworkEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName =~ "Zoom.exe" or InitiatingProcessFileName =~ "CptHost.exe"
| where RemoteIP !startswith "10." and RemoteIP !startswith "192.168." and RemoteIP !startswith "172.16."
| where RemoteIP !contains "zoom.us" and RemoteIP !contains "cloudfront.net" // Add known Zoom CDN ranges if available
| summarize ConnectionCount = count(), DistinctIPs = dcount(RemoteIP) by DeviceName, AccountName, RemoteIP, RemotePort
| where DistinctIPs > 5 or ConnectionCount > 100
| order by ConnectionCount desc

Velociraptor VQL

The following VQL artifact can be deployed across Windows endpoints to hunt for indicators of compromise related to CVE-2026-108186 exploitation, focusing on process execution anomalies and suspicious child processes.

VQL — Velociraptor
-- Hunt for Zoom processes spawning suspicious child processes (Privilege Escalation Indicators)
SELECT 
    Pid,
    Name,
    CommandLine,
    Exe,
    Username,
    CreateTime,
    ParentPid,
    (SELECT Name FROM pslist(pid=ParentPid)) as ParentName,
    (SELECT Exe FROM pslist(pid=ParentPid)) as ParentPath
FROM pslist()
WHERE (ParentName =~ '(?i)Zoom\.exe|CptHost\.exe')
  AND (Name =~ '(?i)cmd\.exe|powershell\.exe|pwsh\.exe|rundll32\.exe|regsvr32\.exe|mshta\.exe|wscript\.exe|cscript\.exe|wmic\.exe|sc\.exe|net\.exe|net1\.exe|whoami\.exe|systeminfo\.exe')
ORDER BY CreateTime DESC

Additional VQL for Zoom binary integrity verification:

VQL — Velociraptor
-- Enumerate all running Zoom processes and check their installation paths
SELECT 
    Pid,
    Name,
    Exe,
    CommandLine,
    Username,
    CreateTime
FROM pslist()
WHERE Name =~ '(?i)Zoom\.exe|CptHost\.exe'
  AND NOT Exe =~ '(?i)Program Files|AppData\\\\Roaming\\\\Zoom'

PowerShell Remediation & Verification Script

The following PowerShell script can be deployed via your RMM, SCCM, or Group Policy to identify vulnerable Zoom installations and verify patch status.

PowerShell
# Zoom Workplace CVE-2026-108186 Detection and Remediation Verification Script
# Run with administrative privileges

$ErrorActionPreference = "SilentlyContinue"

function Get-ZoomInstallations {
    $zoomPaths = @()
    
    # Standard installation paths
    $paths = @(
        "${env:ProgramFiles}\Zoom\bin\Zoom.exe",
        "${env:ProgramFiles(x86)}\Zoom\bin\Zoom.exe",
        "${env:LOCALAPPDATA}\Zoom\bin\Zoom.exe",
        "${env:APPDATA}\Zoom\bin\Zoom.exe"
    )
    
    foreach ($path in $paths) {
        if (Test-Path $path) {
            $zoomPaths += $path
        }
    }
    
    # Also check registry for uninstall strings to find non-standard installs
    $uninstallKeys = @(
        "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
        "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
        "HKCU:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*"
    )
    
    foreach ($keyPath in $uninstallKeys) {
        $keys = Get-ItemProperty $keyPath | Where-Object { $_.DisplayName -like "*Zoom*" }
        foreach ($key in $keys) {
            if ($key.InstallLocation) {
                $potentialPath = Join-Path $key.InstallLocation "bin\Zoom.exe"
                if (Test-Path $potentialPath) {
                    $zoomPaths += $potentialPath
                }
            }
        }
    }
    
    return $zoomPaths | Select-Object -Unique
}

function Get-FileVersionInfo {
    param($FilePath)
    try {
        $versionInfo = [System.Diagnostics.FileVersionInfo]::GetVersionInfo($FilePath)
        return @{
            Path = $FilePath
            Version = $versionInfo.FileVersion
            ProductVersion = $versionInfo.ProductVersion
            IsVulnerable = $false  # Will be set based on version check
        }
    } catch {
        return @{
            Path = $FilePath
            Version = "Unknown"
            ProductVersion = "Unknown"
            IsVulnerable = $true
        }
    }
}

# Main execution
Write-Host "[+] Scanning for Zoom Workplace installations..." -ForegroundColor Cyan
$installations = Get-ZoomInstallations

if ($installations.Count -eq 0) {
    Write-Host "[-] No Zoom installations found on this system." -ForegroundColor Yellow
    exit 0
}

Write-Host "[+] Found $($installations.Count) Zoom installation(s):" -ForegroundColor Green

$vulnerableSystems = @()
$patchedSystems = @()

foreach ($install in $installations) {
    $info = Get-FileVersionInfo -FilePath $install
    
    # Version check - Note: Replace with actual patched version when Zoom releases specific version info
    # For now, flag all versions for manual verification or check for latest update date
    $fileInfo = Get-Item $install
    $lastWrite = $fileInfo.LastWriteTime
    $daysSinceUpdate = (New-TimeSpan -Start $lastWrite -End (Get-Date)).Days
    
    # If Zoom hasn't been updated in the last 7 days, flag it as potentially vulnerable
    if ($daysSinceUpdate -gt 7) {
        $info.IsVulnerable = $true
        $vulnerableSystems += $info
        Write-Host "  [!] VULNERABLE: $($info.Path) - Version: $($info.Version), Last Updated: $lastWrite" -ForegroundColor Red
    } else {
        $patchedSystems += $info
        Write-Host "  [+] Recently Updated: $($info.Path) - Version: $($info.Version), Last Updated: $lastWrite" -ForegroundColor Green
    }
}

# Check for suspicious child processes (requires admin)
Write-Host "`n[+] Checking for suspicious Zoom child processes (last 24 hours)..." -ForegroundColor Cyan
$suspiciousParents = @("Zoom.exe", "CptHost.exe")
$suspiciousChildren = @("cmd.exe", "powershell.exe", "pwsh.exe", "rundll32.exe", "regsvr32.exe", "mshta.exe")

$events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4688; StartTime=(Get-Date).AddDays(-1)} | 
    Where-Object { $_.Message -match ($suspiciousParents -join "|") }

if ($events) {
    Write-Host "  [!] Found potential suspicious process execution events. Review Security Event Log 4688 for details." -ForegroundColor Red
} else {
    Write-Host "  [+] No suspicious child processes detected in last 24 hours." -ForegroundColor Green
}

# Summary and Remediation Recommendations
Write-Host "`n[+] SUMMARY" -ForegroundColor Cyan
Write-Host "  Total Zoom Installations: $($installations.Count)" -ForegroundColor White
Write-Host "  Potentially Vulnerable: $($vulnerableSystems.Count)" -ForegroundColor $(if ($vulnerableSystems.Count -gt 0) { "Red" } else { "Green" })
Write-Host "  Recently Updated: $($patchedSystems.Count)" -ForegroundColor Green

if ($vulnerableSystems.Count -gt 0) {
    Write-Host "`n[!] ACTION REQUIRED: Update Zoom Workplace immediately to the latest version." -ForegroundColor Red
    Write-Host "    Download from: https://zoom.us/download" -ForegroundColor Yellow
    Write-Host "    Or deploy via enterprise software management tools." -ForegroundColor Yellow
}

# Check if auto-update is enabled (registry check)
$autoUpdatePath = "HKLM:\SOFTWARE\Policies\Zoom\Zoom Meetings\General"
$autoUpdateEnabled = Get-ItemProperty -Path $autoUpdatePath -Name "EnableAutoUpdate" -ErrorAction SilentlyContinue

if (-not $autoUpdateEnabled) {
    Write-Host "`n[!] WARNING: Zoom Auto-Update policy not enforced via Group Policy." -ForegroundColor Yellow
    Write-Host "    Consider enabling: Computer Configuration > Administrative Templates > Zoom > General > Enable Auto Update" -ForegroundColor Yellow
}

Write-Host "`n[+] Script execution completed." -ForegroundColor Cyan

Remediation

Immediate Actions (Next 24-48 Hours)

  1. Patch Immediately: Update Zoom Workplace for Windows to the latest version available from the Zoom Download Center or via your enterprise software deployment mechanism (SCCM, Intune, WSUS, etc.). Ensure you are running a version released after November 2025 that explicitly addresses CVE-2026-108186.

  2. Verify Patch Deployment: Use the PowerShell script provided above to inventory Zoom installations across your environment and verify update status. Do not assume automatic updates have applied—many enterprise environments disable auto-updates to control change management.

  3. Enable Auto-Updates: If not already enforced, enable Zoom’s automatic update mechanism via Group Policy or registry settings to reduce the window of exposure for future vulnerabilities:

    • Registry: HKLM\SOFTWARE\Policies\Zoom\Zoom Meetings\General\EnableAutoUpdate = 1
    • Group Policy: Computer Configuration > Administrative Templates > Zoom > General > Enable Auto Update

Compensating Controls (If Patching is Delayed)

If you cannot patch immediately due to change control freezes or compatibility testing requirements, implement the following compensating controls:

  1. Network Segmentation: Isolate systems running Zoom Workplace from critical infrastructure. Restrict outbound internet access from Zoom clients to only necessary Zoom infrastructure (zoom.us, zoom.com, and associated CDN endpoints).

  2. Application Control: Implement application whitelisting (AppLocker, Windows Defender Application Control) to prevent Zoom from spawning unauthorized child processes. Block Zoom.exe from executing scripting engines (powershell.exe, cmd.exe, wscript.exe, etc.).

  3. Enhanced Monitoring: Deploy the Sigma rules and KQL queries provided in this article to your SIEM. Create high-priority alerts for:

    • Zoom spawning command shells or script interpreters
    • Zoom processes executing from temp or user-writable directories
    • Unusual network destinations from Zoom processes
  4. User Awareness: Alert users to the risk of joining Zoom meetings from untrusted sources or clicking links in Zoom chat from unknown senders. While the vulnerability is unauthenticated, social engineering may be used to lure users into exploitation scenarios.

Long-Term Hardening

  1. Privileged Access Management: Ensure Zoom clients are not running with administrative privileges unless absolutely necessary. Standard user contexts reduce the impact of privilege escalation exploits.

  2. Endpoint Detection and Response (EDR): Ensure EDR sensors are deployed on all Windows endpoints with Zoom installed. Configure custom detection rules for suspicious parent-child process relationships involving collaboration software.

  3. Vulnerability Management Program: Add Zoom Workplace to your critical asset inventory. Subscribe to Zoom’s security bulletin notifications to receive immediate alerts for future vulnerabilities.

Official References


Related Resources

Security Arsenal Managed SOC Services AlertMonitor Platform Book a SOC Assessment soc-mdr Intel Hub

Is your security operations ready?

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