Skip to content
Tutorials Center
My learning

Topics

Lesson 16 of 36 ยท Memory Forensics

Process Listing and Hidden Processes

Learn how analysts list processes in a memory image, why pslist and psscan can disagree, how to spot suspicious parents, paths and names, and how to cross-check process lists.

The first question about a memory image is almost always "what was running?" Answering it sounds easy, but there are several ways to build the list, and the disagreements between them are the interesting part. A process that appears in one list and not another may have exited, may have been hidden by an intruder, or may just be a tool artifact. This lesson shows how the lists are made, how to read them and how to compare them.

Where process lists come from

On Windows the kernel keeps every process as an EPROCESS structure. These structures are linked in a doubly linked list (ActiveProcessLinks) that tools such as Task Manager walk to list processes. Memory-forensics tools can look at them in different ways:

Method Volatility 3 plugin How it works Finds
List walk windows.pslist Follows the linked list from the kernel's head pointer Processes still linked in
Pool scan windows.psscan Scans all memory for EPROCESS patterns Processes unlinked, plus recently terminated ones
Tree view windows.pstree Draws parent/child relationships Odd parentage
Command lines windows.cmdline Reads each process's arguments What was actually run
Handles / DLLs windows.handles, windows.dlllist Per-process objects and libraries Files, keys, injected libraries

Linux has similar plugins (linux.pslist, linux.psscan, linux.pstree, linux.bash).

A rootkit hides a process by unlinking its EPROCESS from the list ("direct kernel object manipulation", DKOM). Task Manager and pslist then no longer show it, but the structure is still sitting in memory, and psscan finds it by pattern. The classic technique is therefore cross-view detection: compare the lists, and investigate any process in one but not the other.

flowchart LR
    A["Kernel list<br/>(pslist)"] --> C["Compare"]
    B["Pool scan<br/>(psscan)"] --> C
    C --> D["Only in scan, no exit time:<br/>possibly hidden"]
    C --> E["Only in scan, has exit time:<br/>terminated process"]
    C --> F["In both:<br/>normal"]

Sample output (read-only)

A shortened Volatility 3 listing (made-up process names and times, not produced here):

TEXT
$ vol -f mem.raw windows.pslist
PID   PPID  ImageFileName   CreateTime            ExitTime
4     0     System          2025-04-02 08:00:03   -
612   4     smss.exe        2025-04-02 08:00:03   -
1340  612   wininit.exe     2025-04-02 08:00:09   -
2200  1340  services.exe    2025-04-02 08:00:10   -
4012  2200  svchost.exe     2025-04-02 08:01:02   -

Cross-view in practice

The stand-in below holds two made-up lists and classifies each process. Process 6120 is in the scan but not in the linked list and has no exit time, which is exactly the red flag. Process 5004 is only in the scan but has an exit time, so it is just a finished process.

Python Cross-view process comparison

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Reading the process tree

On a healthy Windows system the tree has predictable shapes. Deviations from them are leads:

Process Expected parent Notes
System (PID 4) none One instance
smss.exe System One instance
wininit.exe smss.exe (exits afterwards) Parent often absent in dumps
services.exe wininit.exe One instance
lsass.exe wininit.exe One instance; critical for credentials
svchost.exe services.exe Many instances, normally with -k in the command line
explorer.exe userinit.exe (exits) One per logged-in user
Office apps, browsers explorer.exe A browser started by a service is odd

Typical red flags:

  • Wrong parent: svchost.exe whose parent is not services.exe; cmd.exe or powershell.exe launched by an Office program.
  • Wrong path: a svchost.exe running from a user folder instead of C:\Windows\System32.
  • Look-alike names: scvhost.exe, svch0st.exe, lsass.exe with a capital I instead of a lower-case L.
  • Duplicate single-instance processes (two lsass.exe).
  • Unusual start times (a "system" process created hours after boot) or session mismatch.
  • Suspicious command lines: long encoded arguments, hidden window flags.

The checker below applies several of these rules to a made-up listing.

Python Rule-based triage of a process listing

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Rules like these generate leads, never verdicts: a legitimate program can have an unusual parent, and an attacker can imitate a perfect one.

Command lines and what they reveal

windows.cmdline shows the arguments each process started with. A process name alone says little, but its command line does. Compare:

  • svchost.exe -k netsvcs -p (normal service host)
  • powershell.exe -nop -w hidden -enc <long base64 text> (hidden, encoded commands, which is a frequent sign of automated or malicious activity)

Encoded PowerShell is often Base64 of UTF-16LE text, and decoding it shows the real command (bytes and encodings). Here is a harmless example: decoding the Base64 of a simple command.

Python Decode an encoded command line (harmless example)

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Always decode but never run a decoded command from evidence outside an isolated lab.

Extracting evidence from a process

After spotting a suspicious process, analysts typically:

  1. Note its PID, parent, create time, path and command line.
  2. List its network connections and open handles (files, registry keys, mutexes).
  3. List its loaded DLLs and check for ones loaded from odd places.
  4. Dump the process memory or executable (windows.memmap, windows.pslist --dump) and hash it, for lab analysis or reputation lookups.
  5. Record everything in the case notes with the image's hash.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Why can psscan find a process that pslist misses?

    A rootkit can unlink a process from the kernel list, but the structure is still in memory and can be found by scanning.
  2. 2. A process appears only in psscan and has an exit time. What is the most likely explanation?

    An exit time indicates a normal termination; remnants of finished processes stay until memory is reused.
  3. 3. Which is a typical red flag?

    svchost.exe should be started by services.exe; an Office parent is highly unusual.
  4. 4. What should you do with a Base64 command found in a process command line?

    Decode to read it, but never execute commands found in evidence outside an isolated lab.

Summary

  • Process lists come from walking the kernel list (pslist) or scanning memory (psscan); compare them (cross-view).
  • A process only in the scan with no exit time may be hidden; with an exit time it is just finished.
  • Check parent, path, name, count and command line against what is normal.
  • Rules produce leads, not verdicts; always corroborate.
  • Dump and hash suspicious processes for deeper lab analysis, and never run commands found in evidence.

Next: Strings and artifacts in memory