In this section

Windows Evidence Collection: Order of Volatility, BitLocker and KAPE Triage

Module 0

Introduction

Every Windows investigation starts with a decision that cannot be undone: what to take from the machine, in what order, and whether to switch it off. Evidence on a running host decays at different speeds.

A network connection lasts seconds, a running process lasts until the next reboot, a prefetch file lasts until it is overwritten, and a registry hive lasts years. Collecting in the wrong order means losing the fast evidence while you take the slow.

1. CPU state, caches, memoryrunning processes, network connections, decrypted keys: gone at power-off2. Temporary file systemsfiles that live only while the machine is up3. Diskthe file system, registry hives, event logs, prefetch: survives a reboot4. Remote logsa SIEM or EDR copy, held elsewhere and on its own schedule5. Configuration and archivestopology, backups: the slowest to change

The order of volatility, after RFC 3227, read for one Windows host. Collect from the top: each step down lasts longer, and the top two do not survive the shutdown that imaging usually needs.

This lesson reads one real collection decision and one real collection. The decision is from this course's ransomware case: a finance workstation, encrypted on the night of 18 March, imaged afterwards.

The collection is a KAPE triage of a domain controller from the same company, taken for another investigation, whose logs show exactly what a triage copies, what it skips and what it leaves out. Together they set up Module 1, which teaches every acquisition method in depth.

01

What a Windows Host Holds, and for How Long

The order of volatility

The standard reference for collection order is RFC 3227, a best current practice published in February 2002. Its section on volatility lists, from most to least volatile: registers and cache; routing tables, the ARP cache, the process table, kernel statistics and memory; temporary file systems; disk; remote logging and monitoring data; physical configuration and network topology; and archival media.

More than twenty years later the list still holds, because the physics of it has not changed.

Mapped onto a Windows endpoint, the levels look like this:

One Windows host, level by level

RFC 3227 order

Memory

processes, injected code, open connections, keys

Live state

logged-on users, ARP and DNS caches, open files

Disk, system

registry hives, event logs, prefetch, $MFT, $UsnJrnl

Disk, user

NTUSER.DAT, UsrClass.dat, browser and app databases

Elsewhere

SIEM and EDR copies, backups, shadow copies

Lost at power-off

the first two rows, unless captured first

How to use it

Collect top to bottom. Each row down lasts longer, and the first two do not survive a shutdown.

Read for a Windows endpoint, the top of the list is where attackers live. Memory holds the processes that are running, the code they injected into other processes, the network connections they hold open, the commands typed into a console, and decryption keys for anything mounted. Tools that never touch disk leave evidence only there. All of it disappears when the machine is switched off.

The middle of the list is where forensic analysis does most of its work.

The disk holds the registry, the event logs, prefetch, the master file table and the user profiles, and almost every artifact in this course. It survives a reboot, but not unchanged: every minute a compromised host keeps running, Windows writes new prefetch entries, rolls event logs, and overwrites the unallocated space where deleted files might have been recovered.

The lower levels are copies held elsewhere. A SIEM or an EDR console keeps its own record of the host on its own retention, and that copy cannot be changed by an attacker on the host. It is also less detailed and may lag. A forensic investigation uses both: the remote copy for what the attacker tried to erase, and the host's own artifacts for detail no forwarder sends.

The RFC adds two rules that matter as much as the order.

Do not shut down until evidence collection is complete, because a shutdown destroys the top of the list and an attacker may have changed what runs at shutdown. And do not trust the programs on the system, because a compromised host can lie through its own tools; collection tools run from media you brought, which is why Module 1 builds its toolkit before it touches a host.

02

One Collection Decision, Read Afterwards

What imaging after shutdown could not reach

In this course's ransomware case, the security team was alerted at 02:47 on 18 March to mass file encryption on YORK-WS-033, a finance workstation. The host was switched off and imaged; its own registry records when:

Key        HKLM\SYSTEM\CurrentControlSet\Control\Windows
Value      ShutdownTime = 2026-03-18T04:15:22Z

Key        HKLM\SYSTEM\CurrentControlSet\Control\TimeZoneInformation
Values     TimeZoneKeyName = GMT Standard Time
           ActiveTimeBias  = 0

The shutdown time is 04:15:22 UTC, about an hour and a half after the alert, and the time zone is GMT with a bias of 0, so the host's local times and UTC agree. Checking the time zone is the first thing done with any image, because every timestamp in the case is read through it.

