Back to Intelligence

CVE-2026-124194: Outlook 'Missing User Interaction' Vulnerability Under Active Exploitation — Detection and Remediation Guide

SA
Security Arsenal Team
November 10, 2026
10 min read

CISA has added CVE-2026-124194 to its Known Exploited Vulnerabilities (KEV) catalog, confirming what many of us in IR have suspected since telemetry first surfaced: threat actors are actively weaponizing a Microsoft Office Outlook vulnerability that allows a potentially unsafe action to execute without any user interaction. If your organization runs Outlook — and statistically, it does — this is a patch-and-hunt-now event, not a patch-next-cycle event.

Every KEV addition carries an implicit message: adversaries have already done the cost-benefit analysis, and this bug passed. The 'missing user interaction' classification is particularly dangerous because it removes the last fragile control most organizations depend on — the user deciding not to click.

Technical Analysis

What We Know

  • CVE ID: CVE-2026-124194
  • Affected product: Microsoft Office Outlook (Microsoft 365 Apps and supported perpetual Office editions — verify your specific channel against the Microsoft Security Update Guide entry for this CVE)
  • Vulnerability class: Missing user interaction for a potentially unsafe action
  • Exploitation status: Confirmed active exploitation — listed in the CISA KEV catalog (KEV entry)

Why This Bug Class Matters

A 'missing user interaction for potentially unsafe action' flaw means Outlook will perform a security-relevant operation — typically processing attacker-controlled content embedded in a crafted email — without prompting the user or requiring a click. In practical terms, exploitation typically follows this chain:

  1. Delivery: Attacker sends a specially crafted email to the target. No attachment needs to be opened; the message body or its embedded content is the weapon.
  2. Trigger: Outlook processes the message — during receipt, synchronization, or rendering (including preview-pane scenarios). The unsafe action fires without any user gesture.
  3. Execution: Depending on the attacker's payload, this can chain into code execution, credential/NTLM hash leakage to attacker infrastructure, or retrieval of second-stage payloads.
  4. Post-exploitation: Typical follow-on behaviors we hunt for in these engagements include OUTLOOK.EXE spawning unexpected child processes, Office processes writing executables or scripts to user-writable directories, and outbound connections from Office processes to non-Microsoft infrastructure.

The critical defender takeaway: email-gateway filtering and user awareness training do not stop this class of attack. The exploit path bypasses the human layer entirely. Endpoint visibility and patching are your primary controls.

Exploitation Requirements

From a defender's modeling perspective, assume:

  • No user interaction required beyond the message reaching the mailbox and being processed by Outlook.
  • Attack surface: Any Outlook client syncing mail — including Cached Exchange Mode clients and clients that render HTML email.
  • Likely targets: Organizations with large attack surface via inbound email — legal, finance, government, healthcare, and executive mailboxes.

Detection & Response

The detections below focus on the highest-fidelity behavioral indicators for this exploit class: Office/Outlook spawning child processes it never legitimately spawns, Office processes dropping executable content, and anomalous network egress from Outlook. Tune allowlists to your environment, but deploy these broadly — they are low-noise by design.

Sigma Rules

YAML
---
title: Outlook Spawning Suspicious Child Process (Possible CVE-2026-124194 Exploitation)
id: 8c2e4f61-3b7a-4d29-9e15-6a1c9d4e2f07
status: experimental
description: Detects OUTLOOK.EXE spawning script interpreters, shells, or LOLBins — behavior consistent with post-exploitation following a no-user-interaction Outlook exploit such as CVE-2026-124194.
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2026-124194
  - https://attack.mitre.org/techniques/T1203/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.execution
  - attack.t1203
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith: '\OUTLOOK.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'
      - '\curl.exe'
      - '\msiexec.exe'
      - '\wmic.exe'
  condition: selection_parent and selection_child
falsepositives:
  - Rare — some CRM or add-in integrations may shell out; investigate any hit rather than blanket-excluding
level: high
---
title: Office Process Writing Executable or Script Content to User Directories
id: 2f7a9c34-6e1d-4b85-a392-5d8e1f6c0a43
status: experimental
description: Detects Outlook or other Office processes dropping executables, scripts, or DLLs into user-writable staging directories — consistent with second-stage payload delivery after exploitation of an email-borne Office flaw such as CVE-2026-124194.
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2026-124194
  - https://attack.mitre.org/techniques/T1105/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.command_and_control
  - attack.t1105
logsource:
  category: file_event
  product: windows
detection:
  selection_image:
    Image|endswith:
      - '\OUTLOOK.EXE'
      - '\WINWORD.EXE'
      - '\EXCEL.EXE'
      - '\POWERPNT.EXE'
  selection_path:
    TargetFilename|contains:
      - '\AppData\Local\Temp\'
      - '\AppData\Roaming\'
      - '\Users\Public\'
      - '\ProgramData\'
  selection_ext:
    TargetFilename|endswith:
      - '.exe'
      - '.dll'
      - '.ps1'
      - '.bat'
      - '.cmd'
      - '.vbs'
      - '.js'
      - '.hta'
      - '.scr'
  condition: selection_image and selection_path and selection_ext
