Volatility 3 is the framework most responders reach for when a memory image has to answer what was really running, but it only gives defensible answers when symbols, plugin choice and evidence handling are prepared before the incident. This guide explains how the framework works (translation layers, automagic and symbol tables rather than Volatility 2 profiles), which plugins answer which investigation questions on Windows and Linux, and how to run it safely on sensitive evidence. It goes deeper than the Memory Forensics Guide, which covers when and how to acquire memory, and focuses on the tool itself. It is for DFIR analysts, incident responders and detection engineers. Facts about plugins and options were checked against the project's repository and documentation (framework version 2.28.3 on the develop branch) on 27 October 2026.
This is an independent guide from NHI Mgmt Group, based on the Volatility Foundation's public documentation as of November 2026. It is not sponsored or reviewed by the Volatility Foundation. Product features change, so confirm settings against the Volatility Foundation's current documentation.
Key takeaways
- There are no profiles any more. Volatility 3 uses JSON symbol tables (ISF files); Windows symbols are usually generated from Microsoft PDBs automatically, while Linux and macOS symbols must match the kernel banner exactly.
- Plugin names have moved. Malware-hunting plugins now live under
windows.malware.*and registry plugins underwindows.registry.*; older names such aswindows.malfindstill run but are marked deprecated. - Cross-view comparison finds hiding. List-walking plugins (
pslist,svclist) compared with scanning plugins (psscan,svcscan,psxview,svcdiff) are how unlinked processes and services surface. - Offline mode and a staged symbol cache matter for evidence. By default the framework may fetch PDBs and remote ISF data;
--offlineplus pre-staged symbol packs keeps analysis reproducible and inside your network. - The licence has a wrapper clause. The Volatility Software License requires publishing source for Additions, which explicitly include wrappers built to run Volatility and parse its results.
What the tool does
Volatility 3 is a Python framework, maintained by the Volatility Foundation, that extracts artefacts from a memory sample independently of the system it came from. It was released in 2019 as a complete rewrite of Volatility 2, requires Python 3.8.0 or later and is published on PyPI as volatility3. The stable branch on GitHub holds the latest stable release; develop is the default branch. The command-line entry point is vol (or vol.py from a clone), with volshell for interactive exploration.
Volatility does not acquire memory. The project documentation points to WinPmem and FTK Imager for Windows and Microsoft AVML for Linux; acquisition method and tool choice are covered in the Memory Forensics Guide.
How it is built
| Concept | What it means in Volatility 3 | Why an analyst cares |
|---|---|---|
| Translation layers | Replace Volatility 2 address spaces; a layer can depend on several lower layers, which is how swap files are integrated (--single-swap-locations) | Pagefile or swap evidence can be added to the analysis instead of being ignored |
| Automagic and stackers | Automatically detects the image format and stacks layers (for example a raw file, then an Intel page-table layer) | Most runs need only -f image plugin; when detection fails, verbose logs (-vvv) show where |
| Symbol tables (ISF) | JSON, optionally .json.gz or .json.xz, under the symbols directory or zip packs named after the OS | Wrong or missing symbols are the most common reason a plugin returns nothing |
| Static objects | Data is read once when an object is constructed and does not change during a run | Faster than Volatility 2, but live memory analysis is effectively out of scope |
| Renderers | -r selects quick (default), pretty, csv, json or jsonl | JSON lines with -q feeds directly into a SIEM, Timesketch or a notebook |
Symbols in practice
- Windows: the framework reads the PDB name, GUID and age from the image, looks for a matching ISF under
symbols/windows, and if none exists downloads the PDB from Microsoft's symbol server, converts it and caches it.pdbconv.pyconverts a PDB manually when the analysis host is offline. - Linux and macOS: symbols are matched on the kernel banner string, which must match exactly, including build details such as compile time and compiler version. Run the
bannersplugin first, then obtain the matching debug kernel and convert it withdwarf2json. The documentation is candid that the right symbols may not always be obtainable for a given Linux kernel. - Symbol packs: the project publishes Windows, Mac and Linux packs with SHA256 checksums. Place the zip files as named in the symbols directory (or point
-sat them). The first run builds a cache, which can take time but is only needed once per location. - Cache: cached symbol data lives under
~/.cache/volatility3(or$XDG_CACHE_HOME/volatility3).--clear-cacheresets short-term items and--cache-pathchanges the location.
Defender use cases
The plugins below are grouped by the question an investigator is trying to answer. Names are as published in the current repository; run vol <plugin> -h for options, since plugin options are dynamic and listed after the plugin name.
Windows plugins by investigation question
| Question | Plugins | Related ATT&CK technique |
|---|---|---|
| Can the image be read, and which build is it? | windows.info | (baseline) |
| What was running, and is anything hidden? | windows.pslist, windows.psscan, windows.pstree, windows.malware.psxview | T1014 Rootkit |
| What did processes run with? | windows.cmdline, windows.envars, windows.consoles, windows.cmdscan | T1059.001 PowerShell |
| Is there injected or unbacked code? | windows.malware.malfind, windows.malware.ldrmodules, windows.malware.hollowprocesses, windows.malware.processghosting, windows.malware.pebmasquerade | T1055 Process Injection, T1055.012 Process Hollowing, T1620 Reflective Code Loading |
| Is EDR or ETW being bypassed? | windows.etwpatch, windows.malware.unhooked_system_calls, windows.malware.direct_system_calls, windows.malware.indirect_system_calls | TA0112 Defense Impairment |
| Who talked to whom? | windows.netscan, windows.netstat | T1071.001 Web Protocols |
| How does it persist? | windows.svcscan, windows.malware.svcdiff, windows.registry.scheduled_tasks, windows.registry.printkey | T1543.003 Windows Service, T1053.005 Scheduled Task, T1547.001 Registry Run Keys |
| Is a kernel component hiding activity? | windows.modscan, windows.malware.drivermodule, windows.callbacks, windows.ssdt, windows.timers | T1014 Rootkit |
| Were credentials exposed? | windows.registry.hashdump, windows.registry.lsadump, windows.registry.cachedump, windows.malware.skeleton_key_check | T1003.001 LSASS Memory |
| Which files and executables were present? | windows.filescan, windows.dumpfiles, windows.mftscan, windows.shimcachemem, windows.registry.amcache | (supporting evidence) |
| Does a known signature match? | windows.vadyarascan with your YARA rules | (depends on rule) |
Linux plugins by investigation question
| Question | Plugins |
|---|---|
| Which kernel is this, so I can find symbols? | banners |
| Processes and hidden tasks | linux.pslist, linux.psscan, linux.pstree, linux.malware.process_spoofing |
| Commands typed | linux.bash (history recovered from bash process memory) |
| Kernel rootkits | linux.malware.check_syscall, linux.malware.check_idt, linux.malware.hidden_modules, linux.malware.modxview, linux.malware.tty_check, linux.malware.keyboard_notifiers |
| Privilege abuse | linux.malware.check_creds (shared credential structures), linux.capabilities, linux.ptrace |
| Network and packet filtering | linux.sockstat, linux.malware.netfilter, linux.ebpf |
| Injected code and signatures | linux.malware.malfind, linux.vmayarascan, linux.elfs |
A repeatable triage order
- Validate the image: run
windows.infoorbanners; if it fails, fix symbols or the image format before anything else. - Baseline processes:
pstree, thenpsscanandpsxviewto compare views; note parents that do not fit (an Office process spawning a shell, a service host with an odd path). - Command lines and network:
cmdlineandnetscanfor the processes of interest; pivot on remote addresses in network and proxy logs. - Code integrity:
malfind,ldrmodules,hollowprocessesand the system call plugins; dump suspect regions with--dumpinto a controlled output directory (-o) for static analysis. - Persistence and kernel: services, scheduled tasks, drivers and callbacks.
- Timeline:
timelinercombines time-aware plugin output and can write a bodyfile (--create-bodyfile) for merging with disk timelines in Plaso or other tools. See the Forensic Timeline Analysis Guide.
Dumped regions and files are inputs to the Malware Analysis Guide for Defenders workflow, and strings or byte patterns found there become YARA rules for vadyarascan across other images. See the YARA Rules Guide.
Deployment and safe use
Analysis host
- Install: use a virtual environment and pin a release (
pip install volatility3, or a clone ofstable). Record the framework version in case notes: plugins and output columns change between releases. - Isolation: analyse on a dedicated forensic workstation, not on the affected estate. Memory images may contain live malware pages; Volatility parses rather than executes them, but dumped regions can be executable files.
- Offline operation: stage symbol packs and verify them against the published SHA256SUMS, then run with
--offlineso the tool does not search online for JSON files, Windows symbol tables or Linux and macOS banner repositories. Set it permanently in~/.config/volatility3/vol.json(or%APPDATA%/volatility3/vol.json), remembering that a boolean set true there is not unset by omitting the flag. - Plugin directories:
-ploads extra plugin paths before the built-in ones, and the documentation warns that all Python code in those directories is evaluated. Only load community plugins you have reviewed.
Evidence handling
- Work on a copy: hash the acquired image, analyse a verified working copy and keep the original read-only. See the Evidence Handling and Chain of Custody Guide.
- Record every run:
-lwrites full logs to a file and--save-configwrites aconfig.jsonthat recreates the environment; keep both with the case. This supports NIST CSF 2.0 RS.AN-06 (investigation actions recorded with integrity and provenance preserved). - Treat output as secret:
hashdump,lsadumpandcachedumpoutput, environment variables and dumped process memory can hold passwords, NTLM hashes, LSA secrets, API keys and session tokens. Store output with the same controls as the image.
Licensing
Volatility 3 is released under the Volatility Software License (VSL) version 1.0. It allows free use, sharing and building on the software, but if you make Additions available to others you must publish their source code. The licence text defines Additions to include software designed to execute Volatility and parse its results, such as a wrapper, but not general shell or execution menu software. Teams embedding Volatility in a commercial or shared triage platform should have the licence reviewed before distribution.
Detection and hardening value
Memory analysis findings should feed back into prevention and detection, not stop at the report.
| Finding in memory | Feed it back as | Framework reference |
|---|---|---|
| Unbacked executable region in a signed process | EDR rule on the parent and injection pattern; YARA rule from the dumped bytes | NIST SP 800-53 SI-3, SI-4 |
| ETW patching or unhooked ntdll stubs | Alert on loss of telemetry from a host; review EDR tamper protection | TA0112 Defense Impairment; see the EDR Tampering and BYOVD Response Playbook |
| Credential material exposed (hashdump, LSA secrets) | Rotate the affected accounts, including service accounts; enable LSA protection where supported | T1003.001; NIST SP 800-53 IR-4 |
| Malicious service, task or Run key | Detection on service and task creation events; hunt the same artefact fleet-wide | T1543.003, T1053.005, T1547.001 |
C2 address in netscan | Block and hunt in proxy and DNS logs; share as an indicator | NIST CSF 2.0 DE.AE-02, DE.AE-03 |
Where identity fits
Memory is where attackers harvest machine credentials: service account passwords in LSA secrets, cached domain credentials, cloud tokens in process environments and API keys in application heaps. Every memory case should end with a list of identities whose secrets were resident on the host and a rotation decision for each. See the Credential Dumping Guide and the Service Account Security Guide.
Measuring the capability
- Image-to-first-answer time: minutes from receiving an image to a validated process list; target under 30 minutes for Windows images with staged symbols.
- Symbol coverage: share of your Linux kernel builds (by banner) with a tested ISF file on the analysis host.
- Offline success rate: share of exercise images analysed with
--offlinewithout missing-symbol failures. - Feedback rate: share of memory cases producing at least one new detection, YARA rule or hardening ticket.
- Credential follow-through: share of exposed identities rotated within the agreed window.
Common failure patterns
- Empty output blamed on the image: a Linux image analysed with a near-match symbol file produces nothing; the banner must match exactly, so stage symbols for your production kernels in advance.
- Trusting one plugin:
pslistalone misses unlinked processes; always compare withpsscanandpsxview. - Old command references: runbooks written for Volatility 2 (
--profile,imageinfo) or for early Volatility 3 plugin names slow responders down; update them to thewindows.malware.*andwindows.registry.*names. - Silent internet dependency: analysis fails or leaks indicators of a case because the workstation fetched PDBs or ISF data during a run; use
--offlinewith staged symbols. - Exposed credentials left unrotated: the report notes hashes and secrets found in memory but nobody owns rotation, so the attacker's harvested access survives remediation.
Alternatives
| Option | Choose it when | Trade-off |
|---|---|---|
| Volatility 3 CLI | Deep, scripted analysis of individual images with full control of plugins and output | Needs Python skills and symbol preparation, especially for Linux |
| Volatility 2 | Only for reproducing old case results that depended on its plugins | Python 2 era code and profiles; not the basis for new runbooks |
| Live response via an endpoint agent | Fleet-wide questions (is this process or mutex anywhere?) where a full image per host is impractical | Queries a running, possibly compromised, OS; see the Velociraptor Guide |
| Commercial memory forensics suites | Teams wanting a GUI, vendor support and integrated reporting | Licence cost; confirm with the vendor how artefacts are parsed |
| EDR memory scanning | Continuous detection of known injection patterns | Detection, not forensic analysis; results are not a substitute for an image |
Small teams usually do best with Volatility 3 for occasional deep cases and an incident response retainer for surge work; larger teams build a symbol pipeline for every production kernel and automate the triage order above with JSON lines output. See the Open Source DFIR Tools Landscape Guide for where it sits in a wider toolkit.
Practitioner checklist
- Pin a Volatility 3 release in a virtual environment on a dedicated forensic workstation and record the version in every case.
- Download the Windows, Mac and Linux symbol packs, verify SHA256 checksums and pre-build the cache.
- Generate and test ISF files with
dwarf2jsonfor every Linux kernel you run in production. - Set
--offlineas the default invol.jsonfor case work. - Update runbooks to current plugin names (
windows.malware.*,windows.registry.*). - Compare list-walking and scanning plugins before concluding nothing is hidden.
- Keep
-llogs and--save-configfiles with case evidence; protect plugin output as secret data. - Turn each finding into a detection, YARA rule or credential rotation ticket.
- Have the VSL reviewed before distributing any wrapper or platform built on Volatility.
Standards and references
- Volatility Foundation: Volatility 3 repository and README
- Volatility Foundation: Volatility 3 documentation
- Volatility Foundation: Volatility Software License v1.0
- Volatility Foundation: dwarf2json
- Microsoft: AVML (Acquire Volatile Memory for Linux)
- NIST: SP 800-86 Guide to Integrating Forensic Techniques into Incident Response
- MITRE ATT&CK: Process Injection
- NIST: Cybersecurity Framework 2.0
Related NHI Mgmt Group resources: Memory Forensics Guide · Open Source DFIR Tools Landscape Guide · Malware Analysis Guide for Defenders · Forensic Timeline Analysis Guide · Credential Dumping Guide