A host set to a different zone, or with a clock that had drifted, shifts every event it recorded by the same amount, and a timeline built across hosts inherits the error. In March 2026, before British Summer Time began on the 29th, GMT Standard Time and UTC were the same clock.

What the disk kept, and what it could not:

Helper runs02:01:15mshelper64.exeEncryption02:30:00locker.exeLog cleared02:45:11Security, by SYSTEMAlert02:47mass encryptionShut down, imaged04:15:22disk only

YORK-WS-033 on 18 March 2026. The disk kept what each program left behind; nothing kept what the helper was doing in memory or which connections it held open when the host was switched off.

The disk shows that mshelper64.exe ran at 02:01:15 and locker.exe at 02:30:00, because each left a prefetch file. It shows the Security log was cleared at 02:45:11. It cannot show what the helper did while it ran: which process it injected into, which commands it received, which connections it held.

Sysmon recorded 32 network connections on the host in the parsed logs, but only the ones its configuration asked for, and with nothing about what was sent over them.

None of this is a criticism of the decision. Containing an active encryption is a legitimate reason to switch a host off, and a responder at three in the morning may not have the tools or the authority to capture memory first. What the decision needs is to be written down: who decided, when, and what was knowingly given up.

An investigation that later finds a gap at the top of the list can then explain it, rather than discover it under questioning. The point is that the decision has a cost, and an investigator has to know exactly what it was, because a finding that rests on evidence nobody collected cannot be made.

03

Encryption Before You Image

The question that decides whether the disk is readable at all

Most corporate Windows laptops are encrypted with BitLocker. While the machine is running and the volume is unlocked, everything on it is readable through the operating system.

Once it is switched off, the volume is ciphertext until somebody supplies a key protector: the TPM, a PIN, or a recovery password. An image taken from a powered-off encrypted disk is useless without the recovery key, and some organizations do not escrow those keys reliably.

That is why the live-response sequence checks encryption before memory and long before the disk:

1. Photograph and note the statescreen, time, who is on, what is attached2. Check for encryptionBitLocker on, and unlocked right now?3. Capture memorybefore anything changes the running state4. Collect volatile artifactsconnections, processes, keys5. Image or triage the diskfull image, or targeted artifacts6. Hash and recordevery file and container, recordedLiveonly while it is runningDurablecan wait if it must

The live-response sequence Module 1 teaches. The encryption check sits before memory because a locked volume may be unreadable once the machine is off, and the key may only exist in memory.

On a running host the check is two commands, run from the responder's own toolkit media:

PS C:\> manage-bde -status C:
PS C:\> manage-bde -protectors -get C:

Microsoft documents manage-bde -status as reporting, for every drive, its conversion status, the percentage encrypted, the protection status, the lock status and the key protectors. Three of those decide the next step. A volume that is fully encrypted, with protection on and currently unlocked, should be collected now, while the operating system can still read it.

The key protectors say how the volume would be unlocked later. A TPM protector alone means the machine unlocks itself at boot on the same hardware, which does not help with an image on a forensic workstation; the numerical password, the recovery key, is what does, and the investigator has to obtain it from wherever the organization escrows it before relying on an offline image.

If the recovery key cannot be found, the choice changes. A logical collection from the running system, taken through the unlocked volume, may be the only readable copy of the disk that will ever exist. Module 1 works through that decision and through capturing memory, which often holds the volume master key itself.

04

A Triage Collection

Taking the artifacts rather than the disk

A full disk image is the most complete collection and the slowest. A 512 GB laptop drive takes hours to image and more hours to process, and in an incident spanning many hosts there is not time for every machine.

A triage collection takes only the files an investigation reads: registry hives, event logs, prefetch, the master file table, browser databases, user profile artifacts. Minutes instead of hours, and a few hundred megabytes instead of hundreds of gigabytes.

KAPE, Eric Zimmerman's Kroll Artifact Parser and Extractor, is the most widely used tool for it on Windows. A target is a named set of file paths and masks; KAPE expands the targets into a list, searches the source volume, and copies every match to the destination with its timestamps preserved.

With shadow copies enabled, it searches each volume shadow copy as well. A collection of a domain controller's event logs and registry hives, run for another investigation in the same company:

