Skip to content

Find what keeps coming back.

Autoruns for Windows collections, in your browser. Drop a KAPE or Velociraptor collection, a zip of hives or single hive files: every Run key, service, driver, scheduled task, WMI subscription, Winlogon value, IFEO debugger and COM hijack, compared with Windows' defaults and flagged when it stands out. Nothing leaves your machine.

Offline · Registry, tasks and WMI · ATT&CK-mapped

Drop a Windows collection, archive or folder

A zip from the collection command below, a KAPE or Velociraptor collection, or hives and folders exported from a disk image (Windows\System32\config, Windows\System32\Tasks, the wbem repository and the Users folders). Single hives (SOFTWARE, SYSTEM, NTUSER.DAT…) work too. Only the persistence locations are read.

The sample is FIN-WKS-07, a Windows 11 workstation where a rogue admin account planted the same implant behind a Run value, a service, scheduled tasks and a WMI subscription, and excluded it from Defender.

Runs entirely in your browser: files are never uploaded.

Collect from a live Windows machine

Run this in PowerShell as an administrator. It copies the registry hives (through a shadow copy, since Windows keeps them locked), the scheduled tasks, the WMI repository, the Startup folders, PowerShell profiles and local Group Policy scripts into a zip; open the zip here. KAPE (RegistryHives, ScheduledTasks, WMI, StartupFolders targets) and Velociraptor collections work as they are.

$o = "$env:COMPUTERNAME-persistence"; $c = Join-Path $o 'C'
function Get-Copy($p) { $d = Join-Path $c $p.Substring(3); New-Item -ItemType Directory -Force (Split-Path $d) | Out-Null; esentutl.exe /y /vss $p /d $d | Out-Null }
'SOFTWARE','SYSTEM','SAM' | ForEach-Object { Get-Copy "C:\Windows\System32\config\$_" }
Get-ChildItem C:\Users -Directory -Force | ForEach-Object { foreach ($f in 'NTUSER.DAT','AppData\Local\Microsoft\Windows\UsrClass.dat') { $p = Join-Path $_.FullName $f; if (Test-Path -LiteralPath $p -PathType Leaf) { Get-Copy $p } } }
Get-ChildItem C:\Windows\System32\wbem\Repository -File | ForEach-Object { Get-Copy $_.FullName }
'C:\Windows\System32\Tasks','C:\Windows\Tasks','C:\Windows\System32\GroupPolicy','C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup' | Where-Object { Test-Path $_ } | ForEach-Object { robocopy $_ (Join-Path $c $_.Substring(3)) /E /COPY:DT /DCOPY:T /R:0 /W:0 /XJ /NFL /NDL /NJH /NJS /NP | Out-Null }
Get-ChildItem C:\Users\*\AppData\Roaming\Microsoft\Windows\'Start Menu'\Programs\Startup\*, C:\Users\*\Documents\*PowerShell\*profile.ps1, C:\Windows\System32\WindowsPowerShell\v1.0\*profile.ps1 -File -Force -ErrorAction SilentlyContinue | ForEach-Object { $d = Join-Path $c $_.FullName.Substring(3); New-Item -ItemType Directory -Force (Split-Path $d) | Out-Null; Copy-Item -LiteralPath $_.FullName $d }
Compress-Archive -Path $o -DestinationPath "$o.zip" -Force

Paths that do not exist are skipped. The SAM and SYSTEM hives together hold password hashes: treat the zip as evidence. The tool reads account names, RIDs and flags, never the hashes. Zip entry times are local time.

What is Windows persistence?

Persistence is how an intruder makes sure their access survives a reboot, a logoff or a password change. On Windows most of it lives in the registry: a Run value, a service, a Winlogon value, a debugger set on a program, a COM class redefined for one user. Scheduled tasks, WMI event subscriptions, Startup folders and PowerShell profiles are the other doors, and the LSA and the print spooler load DLLs into the most privileged processes on the machine.

This tool reads all of those places from a collection or a disk export, offline, lists every entry with what it runs, as whom and when, and flags the ones that deserve a look first. It works like Sysinternals Autoruns does on a live system, for the registry hives and files you have during an investigation.

