Reading width
Wide uses the full column for everything, text, diagrams, code, and exercises. Narrow keeps the standard reading width.
Text size
Scales the body text. Headings and code blocks keep their size.
In this section
Memory Forensics Foundations: What RAM Holds, WinPmem Capture, windows.info and Symbol Tables
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.
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.
What Only Memory Holds
One connection, and the process behind itStart 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.
The Capture Is in the Evidence
Your own footprint, read from the imageCapturing 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 timeWhy 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.
What the Image Says About Itself
windows.info, read before anything elseBefore 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.
Symbol Tables
Why nothing reads without oneA 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 errorWhy 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.
Proving the Image Resolves
Readable is a finding, not an assumptionAn 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.
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.
An Image Takes Seconds
What moves while memory is copiedThe 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.
What Module 1 Builds On It
Memory acquisition in depthModule 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 1Every 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.
Practice
Separate the capture from the compromise prepared evidenceThe 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.