In this section

Memory Forensics Foundations: What RAM Holds, WinPmem Capture, windows.info and Symbol Tables

Module 0

Introduction

Most of what an attacker does on a Windows host happens in memory and never reaches the disk in a form anyone can read later. Code is loaded into another process without a file behind it, a network session is held by a process that has no business holding one, a tool runs, does its work and exits.

When the host is switched off, all of it goes. Memory forensics is the practice of capturing that state before it goes, and then reading it with the same rigor as any other evidence.

The diskfiles, hives, logsprefetch, MFTonly while runningMemory onlycode with no fileconnection ownersexited processesunless capturedLost at power-offeverything in themiddle box

What a running Windows host holds that its disk does not. The middle box is the subject of this course, and it is gone the moment the host stops.

This lesson reads one capture from the course's Memory Range: NE-ENG-031, a Windows 11 workstation captured with WinPmem at 14:30 on 15 March 2026, after a reflective injection into explorer.exe earlier that afternoon. Every output on this page is what the range prints for the same command.

The lesson covers what only memory holds, what the capture itself leaves in the image, what the image says about itself, the symbol tables every plugin depends on, and the seconds an acquisition takes. Module 1 teaches acquisition in depth.

01

What Only Memory Holds

One connection, and the process behind it

Start with one question a firewall cannot answer. A session from this workstation to 10.5.0.20 on port 4444 is suspicious on its face. Every network record can say that the session existed. Only the host knows which process owned it:

$ vol --hide-columns Offset Proto State -f NE-ENG-031-1431.raw windows.netscan \
    | grep -e Owner -e 4444
Progress:  100.00		PDB scanning finished
LocalAddr	LocalPort	ForeignAddr	ForeignPort	PID	Owner	Created
10.5.0.31	52014	10.5.0.20	4444	1428	explorer.exe	2026-03-15 14:06:58.000000 UTC

The owner is explorer.exe, PID 1428: the Windows shell, the process that draws the desktop and the taskbar. It has no reason to hold a session to an address on port 4444, and in this capture it does because code was injected into it and that code opened the session. The connection's creation time, 14:06:58, is recorded alongside it.

That pairing of socket and process is the kind of fact memory is uniquely good at. The disk has no record of which process owned a socket that has since closed. The event logs may or may not, depending on what was configured.

A packet capture holds the conversation and nothing about the process. Memory holds the kernel's own table of connections with the owner written into each one, for as long as the host runs.

The same is true of the injected code itself, which exists only in explorer.exe's memory, and of processes that ran and exited, which the kernel may still hold traces of until their memory is reused. Each of those has its own lesson in this module.

The point here is the one that decides the first minutes of an incident: everything in this paragraph is lost when the host is switched off, and nothing on the disk can bring it back. The order an analyst collects in, and whether memory is captured at all, decides which of these questions the investigation can ever answer.

Notice what the output did not need. No reputation lookup, no knowledge of the attacker's tools, no prior baseline. A process that draws the desktop owning a session to a high port on an internal address is unusual on its own terms, and memory says so in one line. Most of this course is that kind of reading: knowing what a structure normally holds and noticing where it does not.

02

The Capture Is in the Evidence

Your own footprint, read from the image

Capturing memory from a running host means running a program on it, and that program is in the image it captures. The last rows of the process list:

$ vol --hide-columns Threads Handles Wow64 File Exit -f NE-ENG-031-1431.raw \
    windows.pslist | tail -7
Progress:  100.00		PDB scanning finished
2884	1428	OUTLOOK.EXE	0xd187c07a44c0	1	2026-03-15 09:02:17.000000 UTC
3312	1428	cmd.exe	0xd187c3dd24c0	1	2026-03-15 14:07:33.000000 UTC
5128	3312	conhost.exe	0xd187c3ec0300	1	2026-03-15 14:07:34.000000 UTC
6940	1428	cmd.exe	0xd187c0789ec0	1	2026-03-15 14:30:41.000000 UTC
6952	6940	conhost.exe	0xd187c3bbf900	1	2026-03-15 14:30:42.000000 UTC
4120	6940	winpmem.exe	0xd187c2db7d40	1	2026-03-15 14:30:58.000000 UTC
4128	4120	conhost.exe	0xd187c278ad80	1	2026-03-15 14:30:58.000000 UTC

The capture tool is there, winpmem.exe PID 4120, started at 14:30:58 from a command prompt, cmd.exe PID 6940, opened at 14:30:41. Each has a console host beside it. The image of 101 processes includes four that exist only because somebody captured it.

Look at the parents. The analyst's cmd.exe 6940 is a child of explorer.exe 1428, because the analyst opened it from the desktop. So is cmd.exe 3312, started at 14:07:33, which is the attacker's: the injected code in explorer.exe launched it. Two command prompts with the same parent, twenty minutes apart. The process list cannot say which is which. The command lines say more:

$ vol -f NE-ENG-031-1431.raw windows.cmdline --pid 3312 6940 4120
Volatility 3 Framework 2.28.2
Progress:  100.00		PDB scanning finished

PID	Process	Args

3312	cmd.exe	"C:\Windows\system32\cmd.exe"
6940	cmd.exe	"C:\Windows\system32\cmd.exe"
4120	winpmem.exe	E:\tools\winpmem.exe E:\evidence\NE-ENG-031-1431.raw

The capture tool's command line names its output, an image written to E:, not to the workstation's own system drive, so the act of capturing did not overwrite deleted data on the disk under investigation. What separates the analyst's cmd.exe from the attacker's is not anything in memory. It is the acquisition record, written at the time:

Acquisition record: NE-ENG-031

Written at the time

Tool

WinPmem, raw image

Started

14:30:58 UTC, PID 4120

From

cmd.exe PID 6940, at the console

Written to

E:\evidence\NE-ENG-031-1431.raw

Image time

2026-03-15 14:31:06 UTC

Hash

SHA-256, taken at acquisition

Why it matters here

Two cmd.exe processes sit under explorer.exe in this image. The record is what says which one was the analyst.

That record is the first artifact of every memory investigation, and Module 1 treats it as part of the evidence. Without it, a later reader of this image has two unexplained command prompts and no way to rule one out.

The footprint is also why a capture tool's choice and location matter. A tool run from a USB drive or a network share leaves its path in the process list and its driver in the module list, and both are expected; a tool copied onto the system drive first overwrites free space that might have held deleted evidence.

Every one of those choices should be in the record, so that a reviewer can tell an artifact of the response from an artifact of the attack.

03

What the Image Says About Itself

windows.info, read before anything else

Before reading a single process, ask the image what it is. windows.info finds the kernel, reports how Volatility is reading the file and prints the values the kernel itself keeps about the machine:

$ vol -f NE-ENG-031-1431.raw windows.info
Volatility 3 Framework 2.28.2
Progress:  100.00		PDB scanning finished

Variable	Value

Kernel Base	0xf80342a00000
DTB	0x1ad000
Symbols	file:///.../windows/ntkrnlmp.pdb/B857959AD591F829F5D6CDAEDBEA975C-1.json.xz
Is64Bit	True
IsPAE	False
layer_name	0 WindowsIntel32e
memory_layer	1 FileLayer
KdVersionBlock	0xf8034392c400
Major/Minor	15.26100
MachineType	34404
KeNumberProcessors	2
SystemTime	2026-03-15 14:31:06+00:00
NtSystemRoot	C:\Windows
NtProductType	NtProductWinNt
NtMajorVersion	10
NtMinorVersion	0
PE MajorOperatingSystemVersion	10
PE MinorOperatingSystemVersion	0
PE Machine	34404
PE TimeDateStamp	Thu Jan  9 06:42:18 2025

Read it top to bottom. Is64Bit and layer_name say Volatility found a 64-bit kernel and built a view of virtual memory on it; memory_layer says that view sits on a file. Major/Minor and NtMajorVersion identify the Windows build, 26100 here, which matters for every plugin that reads structures whose layout changes between builds. KeNumberProcessors is the number of processors the kernel was using.

SystemTime is the kernel's clock as the image holds it: 2026-03-15 14:31:06+00:00. That is the nearest thing an image has to a timestamp of its own, and it is eight seconds after winpmem.exe started. Write it down beside the hash, because every later time in the investigation is read against it.

If it disagrees with the time the analyst recorded for the capture by more than the capture's own duration, the host's clock was wrong, and every timestamp in the image is offset by the same amount.

The output also says where the analysis can go wrong before it starts. If windows.info fails, nothing after it will work, and the reason is almost always the next section's subject rather than the image. Running it first costs a few seconds and tells you whether the rest of the morning will be spent reading evidence or fixing a toolchain.

Note also what windows.info does not report. It does not say who was logged on, what was running or whether anything was wrong. It describes the container, not the contents: the build, the architecture, the clock and the layers.

That is exactly what is needed before reading the contents, because every plugin that follows interprets bytes according to what windows.info found, and a wrong answer here makes every later answer wrong in ways that look plausible.

04

Symbol Tables

Why nothing reads without one

A memory image is bytes. To find a process in it, Volatility needs to know where the kernel keeps its process list and the layout of the structure each entry points to: which offset holds the name, which the PID, which the parent.

That layout is not in the image. It is in the debugging symbols Microsoft publishes for each kernel build, and Volatility uses them converted into its own JSON symbol tables:

