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 Timelines: netscan Owners, Kernel Timestamps, Shimcache and Correlating Hosts
Introduction
Two questions come up in almost every memory investigation, usually from someone outside the analysis: what was the machine talking to, and when did each thing happen.
The first is a question for the network evidence a memory image holds, and the second is a question for its timestamps. Both look simple and both reward care. A connection's owner is not always the program responsible for it, and a timestamp is only as good as whatever wrote it.
This lesson answers both questions for the 14:31 capture that the earlier lessons have been reading, and then looks at a second workstation captured the next morning.
Lesson 0.1 found the session to 10.5.0.20:4444 in this image; lesson 0.3 found the injected region and the thread behind it. Here the same evidence is read for its times, so that the case can be told in order and each step carries its source.
The foundation is a single discipline that Module 8 builds into a method: before any time goes into a timeline, decide who wrote it. A time written by the kernel as the event happened is very hard for an attacker in user space to alter.
A time copied from a file, a registry value or a header is only as trustworthy as the thing it was copied from, and some of those an attacker can set with ordinary tools. A timeline that mixes the two without saying so looks precise and is not.
The Connection and Its Owner
What netscan proveswindows.netscan reads the network stack's own structures out of memory, so it lists connections and listening sockets whether or not any program on the machine would report them. In the 14:31 capture there is exactly one connection to the attacker's server:
$ vol --hide-columns Offset Proto LocalAddr State -f NE-ENG-031-1431.raw \
windows.netscan | grep -e Owner -e 10.5.0.20
Progress: 100.00 PDB scanning finished
LocalPort ForeignAddr ForeignPort PID Owner Created
52014 10.5.0.20 4444 1428 explorer.exe 2026-03-15 14:06:58.000000 UTC
A connection from local port 52014 to 10.5.0.20 on port 4444, owned by explorer.exe, PID 1428, created at 14:06:58. The owner column is the one a firewall cannot supply: the firewall sees the workstation's address talking to 10.5.0.20, and only the host knows which process held the socket. That is the reason to capture memory on a network alert at all.
It is one row among many. The scan returns 38 entries, and none of them belongs to update.exe:
$ vol -f NE-ENG-031-1431.raw windows.netscan | grep -c 0x
Progress: 100.00 PDB scanning finished
38
$ vol -f NE-ENG-031-1431.raw windows.netscan | grep -c 5304
Progress: 100.00 PDB scanning finished
0
That second count matters. update.exe, PID 5304, ran from the user's Temp folder and exited at 14:07:04, and its sockets were closed with it, so nothing in the network view ties it to the server. Without lesson 0.2's psscan, which found the exited process, the only owner this image offers for the attacker's session is explorer.exe.
Most of the other rows are the machine's ordinary traffic: Edge, Teams, Outlook, OneDrive, Defender and the system's own services connecting out on 443, and listening sockets opened at boot. One deserves a moment because it looks sensitive and is not:
$ vol --hide-columns Offset Proto LocalAddr State -f NE-ENG-031-1431.raw \
windows.netscan | grep -e Owner -e lsass
Progress: 100.00 PDB scanning finished
LocalPort ForeignAddr ForeignPort PID Owner Created
51990 10.5.0.10 389 672 lsass.exe 2026-03-15 13:58:02.000000 UTC
49664 0.0.0.0 0 672 lsass.exe 2026-03-15 07:41:19.000000 UTC
lsass.exe connecting to 10.5.0.10 on port 389 is LDAP, the workstation authenticating against a directory server on the lab network, and it is what a domain-joined machine does. Reading the owner and the port together, before reacting to the owner alone, is the habit that keeps an analyst from chasing it.
The Created column deserves the same care as the owner. It records when the network stack made the endpoint, so for an established connection it is close to when the connection was opened, and for a listening socket it is when the service began listening, which on this machine is a few seconds after boot.
A connection's creation time says nothing about when it last carried data, so a session created at 14:06:58 and captured at 14:31 was open for the whole of that time, not necessarily busy for it.
The Owner Is Not the Actor
A socket held by a host processexplorer.exe owns the connection, but explorer.exe did not decide to make it. Lesson 0.3 found the reason: a region of explorer's memory with no file behind it, containing a reflective loader, and a thread running from it. The thread's start time and the socket's creation time sit next to each other:
$ vol -f NE-ENG-031-1431.raw windows.thrdscan | grep -e Owner -e 6188 \
| cut -f2,3,6,8
Progress: 100.00 PDB scanning finished
1428 6188 0x2a11a40 2026-03-15 14:06:57.000000 UTC
Thread 6188 in explorer.exe, starting at 0x2a11a40 inside the injected region, created at 14:06:57. One second later the socket to 10.5.0.20:4444 was created. Together, the two times say what the owner column alone cannot: the code that was injected into explorer.exe started running and opened its connection back to the server straight away. explorer.exe is the host, not the author.
This is why an owner column is a lead, not a conclusion. A connection owned by a browser, a system service or a desktop shell is not cleared by the name, because those are exactly the processes an attacker chooses to hide in; and a connection owned by an unfamiliar name is not convicted by it, because plenty of software makes network connections.
The decision comes from what else the owning process contains: an injected region, a thread with no module behind its start address, a handle it should not hold.
The 4444 port is worth a note for the same reason. It is a well-known default for some attack frameworks, which makes it a useful hint and a poor rule: an attacker who changes one setting removes it, and the fileless capture in lesson 0.5 reached the same server on 443.
The evidence that holds up is the structure behind the connection, which an attacker cannot change by editing a configuration file.
On a real case this is also the point where the network evidence leaves the host. The connection record here, local port 52014 to 10.5.0.20:4444 at 14:06:58, is what the firewall and the proxy will have logged too, on devices the attacker never touched. Module 8 matches the two and reconciles their clocks.
Who Wrote Each Time
Sort before orderingA memory image is full of times, and they are not all the same kind of evidence. psscan gives the processes in this case their start and exit times:
$ vol -f NE-ENG-031-1431.raw windows.psscan \
| grep -e PPID -e update -e 3312 -e 6940 -e winpmem | cut -f1-3,9,10
Progress: 100.00 PDB scanning finished
PID PPID ImageFileName CreateTime ExitTime
3312 1428 cmd.exe 2026-03-15 14:07:33.000000 UTC N/A
6940 1428 cmd.exe 2026-03-15 14:30:41.000000 UTC N/A
6952 6940 conhost.exe 2026-03-15 14:30:42.000000 UTC N/A
4120 6940 winpmem.exe 2026-03-15 14:30:58.000000 UTC N/A
5128 3312 conhost.exe 2026-03-15 14:07:34.000000 UTC N/A
5304 4108 update.exe 2026-03-15 14:05:12.000000 UTC 2026-03-15 14:07:04.000000 UTC
The kernel writes a process's creation time when it creates the process, and its exit time when the process ends, in structures that user-space code has no ordinary way to change. The same is true of thread creation times and of the creation time the network stack records for a socket. These are the anchors of a memory timeline.
Other times in the image were copied from somewhere else. The shimcache, which Windows keeps in memory and saves to the registry, holds an entry for update.exe:
$ vol -f NE-ENG-031-1431.raw windows.shimcachemem | grep -i -e Order -e update \
| cut -f2,6
Progress: 100.00 PDB scanning finished
Last Modified File Path
2026-03-15 14:05:12.000000 UTC C:\Users\d.whitfield\AppData\Local\Temp\update.exe
Its Last Modified time is 14:05:12, identical to the process's creation time. But this is not the time the program ran. It is the file's own last-modified time, copied out of the file system, and a file's times can be rewritten by anyone with ordinary tools on the host.
Here it agrees with the kernel's time to the second, which supports both, and is consistent with a file written and run in the same moment. Had the two disagreed, the kernel's time would win and the disagreement would itself be evidence that someone had altered the file.
That is the general rule for every copied time. It is a claim made by something the attacker may control, so it is weighed against an anchor the attacker could not reach. When a copied time agrees with an anchor, it adds detail without adding risk.
When it stands alone, with no anchor to check it against, it goes in the timeline marked as uncorroborated, and the report says so in plain words rather than letting it sit beside the anchors as an equal.
Who wrote each time
Sort before orderingThe Amcache, read from the registry hive in memory, adds something time cannot: a hash of the file.
$ vol -f NE-ENG-031-1431.raw windows.registry.amcache | grep -i update | cut -f2,8 \
| sed "s/C:.*Temp.//"
Progress: 100.00 PDB scanning finished
update.exe 150de9b262f9d67172ff3e268b4aae4bb0345cdf
A SHA1 for update.exe. filescan finds no file object for update.exe in this image, so this hash may be the only identifier the investigation has to search for it across the estate. Which of the Amcache's columns records what, and how far each can be trusted, is part of Module 8's sorting.
A Sequence From One Image
And what it cannot saySorted, the kernel-written times give the 14:31 capture its sequence:
The 14:31 capture's sequence, every time read from a structure the kernel wrote.
update.exe started at 14:05:12. A minute and 45 seconds later, at 14:06:57, a thread started in explorer.exe from the injected region, and one second after that the session to 10.5.0.20:4444 opened. update.exe exited at 14:07:04, six seconds after the session opened, which is what a loader does once its payload has moved somewhere safer.
At 14:07:33 a cmd.exe appeared under explorer.exe: the operator's shell, started from inside the injected session. Then nothing attributable to the attacker until the analyst's own cmd.exe at 14:30:41 and winpmem.exe at 14:30:58, and the image's system time:
$ vol -f NE-ENG-031-1431.raw windows.info | grep SystemTime
Progress: 100.00 PDB scanning finished
SystemTime 2026-03-15 14:31:06+00:00
$ vol -f NE-ENG-044-0915.raw windows.info | grep SystemTime
Progress: 100.00 PDB scanning finished
SystemTime 2026-03-16 09:15:30+00:00
The first line is this capture, 14:31:06. The second is the next morning's capture of NE-ENG-044, which the last section reads. The analyst's processes go in the timeline too, labeled as the investigation's, so that nobody later reads them as the attacker's.
What the sequence cannot say matters as much as what it says.
Lesson 0.4 found explorer.exe holding a handle to lsass.exe with rights to read its memory, and handles carry no time; the image shows that the credential read was possible from the session, not when it happened. update.exe's parent, PID 4108, is absent from the image entirely, so how update.exe came to run, a download, an attachment or a remote command, is not something this capture can answer.
And anything that happened and ended before the capture, a process started and exited long ago, may simply no longer be in memory.
A memory-only timeline states those limits beside the rows rather than filling them. The event logs, the disk and the network devices each answer some of them, and Module 8 adds each in turn.
Notice also how much of the sequence the earlier lessons already found, one plugin at a time. Lesson 0.2's psscan gave update.exe's start and exit, lesson 0.3's thrdscan gave the injected thread, lesson 0.1's netscan gave the session. Each finding carried its time from the start; the timeline is not a separate analysis but the same evidence read in order.
That is why the habit of recording the time beside every finding, from the first plugin run, saves an afternoon at the end of a case.
Two Hosts, One Server
A common actor, not a pathThe next morning, a second engineering workstation, NE-ENG-044, was captured at 09:15. Its network view has one row to the same server:
$ vol --hide-columns Offset Proto LocalAddr State -f NE-ENG-044-0915.raw \
windows.netscan | grep -e Owner -e 10.5.0.20
Progress: 100.00 PDB scanning finished
LocalPort ForeignAddr ForeignPort PID Owner Created
51204 10.5.0.20 443 4120 explorer.exe 2026-03-16 08:57:43.000000 UTC
explorer.exe on NE-ENG-044, PID 4120, connected to 10.5.0.20 on port 443 at 08:57:43 on 16 March. Same server, same kind of host process, a different port and a different day.
Two hosts, one server
A common actorThe tempting reading is that the attacker moved from NE-ENG-031 to NE-ENG-044. Neither image shows that. A common destination establishes a common actor, or at least common infrastructure; a path from one host to the other needs evidence on both ends of it, such as a logon to NE-ENG-044 from NE-ENG-031's address or a connection between the two, and neither capture holds one.
Writing "lateral movement from 031 to 044" in a report on this evidence would be a claim the evidence does not carry, and a careful reviewer would remove it.
Ordering events across hosts adds a second problem: each host's times come from its own clock. On these two workstations the gap is nearly a day, so a few seconds of drift change nothing. When two hosts' events fall minutes apart, though, the order depends on how far each clock was from the truth, and that has to be measured, not assumed.
Module 8 measures it against sources outside both hosts, such as a firewall or a domain controller whose clock is known. Even the captures carry their own clocks: the system times above are each machine's reading at the moment of capture, and nothing in either image says how far that reading was from the true time.
The point for now is the habit: draw only the edges the evidence carries. A shared server is a reason to capture and examine every host that reached it, which is exactly what the investigation did here. It is not, by itself, a map of how the attacker got from one to the next. The same discipline applies inside one host.
The cmd.exe that appeared under explorer.exe at 14:07:33 is attributed to the operator because it started from the injected session's process, half a minute after the session opened, and nearly 23 minutes before the analyst's first process on the machine, at 14:30:41. That attribution rests on three facts, each with its source, and the report should say all three.
What Module 8 Builds On It
Timeline and correlationModule 8 begins by sorting every timestamp a memory image holds by who wrote it, then builds a memory-only timeline and states plainly what such a timeline cannot establish.
It then correlates the memory anchors with event logs recovered from the image, with the disk's file records, which is where timestomping shows itself, and with network logs from devices the attacker never touched. It ends with several hosts, a single unified timeline, and the ways an attacker can manipulate times and the clocks that manipulation cannot reach.
What Module 8 builds
Module 8The order matters. Correlation with outside sources is only as good as the anchors brought to it, and an anchor that turns out to be a copied, editable time can pull a whole timeline out of shape.
A firewall record matched against a shimcache time, for example, may line up neatly and still be wrong, because the shimcache time was never the moment the program ran. Sorting first is what keeps a correlated timeline from inheriting the attacker's edits.
The audience matters too. A timeline is usually read by people who were not in the analysis: the response lead deciding what to contain, an executive deciding what to disclose, sometimes a lawyer. Each row that names its source and says who wrote its time can be checked by any of them, or by someone they bring in, without re-running the analysis.
That is the difference between a timeline people act on and one they argue about.
Each of those steps rests on this lesson's two habits. The owner column is a lead to the process that holds a connection, and the process's contents decide what the connection means. Every time is sorted by who wrote it before it is ordered, the kernel's anchors carry the sequence, and the gaps are written down rather than filled.
There is a practical side to the second habit. Times copied from files and registry values are the ones an attacker can change with ordinary tools, which is why the agreement between update.exe's shimcache time and its creation time was worth checking rather than assuming.
In this case they agree. When they do not, the difference is evidence in its own right, and Module 8 shows the disk-side records that settle it.
The other practical side is the analyst's own footprint. Every capture in this course was taken by someone, and their tools appear in the image with their own creation times. Recording them as the investigation's actions, with the times they ran, is what lets a reviewer read the timeline without wondering which rows are whose.
In this case it takes two rows and two times, and leaving them out would not make the timeline cleaner; it would make the next reader wonder whether the cmd.exe at 14:30:41 was a second operator shell.
Practice
Sort eleven times before ordering them prepared evidenceThe prepared evidence below is eleven events read out of the two captures, each with the plugin it came from and who wrote its time. Decide which time an attacker could have set, which rows are the investigation's own, and what the second host's row establishes. Each answer comes with its reasoning, so check it against the rows rather than only the choice.
In the range, open NE-ENG-031-1431, run netscan and count the owners: every connection in the image has one, and only one row goes to 10.5.0.20. Then run thrdscan and psscan and put the times next to the socket's, to see the one-second gap between the injected thread and the connection for yourself.
Then open NE-ENG-044-0915 and run the same netscan: one row to the same server, from a different explorer.exe, on a different day. Before you write a sentence that links the two hosts, list what each image shows and what neither does.
Keep the eleven rows from the practice in mind for the next lesson. Its image comes with no indicator to search for, and the sorting you did here is how you will decide which of its times to trust.
A connection's owner is a lead, not a verdict: the process that holds a socket may be hosting code that someone else put there, and the times of its threads and sockets show when that code ran. Before any time is ordered, it is sorted by who wrote it.
Kernel-written times carry the sequence, times copied from files and registry values are checked against them, and what the image cannot say is written down beside the rows. Across hosts, a common destination shows a common actor, not a path.
The last lesson puts every habit in this module to work on an image you have not seen.