kjones went looking for tax forms and ended up handing an attacker a foothold. The task is to reconstruct the full chain from a triage collection: how the rogue file arrived, how remote access was established, what the attacker did once inside, and how they eventually neutralised Windows Defender using a Bring Your Own Vulnerable Driver (BYOVD) technique to dump LSASS. The investigation correlates event logs, browser history and prefetch, then finishes with a short static-analysis pass over the EDR killer in IDA Pro.
The intrusion is a near-exact match for the Huntress “From W-2 to BYOVD” campaign (March 2026) — tax-themed malvertising → rogue RMM → signed Huawei audio driver abused to kill EDR. Worth reading that report first for context, but the lab reskins the tooling: where Huntress saw ScreenConnect/FleetDeck and a driver service named Havoc, this lab uses Atera/Splashtop and a service named HwAudio. The lesson that paid off repeatedly here: trust the artefacts and the answer-format masks over the source report.
The collection isn’t a KAPE output. The folder structure under uploads\ — a host-named root (WKSTN-01-C.<id>) containing auto\ and ntfs\ — is a Velociraptor offline collector.

That split dictates where everything lives. ntfs\ holds the raw NTFS extraction — $MFT, $J, the registry hives, browser profiles, prefetch, and the actual dropped binaries. auto\ holds Velociraptor’s pre-parsed artifact output (event logs, browser history, etc.) as CSV/JSON, which is faster to triage than parsing raw EVTX by hand. The event logs themselves sit at ntfs\...\Windows\System32\winevt\Logs\ if you’d rather parse them yourself, which is the route taken here.
The three logs that carry this entire case are Sysmon Operational, System, and Windows Defender Operational. Parse all three into CSV for Timeline Explorer:
EvtxECmd.exe -f ".\Microsoft-Windows-Sysmon%4Operational.evtx" --csv ".\out" --csvf sysmon.csv
EvtxECmd.exe -f ".\System.evtx" --csv ".\out" --csvf system.csv
EvtxECmd.exe -f ".\Microsoft-Windows-Windows Defender%4Operational.evtx" --csv ".\out" --csvf defender.csv
EvtxECmd writes timestamps in UTC. CyberDefenders answers for this lab are the UTC values as logged
kjones was searching for and downloading tax forms, so browser history is the starting point. Chrome’s history database (ntfs\...\Users\kjones\AppData\Local\Google\Chrome\User Data\Default\History) holds the downloads and downloads_url_chains tables — the latter preserves the full redirect chain a download travelled, which matters when malvertising bounces a victim through several hops.
Among the legitimate .pdf tax forms is one file that doesn’t belong: form_w9.msi. An MSI installer is not a tax form. It was pulled from bringetax[.]com — the rogue delivery domain, consistent with the malvertising landing-page pattern.

The download time comes off the WebKit timestamp on that downloads row. WebKit stores time as microseconds since 1601-01-01, so it needs converting:
# WebKit value 13422046212290429
# /1e6 seconds since 1601, minus 11644473600 to reach Unix epoch
date -u -d @1777572612
# -> Thu Apr 30 18:10:12 UTC 2026
That places the download at 2026-04-30 18:10. (CyberChef does the same with Windows Filetime to UNIX Timestamp → From UNIX Timestamp if you prefer a GUI.)

The file sat for four minutes before kjones opened it. Execution shows up in Sysmon as a process-create (EID 1) for msiexec.exe launching the MSI from the Downloads folder:
"C:\Windows\System32\msiexec.exe" /i "C:\Users\kjones\Downloads\form_w9.msi"

The UtcTime on that record is 2026-04-30 18:14 — the moment the rogue installer ran and the chain kicked off. The four-minute gap between download and execution reads like a real user double-clicking it from Downloads, not an automated drop.
Running the MSI installed a remote management tool, which registers a service. Service installations land in the System log as Event ID 7045, so filter system.csv on EventId == 7045 and read the PayloadData column (it carries ServiceName, ImagePath and ServiceType).
The first service registered shortly after the MSI ran is AteraAgent