$ vol -f NE-ENG-031-1431.raw windows.info | grep -e Symbols -e layer -e Is64Bit
Progress:  100.00		PDB scanning finished
Symbols	file:///.../windows/ntkrnlmp.pdb/B857959AD591F829F5D6CDAEDBEA975C-1.json.xz
Is64Bit	True
layer_name	0 WindowsIntel32e
memory_layer	1 FileLayer

The Symbols line names the table this image resolved to. Volatility's documentation describes how it gets one for Windows: it identifies the kernel's PDB by its GUID and age, searches the symbol directories it has been given, and if no table matches, downloads the PDB from Microsoft's Symbol Server and converts it. It keeps a cache of which identifier maps to which file under the user's home directory, in .cache/volatility3.

Two practical consequences follow. An analysis workstation with no internet access cannot fetch a table it has never seen, so a lab that will analyze images offline needs the tables in place beforehand. And when a table is missing, the failure does not say so plainly:

When every plugin fails at once

Read the right error

Symptom

unsatisfied requirements, on every plugin

Looks like

a corrupt or invalid image

Usually is

no symbol table for this kernel build

Check first

windows.info, and the Symbols line

Why it misleads

Volatility cannot read a single structure without the table, so a missing table and a broken capture fail the same way. Rule out symbols before you doubt the capture.

Linux is harder still. There is no central symbol server for Linux kernels, so a table has to be built for the exact kernel the image came from, from that kernel's debugging information. Module 1's Linux acquisition lesson and Module 7 both turn on whether that can be done, and an image whose kernel's symbols are gone may never be readable at all.

For an investigation, the lesson is about preparation rather than analysis. The time to make sure symbol tables can be obtained for a fleet's kernels is before an incident, when the machines and their updates are known, not afterwards, when the image is the only copy of a kernel that may have been patched since.

A team that analyzes memory offline keeps the tables for its own builds beside its tools.

05

Proving the Image Resolves

Readable is a finding, not an assumption

An image is usable when three things are true: the file is the one that was captured, Volatility can find the kernel in it, and the structures it walks come back consistent. Each is checked separately.

1. Record the state firsttime, logged-on users, network, what is attached2. Run the capture toolWinPmem to a drive that is not the evidence disk3. Hash the imageand write the hash into the acquisition record4. Check that it resolveswindows.info finds a kernel, pslist returns processes5. Note your own footprintthe shell and tool you started, with their PIDs

Acquiring memory from a running Windows host, in the order Module 1 teaches it. Every step leaves something the next analyst reads.

The first is the hash. WinPmem's documentation describes its output as a raw image, a straight copy of physical memory; the hash taken when it is written is what proves later that the file analyzed is the file captured. It is not a check on the image's quality, only on its identity, and it belongs in the acquisition record next to the tool, the time and the destination.

The second is windows.info returning a kernel, as in section 3. The third is a plugin returning what a running Windows machine should. The first rows of the process list:

$ vol --hide-columns Threads Handles Wow64 File Exit -f NE-ENG-031-1431.raw \
    windows.pslist | head -8
Progress:  100.00		PDB scanning finished
Volatility 3 Framework 2.28.2

PID	PPID	ImageFileName	Offset(V)	SessionId	CreateTime

4	0	System	0xd187c2060580	N/A	2026-03-15 07:41:02.000000 UTC
336	4	smss.exe	0xd187c0a4e600	N/A	2026-03-15 07:41:04.000000 UTC
120	4	Registry	0xd187c3761f40	N/A	2026-03-15 07:41:06.000000 UTC
2188	4	MemCompression	0xd187c22204c0	N/A	2026-03-15 07:41:09.000000 UTC

That is what a coherent image looks like: System as PID 4 with no parent, smss.exe as its child two seconds later, then Registry and MemCompression, also children of System, each parent present and each child created after it.

The list goes on in the same order through the services, the user's logon and the applications that followed. This image returns 101 processes, starting from System at boot, which is ordinary for a Windows 11 workstation with a user signed in.

A capture that passes the first check and fails the others is still evidence, but of something else: a capture tool that failed, a format Volatility did not recognize, or a host that was changing too fast to copy coherently. Module 1's verification lesson builds those checks into a routine, and its lesson on anti-acquisition reads what an attacker can do to make an image fail them on purpose.

The order of the checks matters as much as the checks. Hashing first means any later doubt about the file can be settled against the record. Resolving the kernel second separates a toolchain problem from an evidence problem.

Reading a coherent process list third confirms that the structures came out of the copy in a usable state. An analyst who skips straight to hunting for injected code has assumed all three.

06

An Image Takes Seconds

What moves while memory is copied

The image is not a photograph. WinPmem's documentation says it loads a driver and reads physical memory with one of three methods, page by page, while the machine keeps running. Here it started at 14:30:58 and the kernel's clock in the image reads 14:31:06: the copy took about 8 seconds, and every page was copied at a slightly different moment within them.