PS C:\> .\kape.exe --tsource C: --target EventLogs,RegistryHives `
    --tdest E:\Cases\NGE-DC-01 --tflush --vss --vhdx NGE-DC-01 --zv false

The source is the live C: volume, the targets are the two compound sets, the destination is an evidence drive, and --vss adds the shadow copies. --vhdx wraps the result in a virtual disk container so it can be hashed and mounted read-only later.

Deduplication is on by default: KapeDocs describes it as comparing SHA-1 values, with the first file found winning, which is generally the active file rather than a shadow-copy version.

A triage collection is a plan in disguise. Every target included is a question someone expects to ask; every target left out is a question this collection cannot answer. The plan should exist before the collection, written as questions, so that the collection can be checked against it afterwards:

Collection plan: YORK-WS-033

Written before collecting

Question 1

How did the attacker get in?

Needs

mail metadata, browser, Security log

Question 2

What ran, and when?

Needs

prefetch, amcache, Sysmon, user hives

Question 3

What did they hide?

Needs

MFT, USN journal, System log

Why it comes first

A collection is complete only against the questions it has to answer. Writing them down first is what lets you check the copy log afterwards and say what is missing.

Module 1 builds that plan, writes KAPE's targets for it, and collects across a fleet with Velociraptor when there are more hosts than time.

05

Reading the Copy Log

A manifest of what was taken

Every KAPE run writes logs to the destination, and the copy log is the most important of them.

KapeDocs lists its columns: the time each file was copied, its source and destination paths, its size, its SHA-1, whether the copy was deferred, the source file's created, modified and accessed times, and how long the copy took. It is a manifest of the collection, and it is evidence in its own right.

The domain controller's collection copied 30 files, 353 MB in all: 11 event logs, 15 system hive files with their transaction logs, 3 user hive files, and one hive from a shadow copy. Six rows show the pattern:

SourceFile                                    FileSize   DeferredCopy
--------------------------------------------  ---------  ------------
...\Logs\Security.evtx                        134217728  True
...\Logs\System.evtx                           20975616  True
...\config\SYSTEM                              20971520  True
C:\Users\Administrator\NTUSER.DAT               1310720  False
C:\Users\Administrator\NTUSER.DAT.LOG1           131072  False
C:\Users\Administrator\AppData\Local\Microso    1048576  False
VSS1\Windows\System32\config\SYSTEM            20447232  False

The DeferredCopy column is the one to read first. KapeDocs defines it: if true, the file was locked and subsequently read via a raw disk read. Event logs and the system hives are always locked on a running Windows system, because the operating system holds them open, so a tool that only used ordinary file access would fail to copy them. 26 of the 30 files were read raw.

The rows marked False say something about the host. A user's NTUSER.DAT and UsrClass.dat are locked only while that user is signed in, and the Administrator profile's hives were copied normally: nobody was signed in as Administrator when the collection ran.

The shadow copy's SYSTEM hive was copied normally too, because a shadow copy is a frozen snapshot that the operating system does not hold open. A collection log is a record of the system's state as well as of the copy.

The sizes are worth a glance too. A Security log of exactly 134,217,728 bytes is 128 MB, a common maximum size, which suggests the log had reached its limit and may already have been overwriting its oldest events. How far back it reaches is a question to answer from the log itself before relying on it for anything early in an incident.

06

Reading the Skip Log

What was left out, and why

The skip log lists every file KAPE found and did not copy. KapeDocs gives two possible reasons: Excluded, when the file's SHA-1 matched a list the analyst supplied to leave out known files, and Deduped, when it matched a file already copied. On the domain controller, all 23 skipped files were deduplicated, and every one came from the shadow copy:

SourceFile                                       Reason
-----------------------------------------------  -------
VSS1\Windows\System32\config\SAM                 Deduped
VSS1\Windows\System32\config\SAM.LOG1            Deduped
VSS1\Windows\System32\config\SAM.LOG2            Deduped
VSS1\Windows\System32\winevt\Logs\Application.e  Deduped
VSS1\Windows\System32\winevt\Logs\Directory Ser  Deduped

Each shadow-copy file was identical to the live file KAPE had already copied, so one copy stands for both and nothing is lost. The interesting entries are the ones that are not in the skip log. The shadow copy's SYSTEM hive is missing from it, and appears instead in the copy log as a separate file. Its hash differed from the live SYSTEM hive, so KAPE kept both.

That difference is evidence. A registry hive that changed between the shadow copy and the collection holds keys that were written in between, and comparing the two versions shows exactly what changed: a new service, a modified run key, a changed setting.

Shadow copies are one of the few places on a Windows host where an earlier state of the system survives, which is precisely why ransomware deletes them, as lesson 0.8 shows.

Reading the skip log also guards against a quiet failure. A collection run with the wrong exclusion list can leave out files that matter, and the console shows nothing unusual. The skip log is where that shows up, as rows with the reason Excluded for files nobody meant to exclude. On this collection there are none, and saying so is part of the acquisition record.

07

Proving the Collection Is Complete

Complete against the questions, not against the disk

No triage collection is complete in the sense of containing everything; that is what a full image is for. A triage collection is complete when it holds every artifact the investigation's questions need, and incomplete when it does not. Proving it means reading the logs against the plan, then hashing the result so that nobody can later dispute what was collected:

Acquisition record: NGE-DC-01 triage

Checked against the logs

Tool

KAPE, targets EventLogs and RegistryHives

Source

C: and its shadow copies

Copied

30 files, 353 MB

Skipped

23, all Deduped

Locked, read raw

26 of 30

Container

VHDX, hashed on completion

What it does not hold

No prefetch, no amcache, no MFT and only one user's hives: this collection answers questions about logons and system configuration, not about what ran.

Against the plan for the ransomware workstation, a collection like this one would fail. It answers who logged on and how, from the Security log and the SAM and SECURITY hives, and whether a service was installed, from the System log and the SYSTEM hive.

It cannot answer how the attacker got in, what ran, or which files were created and deleted, because mail metadata, prefetch, amcache and the master file table were never targeted. The gap is visible in minutes from the copy log, and closing it means another collection while the host is still available.

The hash is the other half. A hash of the VHDX container, taken when the collection finishes and recorded in the acquisition record, lets anyone verify later that the evidence examined is the evidence collected. The copy log adds a hash for every file inside it.

Mounting the container read-only before examining it keeps both valid. Module 1 ends with this check and with the collection that cannot be repeated, the one where the host has already been rebuilt and the logs are all there is.

08

What Module 1 Builds On It

Acquisition, from volatility to proof

Its working procedure for the first hour fits on one card, and every step on it is a decision rather than a click:

The first hour on a compromised Windows host

Module 1

1

Record the state: time, users, network, what is attached

2

Check encryption and obtain the recovery key

3

Capture memory

4

Collect volatile artifacts and a triage set

5

Image if time and the question demand it

6

Hash, read the logs against the plan, record

What changes it

An active encryption may justify switching off first. Write down that decision and its cost.

Module 1 takes each step of this lesson into depth: the order of volatility as a working procedure, encryption before imaging, memory acquisition, KAPE triage, collection with Velociraptor, full disk imaging, processing the evidence into parsed output, collecting across a fleet, proving a collection is complete, and the collection you cannot repeat. Each of its lessons ends with a procedure a responder can run on a real host.

The habit this lesson sets is to treat collection as the first analytical act rather than a mechanical step. The order of collection decides what evidence exists. The targets decide which questions can be answered. The logs record what was actually taken, including things the responder did not intend, such as which files were locked and which user was signed in.

Collection is also where most investigations quietly lose their strongest evidence. A host reimaged before anyone collected, a log rolled over while a ticket waited, a laptop switched off with its recovery key unknown: none of these is visible in the analysis that follows, only in what the analysis cannot say.

The acquisition record is where those losses are written down, and an honest one is worth more than a long one.

Every artifact in the rest of this module, prefetch, amcache, event logs, the master file table, shellbags, SRUM, the USN journal, arrived at an investigator through a collection like this one.

Reading it starts with knowing whether it was collected at all, which is the question the practice below asks of a real copy log. Every later lesson in this module assumes the answer is yes, and says where the artifact came from.

Do

Practice

Is this collection complete?
prepared evidence

The prepared evidence below is the domain controller's collection: part of its copy log, part of its skip log, and the questions the investigation lead wrote down before anyone touched the host. Read the logs as a manifest and decide which questions this collection can answer.

If you have KAPE, run it against your own machine with the EventLogs and RegistryHives targets and a shadow copy present, then open the copy and skip logs. Find the files read raw, the files deduplicated from the shadow copy, and the one file whose shadow-copy version differed.

Evidence on a running Windows host decays in a known order, and collection follows it: memory and live state first, then the disk, with encryption checked before anything is switched off.

A triage collection is a plan expressed as targets, its copy and skip logs are the manifest of what it took, and it is complete only against the questions written down before it ran. Whatever it did not take, and why, belongs in the acquisition record beside the hashes.

The next lesson reads what one of those collections holds about a single program: whether it ran, when, how many times, and how sure anyone can be about each of those answers.

Resources

Microsoft revises these pages; where a page and this lesson disagree, the page is newer.