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
LSASS Credential Theft in Memory Forensics: Handles, Access Masks, pypykatz and Credential Guard
Introduction
Most intrusions that go beyond one machine do it with stolen credentials, and on Windows the richest place to steal them from is the memory of one process, lsass.exe, the Local Security Authority. It holds the secrets that let a signed-in user reach other machines without typing a password again.
Reading them requires reading lsass.exe's memory, and that leaves evidence an analyst can find in a memory image: who opened lsass.exe, with which rights, and what its memory exposed at the time.
How credential theft from memory works, and the four things a memory image can show about it.
This lesson reads three captures of the same workstation: the injection capture from the last three lessons, a capture taken after a deliberate credential-theft run, and a capture of the host rebuilt with Credential Guard. It covers who held a handle to lsass.exe, what an access mask means, what a credential plugin recovers, and what Credential Guard hides and does not. Module 3 teaches each part in depth.
Who Held a Handle to lsass.exe
The access, recorded by the kernelTo read another process's memory, a program first asks Windows for a handle to it, naming the rights it wants, and the kernel records the handle and the rights it granted. windows.handles lists every handle every process holds. Filtered to the handles that point at lsass.exe in the injection capture:
$ vol -f NE-ENG-031-1431.raw windows.handles | grep "lsass.exe Pid" | cut -f1,2,4-7
Progress: 100.00 PDB scanning finished
468 csrss.exe 0x61c Process 0x1fffff lsass.exe Pid 672
624 services.exe 0x3c4 Process 0x1000 lsass.exe Pid 672
1344 MsMpEng.exe 0x7a8 Process 0x1fffff lsass.exe Pid 672
1428 explorer.exe 0x2e0 Process 0x1410 lsass.exe Pid 672
Four processes held one. csrss.exe, the Windows subsystem, holds all access, as it does in the baseline below. MsMpEng.exe, the Microsoft Defender engine, holds all access too; an antivirus engine opens processes to scan them, and its presence is ordinary on a machine running Defender. services.exe holds a handle with one right, 0x1000. explorer.exe, the desktop shell, holds a handle with 0x1410.
The same filter on the baseline capture of this workstation, taken the day before:
$ vol -f NE-ENG-031-baseline.raw windows.handles | grep "lsass.exe Pid" \
| cut -f1,2,4-7
Progress: 100.00 PDB scanning finished
476 csrss.exe 0x540 Process 0x1fffff lsass.exe Pid 680
On the ordinary day, nothing like explorer.exe's handle exists. A shell has no reason to open the credential store, and in this capture it is the same explorer.exe that lesson 0.3 found holding injected code. The handle is the trace of what that code did next.
Note what the handle does and does not prove. It proves that explorer.exe was granted the right to read lsass.exe's memory, and that the handle was still open when the image was taken. It does not prove that the memory was read, or what was taken; those come from other evidence, from the tool's own traces to the accounts used afterwards elsewhere.
In practice, a process with no reason to hold such a handle is enough to treat every credential lsass.exe held as exposed, because the cost of being wrong in the other direction is an attacker with valid passwords.
Handles also have a lifetime. A tool that opens lsass.exe, reads it and closes the handle within a second leaves no handle for a later capture to find. The handle here survived because the injected code kept it open, which is common for code living inside a long-running process and rare for a tool that runs and exits.
Reading an Access Mask
What 0x1410 allowedA granted access value is a sum of individual rights, each a power of two, defined in Microsoft's documentation on process security and access rights. Decoded:
An access mask is a sum of rights. 0x1410 breaks into three, and the last one is the right that reads credentials out of lsass.exe.
0x1000 is PROCESS_QUERY_LIMITED_INFORMATION, a subset of a process's information such as its exit code. 0x0400 is PROCESS_QUERY_INFORMATION, which reaches further, including the process's token. 0x0010 is PROCESS_VM_READ, which Microsoft's documentation describes as required to read memory in a process with ReadProcessMemory. The full-access value csrss.exe and Defender hold, 0x1fffff, is the documented value for all possible rights.
So explorer.exe could read lsass.exe's memory, and it asked for exactly enough to do so: no right to write, none to create a thread, none of the rights that would let it change lsass.exe. Set beside the other three handles in this capture:
Handles to lsass.exe, decoded
NE-ENG-031-1431The one that matters
Only explorer.exe combines memory read with no reason to hold it.
Reading masks this way takes a few seconds once the values are familiar, and the values that matter for credential theft are few. That shape, the query rights plus memory read and nothing else, is the minimum a tool needs to read credentials, and Module 3 reads the different masks different tools leave.
services.exe's 0x1000 is the opposite case: a right that reads a little information about lsass.exe and nothing inside it. A handle to lsass.exe is not evidence of theft.
A handle that can read its memory, held by a process that has no reason to, is. The mask is the difference between those two statements, which is why it is worth decoding every time rather than reading the process name and moving on.
The documentation is also the reference for the rights an attacker did not take. A mask with PROCESS_VM_WRITE or PROCESS_CREATE_THREAD on lsass.exe would mean something else again: not reading credentials, but changing the process or running code inside it, which Module 3 treats as a different and more serious class of finding.
A Theft, Read From Both Sides
The handle, the tool and what was exposedThe course's credential-theft capture was taken after an operator ran two tools on the same workstation: a credential module loaded into an injected explorer.exe, and mimikatz.exe run as a program. The handles to lsass.exe there:
$ vol -f NE-ENG-031-theft.raw windows.handles | grep "lsass.exe Pid" | cut -f1,2,4-7
Progress: 100.00 PDB scanning finished
476 csrss.exe 0x4d0 Process 0x1fffff lsass.exe Pid 680
4460 explorer.exe 0xb38 Process 0x1010 lsass.exe Pid 680
explorer.exe, PID 4460 in this capture, holds 0x1010: query limited information and memory read, the minimum needed. mimikatz.exe holds nothing, because it is no longer running:
$ vol -f NE-ENG-031-theft.raw windows.malware.psxview | grep -e pslist -e mimikatz
Progress: 100.00 PDB scanning finished
Offset(Virtual) Name PID pslist psscan thrdscan csrss Exit Time
0xd187c2d05280 mimikatz.exe 7180 False True False False 2026-03-16 10:09:15.000000 UTC
It is found only by the scan, with an exit time, the pattern lesson 0.2 taught: it ran, did its work and left. Its handles left with it, so the only evidence of its access to lsass.exe in this image is whatever it left behind elsewhere, which Module 3 reads.
This is the general shape of credential theft by short-lived tools: the process is gone, the handle is gone, and what remains is the scan's record that it ran, any files it wrote, and the use of the stolen material later. Module 3 produces all three trails in the lab, so that each can be recognized from the evidence it leaves.
The two methods in this capture also differ in what they leave in memory afterwards. Code injected into a long-running process stays there until the process ends, with its handle, its region and its thread; a program that runs and exits leaves a process structure with an exit time and little else.
An attacker who wants to be found less often chooses the first for persistence and the second for speed, and an analyst who knows both looks for both.
The other side of the theft is what lsass.exe held. The course runs pypykatz as a Volatility plugin to read the same structures a theft tool reads. Its output, reduced to the credential type, domain and account:
$ vol -f NE-ENG-031-theft.raw -p ./pypykatz-volatility3 pypykatz | cut -f1-3 \
| sort -u
Progress: 100.00 PDB scanning finished
Volatility 3 Framework 2.28.2
credman TERMSRV/NE-JUMP01 NE\d.whitfield-adm
credtype domainname username
dpapi
msv Font Driver Host UMFD-0
msv Font Driver Host UMFD-1
msv NE NE-ENG-031$
msv NE d.whitfield
msv NE j.okafor
msv NE svc-backup
msv NE svc-inventory
msv Window Manager DWM-1
Every account with a logon session on the machine at the time is listed: the machine account, the signed-in user d.whitfield, j.okafor, two service accounts, and a saved credential for a jump server under an administrative account. That list is the exposure: whatever lsass.exe held for each of those accounts was readable by anything holding a handle like explorer.exe's.
The plugin's output has more columns than shown here, including the hash values themselves; Module 3 reads them, and the course's lab accounts make it safe to do so.
For the assessment, what matters first is the list of names and the credential types, because each type is used differently. An NT hash can be passed to authenticate as the account without the password. A Kerberos ticket works until it expires.
A saved credential for a remote desktop target, the credman row here, is a password the user asked Windows to remember, and it goes to exactly the machine it names. Here that machine is NE-JUMP01, a jump server, and the account is an administrative one, which makes it the most valuable credential in the list for an attacker and the first one to reset.
Credential Guard
The same host, with the secrets moved outMicrosoft's documentation describes Credential Guard as protecting NTLM password hashes, Kerberos ticket-granting tickets and credentials applications store as domain credentials, by isolating them with virtualization-based security in a separate process, LSAIso.exe, which malware running with administrative rights in the operating system cannot read. The same plugin on the capture of this host built with Credential Guard, and the two processes involved:
$ vol -f NE-ENG-031-cg.raw -p ./pypykatz-volatility3 pypykatz | cut -f1-4
Progress: 100.00 PDB scanning finished
Volatility 3 Framework 2.28.2
credtype domainname username NThash
msv NE NE-ENG-031$
msv Font Driver Host UMFD-0
msv Font Driver Host UMFD-1
msv Window Manager DWM-1
msv NE svc-backup
dpapi
msv NE d.whitfield
dpapi
dpapi
$ vol -f NE-ENG-031-cg.raw windows.pslist | grep -i -e lsass -e lsaiso | cut -f1-3
Progress: 100.00 PDB scanning finished
680 556 lsass.exe
688 556 LsaIso.exe
lsass.exe still lists the logon sessions: the machine account, the font and window-manager sessions and a service account. The NT hash column is empty for every one of them. LsaIso.exe is running beside lsass.exe, and the hashes are in its memory, which this kind of reading cannot open.
The isolation is enforced by virtualization-based security rather than by the operating system's own access checks, which is why a tool running with administrative rights inside the operating system cannot simply open LsaIso.exe the way it opens lsass.exe.
For the analyst, LsaIso.exe in the process list is the quickest way to know which situation an image is in. Its presence changes what a handle to lsass.exe could have yielded, and therefore how the exposure is written. Check for it before reading any credential plugin's output, so that empty hash columns are read as protection working rather than as the plugin failing.
The documentation also notes the protection can be turned off by a registry change on machines without its UEFI lock. An image showing Credential Guard configured but LsaIso.exe absent is therefore a question in its own right: was it never active on this host, or was it disabled? Module 3 reads both cases.
Credential Guard, in Microsoft's words
Partial exposureWhat changes for the analyst
The question shifts from which hashes were stolen to what was still exposed: names, sessions, and credential types the isolation does not cover.
That is a partial exposure, not none. The documentation says Credential Guard does not protect the Active Directory database or the SAM, and the session list itself tells an attacker which accounts were active on the machine. Module 3's Credential Guard lesson builds the partial-exposure assessment: what an attacker could still learn and use from a protected host, and what they could not.
From Evidence to Exposure
The assessment the evidence supportsThe point of reading credentials in memory is not to recover passwords; it is to answer the question an incident lead asks next: which accounts must be treated as compromised, and where could they be used?
An exposure assessment from one memory image, in the order Module 3 builds it.
For the theft capture, the answer starts from the plugin's list.
Every account there had material in lsass.exe while a process with memory-read access was holding a handle to it, so each is exposed: the user, the other user with a session, both service accounts and the administrative account saved for the jump server. Each has to be reset, and each one's reach, the machines and services it can sign in to, defines how far the attacker could go next.
Written as a record, with the basis for it:
Exposure assessment: NE-ENG-031-theft
Every account in lsass.exeBasis
explorer.exe held 0x1010 on lsass.exe; mimikatz.exe ran and exited; pypykatz lists these accounts with material present.
The administrative account comes first because a saved credential for a jump server is the shortest path from one workstation to the rest of the estate. The service accounts come next because they often run on many machines with the same password, so one exposure reaches all of them.
For the Credential Guard capture, the same evidence supports a narrower statement: the accounts were present, their hashes and tickets were isolated, and the exposure is limited to what the isolation does not cover. The assessment says so, with the reason, rather than declaring the host safe.
An image of a protected host still shows a handle to lsass.exe with memory-read rights if an attacker tried, and that attempt is a finding in its own right even when it yielded little: it says an attacker with that level of access was on the machine.
Time matters as well. The exposure starts when material entered lsass.exe, which for an interactive user is the logon, and when the attacker could first read it, which is the earliest evidence of a handle or a tool. It ends when the credentials are reset. Anything an exposed account did between those two points, on any machine, is in scope for the next stage of the investigation.
For the injection capture, the evidence is the handle, the injected code that owned it and the time: lesson 0.3's thread started at 14:06:57, and the case timeline has the operator reading credentials from the injected session at 14:08. Module 3 adds the rest: Kerberos tickets and how far a stolen ticket reaches, credential sources outside lsass.exe, and the memory signatures of the tools themselves.
The assessment is the deliverable that matters to everyone outside the investigation. The identity team needs the account list to reset and the reach of each account to know what else to check.
The incident lead needs the time window, from the first handle to the capture, to scope where those accounts might have been used. Neither needs the hash values, and a report that leads with them has missed what its readers need.
What Module 3 Builds On It
Credential theft in depthModule 3 starts with LSASS and the authentication architecture it serves, because which secrets lsass.exe holds depends on how each account signed in: interactively, over the network, as a service or through remote desktop, and each leaves different material behind. produces three different credential-theft trails in the course lab and captures each, extracts what each exposed and builds the exposure assessment.
It reads Kerberos tickets and the blast radius of a stolen ticket-granting ticket, the partial exposure under Credential Guard, the memory signatures of the common tools, and credentials held outside lsass.exe.
What Module 3 builds
Module 3Module 3's captures of NE-ENG-031 are variations on the three read here: the same host and accounts, with a different combination of handle, tool and protection. That is deliberate. Holding everything else constant is what makes the difference each change produces visible, and it is the same discipline as reading an incident image against a baseline.
Its hunt gives three hosts with three different problems: one with credentials exposed and no theft, one with Credential Guard, and one where an injected service host holds a handle to lsass.exe. Telling them apart takes every step this lesson introduced.
The host with credentials exposed and no theft is the one most analysts misjudge: everything a theft would expose is there, and nothing shows it was taken, so the right answer is a statement of risk rather than a finding of compromise.
The habit to carry into it: start from the handles, decode the mask, check for Credential Guard, list what lsass.exe held, and write the exposure per account with the evidence for each. Recovering a hash is the least important part; knowing which accounts to reset, and why, is the outcome.
Module 3 also reads Kerberos tickets in detail, because a stolen ticket-granting ticket lets an attacker request access to services as the user until it expires, and the expiry time in memory says how long that window was.
Practice
Find the handle that read the credentials prepared evidenceThe prepared evidence below is the handles to lsass.exe in the injection capture, with their rights decoded, and the accounts a credential plugin recovers from the theft and Credential Guard captures. Find the handle that matters, the right that made it matter, and what Credential Guard hid. Each answer comes with its reasoning, so check it against the rows rather than only the choice.
Start with the handles tab, because it is the evidence that an attacker had the access at all; the Recovered tab only says what that access could reach. Decode each mask from the Rights column before deciding, and compare the two captures in the Recovered tab by what is missing rather than by what is present.
The theft rows are a sample of the accounts the plugin listed; the Credential Guard rows are every account it listed on that host, all with empty hash columns, which is the point of the comparison.
In the range, run the handles filter on all three captures and the baseline, side by side. Then run the pypykatz plugin on the theft and Credential Guard captures and compare the credential types each lists, not only the hashes. The process that should not be there is easy to see once the ordinary holders are known.
Note which holders appear in every capture and which in only one: the ordinary ones are the same everywhere, and the attacker's handle sits in explorer.exe in both the injection and theft captures, under a different PID in each, because both attacks injected code into the shell.
The shell is a common target for exactly that reason: it runs for the whole of a user's session, under the user's account, and nobody expects to see it in a list of suspicious processes. Seeing it there, holding a handle it has no use for, is the signal worth acting on, every single time.
lsass.exe holds the credentials that make lateral movement easy, and reading it leaves a handle whose access mask the kernel records; PROCESS_VM_READ in that mask, held by a process with no reason for it, is the trace.
A credential plugin lists what lsass.exe held, which is the exposure; Credential Guard moves hashes and tickets into LsaIso.exe and leaves a narrower exposure that still has to be assessed. The outcome is a list of accounts to treat as compromised, with the evidence for each.
The next lesson follows an attack that never wrote its payload to disk at all.