Live Windows forensics: how to minimise changes to evidence
You can't collect from a running Windows machine without changing it. What you can do is keep the change small, known and written down. Here's how.
Researched and drafted with AI assistance · reviewed by Prince

People often search for a way to collect evidence from a live Windows machine “without changing metadata”. The honest answer is that you can’t. A running computer is changing all the time on its own, and the moment you touch it you add your own changes on top. What you can do is keep your changes small, know exactly what they are, and write them down so that anyone reviewing your work later can tell your footprint apart from the attacker’s.
That’s the whole game. The rest of this post is about how to play it well.
Why zero change is impossible
Think about what happens when you so much as log on to a suspect workstation. Windows records the logon. Your session starts processes, which take memory that may previously have held something useful. If you run a tool, Windows may note that it ran. If you plug in a USB drive, Windows records the device. None of this is a failure of technique; it’s how the operating system works.
NIST makes the point plainly in SP 800-86: any action on a live system, whether yours or the operating system’s, will almost certainly alter volatile data in some way. RFC 3227, the long-standing IETF guidance on evidence collection, asks you to minimise changes rather than avoid them, and it’s specific that this includes not needlessly updating file and directory access times.
So “minimal” has a practical meaning. It means you choose the least invasive way to get what you need, you understand what each step leaves behind, and you record it. A collection where the examiner can say “these three artefacts are mine, here’s the log” is in far better shape than one where nobody knows what was touched.
The principles, and why each one matters
Work from the most volatile to the least. RFC 3227 gives an order of volatility: CPU registers and cache first, then memory and live system state like the routing table, ARP cache and process list, then temporary file systems, then disk, then remote logs, and finally physical configuration and archival media. The reasoning is simple. Memory disappears when the power does, and it also degrades while you work, because your own activity overwrites it. Disk will still be there in an hour. If you image the disk first, you’ll lose the things that only ever existed in RAM.
In practice this is a judgement call, not a law. Sometimes you pull memory first. Sometimes you can’t: the machine is a production server that can’t tolerate the load, or you don’t have authority yet, or the incident is about a file that’s about to be deleted by a scheduled job. Know the default order, and be ready to explain why you departed from it.
Bring your own tools, on media you trust. RFC 3227 tells you not to trust the programs on the system, and SP 800-86 recommends running forensic tools from external media rather than from the suspect machine. If an attacker has replaced a system utility, the output you get back is whatever they want you to see. Tools you carry in also means you’re not installing anything, which matters because installation writes far more to disk and the registry than simply running a portable executable.
Never write output to the suspect disk. When a file is deleted on NTFS, the data usually stays on the disk until the space is reused. SP 800-86 describes exactly this: deleted files and free space can still hold recoverable data. Every byte you write to that disk can land in space that held something you needed. Send output to external storage or a network share you control.
Hash as you go. A hash taken at collection time is what lets you show, months later, that the file you analysed is the file you collected. SP 800-86 treats integrity verification as a standard step, computing and comparing message digests of original and copy. Doing it at the point of collection, rather than after you’ve copied things around, closes the gap.
Log every action with the time. RFC 3227 asks for detailed notes with dates and times, and for you to record the difference between the system clock and UTC. You’ll want this when you build a timeline and find an entry at 14:32 that could be yours or the attacker’s. Your log is what settles it.
Don’t browse, don’t open, don’t install. Opening a document in its application, poking around in Explorer, or installing an agent all leave traces in places investigators routinely examine. If you need to look at something, collect it and look at the copy.
A live collection, walked through
Let’s make this concrete. Say you’ve been asked to collect from a Windows 11 workstation that’s suspected of running something it shouldn’t. The machine is on, a user is logged in, and you have authority to proceed.
Before you touch the keyboard, write down the time, the machine’s name and asset tag, who’s present, and what’s on screen. Photograph the screen if anything is open. Note whether it’s on the network. That decision about isolation is worth a moment’s thought: RFC 3227 warns that some malware watches for loss of connectivity and destroys evidence when it goes offline. Containment may still be the right call, but make it deliberately and log it.
Next, decide how you’re going to interact, because whatever account you use will be all over the logs. Our default is simple. If an authorised administrator session is already open on the machine, use it: you avoid creating a fresh logon, and you’ll note in your log that everything from this point under that session is yours. If there isn’t one, log on with a dedicated local responder account, created for the job and named so nobody can mistake it for a user. That gives you a clean 4624 record and a separate profile, so your activity separates neatly from everyone else’s.
The one thing we’d never do is log on to a suspect host as a domain administrator. If the machine is compromised, an interactive logon puts that account’s credentials within reach of whatever is running there, and you could hand the attacker the keys to the whole domain while trying to investigate one workstation.
Now plug in your collection drive. This is the change people forget about, and it’s one of the most visible ones (see the table below). Ideally your tools live on one device and output goes to another with plenty of space, or to a share. Before you start, check the clock: compare the system time with a reliable reference and note the offset.
If you’re capturing memory, do it first. It’s the most volatile thing on the machine, and every minute you spend doing other things erodes it. Write the image to your external storage, and record the tool, its version and when it started and finished.
Then the live state that won’t survive a reboot: running processes with their command lines and parents, network connections and the processes that own them, logged-on users, services and scheduled tasks. After that, the files and logs: event logs, registry hives, the files that record program execution. Where you can, collect locked system files through the Volume Shadow Copy Service rather than forcing your way in.
Hash everything as it lands. When you’re done, hash again, eject your drives properly, and note the time you stopped. Your notes should now let a stranger reconstruct every step you took.
What your own actions change
This is the table to keep in mind while you work. It isn’t exhaustive, and the details vary by Windows version and configuration, so check the target rather than assuming.
| Your action | What it leaves behind | Why it matters |
|---|---|---|
| Logging on at the console | Security event 4624 with logon type 2 (interactive), if logon auditing is enabled | Your logon sits in the same log as the attacker’s; you need to be able to tell them apart |
| Connecting over Remote Desktop | Security event 4624 with logon type 10 (RemoteInteractive) | Remote access from an admin workstation can look like lateral movement unless it’s documented |
| Using a remote tool that authenticates over the network | Security event 4624 with logon type 3 (network) | Same problem; record the source host and account |
| Plugging in a USB drive | An entry in C:\Windows\INF\setupapi.dev.log the first time that device is installed; a key under HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR; values in HKLM\SYSTEM\MountedDevices; a MountPoints2 entry in the logged-on user’s NTUSER.DAT; on Windows 10 and 11, entries in the Microsoft-Windows-Partition/Diagnostic log | USB history is often central to data-theft cases, and your drive now appears in it. Note its make, model and serial |
| Running a tool | A Prefetch file in C:\Windows\Prefetch named after the executable, on systems where Prefetch is enabled; Security event 4688 if process-creation auditing is turned on | Prefetch is a key execution artefact. It’s normally on for client editions of Windows and is often disabled on Windows Server, so check EnablePrefetcher before drawing conclusions either way |
| Reading or copying files | Possibly an updated last-access timestamp, depending on the NtfsDisableLastAccessUpdate setting | Last-access times can’t be relied on as “the user opened this” if your collection touched the file. NTFS can also defer writing them to disk for up to an hour |
| Writing anything to the suspect disk | New file records and data written over free space | Free space may hold deleted files you haven’t recovered yet |
| Running any process at all | Memory allocated to your tools, displacing what was there | Memory is the most volatile evidence; this is why it comes first |
Two caveats deserve emphasis. First, setupapi.dev.log records times in the system’s local time, while event logs and registry timestamps are stored in UTC, so align them before you build a timeline. Second, an absence proves less than you’d think: an empty Prefetch folder on a server is much more likely to mean Prefetch was off than that nothing ran.
Where TVAK Collector fits
We built TVAK Collector for exactly this step. The command-line collector is a single portable executable, and the GUI ships as a self-contained folder, so neither needs installing; you copy it to a USB drive or the target and run it. Both bundle their own .NET runtime rather than depending on what’s installed on the machine.
The detail that matters most for this post is output location. The CLI’s --output option sets the root for both the finished package and its working files, and it defaults to the current directory. That means if you launch it from a prompt sitting in a folder on the suspect disk, that’s where it’ll write. Always pass --output explicitly and point it at your external drive or share (CLI reference).
Every file in the package is SHA-256 hashed and recorded in manifest.json, along with a status for each collector, so the hash-as-you-go principle is built in (evidence handling). Memory capture is opt-in and uses a winpmem executable you supply. Running Collector still makes the changes in the table above: it’s a program running on the machine. The point is that those changes are predictable and documented, not that they don’t exist.
A printable checklist
- Confirm your authority to collect, and from which systems.
- Prepare tools on trusted external media; verify their hashes before you leave.
- Record the time, system name, people present and what’s on screen.
- Decide on network isolation deliberately; note the risk of evidence-destroying malware.
- Use an open authorised admin session, or a dedicated local responder account; never a domain admin. Note which.
- Compare the system clock with a reference; record the offset and time zone.
- Connect external storage for output; record its make, model and serial.
- Capture memory first, if appropriate; note tool, version, start and end.
- Collect live state: processes, connections, users, services, tasks.
- Collect logs, registry hives and execution artefacts, using VSS where possible.
- Hash outputs at collection time; keep the manifest with the evidence.
- Never write to the suspect disk, open files, browse or install anything.
- Log every action with a timestamp as you go.
- Hash again at the end, eject cleanly, record the stop time.
- Store originals untouched; analyse copies only.
FAQ
Does running a forensic tool change file timestamps?
It can. Reading a file may update its last-access time, depending on the NtfsDisableLastAccessUpdate setting on that machine, and a well-behaved collection tool shouldn’t change creation or modification times of the files it reads. Running the tool itself can create a Prefetch entry and, if auditing is on, a 4688 event. Check the setting on the target and note it in your report.
Can you collect evidence from a live Windows machine without changing metadata?
No. Logging on, plugging in storage and running any program all leave records, and memory changes constantly. The achievable goal is minimal, known and documented change, so that your footprint can be separated from the activity you’re investigating.
Should I pull the plug or collect live first?
Pulling the power preserves the disk exactly as it was, but you lose everything in memory: running processes, network connections, decrypted data and anything that never touched the disk. If those matter to the case, collect live first. If the machine is actively destroying data, or you can’t collect safely, a controlled shutdown or power-off may be the lesser loss. Whichever you choose, record why.
Is it safe to plug a USB drive into a suspect machine?
It’s usually the most practical option, but it isn’t invisible. Windows records the device in several places, and a compromised machine could in principle tamper with what you plug in. Use a drive you’ve prepared for the purpose, write-protect your tools if you can, and note the drive’s details so its entries can be explained later.
Sources
- RFC 3227: Guidelines for Evidence Collection and Archiving
- SP 800-86: Guide to Integrating Forensic Techniques into Incident Response
- 4624(S): An account was successfully logged on
- 4688(S): A new process has been created
- SetupAPI device installation log entries
- fsutil behavior
- Windows forensics: tracking program execution with Prefetch
- Digital Forensics: Artifact Profile – USB Devices
- Windows USB forensics: trace device history
Was this useful?