The same install deployed Atera’s bundled remote-access component, registered as Splashtop® Remote Service (copy it verbatim — the ® and spacing matter for the flag).

To separate the two RMM services from the kernel driver that appears later, check ServiceType in the 7045 payload: Atera and Splashtop install as user-mode services, while the BYOVD driver (covered below) installs as a kernel-mode driver with an ImagePath ending in .sys.
With Atera live, the attacker ran commands through it. In Atera, interactive commands are spawned by a specific agent process, and finding it gives you a single filter that surfaces every attacker action. Pivoting on Sysmon EID 1 and looking at parent images for the post-install activity, the parent of all attacker commands is AgentPackageRunCommandInteractive.exe.

This is the key move of the whole investigation. Filtering Sysmon EID 1 on ParentImage containing AgentPackageRunCommandInteractive.exe lays out the attacker’s command sequence in order, and the rest of the answers fall out of that single view.
The first thing the attacker did was reconnaissance — querying the registry to check system state before changing anything. The first key queried is the LSA configuration key:
reg query HKLM\SYSTEM\CurrentControlSet\Control\Lsa

Checking HKLM\SYSTEM\CurrentControlSet\Control\Lsa before touching LSASS is deliberate — the attacker is looking at whether LSA protection (RunAsPPL) is enabled, which would determine whether a straight LSASS dump will succeed.
Having checked the ground, the attacker tried to dump LSASS — and Defender caught it. That detection isn’t in Sysmon; it’s in the Windows Defender Operational log. Filtering defender.csv shows three detections in sequence:
2026-04-30 19:32:38 AMSI HackTool:PowerShell/Lsassdump.A powershell.exe
2026-04-30 19:33:43 System Trojan:Win32/MpTamperSrvDisableAV.D CmdLine: sc.exe stop WinDefend
2026-04-30 19:36:20 RTP Trojan:Win32/LsassDump.A file: ...\Roaming\lsass.dmp

The first detection — AMSI catching HackTool:PowerShell/Lsassdump.A at 2026-04-30 19:32 — is when Defender first blocked the credential-theft attempt. Note that AMSI fired on the PowerShell tooling itself, not on a file, which is why this is the earliest of the three signals.
Blocked on the dump, the attacker tried to disable Defender outright. The second Defender detection (MpTamperSrvDisableAV.D) tells you exactly what was run and that it was blocked:
sc.exe stop WinDefend
That attempt failed too — Defender’s tamper protection stopped the service control call. With both the dump and the direct stop blocked, the attacker escalated to BYOVD: kill Defender from kernel mode using a legitimately signed but abusable driver, which usermode tamper protection can’t stop.
They launched an interactive PowerShell session and dropped two files into C:\Users\kjones\AppData\Roaming\. Finding them in Sysmon EID 11 (FileCreate) takes a little care — filtering on powershell.exe as the writing image returns a wall of noise first: __PSScriptPolicyTest_*.ps1 execution-policy probes and the .cmdline / .0.cs / .dll / .tmp / .out / .err family that .NET’s csc compiler emits whenever PowerShell uses Add-Type to compile inline C#. None of those are the payload.

The faster route is to filter the TargetFilename column on the extension directly. Searching .sys returns almost nothing and points straight at the driver; searching .exe in the same window finds its partner. The two dropped files are HWAuidoOs2Ec.sys (the signed Huawei audio driver) and kd.exe (the EDR killer):

The mask for this question (************.***, **.***) is the tell for which order to report them and which is which — a 12-character stem then a 2-character stem. HWAuidoOs2Ec is the 12-char file (the driver), kd is the 2-char file (the killer). The .sys write also cross-checks against the kernel service ImagePath in the next step.

The attacker registered the dropped driver as a kernel service. Back in the System log 7045 events, the kernel-mode driver service — ServiceType of kernel driver, ImagePath pointing at ...\Roaming\HWAuidoOs2Ec.sys — is named HwAudio:
sc create HwAudio binPath= "C:\Users\kjones\AppData\Roaming\HWAuidoOs2Ec.sys" type= kernel start= demand
sc start HwAudio

