skip to content

Why does hunting for LSASS credential dumping by tool name miss most of the technique?

level: juniorimportance: must knowfreq 62%

answer

  1. one technique, many procedures
  2. renaming the binary is free
  3. list the ways, not the names
  4. what must every variant do?
  5. a handle to the process

basics

~20 s

One technique has many procedures. LSASS memory can be read by comsvcs.dll's MiniDump export, a renamed dumping utility, a vulnerable signed driver, direct syscalls or a process clone. A tool-name hunt catches only whoever did not rename it.

solid answer

~40 s

Reading credentials out of LSASS memory is one technique, `T1003.001`, but there are many procedures for it: `rundll32` invoking the `MiniDump` export of `comsvcs.dll`, a purpose-built dumping utility renamed to anything, a bring-your-own-vulnerable-driver read from kernel mode, an implant calling `MiniDumpWriteDump` through direct syscalls, or dumping a forked clone of the process instead of the process itself. A filename or hash is the cheapest thing an intruder changes, so a hunt scoped to one catches only the careless. The productive move is to expand the technique into its procedure list first, then ask what every procedure must do that it cannot avoid — here, most user-mode variants must obtain a handle to the process carrying memory-read rights. Hunt that invariant, then handle the leftovers as separate, named gaps.

go deeper

for a junior

Be ready to say plainly that a technique is a behaviour and a procedure is one way of doing it, and to name two or three different ways the same credential-dumping behaviour can be carried out.

for a middle

An interviewer expects you to run the expansion out loud: enumerate the procedures, then identify the step none of the user-mode ones can skip, and say which telemetry records that step.

for a senior

Show that you turn the expansion into a durable artefact — a variant list annotated with the observable for each row and whether the estate actually collects it — and that you name the variants your invariant misses instead of quietly dropping them.

for a principal

Own the consequence for coverage reporting: a technique with one tool-name sweep behind it must not appear as covered on any map that a control-investment decision is made from.

## Three different levels, and only one of them is stable A **technique** is a class of behaviour — reading credential material out of the memory of the Windows process that holds it, catalogued as `T1003.001`. A **procedure** is one specific way of carrying that behaviour out. A **tool** is one implementation of a procedure, with a filename, a hash and a signing certificate. These three levels decay at wildly different rates. A hash changes when a byte changes. A filename changes with a `copy` command. A procedure changes when someone writes new code. The technique — that credential material lives in that process's memory and something must read it — does not change at all until the platform changes. "Technique over tool" is the instruction to pin your hunt to the layer the adversary cannot cheaply move. ## The expansion exercise The first real work of a hunt on this technique is not a query, it is a list. Sit down with public technique documentation, incident reports, the readmes of open-source offensive tooling, and whatever your own red team uses, and write out the procedures: - `rundll32` calling the `MiniDump` export inside `comsvcs.dll` — a Microsoft-signed DLL already on the host, so nothing new is dropped. - A dedicated dumping utility, frequently a legitimately signed one, copied in under any name at all. - A bespoke implant calling `MiniDumpWriteDump` in-process, sometimes issuing the underlying syscalls directly to sidestep user-mode API hooks. - A **bring-your-own-vulnerable-driver** read: load a signed but flawed driver and have it read the target's memory from kernel mode. - Snapshotting or forking the process and dumping the clone, so the read that matters lands on a child object rather than on `lsass.exe`. - Persuading the operating system to write the dump for you through an error-reporting or crash-dump path. That list is the deliverable. It is longer than most people expect, and its length is exactly the point: a hunt for one filename covers one row of it. ## Finding the invariant Now read the list column-wise and ask what the variants share. Every user-mode variant on that list — the `comsvcs` one, the renamed utility, the direct-syscall implant, the snapshot — has to obtain a **handle to the target process with memory-read rights** before it can read anything. It cannot skip that step, because that is how the operating system arbitrates cross-process memory access. That is an invariant, and it is what you hunt: process-access telemetry where the target is the credential process and the granted access mask includes read rights. One query written against that invariant covers most of the list at once. It does not cover the kernel-driver variant, because a driver reading memory from kernel mode never asks for a user-mode handle, and it may not cleanly cover the clone variant, because the target image of the read is no longer the process you filtered on. Those become **separately named gaps** with their own observables — driver-load and service-creation records for the first, the dump file appearing on disk for the second — rather than silent holes you never noticed. ## Bank the list as a hunt asset The variant list, annotated per row with *which record would show this*, *does this estate collect that record*, and *is this variant hunted or actually detected*, outlives the hunt. Re-running the sweep next quarter becomes an hour instead of a day, a new published variant becomes one added row, and the annotations are the honest input to any coverage discussion. ## What this does not mean It does not mean artefacts are worthless. A sweep for a known dumping utility's name or hash is cheap to run, and a hit on it is high-confidence and immediately actionable. Run it — as a supplement. The error is arithmetic, not moral: counting that sweep as coverage of the technique, when it covers one procedure performed by one careless operator. It also does not mean every credential-access problem is this technique. Pulling the same secrets from a domain controller's directory database, or from a password manager, is a different technique with a different variant list and a different hunt. Expand the technique you actually chose; do not let the list sprawl into everything an intruder might do with a credential. ## The direction of the claim One last discipline, because it is where junior candidates trip. Finding no hits for your tool-name sweep tells you that this tool, under this name, was not seen in the records you searched. It says nothing about the other five procedures, nothing about hosts that were not reporting, and nothing about the period beyond your retention. State the claim as narrowly as the evidence supports it.

  • Where does the "every variant must open a handle to the process" invariant break down?
    Two places. A vulnerable signed driver reads the memory from kernel mode and never requests a user-mode handle, so no handle-access record exists. And a variant that snapshots or forks the process dumps a clone, so the read lands on an object whose image name is not the credential process you filtered on. Both need their own observables — driver load and service creation for the first, the dump file's creation for the second.
  • Is there any value left in sweeping for a known dumping utility's filename?
    Yes, as a cheap supplement. It costs almost nothing to run and a hit is high-confidence, because few legitimate reasons exist for that binary to be on a workstation. The mistake is counting it as coverage of the technique: it covers one procedure, executed by someone who did not bother to rename anything.
  • How do you build the procedure list if you have no red team to ask?
    Public technique documentation and vendor incident reports name procedures explicitly, open-source offensive tooling documents its own methods, and your own telemetry shows which legitimate software already performs the behaviour. Write the list down, cite where each row came from, and add rows as new ones are published rather than rebuilding it each hunt.

Hunting the tool name is like searching for burglars by the brand of crowbar. The crowbar is swapped in a second; having to get through the door is not.

saying these in an interview costs you the question

  • Treats one tool name as equivalent to the whole technique
  • Assumes renaming or recompiling a binary is hard for an intruder
  • Thinks one technique identifier implies one detection
  • Calls a technique covered after a hash sweep returns nothing
  • Never writes the variant list down, so every hunt restarts from zero

context