What Autoruns Is
Most security tools answer "what just happened." Autoruns answers a different question: "what is this machine configured to run automatically, right now, the next time it boots, logs in, or hits a scheduled trigger?" In CTA, Autoruns (src/persistence/autoruns_scanner.py, surfaced through the Investigate → Autoruns tab in src/gui/main_window.py) is a deliberately on-demand, single-pass sweep — not a background monitor. CTA already has two always-on subsystems watching for persistence changes as they happen (the Registry Persistence Monitor and File Integrity Monitoring); Autoruns is the complementary "stop and look at everything, right now" counterpart, in the same spirit as the on-demand YARA Scan and Memory Scan tabs sitting alongside their own real-time equivalents.
The name and framing borrow deliberately from Sysinternals Autoruns, the long-standing Windows utility SOC analysts and incident responders already know — CTA's version keeps the same mental model (enumerate every auto-start mechanism in one report) but adds risk scoring, reputation lookups, and baseline comparison on top, so the output is triage-ready rather than a raw list an analyst has to interpret by hand.
What It Does
A single scan enumerates seven classic Windows persistence mechanisms:
- Run / RunOnce registry keys
- Winlogon entries
- Shell Folder redirection
- Windows Services
- Scheduled Tasks
- WMI event subscriptions (
__EventFilter/__EventConsumerbindings) - Startup folders, including resolved
.lnkshortcut targets
Every entry is additionally checked against IOC/VirusTotal hash reputation, and a fresh scan can be diffed against a saved baseline to highlight only what's new since the last known-good snapshot. One resilience detail worth calling out: each enumeration source (WMI, Task Scheduler's COM interface, the registry, etc.) is wrapped independently, so one source failing — WMI access denied, Task Scheduler COM not registered — degrades that one category instead of silently returning an empty, misleadingly clean report.
How to Use It
- Open the Autoruns tab. It lives under Investigate → Autoruns in the desktop GUI's workflow sidebar.
- Run the scan. It's a deliberate, on-demand action — nothing runs until you ask it to, and a scan takes a single pass rather than polling continuously.
- Read the results sorted by risk. Entries land with the highest-risk items first — an unsigned binary in a sensitive location, or a WMI subscription whose command doesn't match its recognized name, surface above a routine Run key pointing at a signed vendor binary.
- Drill into a flagged entry. Right-clicking an entry opens further investigation actions and context — the same instinct as right-clicking a row in Live Events or Alerts elsewhere in CTA.
- Save a baseline once the host is known-clean. This is what turns Autoruns from a one-off snapshot into a detection tool: the next scan can be diffed against it.
- Re-run periodically and compare. After a suspected compromise, before/after a patch cycle, or as part of routine hardening review, a fresh scan diffed against the saved baseline surfaces only what's new — a freshly planted scheduled task or WMI subscription stands out immediately instead of being buried in the host's normal persistence noise.
The point-in-time nature is the whole design: it answers "what's set up to run automatically on this box, right now, across every major mechanism at once," which is a different and complementary question to what the always-on Registry Monitor and FIM are answering continuously in the background.
Why This Matters for an EDR/SIEM/Antivirus-Class Platform
Traditional antivirus is built to answer "is this file malicious," checked against signatures or heuristics at write-time or execution-time. That model has a structural blind spot: a WMI event subscription, a scheduled task, or a Winlogon registry hijack isn't a file AV scans — it's configuration. The payload it eventually launches might get caught by AV when it runs, but the persistence mechanism that keeps relaunching it after every reboot usually isn't inspected as its own object at all. That's exactly why WMI-based, fileless persistence remains a favorite technique in real intrusions: it survives a clean AV scan because there's no suspicious file sitting still to scan.
Autoruns closes that gap by treating persistence configuration itself as the thing under inspection, not a side effect of file scanning. For CTA specifically, this plugs into three things already built:
- Complements, doesn't duplicate, real-time detection. The Registry Persistence Monitor and FIM already catch persistence changes as they happen. Autoruns answers the question they can't: "what already got through, before monitoring was watching, or before this host was even enrolled?" A monitor that started watching yesterday has no opinion about a scheduled task planted six months ago; a point-in-time sweep does.
- Feeds the same correlation and reputation pipeline as everything else in CTA. Flagged Autoruns entries get the same IOC/VirusTotal hash-reputation treatment as FIM-observed files, so an analyst isn't maintaining a separate mental model for "stuff from the Autoruns tab" versus "stuff from everywhere else."
- Baseline diffing is forensic triage, not just a feature checkbox. Comparing against a known-good snapshot is the single fastest way to separate "this has always been here" from "this showed up since the incident started" — a workflow most consumer and even many commercial AV products don't expose at all, because they're oriented around real-time blocking, not retrospective comparison.
The broader point for a SIEM-adjacent platform like CTA: persistence mechanisms are where an intrusion's durability lives, not where its initial detection usually happens. A SOC that only watches for execution-time badness will eventually face an attacker who got in, planted persistence, and went quiet — at which point a point-in-time sweep across every mechanism at once is the tool that actually finds them.
Where This Could Go Next
A few realistic next steps, roughly in order of how directly they build on what already exists:
- More persistence categories. The seven covered today are the classics, but there's real coverage left on the table: AppInit_DLLs / COM CLSID hijacking, BITS jobs, LSA security providers, PowerShell profile scripts, and browser extensions/startup items are all known persistence vectors that a from-scratch Autoruns-style scanner can add incrementally, one enumerator at a time, following the same independently-wrapped-source pattern the current seven already use.
- Scheduled, automatic sweeps. Right now Autoruns only runs when an analyst clicks it. An opt-in scheduled sweep (daily or weekly, mirroring the cadence already used for intelligence sync elsewhere in CTA) would catch newly planted persistence without anyone remembering to go run it — while keeping the on-demand button for incident-driven sweeps.
- Fleet-wide, cross-host baseline diffing. Today baseline comparison is per-host. With agents already reporting to a central server, the natural extension is comparing one host's Autoruns findings against the fleet's baseline — surfacing the one machine whose WMI subscriptions or services don't match what every other endpoint looks like, which is often a stronger signal than any single host's self-comparison.
- Folding Autoruns findings into the cross-source Timeline. The Timeline tab's histogram (see CTA's own recent upgrade) already merges Events, Alerts, and Vulnerability findings into one chronological, source-stacked view. Autoruns findings are a natural fourth source: a newly-flagged persistence entry has a timestamp like everything else, and seeing it appear on the same timeline as the Events and Alerts around it would let an analyst place a persistence discovery directly in the sequence of an incident, rather than checking a separate tab.
None of these require a different architecture — they're extensions of the same enumerate-score-compare pattern Autoruns already follows.
No comments:
Post a Comment