This is where blindly following the Huntress report would have cost time — their service was Havoc. The 7-character answer mask ruled that out immediately, and the artefact confirmed HwAudio.
The killer kd.exe needs a first-execution timestamp. Sysmon EID 11 confirms the file was written — powershell.exe creating C:\Users\kjones\AppData\Roaming\kd.exe — but filtering EID 1 (ProcessCreate) for kd.exe returns nothing. Sysmon captured the drop but never logged the binary executing.

When ProcessCreate is missing, Prefetch is the authoritative source for first execution. Running PECmd over the prefetch file:
PECmd.exe -f "C:\...\Windows\Prefetch\KD.EXE-56679BDE.pf"
gives a run count of 3 and the run times. The earliest is the first execution:
Run count: 3
Last run: 2026-04-30 19:37:26
Other run times: 2026-04-30 19:36:42, 2026-04-30 19:35:51

First execution is 2026-04-30 19:35 (19:35:51). Ignore the prefetch file’s own Created/Last accessed of 2026-06-22 — that’s the collection date, not execution; the volume FILETIME run times are the real evidence. The three runs (19:35, 19:36, 19:37) read as the attacker re-firing the killer to keep Defender down across retries.
kd.exe is small (≈5 KB) and unsigned. Loading it in IDA confirms what it does without needing to run it. Two things to pull out.
The target process name appears as a string and in the process-enumeration comparison — the killer walks the process list and matches against MsMpEng.exe, the Windows Defender Antivirus service engine. Killing MsMpEng.exe from kernel mode is what finally takes Defender offline.

The killer talks to the loaded driver through DeviceIoControl. Following the call, the control code passed in is 0x2248DC — the driver’s process-termination IOCTL. The handle is opened against the driver’s device symlink (\\.\HWAudioX64), the target PID goes in as the input buffer, and the driver’s kernel-mode dispatch calls ZwOpenProcess + ZwTerminateProcess with no validation on the target. That missing validation is the whole vulnerability — a signed driver exposing an unguarded kill primitive to usermode.

With MsMpEng.exe terminated and Defender blind, the attacker re-ran the LSASS dump and it succeeded. The dump file lands back in the staging directory, so filter Sysmon EID 11 on TargetFilename ending lsass.dmp:
C:\Users\kjones\AppData\Roaming\lsass.dmp

