In this section

NTFS Forensics: MFT, USN Journal, Timestomping and Ransomware Encryption Rate

Module 0

Introduction

Every artifact in the earlier lessons is a file: a Prefetch file, a registry hive, an event log. Beneath all of them is the filesystem, and NTFS keeps two records of its own that no application writes and few attackers think to touch.

The master file table holds a record for every file on the volume, with its name, its location, its size and two sets of timestamps. The change journal holds a running list of what happened to files, in the order it happened.

$MFTOne record per filename, parent, size, attributesTwo timestamp setsSI and FN, four times eachStreamsthe data, and any extra namedstreams$UsnJrnl:$JOne entry per changecreated, written, renamed,deletedIn write ordera sequence number per entryRollingthe oldest entries fall off

The two records beneath every artifact. The MFT says what each file is now; the change journal says what happened to files recently, in order.

This lesson reads both on the ransomware case: one file's record in full, two files whose times were falsified, the attack's order from the journal alone, and the encryption measured to the minute. Module 7 teaches NTFS in depth, the journal and the transaction log, deleted-file recovery, timestomping, streams and the filesystem timeline.

01

Two Records Beneath Everything

The MFT and the change journal

The master file table, $MFT, is itself a file at the root of every NTFS volume.

Each file and folder has at least one record in it, holding attributes: the standard information attribute with four timestamps and the file's flags, one or more file name attributes with their own timestamps and the parent folder, and the data, either inside the record for very small files or as a pointer to where it lives on disk.

The MFT describes the volume as it is at the moment it is collected.

The change journal, stored as the $J stream of $Extend\$UsnJrnl, is a different kind of record. Each time a file is created, written, renamed, has its attributes changed or is deleted, NTFS appends an entry naming the file, its parent, the time and a reason code.

It holds history rather than state, but only recent history: it has a fixed maximum size, and the oldest entries are discarded as new ones arrive.

Both are parsed with MFTECmd, which reads $MFT, $J and the transaction log $LogFile, among others. Collecting them needs raw disk access because the files are locked on a running system, which KAPE and similar tools handle:

PS C:\> .\MFTECmd.exe -f 'E:\YORK-WS-033\C\$MFT' --csv E:\Out --csvf mft.csv
PS C:\> .\MFTECmd.exe -f 'E:\YORK-WS-033\C\$Extend\$J' --csv E:\Out --csvf usn.csv

Each MFT record is a fixed-size block, so the table is effectively an array: a file's entry number is its position in it, and the parsed output keeps that number so records can be matched across tools. The same numbering appears in the change journal, which names the record each entry is about.

Parsing takes minutes even on a large volume, and the outputs are large: one row per file for the MFT, and one row per change for the journal, which on a busy machine runs to hundreds of thousands of rows a day.

Nobody reads them top to bottom. The work is filtering, by time window, by folder, by extension or by reason code, and the rest of this lesson is a sequence of such filters on one host.

The two outputs answer different questions. The MFT answers what is on the disk and what each file's metadata says; the journal answers what happened to files in the hours or days it covers. Most filesystem findings use both, and the strongest are the ones where they agree.

02

One Record, Read in Full

The payload from lesson 0.4

The downloaded payload's MFT record holds more than its path:

Entry            50636   in use True
Path             C:\Users\t.bennett\Downloads\DocuSign_Review.exe
Size             4,523,891 bytes
SI created       2026-03-18T01:50:44.000Z
SI modified      2026-03-18T01:50:44.000Z
SI accessed      2026-03-18T01:51:22.000Z
SI entry mod.    2026-03-18T01:51:22.000Z
FN created       2026-03-18T01:50:44.000Z
FN modified      2026-03-18T01:50:44.000Z
Streams          Zone.Identifier, ZoneId 3

The size is 4,523,891 bytes, exactly the byte count Edge's download record gave in lesson 0.4: the file on disk is the file that was downloaded. Both sets of timestamps agree on its creation at 01:50:44, eleven seconds after the download began. The accessed and entry-modified times moved to 01:51:22, the second Sysmon recorded the program starting.

The last line is the alternate data stream. The file carries a second named stream, Zone.Identifier, which Microsoft's file system specification gives in the form of a ZoneTransfer section with a ZoneId. Here the value is 3, the Internet zone.

Browsers write it on files they download, so the stream survives even if the browser history is cleared. It is one of the records Module 4's lesson on the Mark of the Web reads in full.

The stream's absence proves less than its presence. Files copied from a USB drive or extracted by some archive tools lose it, and an attacker can remove it in one command. Present, it says where a file came from; absent, it says only that the record was not kept or not kept here.

