A newly disclosed, currently unpatched technique dubbed FastUnlock allows anyone with physical access to a locked Windows workstation to launch programs without ever authenticating. The research was published by a researcher operating under the handles MSNightmare / Nightmare Eclipse and has been analyzed by endpoint-security firm ThreatLocker. The good news — and it is meaningful — is that code executed through FastUnlock runs in the context of a limited user account, not SYSTEM or an administrator. The bad news: limited-user code execution on a locked machine is still an unacceptable foothold for data theft, staging, persistence, and lateral-movement preparation.
As of this writing there is no CVE assigned and no vendor patch. That puts the burden squarely on defenders: detection engineering, physical-access controls, and lock-surface hardening are your only compensating controls until Microsoft ships a fix. This post gives you the practical playbook.
Why Defenders Should Care
Lock-screen bypasses are a recurring class of physical-access attack, and they matter most in exactly the environments where physical access is easiest to get:
- Shared or open-floor offices, reception areas, and hot-desking environments
- Healthcare and retail floors with workstations in semi-public areas
- Insider-threat scenarios, where a disgruntled employee doesn't need to defeat your perimeter — they just walk up to a colleague's locked machine
- Tailgating and "evil maid" scenarios targeting executives and traveling staff
The limited-user constraint reduces — but does not eliminate — impact. From a limited context an attacker can still read user-accessible files, enumerate the environment, execute living-off-the-land binaries, exfiltrate data to removable media or over the network, drop persistence that activates on the next legitimate logon, and interact with anything the interactive user can reach. If the locked session belongs to a privileged user, the blast radius grows accordingly.
Technical Analysis
What We Know
- Affected platform: Locked Windows workstations (the technique targets the Windows lock/logon UI surface).
- Attack vector: Physical access to a machine in a locked state. No credentials required.
- Result: Arbitrary program execution in a limited (non-administrative) account context without unlocking the session.
- Status: Unpatched, no CVE assigned at time of disclosure. Publicly documented by the researcher, which means the technique is now available to anyone — including red teamers, pen testers, and opportunistic insiders.
- Exploitation status: Technique is public and reproducible from the researcher's disclosure. There are no confirmed widespread in-the-wild campaigns at this time, and it has not been added to the CISA KEV catalog. Treat it as an available capability, not a theoretical one.
Why the Lock Screen Keeps Failing as a Trust Boundary
Historically, this attack class has exploited the UI surface that must remain reachable from the lock screen: accessibility tools (Utilman, On-Screen Keyboard, Narrator, Sticky Keys), input method editors, voice assistants, and UI automation. While the specific FastUnlock mechanics differ, the defensive lesson is consistent — any interactive element rendered before authentication is attack surface, and child processes spawned out of the pre-authentication context are high-fidelity detection signals. Processes unexpectedly parented by LogonUI.exe, winlogon.exe child processes launching user-context tooling at the lock screen, or accessibility binaries spawning non-system children are all behaviors worth hunting.
Detection & Response
Because there is no patch, your detections are your mitigation. The following analytics target the observable behavior class: unexpected process execution in a pre-authentication or locked-session context, and abuse of accessibility/logon-UI components — the canonical mechanics of lock-screen bypasses.
---
title: Process Spawned From Windows Logon UI Context
id: 6f2b1a44-9c3d-4e81-b5f2-7d8a9c0e1f23
status: experimental
description: Detects processes spawned by LogonUI.exe or from the pre-authentication logon surface, consistent with lock-screen bypass techniques such as FastUnlock that execute programs without signing in.
references:
- https://thehackernews.com/2026/11/new-unpatched-windows-0-day-fastunlock.html
- https://attack.mitre.org/techniques/T1546/008/
author: Security Arsenal
date: 2026/11/20
tags:
- attack.privilege_escalation
- attack.t1546.008
logsource:
category: process_creation
product: windows
detection:
selection_parent:
ParentImage|endswith:
- '\LogonUI.exe'
- '\Utilman.exe'
- '\osk.exe'
- '\Narrator.exe'
- '\Magnify.exe'
- '\sethc.exe'
filter_legit:
Image|endswith:
- '\osk.exe'
- '\Narrator.exe'
- '\Magnify.exe'
condition: selection_parent and not filter_legit
falsepositives:
- Rare legitimate accessibility tool chains on assistive-technology-configured systems
level: high
---
title: Command Shell or Scripting Engine Executed Outside Authenticated Session
id: 8c4e2b17-3a5f-4d90-a6c1-2e7b8d9f0a34
status: experimental
description: Detects command interpreters and scripting engines spawned by system-level parents during locked/pre-logon states, a hallmark of interactive code execution achieved via lock-screen bypass.
references:
- https://thehackernews.com/2026/11/new-unpatched-windows-0-day-fastunlock.html
- https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/11/20
tags:
- attack.execution
- attack.t1059
logsource:
category: process_creation
product: windows
detection:
selection_shell:
Image|endswith:
- '\cmd.exe'
- '\powershell.exe'
- '\pwsh.exe'
- '\wscript.exe'
- '\cscript.exe'
- '\mshta.exe'
- '\rundll32.exe'
selection_parent:
ParentImage|endswith:
- '\LogonUI.exe'
- '\winlogon.exe'
- '\Utilman.exe'
- '\sethc.exe'
condition: selection_shell and selection_parent
falsepositives:
- Logon scripts during interactive sign-in (winlogon parent) — tune with user and workstation context
level: critical
---
title: Accessibility Binary Replaced or Reconfigured for Persistence
id: 2d7f3e90-6b1c-4a58-b9d4-5f8e0a2c7b15
status: experimental
description: Detects file writes or Image File Execution Options debugger registrations targeting accessibility binaries, a common persistence companion technique used after achieving lock-screen code execution.
references:
- https://attack.mitre.org/techniques/T1546/008/
author: Security Arsenal
date: 2026/11/20
tags:
- attack.persistence
- attack.privilege_escalation
- attack.t1546.008
logsource:
category: registry_set
product: windows
detection:
selection:
TargetObject|contains:
- 'Image File Execution Options\\sethc.exe'
- 'Image File Execution Options\\utilman.exe'
- 'Image File Execution Options\\osk.exe'
- 'Image File Execution Options\\Narrator.exe'
- 'Image File Execution Options\\Magnify.exe'
Details|contains: 'Debugger'
falsepositives:
- Legitimate assistive-technology debugging in accessibility development environments
level: high
// Hunt for process execution from the pre-authentication / lock-screen surface
// Correlate with session lock events where available
let LockSurfaceParents = dynamic(["LogonUI.exe", "Utilman.exe", "osk.exe", "Narrator.exe", "Magnify.exe", "sethc.exe"]);
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where InitiatingProcessFileName in~ (LockSurfaceParents)
| where FileName !in~ ("osk.exe", "Narrator.exe", "Magnify.exe")
| project TimeGenerated, DeviceName, FileName, ProcessCommandLine,
InitiatingProcessFileName, AccountName, InitiatingProcessId,
SHA256, FolderPath
| sort by TimeGenerated desc
// Defender XDR variant: cross-reference with logon/lock events to confirm pre-authentication execution
DeviceLogonEvents
| where TimeGenerated > ago(7d)
| where LogonType == "Interactive"
| summarize LastLogon = max(TimeGenerated) by DeviceName, AccountName
| join kind=inner (
DeviceProcessEvents
| where InitiatingProcessFileName =~ "LogonUI.exe"
) on DeviceName
| where TimeGenerated < LastLogon or isempty(LastLogon)
| project TimeGenerated, DeviceName, FileName, ProcessCommandLine, AccountName, LastLogon
-- FastUnlock triage: enumerate processes parented by the logon/lock surface
-- Run fleet-wide to identify unauthorized pre-authentication execution
SELECT Pid, Ppid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Ppid IN (
SELECT Pid FROM pslist()
WHERE Name =~ '(?i)(LogonUI|Utilman|osk|Narrator|Magnify|sethc)\.exe'
)
AND Name !~ '(?i)(osk|Narrator|Magnify)\.exe'
-- Check for IFEO debugger persistence on accessibility binaries
SELECT Key.Name AS IFEOEntry, Key.Path, Mtime
FROM glob(globs='HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\*\\Debugger',
accessor='registry')
WHERE Key.Name =~ '(?i)(sethc|utilman|osk|narrator|magnify)'
Tuning Guidance
These analytics are intentionally parent-process anchored. In a well-managed fleet, LogonUI.exe spawning anything other than accessibility tooling is nearly always anomalous. Expect a small tail of false positives from assistive-technology configurations and certain kiosk software — build an allowlist per-OU rather than disabling the rule.
Remediation & Hardening
No patch exists today, so mitigation is defense-in-depth. Apply the following in priority order.
1. Application Control at the Lock Surface
This is the single most effective compensating control — and notably the angle ThreatLocker's analysis emphasizes. Use application allowlisting (AppLocker or WDAC) to restrict what can execute in the pre-authentication context. If an attacker can invoke a UI element but the resulting binary is blocked by policy, the technique fails closed.
2. Reduce the Physical Attack Window
- Enforce aggressive auto-lock: screensaver/GPO lock at 5 minutes or less in open environments, with Dynamic Lock (Bluetooth proximity) enabled for mobile users.
- Deploy cable locks in semi-public areas; prohibit unattended laptops in common spaces by policy.
- Enable BitLocker with TPM+PIN on all endpoints — it doesn't stop FastUnlock, but it ensures the powered-off state remains a hard boundary, shrinking the window to locked-but-running machines.
3. Harden the Logon Surface
# FastUnlock compensating controls - run elevated, verify in a pilot OU first
# 1. Disable voice assistant and consumer features on the lock screen
Set-ItemProperty -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\Personalization' `
-Name 'NoLockScreenCamera' -Value 1 -Force
New-Item -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\System' -Force | Out-Null
Set-ItemProperty -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\System' `
-Name 'AllowDomainPINLogon' -Value 0 -Force
# 2. Disable Cortana/voice activation above the lock screen
New-Item -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\Windows Search' -Force | Out-Null
Set-ItemProperty -Path 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\Windows Search' `
-Name 'AllowCortanaAboveLock' -Value 0 -Force
# 3. Verify accessibility binaries are untampered (compare against known-good hashes)
$targets = @('sethc.exe','utilman.exe','osk.exe','Narrator.exe','Magnify.exe')
foreach ($t in $targets) {
$p = "$env:SystemRoot\System32\$t"
if (Test-Path $p) {
$sig = Get-AuthenticodeSignature $p
Write-Output "$p : $($sig.Status) : $((Get-FileHash $p -Algorithm SHA256).Hash)"
}
}
# 4. Audit IFEO keys for debugger-based persistence
Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options' |
Where-Object { $_.Property -contains 'Debugger' } |
ForEach-Object { Write-Warning "IFEO Debugger set: $($_.PSChildName)" }
# 5. Confirm machine-inactivity lock is enforced
Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System' `
-Name 'InactivityTimeoutSecs' -ErrorAction SilentlyContinue
4. Detect at the Identity Layer
Alert on interactive logons from unexpected physical consoles and on sessions that show process activity without a preceding logon event — the VQL and KQL above give you the endpoint view; your SIEM correlation gives you the timeline anomaly.
5. Monitor for the Patch
Track Microsoft's Security Update Guide and the original ThreatLocker/researcher disclosure for a CVE assignment and patch. Once assigned, fast-track it through your vulnerability management workflow — physical-access bugs get deprioritized by risk-scoring models that overweight network vectors; don't let yours do that for endpoints in public-facing areas.
Bottom Line
FastUnlock is a limited-context execution primitive, not a full compromise — but "limited" is doing a lot of work in that sentence. On a locked executive workstation, limited-user execution is plenty. Until a patch ships, your controls are: application allowlisting, tight auto-lock, tamper verification of accessibility binaries, and the parent-process detections above. Lock screens are a convenience boundary; make your compensating controls the real one.
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.