The successful create is 2026-04-30 19:36 — after the killer’s first run (19:35) and after Defender went dark, which is the ordering that proves it’s the successful dump rather than the earlier blocked attempt. (The 19:36:20 Defender detection of lsass.dmp is the dying log of an engine being killed mid-action; cross-check the create against MFT‘‘MFT MFT‘‘SI birth time with MFTECmd if you want it to the second.)
The full sequence ties together cleanly: 19:32 first dump blocked → 19:33 sc stop WinDefend blocked → 19:35 kd.exe runs and kills Defender via the Huawei driver → 19:36 LSASS dumped successfully.
| Phase | Action |
|---|---|
| Initial Access | Malvertising — kjones searches for tax forms, downloads form_w9.msi from bringetax[.]com (18:10) |
| Execution | kjones runs form_w9.msi via msiexec (18:14) |
| Persistence | Atera RMM (AteraAgent) + Splashtop (Splashtop® Remote Service) services installed |
| Discovery | Attacker commands spawned by AgentPackageRunCommandInteractive.exe; queries HKLM\SYSTEM\CurrentControlSet\Control\Lsa |
| Credential Access (blocked) | LSASS dump attempt blocked by Defender AMSI (19:32) |
| Defense Evasion (blocked) | sc.exe stop WinDefend blocked by tamper protection (19:33) |
| Defense Evasion (BYOVD) | PowerShell drops HWAuidoOs2Ec.sys + kd.exe; driver registered as kernel service HwAudio |
| Defense Evasion (kill) | kd.exe first run (19:35) terminates MsMpEng.exe from kernel via IOCTL 0x2248DC |
| Credential Access (success) | lsass.dmp written to disk after Defender neutralised (19:36) |
| Type | Value |
|---|---|
| Domain (delivery) | bringetax[.]com |
| File (rogue installer) | form_w9.msi |
| File (dropped path) | C:\Users\kjones\AppData\Roaming| |
| File (BYOVD driver) | HWAuidoOs2Ec.sys (signed Huawei Device Co., Ltd. audio driver) |
| File (EDR killer) | kd.exe (unsigned) |
| Service (RMM) | AteraAgent |
| Service (RMM) | Splashtop® Remote Service |
| Service (kernel driver) | HwAudio |
| Process (command parent) | AgentPackageRunCommandInteractive.exe |
| Driver device symlink | .\HWAudioX64 |
| IOCTL (process kill) | 0x2248DC |
| Target process (Defender) | MsMpEng.exe |
| Artifact (creds) | C:\Users\kjones\AppData\Roaming\lsass.dmp |
| Technique | ID | Description |
|---|---|---|
| Drive-by Compromise | T1189 | Tax-themed malvertising delivers form_w9.msi via search ad |
| User Execution: Malicious File | T1204.002 | kjones runs the rogue MSI from Downloads |
| Remote Access Software | T1219 | Atera and Splashtop deployed for hands-on-keyboard access |
| Create or Modify System Process: Windows Service | T1543.003 | AteraAgent, Splashtop and HwAudio services registered |
| Query Registry | T1012 | LSA key queried to check LSASS protection state |
| Command and Scripting Interpreter: PowerShell | T1059.001 | Interactive PowerShell drops driver and killer |
| OS Credential Dumping: LSASS Memory | T1003.001 | LSASS dumped to lsass.dmp after Defender disabled |
| Impair Defenses: Disable or Modify Tools | T1562.001 | sc stop WinDefend attempt, then kernel-mode kill of MsMpEng.exe |
| Exploitation for Privilege Escalation | T1068 | Signed Huawei driver IOCTL abused for kernel-mode process termination |
| Ingress Tool Transfer | T1105 | HWAuidoOs2Ec.sys and kd.exe written to disk |
| Masquerading: Match Legitimate Name or Location | T1036.005 | Kernel service named HwAudio; abuse of a legitimately signed vendor driver |
Treat unapproved RMM installs as compromise, not noise. The entire intrusion rode in on Atera and Splashtop — legitimate tools that an MSP might genuinely use, which is exactly why they’re abused. Maintain an allowlist of approved RMM products and relay endpoints, and alert on any 7045 service install for an RMM that isn’t on it. The appearance of AteraAgent immediately after an MSI executed from a user’s Downloads folder is the signal here.
Kernel driver service creation from a user-writable path is almost never legitimate. The HwAudio service loaded HWAuidoOs2Ec.sys from C:\Users\kjones\AppData\Roaming\ — a kernel driver has no business living in a Roaming profile. Correlating System log 7045 (ServiceType kernel) with Sysmon EID 6 (DriverLoad) on any path under a user profile or %TEMP% gives high-fidelity BYOVD detection, and catches it before the EDR is blinded rather than after.
Defender’s own logs narrate the attack even as it’s being disabled. The Defender Operational log captured the blocked LSASS dump and the blocked sc stop attempt, which is what tells you the BYOVD pivot was a fallback after simpler evasion failed. Forwarding Defender Operational events to a SIEM means those detections survive even when the local engine is later killed — the kill itself becomes the loudest signal if you’re watching for MsMpEng.exe terminating unexpectedly.
Prefetch and Amcache fill the gaps when process-create logging misses. kd.exe had no Sysmon EID 1 record, but Prefetch preserved three execution times and Amcache would corroborate. Don’t treat a missing ProcessCreate as proof a binary didn’t run — execution artefacts are independent evidence and should be a standard part of the timeline, not a last resort.
The vulnerability is a signed driver, not the malware. No exploit, no zero-day — just a legitimately signed Huawei audio driver exposing an unvalidated process-termination IOCTL. Deploying Microsoft’s Vulnerable Driver Blocklist (HVCI) and monitoring driver loads against LOLDrivers is the durable control, because IPs and binaries rotate but a careless signed driver is expensive for the attacker to replace.