The entry-modified time on this record is worth a second look too. It matches the accessed time, because running the program read the file and NTFS updated the record. On a file nobody touched after creating it, all four SI times would still match the creation time.

An ordinary file looks like this:

Entry            50309   in use True
Path             C:\Users\t.bennett\Downloads\file_90535.xlsx
Size             14,680,236 bytes
SI created       2025-06-02T04:13:59.134Z
SI modified      2025-10-23T16:15:22.206Z
SI accessed      2026-02-11T00:37:29.429Z
SI entry mod.    2025-10-23T16:15:22.206Z
FN created       2025-06-02T04:13:59.134Z
FN modified      2025-10-23T16:15:22.206Z
Streams          data only

Its times are spread over months, every one carries a fractional second, and the SI and FN creation times are identical. That is what normal looks like, and it is the baseline the next two records are read against.

03

Two Sets of Times

One can be set, one cannot

Every file has two sets of timestamps in its MFT record. The standard information attribute, SI, holds created, modified, accessed and entry-modified times; it is what Explorer shows and what most tools display. The file name attribute, FN, holds its own created and modified times, written by NTFS when the file is created, renamed or moved.

The difference that matters is who can change them. Microsoft's documentation for the SetFileTime function says it sets the time a file was created, last accessed or last modified, and that it needs only a handle with the right to write the file's attributes.

Any program that can write to a file can rewrite three of its four SI times to any value. There is no documented call that sets the FN times directly, and none for the SI entry-modified time, which NTFS updates itself whenever the record changes.

Side by side:

SI and FN: who writes each

Read the times a program cannot reach

SI created

settable by any program with attribute-write access

SI modified

settable; also changes when the data is written

SI accessed

settable; updates may be delayed or disabled

SI entry modified

NTFS only: changes whenever the record changes

FN created

NTFS only: set when the name is created

FN modified

NTFS only: updated on rename or move

The accessed time deserves its own caution. Windows can delay or disable last-access updates for performance, so an accessed time is the weakest of the four and rarely carries a finding alone. The entry-modified time is the most useful SI time to an investigator precisely because no ordinary program sets it.

That asymmetry is what makes falsified times detectable. A program can make a file claim it was created last year, but only in the times it can reach.

The times it cannot reach still say when the file arrived, and the record's own entry-modified time moves to the moment the falsification happened. MFTECmd's output flags the FN times when they differ from the SI times, which is where a reviewer looks first.

04

Timestomping

Two tools that claimed to be older

Two files on the ransomware host have SI times that do not fit:

Entry            50634   in use True
Path             C:\Users\t.bennett\AppData\Local\Temp\mshelper64.exe
Size             892,416 bytes
SI created       2026-01-01T00:00:00.0000000
SI modified      2026-01-01T00:00:00.0000000
SI accessed      2026-01-01T00:00:00.0000000
SI entry mod.    2026-03-18T02:01:15.000Z
FN created       2026-03-18T02:00:55.000Z
FN modified      2026-03-18T02:00:55.000Z
Streams          data only

Read against the ordinary spreadsheet above, three things stand out at once. The SI times are identical to each other, the fractional seconds are all zero, and the SI creation time is weeks before the FN creation time. Put in the order the times were actually written:

1. FN created 02:00:55set by the filesystem when the file was made2. SI entry modified 02:01:15the record was changed twenty seconds later3. SI created 2026-01-01 00:00:00whole seconds, zero fraction, before the file existed4. Sysmon: ran at 02:01:15the other records place it on 18 March

Reading a timestomp on mshelper64.exe. The time set from user mode claims 1 January; every time the attacker could not set says 18 March.

Every SI time except one says midnight on 1 January 2026, exactly, with a fractional part of zero. The FN times say 02:00:55 on 18 March. A file cannot have been created 76 days before it existed, so the SI times were set deliberately.

The tell is not only the disagreement: real timestamps almost never fall on a whole second, and a value with seven zeros after the decimal point is a value somebody typed.

The fourth SI time, entry modified, reads 02:01:15: twenty seconds after the file was created, and the same second Sysmon recorded the program running in lesson 0.2. The record changed then, which is when the times were set. The second stomped file, data-tools.exe, shows the same pattern: SI times of 1 January, FN creation at 02:10:11, entry modified at 02:10:22.

Not every disagreement between SI and FN is an attack. Programs that extract files from archives often set the modified time to the time stored in the archive, and some installers preserve the times their files had on the build machine.

Those produce SI times older than FN times too. What separates them from a stomp is the pattern: legitimate preserved times carry real fractional seconds and differ from one another, while a stomp sets several times to one round value.

