MFTparser
100% in your browser · nothing uploaded

MFT Parserfree online MFT viewer & $MFT analyzer

An MFT parser that runs entirely in your browser. Drop an NTFS $MFT file and inspect every record — deleted entries, $STANDARD_INFORMATION and $FILE_NAME timestamps, alternate data streams, resident data — without uploading a byte. WebAssembly under the hood, the omerbenamram/mft Rust crate doing the parsing.

Synthetic $MFT from a fictional intrusion — no real data. Tip: Time range → “Last hour” frames the attack.
Why MFT Parser

Every record. Every timestamp. Zero uploads.

A complete NTFS triage bench compiled to WebAssembly — native-tool speed with the convenience of a web page.

  • Deleted records, surfaced

    Unallocated entries live on in the $MFT until they are reused. Filter them in one click and see what was removed, when, and where it lived.

  • Private by architecture

    Parsing runs in a Web Worker on your machine. Pull the network cable — it still works.

  • Timestomping at a glance

    $STANDARD_INFORMATION and $FILE_NAME side by side, so backdated files stand out.

  • Alternate data streams

    Zone.Identifier, hidden payloads and resident $DATA, downloadable straight from the record.

  • Folder explorer

    Full paths rebuilt from parent references — including orphaned, deleted folders.

  • More than the $MFT

    $UsnJrnl:$J, $Boot, $Secure:$SDS and $I30 indexes are detected and decoded automatically.

  • Report-ready exports

    CSV, super-timeline and an HTML triage report — scoped to any time range.

How to get your data

Never collected a $MFT before? Pick the first method that fits: most people are done in under two minutes.

  1. Collect: run one command below
  2. Drop the $MFT file on the box above
  3. Parsed in your browser, never uploaded

Built-in PowerShell, nothing to install

Windows only · open PowerShell with Run as administrator · paste the whole block.

PowerShell (admin)
# Elevated PowerShell: copies the live C:\$MFT to C:\triage\$MFT by reading the raw volume.
$drive = 'C:'; $dst = 'C:\triage\$MFT'
New-Item -ItemType Directory -Force -Path (Split-Path $dst) | Out-Null
if (-not ('Raw.Vol' -as [type])) { Add-Type -Namespace Raw -Name Vol -MemberDefinition '[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] public static extern Microsoft.Win32.SafeHandles.SafeFileHandle CreateFile(string name, uint access, uint share, IntPtr sa, uint disposition, uint flags, IntPtr template);' }
$h = [Raw.Vol]::CreateFile("\\.\$drive", 2147483648, 3, [IntPtr]::Zero, 3, 0, [IntPtr]::Zero)
if ($h.IsInvalid) { throw "Cannot open \\.\$drive - run PowerShell as administrator" }
$vol = New-Object IO.FileStream($h, [IO.FileAccess]::Read)
function Read-At([long]$pos, [int]$len) { $b = New-Object byte[] $len; [void]$vol.Seek($pos, 'Begin'); $got = 0; while ($got -lt $len) { $n = $vol.Read($b, $got, $len - $got); if ($n -le 0) { throw 'Short read' }; $got += $n }; , $b }
$boot = Read-At 0 4096
$bps = [BitConverter]::ToUInt16($boot, 11); $spc = [int]$boot[13]; if ($spc -gt 128) { $spc = 1 -shl (256 - $spc) }
$cs = [long]$bps * $spc; $c = [int]$boot[64]; $rs = if ($c -gt 127) { 1 -shl (256 - $c) } else { $c * $cs }
$rec = Read-At ([BitConverter]::ToInt64($boot, 48) * $cs) ([math]::Max($rs, 4096))
$uo = [BitConverter]::ToUInt16($rec, 4)
for ($i = 1; $i -lt [BitConverter]::ToUInt16($rec, 6); $i++) { $rec[$i * 512 - 2] = $rec[$uo + 2 * $i]; $rec[$i * 512 - 1] = $rec[$uo + 2 * $i + 1] }
$a = [int][BitConverter]::ToUInt16($rec, 20)
while ($true) { $t = [BitConverter]::ToUInt32($rec, $a); if ($t -eq [uint32]::MaxValue) { throw 'No $DATA in record 0' }; if ($t -eq 0x80 -and $rec[$a + 9] -eq 0) { break }; $a += [int][BitConverter]::ToUInt32($rec, $a + 4) }
$size = [BitConverter]::ToInt64($rec, $a + 48); $p = $a + [BitConverter]::ToUInt16($rec, $a + 32)
$out = [IO.File]::Create($dst); $buf = New-Object byte[] 4MB; $lcn = [long]0
while ($rec[$p] -ne 0) {
  $ln = $rec[$p] -band 15; $lo = $rec[$p] -shr 4; $len = [long]0; $d = [long]0
  for ($i = $ln; $i -ge 1; $i--) { $len = $len * 256 + $rec[$p + $i] }
  for ($i = $ln + $lo; $i -gt $ln; $i--) { $d = $d * 256 + $rec[$p + $i] }
  if ($lo -gt 0 -and $rec[$p + $ln + $lo] -ge 128) { $d -= [long]1 -shl (8 * $lo) }
  $lcn += $d; $p += 1 + $ln + $lo; $left = $len * $cs; [void]$vol.Seek($lcn * $cs, 'Begin')
  while ($left -gt 0) { $n = $vol.Read($buf, 0, [int][math]::Min($left, $buf.Length)); if ($n -le 0) { throw 'Short read' }; $out.Write($buf, 0, $n); $left -= $n }
}
$out.SetLength($size); $out.Close(); $vol.Close()
Get-FileHash -Algorithm SHA256 $dst

