11 min read
Digital ForensicsOctober 20, 2026

Three Clocks You Can't Trust in an Investigation

Every timestamp in an investigation is a claim, not a fact. Three specific ways a clock lies to you, how each one gets caught, and what happens when all three show up in the same case.

dfir · windows forensics · ntfs · timestomping · logon type 9 · incident response · timeline analysis · pass-the-hash

Three Clocks You Can't Trust in an Investigation

A timeline is the backbone of every DFIR case. You pull timestamps out of a dozen artifacts, line them up, and read the story off the sequence. The part nobody tells you early enough: every one of those timestamps is a claim made by something, not a fact about the world. The file system is claiming a time. The log source is claiming a time. The OS's own sense of "now" is claiming a time. Any of the three can be wrong, and they're wrong in different, specific, recognizable ways.

This is a walkthrough of the three failure modes that show up most often, using a case I worked through recently (a Windows intrusion involving a phishing foothold, a timestomped loader, and a credential-injection trick to fake a legitimate-looking backup) as the worked example. The names and some values are specific to that case; the failure modes are not.

Failure mode 1: the timestamp was rewritten on purpose

NTFS stores file timestamps in two places that normally agree, and attackers usually only bother forging one of them.

$STANDARD_INFORMATION is the attribute Explorer, dir, and most forensic tools show you by default. It's also the attribute every mainstream timestomping tool targets, because it's the one people look at.

$FILE_NAME is a second, less-visited copy of the same four timestamps, stored in the MFT's filename attribute. Most timestomping tools don't touch it, because most people don't know to check it.

In the case I'm describing, a loader binary's $STANDARD_INFORMATION claimed:

$MFT record 88214: OneDriveUpdater.exe
  $STANDARD_INFORMATION:
    Created: 2024-11-03 09:14:00 UTC
  $FILE_NAME:
    Created: 2025-09-08 14:12:03 UTC

Ten months of claimed age, designed to make a brand-new malicious file look like something that had been sitting on the box harmlessly since the previous year. The $FILE_NAME attribute disagreed, by ten months, with no explanation other than "someone rewrote the other one."

The tiebreaker isn't a judgment call, it's corroboration. The $UsnJrnl (the NTFS change journal) recorded the actual file-create transaction:

2025-09-08 14:12:03 UTC USN 88214 FileCreate|DataExtend ...OneDriveUpdater.exe
2025-09-08 14:12:04 UTC USN 88215 Close                 ...OneDriveUpdater.exe

Same second as $FILE_NAME. A third artifact, independent of both, the Amcache entry for the same binary, recorded First seen: 2025-09-08 14:12:03 UTC. Three subsystems that don't share an update mechanism (MFT metadata, the change journal, and Amcache's own execution-tracking database) agree with each other to the second, and all three disagree with $STANDARD_INFORMATION by exactly the amount an attacker would want.

$STANDARD_INFORMATION 2024-11-03 09:14:00 UTC rewritten by the attacker off by 10 months $FILE_NAME 2025-09-08 14:12:03 UTC MFT filename attr $UsnJrnl 2025-09-08 14:12:03 UTC change journal Amcache 2025-09-08 14:12:03 UTC execution tracking three subsystems, zero shared code, agree to the second

That's the pattern worth internalizing: a single rewritten timestamp is a claim. Three independent artifacts converging on a different value is as close to a fact as DFIR gets. If you only ever check $STANDARD_INFORMATION, timestomping is invisible. If you check it against $FILE_NAME, the journal, or Amcache/Prefetch and it doesn't match, you've found the rewrite, not just a discrepancy.

Failure mode 2: the clock is honest, but it's not the clock you think it is

The second failure mode isn't malicious. It's just a timezone.

Windows Prefetch logs execution times in local time, and it tells you so:

[Prefetch] ONEDRIVEUPDATER.EXE-7C81D203.pf
  Last run (local): 2025-09-08 08:12:20    (America/Denver, UTC-6)

08:12:20 local. Add six hours for the UTC-6 offset and you get 14:12:20 UTC, within seventeen seconds of the journal and Amcache timestamps from the previous section. That's not a coincidence, it's confirmation that the timezone-offset arithmetic is right before you rely on it anywhere else in the case.

Prefetch (local) 08:12:20 America/Denver, UTC-6 +6h converted to UTC 14:12:20 matches journal, within 17s $UsnJrnl / Amcache 14:12:03 UTC