Timestomping is also a choice an attacker makes knowingly, which matters for the report.

A falsified time is not an accident of software; it is an action taken to mislead an investigation, and it belongs in the anti-forensics section of a finding alongside the log clearing lesson 0.8 reads. Here it also tells the investigator something about the attacker: they expected someone to build a timeline, and prepared for it, but only for the times most tools show by default.

The purpose of timestomping is to hide a file from a timeline sorted by the times investigators usually look at. Sorted by SI created, these two files sit in January among ordinary files and are easily skipped. Sorted by FN created, they sit in the middle of the attack. Module 7 reads detection across the MFT, the change journal and the transaction log, which records the time update itself.

05

The Journal: Arrival in Order

Executables created on 18 March

The change journal on this host covers 17 and 18 March. Filtered to executables created on the day of the attack:

2026-03-18T01:50:44  FILE_CREATE  ~\Downloads\DocuSign_Review.exe
2026-03-18T02:00:55  FILE_CREATE  ~\AppData\Local\Temp\mshelper64.exe
2026-03-18T02:11:33  FILE_CREATE  ~\AppData\Local\Temp\PsExec.exe
2026-03-18T02:28:33  FILE_CREATE  ~\AppData\Local\Temp\locker.exe

Each line is one journal entry with the reason FILE_CREATE. Laid out as a sequence with the encryption that followed:

DocuSign01:50:44createdmshelper6402:00:55createdPsExec02:11:33createdlocker02:28:33created2,847 writes02:30 to 02:47.locked files

The attack in the change journal alone: four executables arriving, then the encryption. No event log was needed for this sequence.

Four executables arrived in the user's Downloads and Temp folders between 01:50:44 and 02:28:33: the payload, the credential tool, PsExec and the ransomware. Each journal entry's time is when NTFS created the file, independent of any time the attacker later set on it. The journal recorded mshelper64.exe being created at 02:00:55 whatever its SI times now claim.

Reason codes combine. An entry for a file that was written and then closed reads DATA_OVERWRITE|CLOSE, and one that was extended reads DATA_EXTEND. The CLOSE flag marks the last entry for one opening of the file, which is why counting CLOSE entries for a reason counts operations rather than individual writes. The encryption count in the next section relies on that.

This is the sequence lessons 0.2 and 0.4 built from Sysmon, Prefetch and the Security log, reconstructed from a single filesystem record. On a host where the event logs were cleared, as this one's Security log was at 02:45, the journal is often what still holds the order. It does not say which process created each file; that comes from the process records, where they survive.

Where they do not, the journal's order and the MFT's records still place each file on the timeline, and the finding names which process created it as unknown rather than guessing.

06

Measuring the Encryption

Rate, duration and scope

Ransomware leaves a pattern in the journal that nothing else produces: thousands of writes to files in a short time. Counted per minute:

02:30   167  ###########################
02:31   167  ###########################
02:32   167  ###########################
02:33   167  ###########################
02:34   167  ###########################
02:35   167  ###########################
02:36   167  ###########################
02:37   167  ###########################
02:38   167  ###########################
02:39   167  ###########################
02:40   167  ###########################
02:41   167  ###########################
02:42   167  ###########################
02:43   167  ###########################
02:44   167  ###########################
02:45   167  ###########################
02:46   167  ###########################
02:47     8  #

2,847 writes to files named .locked, beginning at 02:30:00 and ending at 02:47:35: about 17.6 minutes, at an almost perfectly steady 167 files a minute. The count matches the 2,847 files Prefetch recorded locker.exe referencing in lesson 0.2, two independent counts from two different records agreeing on the same number.

A steady rate says something about the program: it worked through files at a fixed pace, not as fast as the disk allowed. The duration says how long a responder had. An alert at 02:47, when the SOC's fired, arrived as the encryption finished.

The rate is also a planning number.

A responder who knows a ransomware family encrypts at a fixed rate can estimate, from the time an alert fires, how much is already lost and how much isolating the host now would save. Here the alert fired at the end, so the answer was nothing, but on a file server holding hundreds of thousands of files, the same arithmetic decides whether to pull the network cable or the power.

Where the writes landed gives the scope:

 487  C:\Users\t.bennett\Desktop
 486  C:\Users\t.bennett\Documents
 474  C:\Users\t.bennett\Documents\Finance\Q4-2025
 473  C:\Users\t.bennett\Documents\Finance\Q1-2026
 472  C:\Users\t.bennett\Documents\Reports
 455  C:\Users\t.bennett\Documents\Finance
2847  total

