Daxin + Stupig — Pre-Login SYSTEM Backdoor Hunt

China-linked espionage resurfaces in Taiwan: a 13-year-dormant Daxin kernel rootkit alongside "Stupig," a trojanized keyboard-layout DLL that runs commands as SYSTEM from the Windows logon screen — before any user signs in.
Threat
Daxin / Stupig (China-nexus)
Severity
ESPIONAGE · SYSTEM PRE-AUTH
Type
Kernel rootkit + logon-screen backdoor
Access
Pre-login SYSTEM RCE
Version
v0.1 · 2026-07-21
Author
HuntPack
Confidence
High (1× Tier-1 primary + 4× Tier-2 corroboration)
01

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.

Defender priority: Watch 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.
02

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.

#SourceTierContributed
1Symantec / security.com (primary)T1Both SHA256 hashes, keyboard-layout persistence, T1547.004 relation, KBDTABLES, secure-desktop execution, passive TCP C2, Digiwin/JDK initial access
2The Hacker NewsT2win32k.sys → winlogon.exe load chain, masquerade as kbdus.dll, no-audit-event execution, 13-year timeline
3GBHackersT2Hash corroboration, %SystemRoot%\System32\drivers location, msyun.dll companion, detection dates
4Cyber Security NewsT2Hash corroboration, secure-desktop SYSTEM shell trigger, explicit "no registry path published" gap
5Security AffairsT2Passive-backdoor multi-hop routing, Digiwin SSO / EOL JDK 1.5-1.6 initial access, attribution context
Gap flagged: no source publishes the specific keyboard-layout registry key, the Layout File value name, network C2 indicators (Daxin is passive), or MD5 hashes. Those are handled as behavioral hunts / REPLACE_WITH_ placeholders.
03

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.

StageBehaviorArtifact / Telemetry
Initial AccessExploit 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.exeModule load (ImageHash) into winlogon.exe; keyboard-layout ASEP registry
Persistence (Daxin)Signed kernel driver srt64.sys installed to System32\driversDriver/module load; PeFileWritten of .sys
Priv-Esc / ExecutionUsername prefix "stupig" at logon → command runs as SYSTEM on secure desktopPre-auth; no logon audit event — hunt the loaded module, not the logon
C2Passive: monitor inbound TCP magic patterns; hijack legit connections; multi-hopNo outbound beacon; hunt driver presence + anomalous connection hijack (hypothesis)
ImpactLong-term stealthy espionage / credential theftCredential access at logon screen
04

Consolidated IOC Table

TypeValueConfidenceActionContext
SHA25649c827cf48efb122a9d6fd87b426482b7496ccd4a2dbca31ebbf6b2b80c98530highdetectsrt64.sys — Backdoor.Daxin
SHA2565bb5cffda4647940919a185df37aab2aef71ca3010a6c1d05bdcc8bc8fb3af3fhighdetecta.dll / kbdus1.dll — Backdoor.Stupig
Filenamesrt64.syshighhuntDaxin kernel driver (System32\drivers)
Filenamekbdus1.dllhighhuntStupig keyboard-layout DLL (masquerades as kbdus.dll)
Filenamea.dllmediumhuntStupig deployment name (generic — corroborate with load context)
Filenamemsyun.dllmediumhuntReferenced Stupig companion module (not recovered)
Logon stringstupig (username prefix)highhuntTyped at logon screen to trigger SYSTEM command execution
Path%SystemRoot%\System32\drivers\srt64.syshighhuntDaxin on-disk location
Baseline (benign)kbdus.dlln/aenrichLegit Microsoft U.S. English layout — the masquerade target
Network C2REPLACE_WITH_C2 (none published — passive backdoor)n/apivotDaxin makes no outbound connections; no atomic network IOC exists
05

Affected Surface & Telemetry Matrix

SurfaceTelemetryPriorityGap
Windows endpoints (winlogon module loads)ImageHash module-load eventsCriticalNone — primary hunt surface
Windows kernel driversModule/driver load + PeFileWrittenCriticalDriver-load event coverage varies by sensor policy — validate
Registry autostart (keyboard-layout / Winlogon\Notify)AsepValueUpdate, RegGenericValueUpdateHighExact key not published; behavioral coverage only
Logon-screen command executionNone — pre-auth, no logon audit eventHighBlind spot — detect the module, not the logon
Network (passive C2)NetworkConnectIP4 (hijacked legit sessions)LowNo beacon; conventional netflow hunting ineffective
Digiwin SSO web tierApp/web logs (non-Falcon)HighEndpoint sensor does not cover the exploited web app
06

MITRE ATT&CK Mapping

TacticTechniqueBehaviorQuery / Control
Initial AccessT1190 — Exploit Public-Facing AppDigiwin SSO portal on EOL JDK 1.5/1.6Patch/EOL audit (s12)
PersistenceT1547.004 — Boot/Logon Autostart: Winlogon Helper (related; novel keyboard-layout variant)Malicious keyboard-layout provider loaded into winlogon.exeQ1, Q4, Q5
Defense EvasionT1036.005 — Masquerading: Match Legitimate Namekbdus1.dll poses as kbdus.dll; valid KBDTABLESQ1, Q7
Defense EvasionT1014 — RootkitSigned kernel driver srt64.sysQ3, Q6
Persistence / Priv-EscT1543.003 — Create/Modify System Process: Windows Service (kernel driver)srt64.sys loaded as kernel driverQ3, Q6
ExecutionT1059 — Command & Scripting Interpreter (SYSTEM shell)"stupig" prefix at logon → SYSTEM command on secure desktopQ1 (detect the loaded module)
Command & ControlT1205 — Traffic Signaling (magic-pattern passive backdoor)Monitors inbound TCP; hijacks legit connectionsHypothesis (s3, H5)
Command & ControlT1090.003 — Multi-hop ProxyChained C2 across infected hostsHypothesis (s3, H5)
Credential AccessT1556 — Modify Authentication ProcessPre-login credential theft from logon screenQ1, hardening (s12)
07

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's Layout File value. Any value that is not a standard kbd*.dll shipped in System32 — or that resolves to a file outside System32 — 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. Sysinternals listdlls winlogon.exe) and flag any DLL outside System32/SysWOW64, any unsigned module, or names a.dll/kbdus1.dll/msyun.dll.
  • Kernel driver inventory: enumerate loaded drivers and System32\drivers\*.sys; flag srt64.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\Notify for 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.