The mistake this guards against is a specific, common one: treating a correctly-labeled local timestamp as if it were UTC, and building a timeline with an artifact silently shifted by whatever the host's offset happens to be. A six-hour error is enough to put an event on the wrong side of a different event, which is enough to swap cause and effect in your narrative. The fix costs nothing, convert every local timestamp to UTC explicitly, at the point you first read it, and write down which timezone and offset you used and why. Do it even when (especially when) a later cross-check confirms you got it right, because the next artifact in the same case might come from a host in a different timezone entirely, and you want the habit already running.

Failure mode 3: the clock itself has drifted, and it told you so

The first two failure modes are about reading a timestamp correctly. The third is about whether the timestamp means anything at all, because the system that generated it had stopped keeping real time.

A Windows host logs its own time-sync health, and it's one of the most underused artifacts in a typical evidence package:

2025-08-30 03:11:00 UTC Event ID 129 (W32Time: "the time service has not
  been able to synchronize since the last reboot")
2025-09-09 06:00:00 UTC Scheduled NTP sync attempt: FAILED (still
  unsynchronized since 2025-08-30)

That host's local clock had been drifting, unsynced, for nine days by the time the incident in question happened. Every "(local)" timestamp that host produced after August 30th is only trustworthy as a relative ordering marker (did A happen before B, on this host, relative to other events on this same host) and not as an absolute UTC time you can line up against artifacts from anywhere else.

This matters most when a timestamp is the only thing standing between two very different readings of an event. In this case, a Windows Security event log recorded:

Event ID 4624 (An account was successfully logged on)
  Time: 2025-09-09 02:14:52 (local, America/Denver, unsynchronized clock)
  Logon Type: 9 (NewCredentials)
  Account Name: d.reyes
  Source Network Address: 10.10.4.41

Read naively, that's a specific person logging in at a specific time, and if you trusted the unsynced local clock as UTC you'd spend your investigation trying to place that person at a keyboard at that exact moment. Two independent, drift-immune artifacts (a badge log and a VPN log, neither of which depend on the compromised host's clock) show that person was neither on-site nor connected remotely anywhere near that window. The timestamp wasn't lying about ordering, it was just never an absolute UTC value to begin with, and treating it as one would have sent the investigation chasing the wrong person entirely.

The actual answer was hiding in a field most people skim past: Logon Type. Type 9, NewCredentials, is what Windows records for runas /netonly-style operations and equivalent credential-injection APIs, pass-the-hash tooling uses the same primitive. The calling session's own identity gets written into the 4624 record; a separate, injected credential is what actually authenticates to the network resource. The account name in the log isn't forged, it's just answering a different question than the one you assumed it was answering. Once the logon type told us this was credential injection rather than an interactive session, the question stopped being "did this person do this" and became "whose credentials were loaded into this process," which pointed at a service account instead, confirmed by file-ownership metadata on a backup archive that service account's credentials had just been used to create.

Logon Type 9 NewCredentials written to the 4624 record Account Name: d.reyes badge log + VPN log: not them the calling session's identity used on the network svc-backup owns the fabricated archive the injected credential

Building a timeline that survives all three

None of these three failure modes are rare or exotic. They show up constantly, usually more than one at a time, in the same case. The practice that catches all three is the same practice, repeated:

  1. Never trust a single-source timestamp for anything load-bearing. If a timestamp is going to anchor a conclusion, find a second artifact, from a different subsystem, that can independently confirm or contradict it. $STANDARD_INFORMATION alone is attacker-controlled; corroborated by $FILE_NAME, $UsnJrnl, and Amcache, it's solid.
  2. Convert to UTC at the point of first contact, explicitly, every time. Don't let a local timestamp travel through your notes unconverted, waiting to be misread three steps later.
  3. Check whether the clock was even working. A time-service health log, an NTP sync-failure event, a reboot timestamp with no sync events after it, these are cheap to check and tell you whether anything that host recorded afterward can be trusted as absolute time at all.
  4. When a timestamp and a field like logon type disagree about what happened, trust the field that describes the mechanism, not the one that just states a name and a time. A log doesn't lie about what event type fired. It can absolutely be misread if you stop at the first plausible-looking value.

A timeline built this way is slower to produce than one built by just sorting every timestamp you can find and reading the result top to bottom. It's also the only kind that survives contact with an attacker who knows what forensic tooling checks by default, which is most of them.