On a quiet workstation that rarely matters. On a busy one, a structure can change between the moment its first page is copied and the moment its last one is, and the image then holds a version of it that never existed: a list whose links point to an entry already freed, a process whose threads were copied after it exited.

That inconsistency is called smear, and its size grows with the load on the host and the time the copy takes.

Smear has a practical consequence for reading output. When two plugins disagree about something that changed during the capture, the disagreement may be smear rather than an attacker hiding something.

The capture tool's own console host, created in the same second as the tool, is a reminder that the image was still being written while the machine kept working. The processes the analyst started are all in the last half minute of the window:

$ vol --hide-columns Threads Handles Wow64 File Exit -f NE-ENG-031-1431.raw \
    windows.pslist | grep -e 14:30:58 -e 14:30:4
Progress:  100.00		PDB scanning finished
6940	1428	cmd.exe	0xd187c0789ec0	1	2026-03-15 14:30:41.000000 UTC
6952	6940	conhost.exe	0xd187c3bbf900	1	2026-03-15 14:30:42.000000 UTC
4120	6940	winpmem.exe	0xd187c2db7d40	1	2026-03-15 14:30:58.000000 UTC
4128	4120	conhost.exe	0xd187c278ad80	1	2026-03-15 14:30:58.000000 UTC

Everything in that output was created during the twenty-five seconds in which the analyst sat down, opened a prompt and started the copy. None of it is evidence of the intrusion, and all of it is evidence of the response. Keep the two apart in every report you write.

Module 1's lesson on smear measures it on the course's own captures and sets a threshold for when an image's inconsistencies stop being acquisition noise and start being evidence. Until then, read times near the end of the capture with that window in mind. The same discipline applies to every capture in this course: the window is short, but it is a window, and a careful report says so.

07

What Module 1 Builds On It

Memory acquisition in depth

Module 1 starts with the acquisition problem, then captures Windows memory with WinPmem, Linux memory with LiME and AVML, and virtual machines from the hypervisor, which avoids running anything on the guest at all.

It reads the pagefile and swap as evidence next to memory, verifies captures, measures smear, and covers the techniques attackers use against acquisition. It ends with a decision exercise: which capture, by which method, under which constraints.

The constraints are the realistic ones: a host that cannot be suspended, a kernel with protections that block a capture driver, an attacker who may notice the capture starting, and a response team that has minutes rather than hours. Each method trades something for something else, and the module measures the trade on real captures rather than describing it.

By the end of it, the checks in this lesson are a routine you run on every capture without thinking about it, which is the point: an acquisition that is checked the same way every time can be defended the same way every time, by anyone who reads the record afterwards.

What Module 1 builds

Module 1

1.1 to 1.2

the acquisition problem; WinPmem

1.3 to 1.4

LiME and AVML; hypervisor capture

1.5 to 1.6

pagefile and swap; verification

1.7 to 1.9

smear; anti-acquisition; the decision

Every later module captures its own images in the course lab and reads them in the Memory Range, so the acquisition record and the checks in this lesson recur on every capture. The range serves the same captures this page reads, with the same output. The range holds Windows captures; Module 1's Linux and hypervisor lessons work from the course lab, where you capture your own.

The habit to carry into it is to treat the capture as an action in the investigation, with consequences, rather than as the step before it starts. Record the state before running anything, write the image off the evidence disk, hash it, prove it resolves, note your own processes by PID, and remember that what you read is a window of a few seconds, not an instant.

Most of the mistakes Module 1 guards against are made before any analysis: a capture taken too late, written to the wrong disk, never hashed, or read without checking that it resolves. Each is cheap to avoid at the time and impossible to repair afterwards, which is why the module spends its first lessons on acquisition rather than on hunting.

Do

Practice

Separate the capture from the compromise
prepared evidence

The prepared evidence below is the last rows of this image's process list, its windows.info values and its connection table. Find the processes the analyst started, the moment the image represents, and the connection that only memory can tie to a process. Each answer comes with its reasoning, so check it against the rows rather than only the choice.

Look at parents and creation times together: the process list alone shows two command prompts under the same parent, and only the order of events, set against what the analyst wrote down, separates them. The Image tab is the image describing itself, and its clock is the one every other time is read against.

If you have a Windows virtual machine, take a snapshot of it and open the snapshot's memory file with windows.info. A hypervisor's suspended state is a memory image taken without running anything on the guest, which is one of the methods Module 1 compares.

Memory holds what the disk never records: code with no file, the owner of a socket, processes that ran and left.

Capturing it runs a tool that appears in the image, so the acquisition record is part of the evidence; windows.info says what the image is; symbol tables decide whether anything reads at all; an image is proven by its hash, a resolved kernel and a coherent process list; and it represents a window of seconds, not an instant.

The next lesson reads the process list properly, and the processes it does not show.