How it separates the normal from the planted

  • Windows' defaults: Userinit, Shell, BootExecute, the LSA package lists, print monitors, netsh helpers, time providers and the program file associations have values Windows sets. Entries that match are marked as defaults; anything added is flagged.
  • Where programs live: offline there is no signature to check, so the tool looks at where each program sits. System32 and Program Files are where installed software lives; a service, driver or SYSTEM task that runs a file from ProgramData, a profile folder, Temp or Public is flagged.
  • Command lines: encoded PowerShell is decoded, download cradles (IEX, certutil, bitsadmin, mshta and regsvr32 pointed at a URL), Windows programs pointed at outside code, look-alike names such as scvhost.exe, Defender changes, deleted backups.
  • Scheduled tasks: the XML files are compared with the TaskCache in SOFTWARE, as Scheduled Tasks Parser does: a task with no security descriptor is hidden from schtasks (Tarrask), a file edited after registration no longer matches its hash, a registered task whose file is gone, a file that was never registered.
  • WMI: event filters, consumers and bindings are read by WMI Parser's engine, including deleted ones recovered from freed space and consumers that were rewritten.
  • Cross-checks: a program inside a Defender exclusion, the same program behind several mechanisms, local administrators created in the week before the collection, accounts hidden from the sign-in screen, RID hijacking.

What it reads

  • Run, RunOnce, RunOnceEx and Policies\Explorer\Run, machine-wide, 32-bit and for every user, with the Task Manager on/off switch (StartupApproved)
  • Winlogon (Userinit, Shell, Taskman, Notify) and per-user shells, Active Setup, logon scripts and local Group Policy scripts
  • Services and drivers in the current control set, with their service DLLs, accounts and failure commands
  • Scheduled tasks: System32\Tasks, the TaskCache and legacy .job files
  • WMI event subscriptions from the repository (OBJECTS.DATA, INDEX.BTR, MAPPING*.MAP)
  • Image File Execution Options debuggers, SilentProcessExit monitors, AppInit_DLLs and AppCertDlls
  • Per-user COM classes (UsrClass.dat), file association and UAC-bypass handlers, cmd.exe AutoRun, PowerShell profiles, screensavers, shims, Office test keys and add-ins
  • LSA authentication, notification and security packages, WDigest, network providers, print monitors and processors, netsh helpers, time providers, BootExecute
  • Startup folders (shortcuts are resolved), local accounts from the SAM, Defender exclusions

Limits

  • It reads files, not a running system: in-memory implants, running processes and loaded drivers need live response or memory forensics.
  • No signature checks: binaries are not read. Where a program lives is a strong hint, not proof: an administrator can drop a file into System32.
  • Hive transaction logs (.LOG1/.LOG2) are not replayed: on a hive that was not cleanly written back, the newest changes may be missing (the Files tab says so).
  • BITS jobs, Office startup templates and browser extensions are not read yet.
  • A flag is a reason to look, not a verdict. Vendors do ship services in ProgramData and tasks that run as SYSTEM.

Questions

Are my files uploaded?

No. The page reads the files in your browser with JavaScript, a Web Worker and WebAssembly for the WMI repository; nothing is sent to a server. You can disconnect from the network after the page has loaded.

Why does the collection copy the hives through a shadow copy?

Windows keeps SOFTWARE, SYSTEM, SAM and loaded NTUSER.DAT files locked while it runs. esentutl /vss reads them from a volume shadow copy, which needs an administrator. reg save works too, for the machine hives.

Can it read a disk image?

Yes, through Disk Image Parser: open the image there and use “Open in Windows Persistence” on its Windows Persistence preset; the files go tab to tab, never through a server. Folders exported by FTK Imager, KAPE or Velociraptor work too.

Is this the same as Autoruns?

Autoruns runs on the live system and checks signatures. This tool works on a copy of the files, offline, which is what you have during an investigation, and adds what offline analysis can see: task tampering, deleted WMI subscriptions, key write times, Defender exclusions.

Why is an entry from a known vendor flagged?

Flags describe traits, not intent: an updater can run as SYSTEM, a vendor can install a service under ProgramData. The flags tell you what to verify.