Writes C:\triage\$MFT and prints its SHA-256. Drop that file above.

Gotchas

  • copy, robocopy and Explorer cannot read $MFT: Windows locks it. You need a raw reader (the script, KAPE, FTK Imager) and an elevated prompt.
  • One $MFT per volume. For D:, change $drive = 'C:' in the script (or --tsource for KAPE).
  • BitLocker: live collection reads decrypted data, but an image of an encrypted disk must be unlocked (recovery key) before $MFT can be exported.
Under the hood

About this MFT parser

An MFT parser reads the NTFS Master File Table — the $MFT file at the start of every NTFS volume — and turns its 1,024-byte records into something a forensic analyst can act on: filenames, timestamps, parent directories, alternate data streams, deleted entries, and resident data. This site is one of those parsers. It runs in your browser.

Drop a $MFT file onto the area above. The file is read into the browser's memory, parsed by the omerbenamram/mft Rust crate compiled to WebAssembly, and rendered as a paginated, searchable table. Nothing is uploaded — you can verify by disconnecting your network before dropping the file. CSV export and a triage report are available for downstream analysis.

What it shows you

  • Every MFT record, allocated or deleted, with the in-use flag exposed.
  • Both timestamp sets — $STANDARD_INFORMATION and $FILE_NAME — so you can spot timestomping at a glance.
  • Alternate data streams attached to each record, including Zone.Identifier.
  • Resident $DATA bytes for small files — often the only recoverable version after deletion.
  • Full path reconstruction by walking parent references through the table.

How it compares to other MFT parsers

On a Windows analyst workstation, MFTECmd is the standard CLI and produces the CSV that Timeline Explorer and KAPE expect. For scripting on Linux, the omerbenamram/mft CLI and Rust crate emit JSON Lines. This browser parser fills the third slot: zero install, runs anywhere a browser does, suitable for quick triage and for situations where evidence cannot be sent to a cloud service. A full comparison is in the post MFT parser tools compared.

Getting an $MFT to parse

$MFT is locked while Windows is running. To extract a copy, use fsutil on a live system, Disk Image Parser to export it from a disk image (E01, dd, VMDK, VHD) right in your browser, or KAPE's MFT target for a full triage collection. Step-by-step in how to extract $MFT from a live Windows system.

FAQ

Forensics FAQ

Straight answers about NTFS, the $MFT and how this parser handles your evidence.

Read the forensics notes
What is the Master File Table?

The Master File Table ($MFT) is NTFS's metadata index. Every file and directory on the volume has at least one 1,024-byte record in $MFT describing its name, attributes, timestamps, and where its data lives on disk.

What does MFT stand for?

MFT stands for Master File Table. On disk it is written $MFT — the dollar sign is the NTFS convention for metadata files.

What file attributes are stored in the Master File Table?

Every record carries $STANDARD_INFORMATION (timestamps, DOS flags), $FILE_NAME (name and a second timestamp set), and $DATA (the file's contents or its cluster runs). Records can also carry $ATTRIBUTE_LIST, $OBJECT_ID, $SECURITY_DESCRIPTOR, $INDEX_ROOT, $INDEX_ALLOCATION, $BITMAP, $REPARSE_POINT, $EA, and $LOGGED_UTILITY_STREAM.

How do I extract $MFT from a Windows system?

$MFT is the first file on every NTFS volume and is normally locked while Windows runs. Use KAPE or the Windows command 'fsutil' to export a copy from a live system, or open a disk image in Disk Image Parser (diskimageparser.com) and export it in your browser.

How do I fix a corrupt Master File Table?

Image the disk before doing anything else. Then run chkdsk /f against the image (fast, may discard unreadable records) or use a recovery tool that scans the raw volume for 'FILE' signatures and reassembles records (slow, preserves more evidence). Never run chkdsk against the original before imaging.

Does this tool upload my $MFT anywhere?

No. Parsing happens in a Web Worker using WebAssembly. The file is read into your browser's memory and never transmitted. Disconnect your network if you want to verify.

Why are some entries marked deleted?

Each MFT record has an in-use flag. When a file is deleted, the flag is cleared but the record stays in $MFT until reused. These deleted records often retain recoverable filenames, timestamps, and even resident data.

Can it parse very large $MFT files?

Parsing runs in a Web Worker thread. Memory scales linearly with file size. Multi-gigabyte $MFT files work in modern browsers, though the initial read into memory takes a moment.

Your $MFT, decoded in seconds.

No account, no install, no upload. Drop a file — or start with the synthetic sample.