falsepositives:
  - Legitimate Office add-in updates (typically signed and in predictable vendor paths — exclude per-vendor, not per-extension)
level: high
---
title: Outlook Outbound Connection to Rare External Destination
id: 5b1d8e90-4c3f-47a6-b218-9e6d2a5c7f18
status: experimental
description: Detects OUTLOOK.EXE establishing outbound connections to non-mail-server destinations on uncommon ports. Exploitation chains for no-click Outlook vulnerabilities often beacon or retrieve payloads from attacker infrastructure distinct from Exchange/Microsoft 365 endpoints.
references:
  - https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2026-124194
  - https://attack.mitre.org/techniques/T1071/
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.command_and_control
  - attack.t1071
logsource:
  category: network_connection
  product: windows
detection:
  selection:
    Image|endswith: '\OUTLOOK.EXE'
    Initiated: 'true'
  filter_ports:
    DestinationPort:
      - 25
      - 80
      - 443
      - 587
      - 993
      - 995
  filter_m365:
    DestinationHostname|endswith:
      - '.outlook.com'
      - '.office365.com'
      - '.microsoftonline.com'
      - '.outlook.office.com'
  condition: selection and not 1 of filter_*
falsepositives:
  - Environments with on-premises Exchange or third-party mail gateways — add those hostnames/IPs to the filter
level: medium

KQL (Microsoft Sentinel / Defender)

This hunt joins the two highest-signal behaviors: Outlook spawning a suspicious child process, and that same host subsequently showing Office-initiated network egress or file drops within a short window. Run it across the last 14 days first; if you get hits, pivot to full IR scoping on those devices and the mailbox owners.

KQL — Microsoft Sentinel / Defender
let lookback = 14d;
let suspiciousChildren = dynamic(["cmd.exe","powershell.exe","pwsh.exe","wscript.exe","cscript.exe","mshta.exe","rundll32.exe","regsvr32.exe","certutil.exe","bitsadmin.exe","msiexec.exe","wmic.exe","curl.exe"]);
let outlookSpawn =
    DeviceProcessEvents
    | where TimeGenerated > ago(lookback)
    | where InitiatingProcessFileName =~ "OUTLOOK.EXE"
    | where FileName in~ (suspiciousChildren)
    | project DeviceId, DeviceName, SpawnTime=TimeGenerated, ChildProcess=FileName, ChildCmd=ProcessCommandLine, AccountName, InitiatingProcessCommandLine;
let officeNet =
    DeviceNetworkEvents
    | where TimeGenerated > ago(lookback)
    | where InitiatingProcessFileName =~ "OUTLOOK.EXE"
    | where RemotePort !in (25, 80, 443, 587, 993, 995)
    | where RemoteUrl !endswith "outlook.com" and RemoteUrl !endswith "office365.com" and RemoteUrl !endswith "microsoftonline.com"
    | project DeviceId, NetTime=TimeGenerated, RemoteUrl, RemoteIP, RemotePort;
outlookSpawn
| join kind=leftouter officeNet on DeviceId
| extend NetWithinWindow = iff(isnotempty(NetTime) and NetTime between (SpawnTime .. SpawnTime + 30m), "Yes", "No")
| project DeviceName, AccountName, SpawnTime, ChildProcess, ChildCmd, RemoteUrl, RemoteIP, RemotePort, NetWithinWindow
| order by SpawnTime desc;

If you ingest Sysmon via SecurityEvent or CEF, adapt the process-creation logic to SecurityEvent (EventID 4688) or CommonSecurityLog — the parent/child pairing is the detection, not the telemetry source.

Velociraptor VQL

Use this artifact for fleet-wide scoping when you need to identify any host where Outlook spawned a script interpreter or shell — useful for retro-hunts during IR triage and for validating patch urgency to leadership with hard numbers.

VQL — Velociraptor
-- CVE-2026-124194 hunt: Outlook spawning suspicious child processes
-- Scope fleet-wide; any hit warrants immediate triage of the endpoint and mailbox
LET suspicious_children = ('cmd.exe', 'powershell.exe', 'pwsh.exe', 'wscript.exe',
                           'cscript.exe', 'mshta.exe', 'rundll32.exe', 'regsvr32.exe',
                           'certutil.exe', 'bitsadmin.exe', 'msiexec.exe', 'wmic.exe', 'curl.exe')

SELECT Pid,
       Ppid,
       Name AS ChildProcess,
       CommandLine AS ChildCommandLine,
       Exe AS ChildPath,
       Username,
       CreateTime AS ProcessStartTime
FROM pslist()
WHERE Name =~ '(?i)^(' + join(array=suspicious_children, sep='|') + ')$'
  AND Ppid IN (
        SELECT Pid FROM pslist()
        WHERE Name =~ '(?i)OUTLOOK\.EXE$'
      )

Remediation & Verification Script (PowerShell)