The folder counts are close to even, between 455 and 487 files each, which is what a program working folder by folder through a profile of similar folders would produce. A large gap between folders would have been worth explaining, for example a folder the program could not open.

Every encrypted file is in one of six folders in the user's profile, which matches the target argument the ransomware ran with: C:\Users. Nothing outside the profile was encrypted. The MFT holds 34 ransom notes across 7 folders, dropped as the program worked through them.

The two counts do not line up perfectly, and the difference is instructive. One note sits in Downloads, a folder where the journal records no encrypted file at all. A ransom note proves the program visited a folder; it does not prove anything there was encrypted. Scope is measured from the writes, and the notes are used only to confirm which folders the program reached.

07

What the Filesystem Cannot Say

Limits, and why collection is urgent

The filesystem's records are durable compared with event logs, but they have limits that shape what a finding can claim:

What the filesystem records, and does not

Know the limits

$MFT

each file as it is now; a reused record loses the old one

$J

recent changes, oldest dropped as the journal fills

Times

SI can be set from user mode; FN is set by NTFS

Content

that a file was written, never what was written

Here

the journal held 17 to 18 March only

So

collect early; the journal is the first thing lost

The journal's limit is the one that bites first. Its fixed size means that a busy volume can turn over its whole journal in a day or two, and every hour a compromised machine keeps running after the incident pushes the oldest entries out.

On this host the journal reaches back only to the morning before the attack. Had the image been taken a week later, the arrival of the four tools might have been gone from it.

The journal can also be deleted outright. An administrator, or an attacker with administrator rights, can delete the change journal with a built-in command, which resets it and discards every entry. Module 7 reads what survives it. On this host the attacker cleared the Security log but left the journal alone, which is common: many attackers know about event logs and fewer think about NTFS.

The MFT's limit is subtler. Records are reused: when a file is deleted, its record is marked free and eventually given to a new file, and the old metadata is overwritten. Module 7's lessons on the transaction log and deleted-file recovery read what survives in the gaps.

And neither record holds content. The journal says a file was written at 02:31; it does not say what was written. For ransomware that hardly matters. For an insider case, where the question is what was copied, the filesystem says which files were touched and when, and the content question goes to other evidence.

08

What Module 7 Builds On It

NTFS in depth

Module 7 takes the filesystem apart in the order an investigator needs it:

Module 7, in order

Module 7

NTFS

the architecture an investigator needs, then the parsed MFT

Change journal

the $J, and mass operations such as ransomware

Transaction log

$LogFile, and recovering deleted files

Timestomping

detection across MFT, journal and log

Streams and metadata

alternate data streams, document metadata

Timeline

directory indexes, then the filesystem timeline

It starts with the NTFS structures this lesson summarized and the parsed MFT, then the change journal and the mass-operation patterns ransomware leaves, then the transaction log and deleted-file recovery. Timestomping gets its own lesson, because detection improves sharply when the MFT, journal and log are read together. Alternate data streams and document metadata follow, and the module ends with directory index analysis and a full filesystem timeline.

The module's See It Done lesson examines a volume eleven days after the activity, when the transaction log has gone and the journal starts three days late, and shows how much of a case is still answerable from what remains. It is the practical answer to the collection urgency in section 7.

Two tools carry most of that work: MFTECmd for parsing and Timeline Explorer for filtering the CSVs it writes. Both are free, both run on any Windows analysis machine, and Module 7 uses both throughout.

The habit to carry into it is to treat the filesystem as the record of last resort and the record of first check. When other logs are gone, the MFT and journal often still hold the order of events. When other logs say something happened, the filesystem is where to confirm a file actually arrived, when, and whether its times are honest.

Do

Practice

What does the filesystem itself say?
prepared evidence

The prepared evidence below is the ransomware host's filesystem in three views: five parsed MFT records, the executables the journal saw created, and the journal's encryption writes per minute. Find the falsified times, the value that dates the falsification, and the duration.

If you have a Windows machine of your own, copy any file and look at its timestamps in Explorer, then run MFTECmd against your own $MFT from an elevated prompt and find the same file. Compare the SI and FN times on the copy; a copy and a move set them differently, which Module 7 explains.

The MFT holds each file's present state with two sets of times, one of which a program can set and one it cannot. The change journal holds recent changes in order, independent of any time an attacker set. Read together, they exposed two timestomped tools, rebuilt the attack's order without an event log, and measured the encryption to the minute and the folder.

The next lesson reads everything the attacker did to cover their tracks, and what each step left behind.

Resources

Microsoft revises these pages; where a page and this lesson disagree, the page is newer.