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
Network Forensics Correlation and Reporting: NAT, DHCP, Timelines, Scope and the Investigation Report
Introduction
Every earlier lesson read one kind of evidence.
A real incident needs all of them at once, joined: an outside party's report to the firewall's translation log, the translation to a lease, the lease to a device, the device to a process and an account, and every event onto one clock so that the order is right. Then it needs to be written down in a form someone else can act on.
Each stage is a join between two records on a shared value inside a window of time. The last step, from an account to a person, leaves the network.
This lesson does both on two of the lab's windows. In the first, an abuse desk reports a connection from the organization's only outside address, and the chain of joins finds the device, process and account behind it.
In the second, one intrusion is merged onto one clock, its systems are sorted into the categories a report uses, and the report's structure is laid out. Module 12 covers the joins, Module 13 the scoping and the report, and Module 14 puts the whole course to work on one case.
The Report From Outside
An address everybody shares, and a portThe abuse desk of a notes service wrote to say that someone on this network posted what look like customer records. The connection they want identified:
$ sed -n '6,8p' abuse-report.txt
organization's customer records. The connection we would like you to identify:
2026-11-11 13:32:20 UTC from 198.51.100.10, source port 47744, account ml-notes
Four facts, and each belongs to someone. The address, 198.51.100.10, is the firewall's only address on the internet; the asset notes say every inside host, the proxy and every VPN user leave through it, so the address alone names nobody.
The port, 47744, is the firewall's choice for one connection, and the server logged it because servers log the client port of every connection they accept. The time is the abuse desk's clock, and the report says so. The account, ml-notes, belongs to their service.
Getting from those facts to an account inside takes a chain of joins, and each join has its own way of failing:
Each join, and how it fails
The firewall logs translations, or the chain stops here
A lease that changes hands within minutes
An endpoint record of the connection, or none
Shared, borrowed or stolen credentials
The port is the key the whole chain depends on, and the time is the weakest fact in the report, because nothing yet says whether their clock agrees with any clock here.
The work starts by writing down which facts will be tested and which accepted: the port against the firewall's translation log, the time against the organization's own records, the content accepted as their description because nothing on this side recorded what was posted.
That habit, deciding what each piece of an outside report is worth before using it, protects the investigation from the most common failure in attribution: matching the wrong record because one field happened to agree. Module 12's first lesson follows this chain end to end before taking each join apart.
The report also lists every request the account made, seven posts over about seven minutes, each with its own outside port.
The investigation needs only one of them to find the device, but the other six are a test: if the chain is right, each of their ports should lead to the same inside address while the same device held its lease. In this window all seven do, which is a stronger result than any single join.
Outside to Inside
The translation log, and a clock that disagreesThe firewall logs its connection tracking events. Searching for the port on the outside half of each entry:
$ grep 'dport=47744' nat.log | grep NEW | cut -c1-20
grep 'dport=47744' nat.log | grep NEW \
| grep -oE '(src|dst|sport|dport)=[^ ]+' | paste -d' ' - - - -
[1794403903.215400]
src=10.20.30.120 dst=203.0.113.160 sport=56944 dport=443
src=203.0.113.160 dst=198.51.100.10 sport=443 dport=47744
The first line is the entry's time; the next two pair the inside half of the connection, 10.20.30.120 port 56944 to 203.0.113.160 port 443, with the outside half, the server answering 198.51.100.10 on port 47744. The bracketed number at the start is the event time in seconds since 1970:
$ date -u -d @1794403903 +%T
13:31:43
The report's time and the firewall's time do not agree, which leads to the first mistake an attribution can make:
The reasonable mistake
Matching to the second on someone else's clock
An analyst searches the NAT log for port 47744 at 13:32:20, the time in the report, finds nothing in that second and concludes the connection did not come from this network.
Instead: Treat an outside party's time as the center of a window. The firewall recorded the translation at 13:31:43, 37 seconds earlier, and the port, not the second, is the key.
The firewall saw the connection begin at 13:31:43. The report says 13:32:20. Either clock could be wrong, or both, and the difference, 37 seconds, is the kind of offset that ends an attribution if the search is too narrow. The port settles it: in a window of minutes there is exactly one translation that used 47744 to that server.
Ports are reused, though, so the window still matters. A busy firewall hands out the same outside port many times a day, and a port search across a whole day can find several translations.
Module 12's lesson on NAT reads the translation log in full, and its lesson on clocks measures the offset between each pair of sources in the lab so that every join can use a window with a stated width rather than a guess.
Note also what the translation log adds that the report could not: the destination, 203.0.113.160 port 443, and the inside source port, 56944. Those two values carry the chain forward. The inside port is what the endpoint will have recorded, and the destination confirms that this translation was to the notes service the report came from rather than to something else that happened to use the same outside port.
The translation log is one of the records most networks do not keep. Firewalls track connections in memory and forget them when they close; logging every event, as this firewall does, has to be switched on, and its volume makes short retention common. Without it, the chain stops at the first link.
Address to Device
A lease that changed hands10.20.30.120 is the hot-desk address: the asset notes say it is the only address in its DHCP scope, with two-minute leases. The DHCP server's log, reduced to the moments the holder changed:
$ grep DHCPACK dhcp.log | awk '{print $3, $6, $8}' | uniq -f2
13:22:24 10.20.30.120 LT-0060
13:28:19 10.20.30.120 LT-0061
The address was leased to LT-0060 from 13:22:24, and to LT-0061 from 13:28:19. The connection began at 13:31:43, inside LT-0061's lease. A search that took the address from the NAT log and looked it up in the asset register would have found nothing, because the address is assigned to no device; a search that took the first device ever seen on it would have named the wrong laptop.
The asset register then says something uncomfortable about the right one: LT-0061 is a laptop from the service desk's loaner pool, assigned to nobody. The device is identified, and the device does not lead to a person. That is common: shared machines, kiosks, lab hosts and loaners are exactly the devices an intruder or an insider would choose.
The lease is the join that most often goes wrong in practice, because DHCP logs are kept for less time than almost anything else and because short leases make one address mean several devices within an hour. Module 12's lesson on DHCP reads leases, renewals and releases, and what to do when the lease log does not reach back far enough.
Two minutes is an extreme lease, chosen for the lab, but hot-desk networks, guest networks and VPN pools all recycle addresses quickly.
The rule that follows is simple: never resolve an internal address to a device without a time, and never trust a lease record without checking that its window covers the moment in question. Here the window does: LT-0061 renewed its lease at 13:31:19 and again at 13:32:19, so it held the address across the whole connection.
LT-0060, which held the same address six minutes earlier, is the device a careless join would have named, and its owner, a sales user, would have been asked to explain a post they never made.
Device to Process and Account
What the endpoint adds, and where the chain endsThe network can go no further than the device. The endpoint can: the laptop's own record of connections, by source port:
$ grep '"sport": 56944' endpoint.jsonl | tr ',' '\n' | sed -n '1,8p'
{"time": "2026-11-11T13:31:40.119Z"
"host": "LT-0061"
"event": "network_connection"
"pid": 8467
"process": "updsvc"
"user": "mlee"
"proto": "tcp"
"src": "10.20.30.120"
Port 56944 on LT-0061 was held by a process called updsvc, running as mlee. The domain controller's log shows mlee authenticating from 10.20.30.120 at 13:28:26, seven seconds after LT-0061 took the lease, so the account is confirmed from a second, independent source.
The chain is now complete as far as records go: outside port to inside address by the firewall, address to device by the lease, device to process and account by the endpoint, account confirmed by the domain controller. Each join used a different system's record and a value two of them shared.
It stops at the account. An account is not a person: a loaner laptop, a process with a name chosen to look routine, and an account whose owner may or may not have been at the keyboard. Who used mlee on LT-0061 at that time is a question for HR, the service desk's loan records and the person themselves.
The endpoint's own clock adds one more detail: it recorded the connection at 13:31:40, three seconds before the firewall did. Three systems, three clocks, each a few seconds apart, and every join in the chain had to tolerate that.
The process name matters as well. updsvc reads like an update service, the kind of name nobody questions in a process list. The endpoint record says it held the connection that posted customer records to a notes service; whatever it calls itself, that is what it did.
A name is a claim the program makes, like the user agent in Module 8; the connection it held is a record of what it did. Module 12's lessons on identities and endpoint processes read the last two joins, and its exercise asks who was behind the address and how sure the answer can be, link by link.
One Intrusion on One Clock
Merging every source into a timelineThe Module 13 window starts from a handover:
$ sed -n '1,5p' alert.txt
SOC finding, beacon hunt (handed over for scoping)
WS46 (10.20.30.46, finance, asmith) connects to api.edge-sync.example.net
over HTTPS about every 45 seconds, with jitter, throughout today's capture
window. No approved software uses that name.
Request
A beacon on WS46, handed over for scoping. The pack's timeline.py merges every source into one line per event on the sensors' clock, each line naming the record it came from: the firewall's translations, both sensors, the HTTP log, the domain controller, srv02's sshd and the endpoint events.
Every one of those sources appeared in an earlier lesson on its own. Here they are read together for the first time, and each line can be traced back to the record that produced it. With the beacon's own lines and ordinary browsing left out, the middle of the window reads:
$ python3 timeline.py | grep -v -e edge-sync -e www.example | sed -n '5,25p'
14:31:34.719 dc01 10.20.30.46 logon it-admin (Kerberos KDC)
14:31:34.956 lan 10.20.30.46 to 10.20.10.11:445
14:31:34.956 srv 10.20.30.46 to 10.20.10.11:445
14:31:54.156 lan 10.20.30.46 to 10.20.10.11:5985
14:31:54.156 srv 10.20.30.46 to 10.20.10.11:5985
14:31:54.798 edr WS46 python3 (it-admin) to 10.20.10.11:5985
14:31:54.812 edr SRV01 python3 (-) to 10.20.30.46:50098
14:33:34.714 dc01 10.20.30.45 logon it-admin (Kerberos KDC)
14:33:34.744 lan 10.20.30.45 to 10.20.10.11:445
14:33:34.744 srv 10.20.30.45 to 10.20.10.11:445
14:34:04.854 lan 10.20.30.45 to 10.20.10.11:5985
14:34:04.854 srv 10.20.30.45 to 10.20.10.11:5985
14:34:05.819 edr WS45 python3 (it-admin) to 10.20.10.11:5985
14:34:05.844 edr SRV01 python3 (-) to 10.20.30.45:53924
14:34:54.887 lan 10.20.30.46 to 10.20.10.12:22
14:34:54.887 srv 10.20.30.46 to 10.20.10.12:22
14:34:55.843 edr WS46 ssh (it-admin) to 10.20.10.12:22
14:34:55.868 edr SRV02 sshd (-) to 10.20.30.46:36680
14:34:56.626 sshd 10.20.30.46 srv02: failed password for it-admin
14:34:58.706 sshd 10.20.30.46 srv02: failed password for it-admin
14:35:01.676 sshd 10.20.30.46 srv02: failed password for it-admin
Drawn by kind of event rather than listed, the same window shows its shape:
Every source the timeline merges, by host. The beacon runs all window; it-admin reaches srv01 from two workstations and fails three times at srv02; srv01 then sends data out.
The timeline does what no single source could. The beacon runs from WS46 all window, under a process named onedrivesync and asmith's account. Then it-admin, a domain administrator, logs on from WS46 and reaches srv01 over SMB and WinRM. Two minutes later it-admin does the same from WS45. Then WS46 tries SSH to srv02 as it-admin three times and is refused each time. Later, srv01 itself runs curl to filedrop.example.net.
Merging is where clock offsets matter most, because an event in the wrong place in the order can reverse cause and effect. timeline.py puts everything on the sensors' clock and keeps the source on every line, so a reader can always go back to the record.
The edr lines show that the endpoint's events land about a second after the sensors' for the same connection, and the merge keeps them apart rather than pretending they are one event. A reader who sees two lines for one connection knows two sources saw it, which is a confirmation, not a duplicate.
The timeline also exposes what is missing. srv01's curl to filedrop.example.net appears with an owner of -, meaning the endpoint poll did not record which account ran it. That gap is a finding in its own right, and it belongs in the report's section on what cannot be established. Module 13's lesson on building the timeline reads how each source's clock compares with the sensors' before trusting the order.
Scope, and the Report
Four categories and a fixed structureScoping sorts every system the investigation touched into one of four categories, each needing its own evidence:
The four scope categories
Evidence the intruder acted on it
Tried and refused, with the refusal on record
Examined, with the evidence that shows nothing happened
Not visible, and who could settle it
On this window, srv02 is the clearest: three refused passwords and no success, which is attempted, with the refusals on record. srv01 was reached with it-admin's credentials and later sent data out, which is far more than attempted. WS46 is where it began.
WS45 is the one the scope has to explain rather than sort: it-admin used it, two minutes after WS46, and the network cannot say from these records alone whether that was the intruder or an administrator. That uncertainty goes in the report as a finding, not a footnote.
Not affected needs the most care of the four. It is a claim that a system was examined and nothing happened on it, and it needs the records that show the examination: the sensor that covers it, the window that was read, and the absence of the events that would have mattered. A system nobody looked at is unknown, not unaffected.
The pack's report template fixes the structure every report in the course uses:
$ grep '^## ' report-template.md | cut -c4-
Summary
Scope
Timeline
Findings
What cannot be established
Recommendations
Handover
A summary short enough to act on, the scope in the four categories, the timeline on one stated clock, findings each with its evidence and level, a section for what cannot be established and who could settle it, recommendations for containment and the evidence to preserve first, and a handover.
The section on what cannot be established is the one most reports leave out, and the one that most protects the investigator when the endpoint and the people involved add what they know.
Module 13 works through each part: scope, timeline, every affected system, visibility gaps, containment, preservation and the report itself, then an exercise in which a second intrusion has a look-alike by address that the scope must not confuse with it. The report it produces follows the template above, section by section, with every finding tied to the record and level that supports it.
What Modules 12 to 14 Build On It
Correlation, reporting and the capstoneModule 12 takes the attribution chain apart one join at a time, through NAT, DHCP, VPN sessions, identities, endpoint processes and clocks, and ends with an exercise on a shared reception laptop. Module 13 scopes one intrusion, contains it and reports it, and ends with a second intrusion to scope.
Module 14 is the capstone: one case, from the alert to the final report, using every method in the course, with a benign window from the same organization to test the detection the case produces.
Modules 12 to 14, in order
The labs are the windows this lesson read, with every record the chain and the timeline used, and the capstone brings its own pack. Nothing has to be captured again. Every module in this stretch reuses the records of the modules before it.
The capstone asks for the same structure: a scope in four categories, a timeline on one clock, findings with their evidence and level, the unknowns, the recommendations and the handover, with a detection built from the case and tested on the organization's benign window.
The habits to carry into them are the ones this lesson used. Decide what each outside fact is worth before using it. Join records on a shared value inside a window, never on a time alone.
Write down each join's source so that the chain can be checked link by link. Put everything on one clock, sort every system into one of four categories, and write what cannot be established as plainly as what can.
That is also the shape of the course. Every earlier module produced a kind of finding; these three produce the account of an incident that a decision can be made from, which is what the network evidence was for. A report that a manager can act on in five lines, and that an investigator can defend line by line, is the course's final output.
Practice
Follow the address, then scope it the lab firewall and timelineThe prepared evidence below is in two tabs: the records that make up the attribution chain from the abuse report, and the systems the intrusion's timeline touches. Find the record that crosses the firewall, the records that get from an address to an account, and the system that belongs in the report as attempted. Each answer comes with its reasoning, so check it against the rows.
The chain tab lists the records in the order the investigation used them, and the systems tab lists what the timeline shows for each host, without the category. For the chain, ask of each row what value it shares with the row before it, and what would break if that record had not been kept; for the systems, ask what evidence would move each one into a different category.
If you are responsible for a network, try the chain on your own logs with any outside address and port your firewall has used today. The first join that you cannot make is the record you are not keeping.
Most networks find the gap at the first or second link: a firewall that does not log translations, or DHCP leases kept for a day when the abuse report arrives a week later. Each is a setting, and each is far cheaper to change before the report than after.
An incident is investigated by joining records on shared values inside windows of time: an outside port to an inside address, an address to a device by its lease, a device to a process and an account, every event onto one clock. It is reported by sorting every system into confirmed affected, attempted, not affected and unknown, and by writing what cannot be established as clearly as what can.
That completes Module 0. Module 1 starts the course properly, with network evidence and how it is kept.