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
Windows Forensic Timeline Analysis: Plaso, Confidence Grading and Writing Findings
Introduction
Every earlier lesson read a few records to answer one question. An investigation ends with all of them on one timeline, because that is where the questions connect: the way in leads to the account change, the account change to the movement, the movement to the anti-forensics and the encryption. The timeline is also where confidence is decided, because it shows, for each event, how many independent records saw it.
Building one timeline from many sources. The last two steps are what turn a sorted list into findings.
This lesson builds that timeline for the ransomware case from every source lessons 0.2 to 0.8 read, grades each row, and states the gaps. Module 9 teaches the tools and the method at scale: Plaso and Timeline Explorer, multi-host correlation, confidence assessment and reporting.
Settle the Clock First
Before any two records are comparedEvery source on a Windows host has its own idea of time. Event logs and the filesystem store UTC; some registry values and log files store local time; browser and application databases use their own epochs. A timeline built without settling this first puts events in the wrong order, and the error is invisible because every row still looks precise. Each source's convention has to be known, not guessed.
The parser documentation usually states whether a field is UTC or local, and where it does not, the safe course is to find one event recorded by both that source and a known-UTC source, and compare. The host's own clock settings come first:
TimeZoneKeyName GMT Standard Time
ActiveTimeBias 0 minutes
Key last written 2025-06-15T08:20:00Z
ShutdownTime 2026-03-18T04:15:22Z
The host was set to GMT Standard Time with an active bias of zero minutes, so on 18 March local time and UTC were the same. That will not always hold for this zone: it moves to British Summer Time in late March, after which local time runs an hour ahead.
An investigation spanning that change, or one that combines this host with machines in other zones, has to convert every source to UTC explicitly rather than assuming. The setupapi log in lesson 0.6 was a local-time source on a different host; on that machine the bias was also zero, which is why its times could be read directly.
Clock settings themselves can change. The time zone key's last write time, in June 2025, is when the setting was last changed, long before the incident, so there is no sign the zone was altered to confuse the timeline. An attacker who changed the system clock would leave a different record, a time-change event in the Security log, which Module 9 reads; there is none in the window here.
The shutdown time is the other anchor. The machine was shut down for imaging at 04:15:22; nothing on the image can be later than that, and anything that claims to be is a clock or parsing error.
One Event, Several Records
Why the times differ, and why that helpsMost events are seen by more than one record, and each records its own moment. The payload is the clearest example:
One payload, five records, three different moments. Each record timestamps the thing it saw, and the differences are the sequence, not an error.
The download began at 01:50:33, the file's record on disk was created eleven seconds later, and the process started at 01:51:22, a moment that Sysmon, Prefetch and BAM agree on to the second. These are not five estimates of one time that disagree; they are three different moments in a sequence, each recorded by the component that saw it.
Laid out record by record, each with its own timestamp field for the moment it saw, the sequence is easier to read than the figure suggests:
2026-03-18T01:50:33 Edge downloads download started, 4,523,891 bytes
2026-03-18T01:50:44 $MFT FN created file record created
2026-03-18T01:50:44 $J FILE_CREATE same moment, same writer
2026-03-18T01:51:22 Sysmon event 1 process created, parent msedge.exe
2026-03-18T01:51:22 Prefetch last run, run count 1
2026-03-18T01:51:22 BAM last execution, user SID ...2156
The six lines hold three distinct moments: the download starting, the file being created, and the program running. Two of the lines are NTFS's two records of the same creation, and three are three components' records of the same run.
That distinction matters when merging. Treating the download start and the process start as "the same event, roughly 01:50 to 01:51" loses the order. Keeping them as separate rows, or as one row with each record's own time, keeps it. The general rule is to merge only records that describe the same moment, and to keep sequences as sequences.
Records also differ in precision. Sysmon and NTFS store fractions of a second; some browser fields and parsed exports round to whole seconds; SRUM, in lesson 0.6, recorded rows covering spans of time. When two records disagree by less than the coarser one's precision, they agree, and a timeline that reports both to the millisecond implies a precision one of them never had.
Agreement to the second between independent records is also a check on the clocks. Sysmon, Prefetch and BAM are written by different components; if one were offset, its times would sit consistently apart from the others across every event. On this host they agree throughout, which is evidence the timeline's clock is sound.
Building It
Plaso, and the targeted alternativeOn a full image, the standard tool is Plaso. Its documentation gives the two steps: log2timeline reads a source, which may be a single file, a storage media image or a directory, and writes a storage file; psort reads the storage file and writes it out, in formats including the CSV used by the original log2timeline, with a date filter at the end of the command:
$ log2timeline.py --storage-file york033.plaso /cases/YORK-WS-033.E01
$ psort.py -o l2tcsv -w york033.csv york033.plaso \
"date > '2026-03-18 01:40:00' and date < '2026-03-18 02:50:00'"
Run against a whole image, log2timeline extracts every timestamp it can parse from every file, which on a workstation means millions of rows and hours of processing. Module 9 teaches the targeted alternative: parsing only the artifacts the investigation needs, which for this case means the dozen sources the earlier lessons read. The result is smaller, faster and easier to review, and every row's origin is obvious.
Timeline Explorer, from the same author as the EZ Tools used throughout this module, opens the CSV that psort or any of the EZ parsers writes and lets an analyst filter, group, color and tag rows without changing the data.
Module 9 uses it to read Plaso output, and it is equally useful for the targeted approach, where each parser's CSV is loaded and the rows that matter are tagged into one view.
The two approaches fail differently. A full extraction misses little but buries the important rows among millions of ordinary ones, and an analyst reading it under time pressure can miss what is there.
A targeted build is quick to read but only contains what the analyst thought to parse, so a source nobody thought of stays invisible. Experienced examiners usually build targeted first, then run a full extraction over a narrow time window to catch what the targeted build left out.
The timeline below was built the targeted way, from the parsed records already in hand. Each row is one event, with every independent record that saw it listed beside it. Building it is the work of an afternoon once the sources are parsed, and the work is mostly reading and deciding which records describe the same event.
The Timeline
Seventeen rows, one hourThe ransomware case from the lure to the last encrypted file, with each row's grade and the number of independent sources behind it:
01:47:11 Low Lure received by mail 1
01:49:22 Low Lookalike page opened from a link 1
01:50:33 Moderate Payload downloaded 2
01:51:22 High Payload runs as t.bennett 3
01:51:33 Low Payload calls the lure's sender 1
02:01:15 High Credential tool runs as SYSTEM 4
02:08:22 Low nge-admin RDP session from 127.0.0.1 1
02:11:44 Moderate PSEXESVC installed on this host 2
02:12:11 High PsExec toward NGE-FILESERVER 3
02:14:11 High PsExec toward NGE-DC01 3
02:14:33 Low nge-admin locked out 1
02:15:22 Low Defender protections turned off 1
02:18:22 High Shadow copies deleted 3
02:20:33 Low Security sites blocked in hosts file 1
02:30:00 High Ransomware runs as SYSTEM 4
02:45:11 Low Security log cleared 1
02:47:35 Low Last encrypted file written 1
The count in the last column is the number of independent records behind each row. The same rows, with those records named, so that any grade can be checked against what supports it:
01:47:11 mailbox header
01:49:22 Edge history
01:50:33 Edge downloads, NTFS (MFT and $J)
01:51:22 Sysmon, Prefetch, BAM
01:51:33 Sysmon
02:01:15 Sysmon, Prefetch, BAM, NTFS (MFT and $J)
02:08:22 Security log
02:11:44 System log, SYSTEM hive
02:12:11 Sysmon, Security log, NTUSER.DAT
02:14:11 Sysmon, Security log, NTUSER.DAT
02:14:33 Security log
02:15:22 PowerShell log
02:18:22 PowerShell log, Prefetch, System log
02:20:33 hosts file
02:30:00 Sysmon, Prefetch, BAM, NTFS (MFT and $J)
02:45:11 Security log
02:47:35 NTFS ($J)
Read top to bottom, the story is the one the earlier lessons told in parts: mail, click, download, run, callback, credential theft, an administrator's session, two moves toward other machines, the defenses and recovery removed, the encryption, the clearing. What the merged view adds is the shape.
The way in took four minutes; the attacker spent nearly half an hour preparing between the credential theft and the encryption; the encryption itself took under eighteen. The pace and the gaps between steps are visible only once everything is in one place.
The intervals are worth reading as evidence too. Ten minutes passed between the payload running and the credential tool, seven more before the administrator session, four before the first move, and then the defenses and recovery fell in five minutes.
That rhythm, quiet at first and then fast, is typical of an operator who spent the first minutes establishing access and then worked through a prepared list. It also bounds how long any defender had to act at each stage.
Grading Confidence
Independent sources, counted honestlyThe grade on each row comes from one rule here: three or more independent sources is high, two is moderate, one is low. Module 9 refines it, because confidence also depends on the size of the claim and the reliability of each source, but source count is where it starts.
On this timeline 6 rows are high and 9 are low. The rest are moderate, and every grade can be recomputed by anyone who has the source list beside it.
Written down as a rule, so that another analyst given the same timeline would assign the same grades:
The grading rule used here
Start here, then refineThe word that matters is independent. Two records count separately only if they are written by different components that could not both be wrong for the same reason:
Counting sources. Three records of one execution written by three different components count three times; the MFT and the change journal are both written by NTFS and count once.
Sysmon, Prefetch and BAM are written by three different parts of Windows, so three records of one execution are three sources. The MFT and the change journal are both written by NTFS. They hold different things and are both valuable, but a fault in the filesystem's clock or a deliberate manipulation at that level would affect both, so their agreement counts once.
The same reasoning applies to a parsed artifact and a report generated from it, or to two tools reading the same log: different outputs, one source.
Applied to this timeline, the rule produces a pattern worth noticing. The events with high grades are executions and file operations, which Windows records in several places by design. The events with low grades are single log entries: a logon, a lockout, a clearing, a configuration change.
That is not a property of this case. Authentication and configuration events are usually recorded once on a host, and their corroboration is usually on another machine, the domain controller or the security product's console.
A low grade is not a judgment that the event did not happen. The RDP session, the lockout and the clearing each stand on one record in one log, and each record is almost certainly accurate. The grade says that if the record were wrong, nothing else on this host would show it, and a finding built on it carries that weight.
The Gaps
Rows for what no record showsA timeline lists what was recorded, and the reader assumes that what is not listed did not happen. That assumption is wrong in every investigation, so the gaps go into the timeline as rows of their own:
Gaps: what happened that no record shows
Gaps are rowsThe first gap is the most important. The payload ran as the user at medium integrity at 01:51; ten minutes later a tool ran as SYSTEM. Something in between raised the privilege, an exploit or a misconfiguration, and nothing on this host recorded it.
Writing that as a gap stops a reader from assuming the timeline is complete and stops the analyst from filling it with a guess that then gets repeated as fact.
Gaps are also where an investigation is most often wrong in hindsight. A timeline that jumped straight from the payload running to the credential tool running would invite the reader to assume the payload contained the exploit, and that assumption might be repeated in the report, the insurance claim and the lessons learned.
If memory later showed the privilege came from a misconfigured service instead, every one of those documents would be wrong. A gap row costs one line and prevents that chain.
Each gap names the evidence that would close it: memory captured from the live machine, the file server's and domain controller's logs, the network records for 10.1.10.10. Some gaps will never close: memory from the live machine is gone once it is powered off, and a log that was never enabled cannot be recovered.
Those stay in the final report as gaps, with the reason they could not be closed. A gap row is a request for collection as much as a statement of ignorance, and a timeline with its gaps listed is the best way to show an incident lead what to fetch next.
Contradictions are the other thing a merged timeline exposes. Two records that claim different times for the same moment cannot both be right, and the resolution is never a vote. Lesson 0.7's timestomp is the example on this host: the SI times said January and the FN times, the journal, Sysmon and Prefetch said 18 March.
The resolution came from asking which record could have been changed and by whom, not from counting which date appeared more often. The same question resolves most contradictions: which writer could be wrong, and how.
Writing Findings
Claim, grade, reason, limitA finding takes rows from the timeline and turns them into a sentence a reader can act on. Module 9 teaches a structure that survives someone setting out to attack it: the claim, the confidence, the reason for that confidence, and what would change it. Two findings from this timeline, at opposite ends:
One finding, written to be checked
Claim, grade, reason, limitThe second sits at the other end of the scale, and the claim is written differently because of it:
A second finding, graded lower
Size the claim to the evidenceThe first is high because three independent records date the run and two independent counts agree on its size.
The second is low, and the claim is sized down to match: the evidence shows a Remote Desktop session arriving from the machine itself, and the tunnel that would explain it is an inference, so the finding states what was seen and names the inference as such. Moving a claim down costs nothing but honesty; moving the evidence up costs collection.
Most findings sit between the two, and the four parts make the difference visible. A reader can see at a glance which claims are solid and which are provisional, and a reviewer can check each reason against the timeline row it cites. That is what makes a report survive challenge: not that every claim is strong, but that every claim says how strong it is and why.
Writing findings this way also changes how a report reads to the people who act on it. An incident lead deciding whether to rebuild a server, a lawyer deciding whether to notify a regulator and an insurer deciding a claim each need to know which statements they can rely on.
A report that grades every finding and gives the reason lets each of them make that judgment for themselves, rather than trusting the author's overall tone.
The worst finding is neither of these. It is a high-confidence label on a large claim with no reason attached, which a reader cannot check and a challenger can dismantle by finding one contradicting record.
What Module 9 Builds On It
Timelines at scale, and the reportModule 9 takes the method in this lesson to full scale:
Module 9, in order
Module 9It starts with why a timeline changes an investigation, then teaches Plaso in its targeted form and Timeline Explorer for reading what Plaso produces. The multi-host lesson joins timelines from several machines, where clock differences and time zones become real problems.
The confidence lesson is the full version of the grading here, and the module ends with reporting and preparing to testify, where every row of a timeline may be asked about under oath.
For this case, the multi-host lesson is where the gaps would start to close. The file server's and domain controller's timelines, joined to this one on UTC, would show whether the PsExec connections at 02:12 and 02:14 arrived, what they did, and what 10.1.10.10 was doing at the moment of the lockout. Each additional host adds rows, and occasionally removes a gap row by replacing it with an event.
The habit to carry into it is the order this lesson used: settle the clock, merge only what describes the same moment, count independent writers rather than records, list the gaps as rows, and write each finding with its reason and its limit.
Practice
How sure is each line of the timeline? prepared evidenceThe prepared evidence below is the merged timeline for the ransomware case, each row with the records that hold it. Find the rows that stand on one record, decide why one pair of sources counts once, and name what the timeline leaves open.
If you have a Windows machine of your own, pick one program you ran today and find it in two places: its Prefetch file and your BAM key, both readable with the tools from lesson 0.2. Compare the times to the second, then decide whether those two records are independent.
A timeline is many sources on one clock, merged only where records describe the same moment. Each row is graded by how many independent components recorded it, with records from one writer counted once, and the gaps are rows too. Findings are written from it with the claim, the grade, the reason and what would change it.
The last lesson turns to the applications people use every day, browsers and communication apps, and what each keeps.
Resources
Microsoft revises these pages; where a page and this lesson disagree, the page is newer.