What does an NTFS $UsnJrnl entry recording a file's deletion prove, and what can it never show?
answer
- written for backup software, not for you
- one record per metadata change
- name, parent reference, timestamp, reason flags
- no content, no size, no actor field
- fixed-size circular file, short horizon
basics
~20 sA $UsnJrnl entry proves a file with that name, under that parent directory, was created, written to or deleted at that time. It carries no content, no size, and no identity of whoever did it.
solid answer
~50 sThe NTFS change journal records one entry per metadata change: a USN sequence number, a timestamp, the file's name, its file reference number, its parent's file reference number, and reason flags such as file-create, data-extend, file-delete and close. That proves a named file existed under a named folder and was deleted at a given time, and it lets you follow renames. It cannot say what was in the file -- the journal stores no content and no size -- nor who did it, since there is no actor field. In an insider case that distinction is the whole conversation: "the file `turbine-housing-rev4.step` existed in that folder and was deleted at 18:42" is defensible, while "it contained our design" is not supported by the journal alone. The journal is also fixed-size and circular, so its horizon can be days, and it can be disabled or deleted outright.
code
json · 18 lines{
"Usn": 74295312,
"TimeStamp": "2026-07-14T18:11:07.412Z",
"FileName": "turbine-housing-rev4.step",
"FileReferenceNumber": "0x0004000000019A3C",
"ParentFileReferenceNumber": "0x0002000000008F11",
"Reason": ["FILE_CREATE", "DATA_EXTEND", "CLOSE"],
"FileAttributes": ["ARCHIVE"]
}
{
"Usn": 74318880,
"TimeStamp": "2026-07-14T18:42:55.907Z",
"FileName": "turbine-housing-rev4.step",
"FileReferenceNumber": "0x0004000000019A3C",
"ParentFileReferenceNumber": "0x0002000000008F11",
"Reason": ["FILE_DELETE", "CLOSE"]
}
...go deeper
Know that NTFS keeps a change journal listing what happened to which file and when, and that it holds no file contents.
Be able to list the fields -- USN, timestamp, name, file and parent reference numbers, reason flags -- and derive existence, lifespan and renames from them, while naming the absent fields.
Demonstrate keeping the existence claim and the content claim separate when reporting, and diagnosing an empty journal as rollover versus never-enabled versus deleted.
Own whether the organisation collects anything that would answer the content question at all -- backups, server-side copies, version control -- before an insider case forces the question.
## What the change journal is NTFS maintains an update sequence number (USN) change journal in a metadata file named $UsnJrnl, whose $J data stream holds the records. Its purpose is not forensic -- it exists so that backup, indexing and replication software can ask "what changed since USN *n*?" without walking the whole volume. Forensics borrows it, which is exactly why it is so useful: it was written by the system for the system, with no attempt to describe intent. ## What one record contains A change-journal record carries, in essence: - **Usn** -- a monotonically increasing offset-like sequence number, which orders changes on the volume. - **TimeStamp** -- when the change was recorded. - **FileName** -- the name at the time of the change (not the full path). - **FileReferenceNumber** -- the identifier of the file's MFT record, with a sequence number that increments when the record is reused. - **ParentFileReferenceNumber** -- the identifier of the containing directory's record, which is how paths are reconstructed. - **Reason** -- a bitmask of what changed: file-create, data-extend, data-overwrite, data-truncation, rename-old-name, rename-new-name, basic-info-change, file-delete, close, and others. - **FileAttributes**, plus a security-descriptor index and source-info flags. There is deliberately **no content**, **no file size**, and **no user or process identity**. The journal answers "what changed about which file", never "what did it hold" or "who touched it". ## What you can legitimately conclude From a sequence of records you can state, with the artefact behind you: - A file with a specific name existed under a specific directory (resolve the parent reference through the MFT, or through other journal records for that reference number). - It was created at one time and deleted at another, giving a lifespan. - It was renamed, because a rename produces a paired rename-old-name and rename-new-name record for the same file reference number -- which is how you follow a file that was renamed before being copied out. - Data was written to it after creation, because data-extend or data-overwrite reasons appear -- so it was not merely an empty placeholder. That last point is the strongest one available: the journal can show that a named file *had bytes written into it*, without showing what those bytes were. ## What you cannot conclude - **Content.** Nothing in the journal touches file data. If the clusters are gone, the journal does not bring them back. - **Size.** There is no size field. A size can sometimes be recovered from a still-intact MFT record or a directory index entry, but it does not come from the journal. - **Actor.** No user SID and no process. Attributing the deletion to a person requires other evidence -- an interactive logon session covering that time, a lock/unlock trail, physical access records. - **Intent.** A delete looks identical whether it was an employee covering tracks, an application cleaning temporary files, or an installer removing its own staging directory. ## Why the horizon is short The journal is a fixed-size circular structure: as it fills, the oldest records are discarded from the front (the file is sparse, so old space is deallocated rather than shrunk). The default is small relative to a busy volume, so the practical horizon can be days rather than months -- and on a build server or a developer laptop with heavy file churn it can be hours. It can also be disabled or deleted by an administrator, and an absent journal is itself a fact worth recording, though absence is weak evidence on its own since not every volume has it enabled. ## Saying this out loud to non-technical people When an examination lands in an HR conversation, the subject's defence is often "that folder never held what you say it held". The disciplined position is to keep the two claims apart. "These records show a file named X existed in folder Y, had data written to it, and was deleted at 18:42 on that date" is what the artefact supports. "X contained the turbine design" is a separate claim that needs a separate artefact -- a backup, a copy on a server, a version-control history, an email attachment. If you do not have one, say so plainly rather than letting the strength of the first claim carry the second.
- The subject says the folder only ever held empty placeholder files. Can the journal contradict that?Partly. A data-extend or data-overwrite reason on that file reference number shows bytes were written into the file after creation, so it was not an empty placeholder. It still says nothing about how many bytes or what they were. If you need size, look for an intact MFT record or a directory index entry; if you need content, you need a copy from somewhere other than this volume.
- How do you follow a file that was renamed before being copied off the machine?Pivot on the file reference number rather than the name. A rename emits a rename-old-name record and a rename-new-name record for the same reference number, so the chain of names is recoverable in order. Watch the sequence number embedded in the reference: when an MFT record is reused for a different file the sequence increments, which is what stops you from stitching two unrelated files together.
- You find no journal entries at all for the period of interest. What does that mean?Ambiguity, and you should report it as such. It could mean the journal rolled over, that it was never enabled on that volume, or that it was deleted. Distinguish them by looking at the oldest surviving USN and its timestamp: if the journal starts after the period you care about, rollover is the plain explanation, and a rollover is not evidence of tampering.
saying these in an interview costs you the question
- Thinks the change journal stores file contents
- Claims the journal names the user who deleted the file
- Treats a journal entry as proof of what the file held
- Assumes the journal covers months of history
- Confuses $UsnJrnl with the Windows Security event log