Daxin + Stupig — Pre-Login SYSTEM Backdoor Hunt
Executive Summary
Broadcom/Symantec's Threat Hunter team reported (2026-07-20) that Daxin — a China-attributed kernel-mode rootkit first documented in March 2022 and in use since ~2013 — was found still operational on a host at a Taiwan-based subsidiary of a multinational high-tech manufacturer. On the same host they recovered a previously undocumented backdoor they named Stupig. Both samples carry early-2013 compile timestamps, yet the host only began reporting telemetry in May 2026 — a possible 13-year undetected intrusion.
The standout novel TTP is Stupig's persistence. It ships as a malicious keyboard-layout DLL (a.dll / kbdus1.dll, masquerading as the legitimate kbdus.dll U.S. English layout). By registering as a keyboard-layout provider, it is loaded by win32k.sys into winlogon.exe at startup. It then watches the logon screen for a username beginning with stupig; any text after that prefix executes as SYSTEM on the secure desktop — before anyone signs in and without raising a logon audit event. The DLL returns a valid KBDTABLES pointer so Windows treats it as a real keyboard layout.
Daxin is a passive backdoor: it makes no outbound connections of its own. The kernel driver (srt64.sys) monitors incoming TCP traffic for specific magic patterns and hijacks existing legitimate connections for encrypted, multi-hop C2 — which is why beacon-hunting will never find it.
winlogon.exe for any non-standard module load (a keyboard-layout DLL loaded from outside System32, or any module named a.dll / kbdus1.dll / msyun.dll), and audit for the kernel driver srt64.sys. Because both the logon-screen execution and Daxin's passive C2 evade conventional auth and network telemetry, module-load and driver-load hunting is your highest-value angle — not netflow.
Source Review & Web Hunter Notes
Five sources fetched and snapshotted at research time (Daxin-Stupig-PreLogin-Hunt-sources/). The two SHA256 hashes are corroborated across three independent sources (Symantec appendix, GBHackers, Cyber Security News). The exact keyboard-layout registry key/value used for loading was not published in any source; that hunt angle is therefore represented behaviorally and with a labelled placeholder rather than an invented registry path.
| # | Source | Tier | Contributed |
|---|---|---|---|
| 1 | Symantec / security.com (primary) | T1 | Both SHA256 hashes, keyboard-layout persistence, T1547.004 relation, KBDTABLES, secure-desktop execution, passive TCP C2, Digiwin/JDK initial access |
| 2 | The Hacker News | T2 | win32k.sys → winlogon.exe load chain, masquerade as kbdus.dll, no-audit-event execution, 13-year timeline |
| 3 | GBHackers | T2 | Hash corroboration, %SystemRoot%\System32\drivers location, msyun.dll companion, detection dates |
| 4 | Cyber Security News | T2 | Hash corroboration, secure-desktop SYSTEM shell trigger, explicit "no registry path published" gap |
| 5 | Security Affairs | T2 | Passive-backdoor multi-hop routing, Digiwin SSO / EOL JDK 1.5-1.6 initial access, attribution context |
Layout File value name, network C2 indicators (Daxin is passive), or MD5 hashes. Those are handled as behavioral hunts / REPLACE_WITH_ placeholders.
Hunt Brief & Attack Chain
Hypotheses: (H1) If Stupig is present, a non-standard keyboard-layout DLL is loaded into winlogon.exe. (H2) If Daxin is present, the kernel driver srt64.sys is on disk in System32\drivers and/or loaded. (H3) The known sample hashes appear in process/module-load/file-write telemetry. (H4) A keyboard-layout or Winlogon-notify autostart registry value references a non-system DLL. (H5) Daxin's passive C2 will NOT appear as an outbound beacon — treat network silence as expected, not clean.
| Stage | Behavior | Artifact / Telemetry |
|---|---|---|
| Initial Access | Exploit outdated Digiwin SSO portal (EOL JDK 1.5/1.6) | Web-app exploitation; out of Falcon endpoint scope (app-tier logs) |
| Persistence (Stupig) | Register malicious keyboard-layout provider; win32k.sys loads DLL into winlogon.exe | Module load (ImageHash) into winlogon.exe; keyboard-layout ASEP registry |
| Persistence (Daxin) | Signed kernel driver srt64.sys installed to System32\drivers | Driver/module load; PeFileWritten of .sys |
| Priv-Esc / Execution | Username prefix "stupig" at logon → command runs as SYSTEM on secure desktop | Pre-auth; no logon audit event — hunt the loaded module, not the logon |
| C2 | Passive: monitor inbound TCP magic patterns; hijack legit connections; multi-hop | No outbound beacon; hunt driver presence + anomalous connection hijack (hypothesis) |
| Impact | Long-term stealthy espionage / credential theft | Credential access at logon screen |
Consolidated IOC Table
| Type | Value | Confidence | Action | Context |
|---|---|---|---|---|
| SHA256 | 49c827cf48efb122a9d6fd87b426482b7496ccd4a2dbca31ebbf6b2b80c98530 | high | detect | srt64.sys — Backdoor.Daxin |
| SHA256 | 5bb5cffda4647940919a185df37aab2aef71ca3010a6c1d05bdcc8bc8fb3af3f | high | detect | a.dll / kbdus1.dll — Backdoor.Stupig |
| Filename | srt64.sys | high | hunt | Daxin kernel driver (System32\drivers) |
| Filename | kbdus1.dll | high | hunt | Stupig keyboard-layout DLL (masquerades as kbdus.dll) |
| Filename | a.dll | medium | hunt | Stupig deployment name (generic — corroborate with load context) |
| Filename | msyun.dll | medium | hunt | Referenced Stupig companion module (not recovered) |
| Logon string | stupig (username prefix) | high | hunt | Typed at logon screen to trigger SYSTEM command execution |
| Path | %SystemRoot%\System32\drivers\srt64.sys | high | hunt | Daxin on-disk location |
| Baseline (benign) | kbdus.dll | n/a | enrich | Legit Microsoft U.S. English layout — the masquerade target |
| Network C2 | REPLACE_WITH_C2 (none published — passive backdoor) | n/a | pivot | Daxin makes no outbound connections; no atomic network IOC exists |
Affected Surface & Telemetry Matrix
| Surface | Telemetry | Priority | Gap |
|---|---|---|---|
| Windows endpoints (winlogon module loads) | ImageHash module-load events | Critical | None — primary hunt surface |
| Windows kernel drivers | Module/driver load + PeFileWritten | Critical | Driver-load event coverage varies by sensor policy — validate |
| Registry autostart (keyboard-layout / Winlogon\Notify) | AsepValueUpdate, RegGenericValueUpdate | High | Exact key not published; behavioral coverage only |
| Logon-screen command execution | None — pre-auth, no logon audit event | High | Blind spot — detect the module, not the logon |
| Network (passive C2) | NetworkConnectIP4 (hijacked legit sessions) | Low | No beacon; conventional netflow hunting ineffective |
| Digiwin SSO web tier | App/web logs (non-Falcon) | High | Endpoint sensor does not cover the exploited web app |
MITRE ATT&CK Mapping
| Tactic | Technique | Behavior | Query / Control |
|---|---|---|---|
| Initial Access | T1190 — Exploit Public-Facing App | Digiwin SSO portal on EOL JDK 1.5/1.6 | Patch/EOL audit (s12) |
| Persistence | T1547.004 — Boot/Logon Autostart: Winlogon Helper (related; novel keyboard-layout variant) | Malicious keyboard-layout provider loaded into winlogon.exe | Q1, Q4, Q5 |
| Defense Evasion | T1036.005 — Masquerading: Match Legitimate Name | kbdus1.dll poses as kbdus.dll; valid KBDTABLES | Q1, Q7 |
| Defense Evasion | T1014 — Rootkit | Signed kernel driver srt64.sys | Q3, Q6 |
| Persistence / Priv-Esc | T1543.003 — Create/Modify System Process: Windows Service (kernel driver) | srt64.sys loaded as kernel driver | Q3, Q6 |
| Execution | T1059 — Command & Scripting Interpreter (SYSTEM shell) | "stupig" prefix at logon → SYSTEM command on secure desktop | Q1 (detect the loaded module) |
| Command & Control | T1205 — Traffic Signaling (magic-pattern passive backdoor) | Monitors inbound TCP; hijacks legit connections | Hypothesis (s3, H5) |
| Command & Control | T1090.003 — Multi-hop Proxy | Chained C2 across infected hosts | Hypothesis (s3, H5) |
| Credential Access | T1556 — Modify Authentication Process | Pre-login credential theft from logon screen | Q1, hardening (s12) |
Native Audit-Log & Live-Response Hunts
Angles that do not require CQL — use where endpoint telemetry is thin or for live triage:
- Registered keyboard layouts (live-response / PowerShell): enumerate
HKLM\SYSTEM\CurrentControlSet\Control\Keyboard Layouts\*and inspect each subkey'sLayout Filevalue. Any value that is not a standardkbd*.dllshipped inSystem32— or that resolves to a file outsideSystem32— is suspect. Compare against a known-clean gold image. - winlogon.exe loaded modules: on a suspect host, list modules loaded by
winlogon.exe(e.g. Sysinternalslistdlls winlogon.exe) and flag any DLL outsideSystem32/SysWOW64, any unsigned module, or namesa.dll/kbdus1.dll/msyun.dll. - Kernel driver inventory: enumerate loaded drivers and
System32\drivers\*.sys; flagsrt64.sys, and more broadly any driver with a 2013-era compile timestamp that is unknown to your baseline. - Winlogon\Notify: review
HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Notifyfor unexpected DLL registrations (legacy notification-provider persistence). - Compile-timestamp sweep: Both samples show early-2013 timestamps. A modern host carrying a 2013-stamped driver/DLL in a system path is a strong anomaly worth manual review.
CrowdStrike LogScale CQL Hunt Queries
Looks for: a module named a.dll or kbdus1.dll loaded into the winlogon.exe process (correlates the module-load event to the winlogon process on the same host + PID). FP: legitimate keyboard layouts are named kbd*.dll and live in System32; a bare a.dll or kbdus1.dll in winlogon is not normal.
// HUNT: Stupig malicious keyboard-layout DLL in winlogon.exe - T1547.004 / T1036.005 // CONF: high FP: medium COST: medium | REQUIRES: module-load (ImageHash) + process telemetry // TUNING: baseline legit layouts (kbdus.dll, kbdusx.dll, kbd*.dll in System32); exclude vendor IME/keyboard software; investigate any non-kbd*.dll basename loaded by winlogon #event_simpleName=/^(ImageHash|ProcessRollup2|SyntheticProcessRollup2)$/ | selfJoinFilter(field=[aid, TargetProcessId], where=[ {#event_simpleName=/^(ProcessRollup2|SyntheticProcessRollup2)$/ | FileName=/^winlogon\.exe$/i}, {#event_simpleName=ImageHash | FileName=/^(a|kbdus1)\.dll$/i} ]) | groupBy([aid, ComputerName, TargetProcessId], function=collect([FileName, FilePath, SHA256HashData]), limit=200)
Looks for: either confirmed SHA256 across process, module-load, and file-write telemetry. Any hit is high-fidelity.
// HUNT: Daxin (srt64.sys) + Stupig (a.dll/kbdus1.dll) known hashes - T1014 / T1547.004 // CONF: high FP: low COST: low | REQUIRES: process / module-load / file-write telemetry #event_simpleName=/^(ProcessRollup2|SyntheticProcessRollup2|ImageHash|PeFileWritten|NewExecutableWritten)$/ | in(field=SHA256HashData, values=["49c827cf48efb122a9d6fd87b426482b7496ccd4a2dbca31ebbf6b2b80c98530","5bb5cffda4647940919a185df37aab2aef71ca3010a6c1d05bdcc8bc8fb3af3f"]) | groupBy([aid, ComputerName, SHA256HashData], function=[count(as=Hits), collect([FileName, FilePath])], limit=200) | sort(Hits, order=desc, limit=100)
Looks for: the driver basename srt64.sys in any module-load or file-write event. srt64.sys is not a standard Windows driver name.
// HUNT: Daxin rootkit driver srt64.sys - T1014 / T1543.003 // CONF: high FP: low COST: low | REQUIRES: module-load / file-write telemetry #event_simpleName=/^(ImageHash|PeFileWritten|NewExecutableWritten)$/ | FileName=/^srt64\.sys$/i | groupBy([aid, ComputerName], function=[count(as=Hits), collect([FilePath, SHA256HashData])], limit=200) | sort(Hits, order=desc, limit=100)
Looks for: generic version of Q1 — any DLL loaded by winlogon.exe whose path is outside System32/SysWOW64. Catches unknown future keyboard-layout / notify-provider variants, not just the named files. FP: some endpoint agents and smartcard/credential providers legitimately inject into winlogon — baseline first.
// HUNT: Anomalous module load in winlogon.exe (behavioral) - T1547.004 // CONF: medium FP: medium COST: medium | REQUIRES: module-load (ImageHash) + process telemetry // TUNING: baseline every DLL winlogon loads on a clean gold image; allowlist known credential/smartcard providers and EDR modules; alert only on paths outside System32/SysWOW64 or unsigned modules #event_simpleName=/^(ImageHash|ProcessRollup2|SyntheticProcessRollup2)$/ | selfJoinFilter(field=[aid, TargetProcessId], where=[ {#event_simpleName=/^(ProcessRollup2|SyntheticProcessRollup2)$/ | FileName=/^winlogon\.exe$/i}, {#event_simpleName=ImageHash | FileName=/\.dll$/i} ]) | FilePath!=/\\(System32|SysWOW64)\\/i | groupBy([aid, ComputerName], function=collect([FileName, FilePath, SHA256HashData]), limit=200)
Looks for: registry writes under the Keyboard Layouts control key or the Winlogon\Notify provider key, especially values that reference a .dll outside System32 or one of the named modules. FP: language-pack installs and legit IME software write keyboard-layout keys — scope to non-standard DLL values.
// HUNT: Keyboard-layout / Winlogon-notify persistence registry write - T1547.004 // CONF: medium FP: medium COST: low | REQUIRES: registry telemetry (AsepValueUpdate/RegGenericValueUpdate) // TUNING: exclude language-pack/IME installers writing standard kbd*.dll under System32; alert on Layout File values pointing outside System32 or named a.dll/kbdus1.dll/msyun.dll; exact key unpublished - review all hits manually #event_simpleName=/^(AsepValueUpdate|RegGenericValueUpdate)$/ | RegObjectName=/(\\Control\\Keyboard Layouts\\|\\Winlogon\\Notify)/i | groupBy([aid, ComputerName, RegObjectName], function=[count(as=Hits), collect([RegValueName, RegStringValue])], limit=200) | sort(Hits, order=desc, limit=100)
Looks for: any kernel driver file written into System32\drivers — a broad anomaly hunt to surface a Daxin-style driver even under a different name. FP: Windows Update, driver installs, and endpoint agents write drivers here constantly — rank by rarity and correlate with 2013-era timestamps / unknown publishers.
// HUNT: Rare / new .sys dropped into System32\drivers (BYOVD / rootkit surface) - T1014 // CONF: low FP: high COST: medium | REQUIRES: file-write telemetry (PeFileWritten/NewExecutableWritten) // TUNING: HIGH NOISE - exclude Windows Update (svchost/TiWorker), signed OEM driver installers, and your EDR; pivot on drivers seen on very few hosts, unsigned, or with anomalous compile timestamps; do not alert on this raw - use as a hunt #event_simpleName=/^(PeFileWritten|NewExecutableWritten)$/ | FileName=/\.sys$/i | FilePath=/\\System32\\drivers\\/i | groupBy([FileName], function=[count(as=Writes), collect([ComputerName, FilePath, SHA256HashData])], limit=500) | sort(Writes, order=asc, limit=100)
Looks for: any module named kbdus1.dll, a.dll, or msyun.dll loaded into any process (catches loads outside winlogon, e.g. staging or testing).
// HUNT: Stupig named modules (kbdus1.dll / a.dll / msyun.dll) loaded anywhere - T1036.005 // CONF: high FP: low COST: low | REQUIRES: module-load telemetry (ImageHash) #event_simpleName=ImageHash | FileName=/^(a|kbdus1|msyun)\.dll$/i | groupBy([aid, ComputerName, FileName], function=[count(as=Loads), collect([FilePath, SHA256HashData, TargetProcessId])], limit=200) | sort(Loads, order=desc, limit=100)
HUNT: Logon Persistence - Malicious Keyboard-Layout DLL in winlogon.exe. Priority HIGH — escalate immediately if the loaded DLL is outside System32 or matches a named IOC. FP sources: credential/smartcard providers, IME/language software, EDR modules. On fire, triage: (1) confirm the loading process is winlogon.exe; (2) pull FilePath + SHA256HashData of the module and compare to the two known hashes; (3) check the host for srt64.sys (pivot to Q3); (4) enumerate keyboard-layout registry values (Q5 / s7); (5) isolate on confirmation — this is pre-auth SYSTEM execution.
Custom IOA Recommendations
IOA-1 · Non-standard module load in winlogon.exe
Rule Group: Logon Integrity · Type: Image Load (or Process, with module context) · Action: Detect first · Severity: Critical · MITRE: T1547.004
- Parent / Process Image Filename:
.*\\winlogon\.exe$ - Loaded module / Image Filename:
.*\\(a|kbdus1|msyun)\.dll$(PCRE) - Description: winlogon.exe loading a DLL whose basename matches a known Stupig keyboard-layout module. Pre-auth SYSTEM execution vector.
- FP tuning: allowlist legitimate
kbd*.dllin System32 and known credential-provider modules; validate on a canary group before promoting to Block.
IOA-2 · Kernel driver srt64.sys
Rule Group: Rootkit Defense · Type: File / Driver · Action: Detect → Block after validation · Severity: Critical · MITRE: T1014
- Image Filename:
.*\\srt64\.sys$ - Description: Presence/load of the Daxin rootkit driver. Non-standard driver name; safe to block once confirmed absent from baseline.
prevent IOCs (see s10) — hash blocks are low-collateral and can go to prevent immediately given high-confidence attribution.
Machine-Readable IOC Appendix
type,value,action,severity,expiration,description,tags sha256,49c827cf48efb122a9d6fd87b426482b7496ccd4a2dbca31ebbf6b2b80c98530,prevent,critical,2027-07-21,Backdoor.Daxin srt64.sys kernel rootkit,campaign:DaxinStupig sha256,5bb5cffda4647940919a185df37aab2aef71ca3010a6c1d05bdcc8bc8fb3af3f,prevent,critical,2027-07-21,Backdoor.Stupig a.dll/kbdus1.dll keyboard-layout backdoor,campaign:DaxinStupig # No network IOCs: Daxin is a PASSIVE backdoor (no outbound C2). Filenames (srt64.sys, # kbdus1.dll, a.dll, msyun.dll) are not a Falcon IOC-import type - hunt them via Q1/Q3/Q7.
winlogon.exe loads a keyboard-layout DLL from outside System32 -> Q1, Q4 winlogon.exe loads a.dll / kbdus1.dll / msyun.dll -> Q1, Q7 Layout File registry value references a non-System32 DLL -> Q5 srt64.sys (or any unknown 2013-stamped driver) in System32\drivers -> Q3, Q6 Username prefix "stupig" typed at logon (pre-auth SYSTEM shell) -> secure-desktop trigger Network silence is EXPECTED - Daxin is passive, do not treat as clean
Backdoor.Daxin : srt64.sys (kernel rootkit, passive TCP magic-pattern C2) Backdoor.Stupig : a.dll, kbdus1.dll (masquerades as kbdus.dll; KBDTABLES stub) Companion (ref) : msyun.dll (referenced, not recovered) Benign baseline : kbdus.dll (legit MS U.S. English keyboard layout) Trigger : logon username beginning with "stupig"
[ ] Retire EOL JDK 1.5/1.6 and legacy Digiwin SSO portal (initial access) [ ] Enforce kernel driver allowlisting / HVCI + Microsoft vulnerable-driver blocklist [ ] Baseline winlogon.exe module set on a gold image; alert on deviation [ ] Enumerate all Keyboard Layouts\Layout File values fleet-wide vs known-good [ ] Enable Credential Guard / LSA protection to blunt logon-screen credential theft
REPLACE_WITH_ placeholders.
Detection Validation Gates
- Telemetry ready: confirm module-load (
ImageHash), file-write (PeFileWritten), and registry (AsepValueUpdate) events are flowing from Windows endpoints. Driver-load coverage varies by sensor policy — verify. - Benign baseline: run Q4/Q5/Q6 across a known-clean fleet window first; record the legit winlogon modules, keyboard-layout writes, and routine driver writes so real hits stand out.
- Positive test (isolated host only, benign payload): on a canary VM, register a harmless custom keyboard layout pointing to a benign test DLL outside System32 and confirm Q4/Q5 surface it. Never use the real samples.
- Promotion: keep behavioral queries (Q1,Q4,Q5,Q6) in Detect for 14+ days and measure FP rate before any Block. Hash IOCs (Q2) and
srt64.sys/named-module rules may go to Prevent immediately given high-confidence attribution.
Hardening — Tiered
- Deploy the vulnerable-driver blocklist + HVCI / Memory Integrity — MITRE M1050/M1038, Microsoft recommended-driver-block rules. Blocks kernel-rootkit loading and BYOVD. Enable Microsoft Vulnerable Driver Blocklist and HVCI on all Windows 10 1809+ / 11 endpoints.
- Enable LSA protection (RunAsPPL) + Credential Guard — MITRE M1043, CIS 18.9.x / MS Security Baseline. Reduces value of pre-login SYSTEM access for credential theft.
- Push the two SHA256 hashes to Falcon prevent — immediate, low-collateral block.
- Baseline and monitor keyboard-layout registrations — MITRE M1047. Snapshot every
Control\Keyboard Layouts\*\Layout Filevalue against a gold image; alert on any non-kbd*.dllor out-of-System32 value. - Retire the Digiwin SSO portal / EOL JDK 1.5-1.6 — MITRE M1051/M1035. This was the initial-access vector; decommission or isolate legacy web apps on end-of-life runtimes.
- Restrict driver installation — MITRE M1033. Enforce signed-driver policy and remove standing local-admin where feasible.
- Application control (WDAC / App Control for Business) — MITRE M1038. Enforce a code-integrity policy so only signed, known modules load into privileged processes like winlogon.exe.
- Legacy-asset lifecycle program — a 13-year dwell time was possible because a 2013-era system persisted unmanaged. Establish continuous EOL-software inventory and forced retirement.
- Network segmentation for passive-C2 resilience — MITRE M1030. Since Daxin hijacks legitimate connections and multi-hops, segment and monitor east-west traffic; you cannot rely on egress beaconing to catch it.
Deployable Playbooks
1 · Enumerate keyboard-layout DLLs fleet-wide (PowerShell, read-only)
# List every registered keyboard layout and its Layout File; flag non-standard DLLs.
$base = 'HKLM:\SYSTEM\CurrentControlSet\Control\Keyboard Layouts'
Get-ChildItem $base | ForEach-Object {
$lf = (Get-ItemProperty $_.PSPath -Name 'Layout File' -ErrorAction SilentlyContinue).'Layout File'
if ($lf -and $lf -notmatch '^kbd.*\.dll$') {
[pscustomobject]@{ Key = $_.PSChildName; LayoutFile = $lf } # review any hit
}
}
2 · Check winlogon module set and for srt64.sys (read-only)
# Modules loaded by winlogon.exe (needs Sysinternals listdlls or use Get-Process modules):
Get-Process winlogon | ForEach-Object { $_.Modules } |
Where-Object { $_.FileName -notmatch '\\System32\\|\\SysWOW64\\' } |
Select-Object ModuleName, FileName
# Daxin driver presence:
Test-Path "$env:SystemRoot\System32\drivers\srt64.sys"
Get-ChildItem "$env:SystemRoot\System32\drivers\*.sys" |
Where-Object { $_.Name -eq 'srt64.sys' } | Select-Object FullName, CreationTime
3 · Enable Microsoft Vulnerable Driver Blocklist + HVCI
# Vulnerable-driver blocklist (Win 11 22H2+ has it on by default; enforce via registry): reg add "HKLM\SYSTEM\CurrentControlSet\Control\CI\Config" /v VulnerableDriverBlocklistEnable /t REG_DWORD /d 1 /f # HVCI / Memory Integrity: # HVCI needs VBS enabled as well -- the scenario key alone is inert and the # control silently never activates. All three values are required. reg add "HKLM\SYSTEM\CurrentControlSet\Control\DeviceGuard" /v EnableVirtualizationBasedSecurity /t REG_DWORD /d 1 /f reg add "HKLM\SYSTEM\CurrentControlSet\Control\DeviceGuard" /v RequirePlatformSecurityFeatures /t REG_DWORD /d 1 /f reg add "HKLM\SYSTEM\CurrentControlSet\Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity" /v Enabled /t REG_DWORD /d 1 /f # Prereqs: UEFI + Secure Boot + virtualization extensions. Reboot required. # PILOT FIRST -- incompatible legacy drivers can block boot under HVCI. # Verify AFTER reboot (SecurityServicesRunning must contain 2): # (Get-CimInstance Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard).SecurityServicesRunning # Rollback: set both DeviceGuard values and the scenario Enabled back to 0, then reboot. # If the host will not boot, revert from Safe Mode or WinRE. # Reboot required. Validate driver compatibility on a pilot group first.Deploying via your RMM: the scripts above are raw PowerShell. Hand them to your RMM deployment tooling to add admin checks, error handling, and custom-field writeback for compliance tracking before fleet rollout.
Containment Runbook
| Phase | Actions | Owner | Evidence |
|---|---|---|---|
| 1 · Confirm | Validate the loaded winlogon module hash / srt64.sys presence against known IOCs (Q1-Q3) | Threat Hunter | Module FilePath+SHA256, driver file metadata |
| 2 · Isolate | Network-contain the host via Falcon RTR — do NOT rely on blocking egress (passive C2) | SOC Lead | Containment timestamp, aid |
| 3 · Preserve | Collect memory + the malicious DLL/driver + keyboard-layout registry hive before remediation | IR / Forensics | Memory image, sample files, reg export |
| 4 · Eradicate | Remove the keyboard-layout registration, delete the DLL and srt64.sys, rebuild if rootkit persistence is uncertain | IR | Removal log, re-scan |
| 5 · Credentials | Assume pre-login SYSTEM access enabled credential theft — force-reset local + domain creds used on the host, rotate secrets | IAM | Reset records |
| 6 · Hunt-wide | Run Q1-Q7 fleet-wide; check other legacy/EOL systems for 13-year dwell peers | Threat Hunter | Fleet query results |
Detection Coverage Map
| Technique | Behavior | CQL | IOA | Coverage |
|---|---|---|---|---|
| T1547.004 | Malicious keyboard-layout DLL in winlogon | Q1, Q4, Q5 | IOA-1 | Good |
| T1036.005 | kbdus1.dll masquerade | Q1, Q7 | IOA-1 | Good |
| T1014 / T1543.003 | srt64.sys kernel rootkit | Q3, Q6 | IOA-2 | Good |
| Known-hash presence | Daxin + Stupig samples | Q2 | Prevent IOC | Good |
| T1059 / T1556 | Pre-login SYSTEM shell ("stupig" prefix) | Detected via module (Q1) | — | Partial |
| T1190 | Digiwin SSO / EOL JDK exploit | — | — | GAP (app-tier logs, hardening s12) |
| T1205 / T1090.003 | Passive magic-pattern multi-hop C2 | Hypothesis only | — | GAP (no beacon telemetry) |
Priority gaps: The pre-login command execution itself raises no logon audit event, so detection depends entirely on catching the loaded module (Q1) — keep that query healthy. Daxin's passive C2 has no reliable endpoint/network signature; coverage is via driver presence (Q3) plus the hypothesis that network silence is not proof of cleanliness. Initial access (T1190) is off the endpoint sensor — close it through hardening (retire EOL JDK / Digiwin SSO). Validation gates: all behavioral queries must clear a benign baseline and a canary positive test before Detect→Block promotion (s11).
Hunt Summary Ticket
TITLE: Daxin + Stupig - Pre-Login SYSTEM Backdoor (China-nexus, Taiwan)
SEVERITY: Critical - pre-auth SYSTEM execution + kernel rootkit, active espionage
SCOPE: Windows endpoints (winlogon module loads, kernel drivers, keyboard-layout ASEP)
HYPOTHESIS: Stupig loads a malicious keyboard-layout DLL into winlogon.exe for pre-login
SYSTEM execution; Daxin (srt64.sys) provides passive kernel-mode C2. Both
samples are 2013-vintage - suspect long-dwell / legacy systems.
QUERIES: Q1 winlogon keyboard-layout DLL | Q2 known hashes | Q3 srt64.sys |
Q4 anomalous winlogon module | Q5 keyboard-layout ASEP | Q6 new .sys |
Q7 named modules anywhere
DO FIRST: Run Q1 + Q3 fleet-wide; compare any winlogon-loaded DLL and any srt64.sys
hash to the two known SHA256s.
FINDINGS: Expected positive = a non-kbd*.dll module in winlogon.exe (esp. a.dll/
kbdus1.dll) OR srt64.sys present OR either known hash. Any single hit =
escalate + isolate. Network silence is NOT exoneration (passive backdoor).
GAPS: Pre-login exec raises no logon audit event; passive C2 has no beacon;
exact keyboard-layout registry key unpublished; initial access off-sensor.
ACTIONS: Detect-mode Q1/Q4/Q5/Q6; prevent the 2 hashes + srt64.sys/named modules;
deploy vulnerable-driver blocklist + HVCI; retire EOL JDK/Digiwin SSO.
OWNER: HuntPack / Threat Hunt team
VERSION: v0.1 - 2026-07-21
Changelog
References
| Tier | Source | Used For | Access Date |
|---|---|---|---|
| T1 | Symantec / security.com — Daxin Returns: Stupig | Primary: hashes, persistence, C2, initial access | 2026-07-21 |
| T2 | The Hacker News — Daxin Resurfaces in Taiwan | Load chain, masquerade, timeline | 2026-07-21 |
| T2 | GBHackers — STUPIG SYSTEM-Level Malware | Hash corroboration, driver path, companion module | 2026-07-21 |
| T2 | Cyber Security News — Secret Username SYSTEM Shell | Hash corroboration, secure-desktop trigger, registry-gap note | 2026-07-21 |
| T2 | Security Affairs — 13-Year-Old Daxin Still Active | Passive multi-hop C2, Digiwin/JDK access, attribution | 2026-07-21 |
| ref | MITRE ATT&CK T1547.004 | Technique mapping (Winlogon Helper / keyboard-layout variant) | 2026-07-21 |