Use this to inventory Office build levels and confirm Click-to-Run update state across endpoints (run via your RMM/Intune/SCCM). It does not replace patching — it tells you who is still exposed and whether update channels are functioning. Cross-reference detected builds against the fixed builds listed in the Microsoft Security Update Guide entry for CVE-2026-124194.

PowerShell
# CVE-2026-124194 - Outlook exposure inventory and update verification
# Run as SYSTEM/Administrator via RMM, Intune, or SCCM

$report = [ordered]@{}

# 1. Detect installed Office Click-to-Run version
$c2rPath = 'HKLM:\SOFTWARE\Microsoft\Office\ClickToRun\Configuration'
if (Test-Path $c2rPath) {
    $c2r = Get-ItemProperty -Path $c2rPath
    $report['OfficeVersion']      = $c2r.VersionToReport
    $report['UpdateChannel']      = $c2r.UpdateChannel
    $report['UpdatesEnabled']     = $c2r.UpdatesEnabled
} else {
    # MSI-based Office fallback
    $report['OfficeVersion'] = 'MSI-based or not detected - check registry uninstall keys'
}

# 2. Confirm Outlook is present
$outlookExe = Get-ChildItem -Path "$env:ProgramFiles\Microsoft Office","${env:ProgramFiles(x86)}\Microsoft Office" `
    -Filter 'OUTLOOK.EXE' -Recurse -ErrorAction SilentlyContinue | Select-Object -First 1
$report['OutlookInstalled'] = [bool]$outlookExe
$report['OutlookPath']      = $outlookExe.FullName

# 3. Check pending Office updates
$pendingPath = 'HKLM:\SOFTWARE\Microsoft\Office\ClickToRun\Updates'
$report['PendingUpdate'] = (Test-Path $pendingPath)

# 4. Force an Office update check (Click-to-Run)
$officeC2RClient = "$env:ProgramFiles\Common Files\Microsoft Shared\ClickToRun\OfficeC2RClient.exe"
if (Test-Path $officeC2RClient) {
    Start-Process -FilePath $officeC2RClient -ArgumentList '/update user displaylevel=false forceappshutdown=true' -Wait -NoNewWindow
    $report['UpdateTriggered'] = $true
} else {
    $report['UpdateTriggered'] = $false
}

# 5. Hardening check: verify Protected View / attachment and preview hardening registry keys
$secKey = 'HKCU:\Software\Microsoft\Office\16.0\Outlook\Security'
if (Test-Path $secKey) {
    $report['OutlookSecurityKeys'] = Get-ItemProperty -Path $secKey | Out-String
}

$report | Format-List

Remediation

  1. Patch immediately. Apply the Microsoft security update addressing CVE-2026-124194 across all Outlook installations — Microsoft 365 Apps (all channels: Current, Monthly Enterprise, Semi-Annual), and supported perpetual editions (Office 2019/2021/2024 and LTSC where applicable). Obtain the exact fixed build numbers for your channel from the Microsoft Security Update Guide entry for CVE-2026-124194 — fixed builds differ per channel, and 'auto-update is on' is not evidence of remediation.
  2. Meet the CISA KEV deadline. Federal civilian agencies are bound by the BOD 22-01 due date on the KEV entry. Private-sector organizations should treat that same date as their internal SLA — CISA sets it based on observed exploitation tempo.
  3. Verify, don't assume. Use the script above (or your EDR's software inventory) to confirm every endpoint reports a build at or above the fixed version. Pay special attention to: laptops that have been offline, VDI gold images, shared workstations, and users who defer update restarts.
  4. Interim mitigations if patching is delayed:
    • Enforce reading mail in plain text where operationally feasible (reduces HTML-rendered attack surface).
    • Ensure Protected View and Application Guard for Office are enabled and not weakened by legacy GPO exceptions.
    • Tighten Attack Surface Reduction rules — specifically 'Block all Office applications from creating child processes' — which directly breaks the post-exploitation chain detected above. Pilot in audit mode first if you have legitimate Office add-in dependencies.
    • Block executable content types at the mail gateway and strip active content from inbound HTML mail where your platform supports it.
  5. Hunt before you close the ticket. KEV listing means exploitation predates your patch. Run the Sigma/KQL/VQL content above across at least 30 days of telemetry on any host that was unpatched after the CVE's public disclosure. A patched endpoint with a pre-existing implant is still compromised.
  6. Credential hygiene. Given the class of Outlook vulnerabilities historically abused for credential capture, if you find evidence of exploitation, force password resets for the affected mailbox users and review for anomalous mailbox rules, delegated access, and OAuth grants.

Final Thoughts

No-click email exploits are the apex predator of phishing-adjacent threats: they neutralize your awareness training, your banner warnings, and your users' skepticism in one stroke. The defenders who come out ahead on CVE-2026-124194 will be the ones who treat KEV addition as the start of an IR scoping exercise, not the end of a patching ticket. Patch fast, hunt back in time, and instrument Outlook child-process behavior permanently — this will not be the last vulnerability of its class.

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.