08

CrowdStrike LogScale CQL Hunt Queries

Pick your tenant's cloud first — every "Open in Falcon" button below uses this selection.
Q1 · Stupig keyboard-layout DLL loaded into winlogon.exe
CONF HIGHFP MEDCOST MED

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)
Q2 · Known Daxin / Stupig sample hashes
CONF HIGHFP LOWCOST LOW

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)
Q3 · Daxin kernel driver srt64.sys (load + on-disk)
CONF HIGHFP LOWCOST LOW

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)
Q4 · winlogon.exe loading any DLL from a non-system path
CONF MEDFP MEDCOST MED

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)
Q5 · Keyboard-layout / Winlogon-notify autostart registry writes
CONF MEDFP MEDCOST LOW

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)
Q6 · New / unsigned .sys written to System32\drivers
CONF LOWFP HIGHCOST MED

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)
Q7 · Stupig module basenames loaded anywhere
CONF HIGHFP LOWCOST LOW

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)
Alert package (from alert-builder-v2): Promote Q1 to a scheduled search 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.
09

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*.dll in 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.
Also deploy the two SHA256 hashes as prevent IOCs (see s10) — hash blocks are low-collateral and can go to prevent immediately given high-confidence attribution.
10

Machine-Readable IOC Appendix

Falcon IOC Management CSVbulk import
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.
Behavioral Signatureshunt logic
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
Named Tooling / Filenamesreference
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"
Patch / Hardening Auditchecklist
[ ] 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
Provenance: both SHA256 values are traceable to the saved source snapshots (Symantec appendix, GBHackers, Cyber Security News). No fabricated hashes or C2 indicators are shipped; unknown values use REPLACE_WITH_ placeholders.
11

Detection Validation Gates

  1. 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.
  2. 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.
  3. 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.
  4. 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.
12

Hardening — Tiered

Immediate (this week)
  • 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.
Near term (1–4 weeks)
  • Baseline and monitor keyboard-layout registrations — MITRE M1047. Snapshot every Control\Keyboard Layouts\*\Layout File value against a gold image; alert on any non-kbd*.dll or 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.
Strategic (1–3 months)
  • 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.
13

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.
14

Containment Runbook

PhaseActionsOwnerEvidence
1 · ConfirmValidate the loaded winlogon module hash / srt64.sys presence against known IOCs (Q1-Q3)Threat HunterModule FilePath+SHA256, driver file metadata
2 · IsolateNetwork-contain the host via Falcon RTR — do NOT rely on blocking egress (passive C2)SOC LeadContainment timestamp, aid
3 · PreserveCollect memory + the malicious DLL/driver + keyboard-layout registry hive before remediationIR / ForensicsMemory image, sample files, reg export
4 · EradicateRemove the keyboard-layout registration, delete the DLL and srt64.sys, rebuild if rootkit persistence is uncertainIRRemoval log, re-scan
5 · CredentialsAssume pre-login SYSTEM access enabled credential theft — force-reset local + domain creds used on the host, rotate secretsIAMReset records
6 · Hunt-wideRun Q1-Q7 fleet-wide; check other legacy/EOL systems for 13-year dwell peersThreat HunterFleet query results
15

Detection Coverage Map

TechniqueBehaviorCQLIOACoverage
T1547.004Malicious keyboard-layout DLL in winlogonQ1, Q4, Q5IOA-1Good
T1036.005kbdus1.dll masqueradeQ1, Q7IOA-1Good
T1014 / T1543.003srt64.sys kernel rootkitQ3, Q6IOA-2Good
Known-hash presenceDaxin + Stupig samplesQ2Prevent IOCGood
T1059 / T1556Pre-login SYSTEM shell ("stupig" prefix)Detected via module (Q1)Partial
T1190Digiwin SSO / EOL JDK exploitGAP (app-tier logs, hardening s12)
T1205 / T1090.003Passive magic-pattern multi-hop C2Hypothesis onlyGAP (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).

16

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
17

Changelog

v0.12026-07-21Initial HuntPack: 7 CQL queries, 2 Custom IOAs, tiered hardening, containment runbook. Built from Symantec/security.com primary report (2026-07-20) + 4 corroborating sources. Two SHA256 hashes provenance-verified; keyboard-layout registry angle represented behaviorally (exact key unpublished).
18

References

TierSourceUsed ForAccess Date
T1Symantec / security.com — Daxin Returns: StupigPrimary: hashes, persistence, C2, initial access2026-07-21
T2The Hacker News — Daxin Resurfaces in TaiwanLoad chain, masquerade, timeline2026-07-21
T2GBHackers — STUPIG SYSTEM-Level MalwareHash corroboration, driver path, companion module2026-07-21
T2Cyber Security News — Secret Username SYSTEM ShellHash corroboration, secure-desktop trigger, registry-gap note2026-07-21
T2Security Affairs — 13-Year-Old Daxin Still ActivePassive multi-hop C2, Digiwin/JDK access, attribution2026-07-21
refMITRE ATT&CK T1547.004Technique mapping (Winlogon Helper / keyboard-layout variant)2026-07-21