What footprint does running a live collection tool leave on the host you are collecting from?
answer
- you are a process on that host too
- the memory you allocate came from somewhere
- execution and removable-media artefacts
- not stealth, but a written record
basics
~20 sIt leaves execution artefacts and consumes memory: a process-creation record, a Prefetch entry, a service installation, removable-media device records, loaded modules, and allocated pages that overwrite free memory. The goal is never a zero footprint, only a documented one.
solid answer
~50 sAnything you run becomes part of the machine's history. On Windows you get a process-creation record in the Security log, a Prefetch entry for the binary on a client system, a `7045` service-installation event in the System log if the collector deploys as a service, and device-installation entries if you plugged in external media. Your process loads modules and allocates memory, and those pages come from what was free - which may have held remnants of a terminated process or a decrypted buffer. Writing output to the host's own disk is worse again: it consumes free space and overwrites unallocated clusters. The mitigations are practical rather than magical: a small approved toolset, run from external media, output written off-host, and a contemporaneous log of what you ran, from where, as which account and at what time.
code
text · 9 lines01:07:22Z Security 4624 logon type 10 (RemoteInteractive)
account: ACME\c.mercer source address: 10.8.44.19
02:39:44Z Registry SYSTEM\CurrentControlSet\Enum\USBSTOR\Disk&Ven_SanDisk&Prod_Ultra...
02:41:07Z Security 4688 new process: D:\ir\collect.exe
creator process: C:\Windows\System32\cmd.exe
(no command line: audit policy does not include it)
02:41:07Z File C:\Windows\Prefetch\COLLECT.EXE-3A1B7C9D.pf run count 1
02:41:09Z System 7045 "A service was installed in the system." service: irhelper
...go deeper
Know that anything you run on a live host creates artefacts on that host, and that the response is to record what you ran and when rather than to try to hide it.
Name the concrete traces — process creation, Prefetch, service installation, removable-media device records, allocated memory — and explain why writing output to the source volume is the worst of them.
Show that you plan the footprint before touching the machine: a small approved kit on prepared media, output off-host, and a contemporaneous log an examiner can subtract from the timeline.
Own the standard rather than the incident: one approved collection kit with a known, published footprint and a recording format that holds up under challenge, instead of each responder improvising.
## Observation changes the observed A live collection is executed *by the machine you are investigating*. There is no way to read a running system's memory without being a process on that system, so the tool becomes part of the evidence. Candidates who have only done offline work are often surprised by this; candidates who have done live response plan for it before they touch the keyboard. ## Where the traces land **Execution artefacts.** Starting a binary produces a process-creation record — Windows Security event ID `4688`, or Sysmon event ID `1` where Sysmon is deployed. On a Windows client with Prefetch enabled, the first run of an executable creates a `.pf` file under the Prefetch directory recording that it ran and when. If your collector installs itself as a service, the System log records event ID `7045`, 'A service was installed in the system' — the same artefact class investigators look for as a persistence indicator. **Device artefacts.** Attaching a USB drive writes device-installation records into the registry and the setup logs. Those entries look exactly like an intruder's exfiltration media unless someone wrote down that they are yours. **Filesystem metadata.** Reading files updates access-related metadata on some configurations; opening directories in a graphical shell touches more than you think. This is a strong argument against 'just having a quick look' before the capture. **Memory.** Your process asks the allocator for pages, and the allocator hands over pages that are currently free. Free is not empty: those pages may still hold the remains of a process that exited, a decrypted buffer, or key material. A large, feature-rich collector can overwrite the very thing you came for. This is why single-purpose tools with a small resident footprint are preferred, and why running six utilities 'to be thorough' is a bad instinct. **Output.** The avoidable half. Writing an image or an artefact archive to the source volume consumes free space and overwrites unallocated clusters that may hold deleted evidence, and grows a file on the volume you are about to acquire. Write to attached external media, or stream over the network to a collection host. ## The defence is documentation, not stealth There is no zero-footprint live collection, and pretending otherwise is a red flag. The standard the work is judged against is whether the change you caused is understood, minimised and recorded. Practically that means a contemporaneous log capturing, for every action: wall-clock time, what was run, its full path and hash, the media it ran from, the account it ran under, and where the output went. Mistakes go in the log too — 'at 02:44 I double-clicked the wrong folder' is far more valuable than a tidy account written from memory two days later. That log is what lets an examiner subtract the responder from the timeline. Without it, a Prefetch entry and a service installation timestamped inside the incident window are indistinguishable from intruder tooling, and any conclusion resting on them can be argued away. ## Choosing the tool before the incident The footprint is a property you should know in advance, not discover at 03:00. A prepared team has an approved collection kit, knows what it writes and where, has it on prepared external media, and has practised running it. The alternative — downloading something onto the compromised host and running it from the local disk — combines the largest possible footprint with the smallest possible confidence in what the tool actually did. ## The trade-off in one line Every live collection destroys some evidence in order to preserve evidence that would otherwise be destroyed anyway. That trade is worth making, and it is only defensible if you can say precisely what you did.
- Your collector allocated a few hundred megabytes of RAM. Why does that matter?Those pages came from the free pool, and free does not mean empty. They may have held the remains of a terminated process, a decrypted buffer or key material — exactly the residue a memory capture is worth taking for. It is the argument for small single-purpose tools, for running as few things as possible, and for recording what you ran so the loss is at least explainable.
- How does an examiner later separate your artefacts from the intruder's?Only from what you wrote down. Log every binary you ran with its path and hash, the media it came from, the account used, and the wall-clock time of each action. Without that, a Prefetch entry and a service installation inside the incident window look like intruder tooling, and someone will argue exactly that.
- Does it matter where the collection output is written?Yes, and it is the part you fully control. Writing to the source volume consumes free space, overwrites unallocated clusters that may hold deleted evidence, and grows a file on the disk you are about to acquire. Write to attached external media or stream it off the host over the network.
saying these in an interview costs you the question
- Claims a good tool leaves no trace on the host
- Writes collection output onto the source volume
- Cannot explain how allocated memory destroys evidence
- Skips the log and reconstructs actions from memory later
- Downloads a tool onto the compromised host and runs it