CyberKit

Decode Range: answer key

Every question with its answer and the reasoning. Work the drill first, or the key only tells you what, not how.

Stages: Timestamps, Encodings, Hashes.

Timestamps

  1. A JSON log field reads "eventTime": 1772369229. Convert it to UTC. Answer as YYYY-MM-DDTHH:MM:SSZ.

    Answer: 2026-03-01T12:47:09Z

    Ten digits is Unix seconds: whole seconds since 1970-01-01 UTC. That is the default assumption for a bare integer in a modern log, and it is right often enough to be dangerous, because the other epochs below produce believable dates too.

    Read more: Timestamp Converter

  2. The same log elsewhere carries 1771000000000. Convert it to UTC. Answer as YYYY-MM-DDTHH:MM:SSZ.

    Answer: 2026-02-13T16:26:40Z

    Thirteen digits is Unix MILLIseconds. Read as seconds it lands in the year 58,096, which is obvious. The dangerous direction is the other one: a millisecond value divided by 1000 and then treated as seconds is right, but a SECONDS value multiplied by nothing and parsed by a millisecond-expecting library lands in January 1970. A timeline row sitting at 1970 is almost always this, not a real date.

    Read more: Timestamp Converter

  3. A parsed Registry key's last-write time is 134169616290000000. Convert it to UTC. Answer as YYYY-MM-DDTHH:MM:SSZ.

    Answer: 2026-03-02T21:47:09Z

    Eighteen digits is Windows FILETIME: 100-nanosecond intervals since 1601-01-01 UTC. It is the timestamp behind nearly every Windows artifact (Registry last-write, $STANDARD_INFORMATION, event log records, Prefetch). Divide by 10,000,000 for seconds, then add the 1601 epoch. Reading it as Unix seconds gives a date well past the year 4 billion, so this one at least fails loudly.

    Read more: Timestamp Converter

  4. A hex dump of a FILETIME field reads 0x01DC5516EF7F2180. Convert it to UTC. Answer as YYYY-MM-DDTHH:MM:SSZ.

    Answer: 2025-11-14T03:29:51Z

    Same value, written the way you actually meet it. Two traps here. FILETIME is stored little-endian on disk, so the bytes in a raw dump read 80 21 7F EF 16 55 DC 01 and have to be reversed before this hex value appears. And a tool that shows you the low and high DWORDs separately is showing you two halves of one 64-bit integer, not two timestamps.

    Read more: Timestamp Converter

  5. A browser history record carries the value 13415810602000000. Convert it to UTC. Answer as YYYY-MM-DDTHH:MM:SSZ.

    Answer: 2026-02-17T14:03:22Z

    Chrome and other WebKit-derived browsers store MICROseconds since 1601-01-01: the FILETIME epoch with a different unit. Seventeen digits rather than eighteen is the tell. Treating it as FILETIME shifts the result by a factor of ten, which lands in 1601 plus a tenth of the real offset: a date around 2004 rather than 2026. That is the kind of wrong that survives review, because 2004 is a real-looking date.

    Read more: Timestamp Converter

  6. A decoded property list holds a date value of 789639344. Convert it to UTC. Answer as YYYY-MM-DDTHH:MM:SSZ.

    Answer: 2026-01-09T08:15:44Z

    macOS absolute time counts seconds from 2001-01-01 UTC. Nine digits, so it looks close enough to a Unix value to be read as one, and reading it that way gives 1995, a plausible-looking, completely wrong date thirty-one years early. Anything sourced from a plist, a Cocoa API or Spotlight metadata uses this epoch.

    Read more: Timestamp Converter

  7. You have a bare integer from an unfamiliar artifact and no documentation. What is the first thing to check?

    Answer: The digit count, then whether each candidate epoch produces a date consistent with the rest of the case

    Digit count narrows it to two or three candidates in one glance: ten is Unix seconds, thirteen Unix milliseconds, seventeen WebKit, eighteen FILETIME. Then convert under each candidate and see which lands anywhere near the incident. Every wrong epoch produces a real date, so the arithmetic never tells you it failed. Corroboration does.

    Read more: Timestamp Converter

  8. A Windows event log shows 09:14:22 in Event Viewer. A colleague in another country opens the same exported .evtx and sees 14:14:22. Who is right?

    Answer: Both. The record stores UTC and each viewer renders it in the local zone of the machine displaying it

    The stored value is UTC; the displayed value is a rendering decision made by whatever is showing it to you. This is why a timeline states its zone once, at the top, and holds every row to it. Mixing a screenshot from one analyst's Event Viewer with parsed UTC output from another's tooling is how two events five hours apart end up next to each other in a report.

    Read more: Timestamp Converter

  9. Which of these is stored in LOCAL time rather than UTC?

    Answer: A FAT filesystem timestamp

    FAT stores local time with no zone recorded, which means a FAT timestamp cannot be converted to UTC without knowing where the machine was and what its clock was set to. This still matters, because FAT and exFAT are what USB media and camera cards use. The other three are UTC. When a USB device's timestamps sit an exact number of hours away from everything else in a timeline, this is usually why.

    Read more: Timestamp Converter

  10. Two hosts' logs disagree by 47 seconds on the same event, and both are correctly converted to UTC. What do you do?

    Answer: Record the offset, correct one source to the other, and state both in the timeline

    Clock skew is a property of the hosts, not of your conversion, and no epoch arithmetic will remove it. The defensible approach is to pick one reference clock, measure each source's offset from it, apply the correction, and say in the report that you did. Averaging invents a time that no source recorded, and discarding a source loses evidence to fix a bookkeeping problem.

    Read more: Timestamp Converter

Encodings

  1. This timestamp appeared in an artifact: 1710408413 Which timestamp format is it?

    Answer: Unix (seconds)

    Unix (seconds). It decodes to 2024-03-14 09:26:53 UTC. Unix and Linux logs, most REST APIs, and the majority of syslog pipelines.

    Read more: Timestamp Converter

  2. This value was pulled out of a script. Decode it and give the plaintext. d2hvYW1pIC9wcml2

    Answer: whoami /priv

    Base64 → whoami /priv Base64 is the most common wrapper in a script or a PowerShell -EncodedCommand. Its alphabet and trailing "=" padding are the giveaway.

    Read more: Deobfuscator

  3. Windows FILETIME counts 100-nanosecond intervals from a different epoch than Unix time. Which year does the FILETIME epoch start in?

    Answer: 1601

    FILETIME counts 100ns intervals since 1601-01-01 UTC. The choice is not arbitrary: 1601 begins the first 400-year Gregorian cycle preceding the design of Windows NT, which makes the calendar arithmetic uniform. Getting this epoch wrong shifts a timeline by roughly 369 years, an error large enough to be obvious, unlike a units mistake.

    Read more: Timestamp Converter

  4. This timestamp appeared in an artifact: 1710408413000 Which timestamp format is it?

    Answer: Unix (milliseconds)

    Unix (milliseconds). It decodes to 2024-03-14 09:26:53 UTC. Java and JavaScript stacks, Elasticsearch, and a great many SIEM ingest pipelines.

    Read more: Timestamp Converter

  5. This value was pulled out of a script. Decode it and give the plaintext. 6e657420757365722061646d696e6973747261746f72

    Answer: net user administrator

    hex → net user administrator Straight hex: two characters per byte, alphabet 0-9a-f. Length is always even, which is a quick sanity check.

    Read more: Deobfuscator

  6. Mac Absolute Time (Cocoa / CFAbsoluteTime) counts seconds from which year?

    Answer: 2001

    Mac Absolute Time counts seconds since 2001-01-01 UTC. Because its epoch is LATER than Unix's, a Mac Absolute value for a given moment is smaller than the Unix value for the same moment, by 978,307,200 seconds. That is the trap: the number still looks like a plausible Unix timestamp, so a mis-read lands you in 2001 rather than throwing an error.

    Read more: Timestamp Converter

  7. This timestamp appeared in an artifact: 133548820130000000 Which timestamp format is it?

    Answer: Windows FILETIME

    Windows FILETIME. It decodes to 2024-03-14 09:26:53 UTC. NTFS $MFT timestamps, the registry, Prefetch, LNK files: most of Windows forensics.

    Read more: Timestamp Converter

  8. This value was pulled out of a script. Decode it and give the plaintext. http%3A%2F%2F198.51.100.7%2Fa.ps1

    Answer: http://198.51.100.7/a.ps1

    URL encoding → http://198.51.100.7/a.ps1 Percent-encoding only escapes what it must, so the readable parts stay readable. That partial legibility is the tell.

    Read more: Deobfuscator

  9. A Chrome history database stores visit times as a 17-digit number. Which epoch does the WebKit timestamp count from?

    Answer: 1601

    WebKit timestamps count MICROseconds since 1601-01-01 UTC. That is the same epoch as Windows FILETIME but a different unit (microseconds rather than 100ns intervals). Sharing an epoch with FILETIME while differing in unit is exactly why these two get confused: a value read with the wrong unit is out by a factor of 10 and still lands on a plausible-looking date.

    Read more: Timestamp Converter

  10. This timestamp appeared in an artifact: 13354882013000000 Which timestamp format is it?

    Answer: WebKit / Chrome timestamp

    WebKit / Chrome timestamp. It decodes to 2024-03-14 09:26:53 UTC. Chrome and Edge history and cookie databases (the History SQLite file's visit times).

    Read more: Timestamp Converter

  11. This timestamp appeared in an artifact: 732101213 Which timestamp format is it?

    Answer: Mac Absolute Time (Cocoa)

    Mac Absolute Time (Cocoa). It decodes to 2024-03-14 09:26:53 UTC. macOS and iOS property lists, Safari history, and Cocoa APIs generally.

    Read more: Timestamp Converter

  12. This timestamp appeared in an artifact: 638460052130000000 Which timestamp format is it?

    Answer: .NET Ticks

    .NET Ticks. It decodes to 2024-03-14 09:26:53 UTC. .NET applications and anything serializing a System.DateTime, including many Windows event payloads.

    Read more: Timestamp Converter

Hashes

  1. Hashing the string "admin" with one of this tool's supported algorithms produced this digest: 21232f29 7a57a5a7 43894a0e 4a801fc3 That's 32 hex characters (128 bits). Which algorithm produced it? (e.g. "MD5", "SHA-256")

    Answer: MD5

    MD5 always produces a 128-bit digest (32 hex characters), regardless of input length. Every algorithm in the reference table has one fixed output length, which is the first thing to check when you don't know a hash's source.

    Read more: Try it in the Hash Calculator

  2. Hashing the string "password123" with one of this tool's supported algorithms produced this digest: cbfdac60 08f9cab4 083784cb d1874f76 618d2a97 That's 40 hex characters (160 bits). Which algorithm produced it? (e.g. "MD5", "SHA-256")

    Answer: SHA-1

    SHA-1 always produces a 160-bit digest (40 hex characters), regardless of input length. Every algorithm in the reference table has one fixed output length, which is the first thing to check when you don't know a hash's source.

    Read more: Try it in the Hash Calculator

  3. Hashing the string "root" with one of this tool's supported algorithms produced this digest: 4813494d 137e1631 bba301d5 acab6e7b b7aa74ce 1185d456 565ef51d 737677b2 That's 64 hex characters (256 bits). Which algorithm produced it? (e.g. "MD5", "SHA-256")

    Answer: SHA-256

    SHA-256 always produces a 256-bit digest (64 hex characters), regardless of input length. Every algorithm in the reference table has one fixed output length, which is the first thing to check when you don't know a hash's source.

    Read more: Try it in the Hash Calculator

  4. Hashing the string "svc_backup" with one of this tool's supported algorithms produced this digest: 2eb894fa b92f51d6 aa26a2ce d87121f2 f6a1ec24 3763d924 3ab8776c f91c1440 e062a7a0 baa7bf8a d2c30e27 cc470c0e That's 96 hex characters (384 bits). Which algorithm produced it? (e.g. "MD5", "SHA-256")

    Answer: SHA-384

    SHA-384 always produces a 384-bit digest (96 hex characters), regardless of input length. Every algorithm in the reference table has one fixed output length, which is the first thing to check when you don't know a hash's source.

    Read more: Try it in the Hash Calculator

  5. Hashing the string "administrator" with one of this tool's supported algorithms produced this digest: cf835de3 d4ea0136 7c45e412 e7a9393a 85a4e40a f149ed8c 3ed6c37c 05b67b27 813d7ff8 072c1035 cedd1941 5adf1712 8d63186f 05f0d656 002b0ca1 c34f44a0 That's 128 hex characters (512 bits). Which algorithm produced it? (e.g. "MD5", "SHA-256")

    Answer: SHA-512

    SHA-512 always produces a 512-bit digest (128 hex characters), regardless of input length. Every algorithm in the reference table has one fixed output length, which is the first thing to check when you don't know a hash's source.

    Read more: Try it in the Hash Calculator

  6. An analyst finds this bare hex string pasted into a ticket, with no other context: 21232f29 7a57a5a7 43894a0e 4a801fc3 It's 32 hex characters. True or false: its format alone is enough to say with confidence that it's an MD5 digest and nothing else.

    Answer: False

    False. Windows NTLM password hashes are also 128-bit/32 hex chars. Identical format to MD5, genuinely indistinguishable without knowing where the value came from (e.g. a SAM/NTDS dump vs. a file hash). The Identify panel marks both MD5 and NTLM as medium confidence here, not a single certain answer. The string's origin (a file hash vs. a SAM/NTDS dump) is what actually disambiguates them, not the hex itself.

    Read more: Try it in the Hash Calculator

  7. The same Identify panel is given this 40-hex-character string: cbfdac60 08f9cab4 083784cb d1874f76 618d2a97 What confidence level (High/Medium/Low) does it assign to SHA-1 as the source?

    Answer: High

    High. 160-bit: overwhelmingly the most common source of a 40-hex-char digest. (RIPEMD-160 shares the exact same 160-bit/40-hex format, but is rare enough in DFIR contexts to only rate low confidence.)

    Read more: Try it in the Hash Calculator

  8. This string turns up in a leaked database dump: $2b$12$KIXQeYQ9Z5W8n1JlY0m0uOe3z7Q4rXk9pC2mN6sT1vB5dF7gH8jK9 What hashing scheme is this? (Short answer: name the format, e.g. "sha256", "crc32", "bcrypt".)

    Answer: bcrypt

    Modular crypt format ($2a$/$2b$/$2y$). A salted, adaptive password hash, not a raw digest. Recognizing the $2b$ prefix is faster and more reliable than reasoning about hex length here, since bcrypt output is not raw hex at all.

    Read more: Try it in the Hash Calculator

  9. This string turns up in a copied /etc/shadow line: $6$rounds=656000$abcXYZ123saltHere$Qk9z5W8n1JlY0m0uOe3z7Q4rXk9pC2mN6sT1vB5dF7gH8jK0m0uOe3z7Q4rXk9pC2mN6sT1vB5dF7gH8jK. What format is this? (short answer, e.g. "bcrypt", "md5crypt", "sha512crypt")

    Answer: sha512crypt

    Modular crypt format ($6$) used in Linux/BSD shadow password files. $5$ is the SHA-256 equivalent of this format; $1$ is the older, weaker MD5 crypt.

    Read more: Try it in the Hash Calculator

  10. Per the algorithm reference table, how many bits does a SHA-384 digest produce? (numeric answer)

    Answer: 384

    SHA-384 always produces a 384-bit digest (96 hex characters), regardless of input length. Fixed output length per algorithm is exactly what makes length-based identification possible in the first place.

    Read more: Try it in the Hash Calculator

  11. A batch of five digests just came off a triage script with no labels attached. Sort each one into the algorithm that produced it, using nothing but digest length.

    Answer: 4813494d137e1631bba301d5acab6e7bb7aa74ce1185d456565ef51d737677b2 → SHA-256 · 21232f297a57a5a743894a0e4a801fc3 → MD5 · cf835de3d4ea01367c45e412e7a9393a85a4e40af149ed8c3ed6c37c05b67b27813d7ff8072c1035cedd19415adf17128d63186f05f0d656002b0ca1c34f44a0 → SHA-512 · cbfdac6008f9cab4083784cbd1874f76618d2a97 → SHA-1 · 2eb894fab92f51d6aa26a2ced87121f2f6a1ec243763d9243ab8776cf91c1440e062a7a0baa7bf8ad2c30e27cc470c0e → SHA-384

    Every algorithm in the reference table has one fixed output length (MD5 is always 32 hex chars, SHA-1 is always 40 hex chars, SHA-256 is always 64 hex chars, SHA-384 is always 96 hex chars, SHA-512 is always 128 hex chars), so length alone is enough to sort a whole batch at once, the same way you'd triage a real dump of unlabeled hashes.

    Read more: Try it in the Hash Calculator

  12. Same idea, different sort: these five strings are labeled only by how confidently the Hash Calculator's Identify panel can name their source. Sort each into its real confidence tier.

    Answer: 21232f297a57a5a743894a0e4a801fc3 → Medium confidence · cbfdac6008f9cab4083784cbd1874f76618d2a97 → High confidence · $2b$12$KIXQeYQ9Z5W8n1JlY0m0uOe3z7Q4rXk9pC2mN6sT1vB5dF7gH8jK9 → High confidence · $6$rounds=656000$abcXYZ123saltHere$Qk9z5W8n1JlY0m0uOe3z7Q4rXk9pC2mN6sT1vB5dF7gH8jK0m0uOe3z7Q4rXk9pC2mN6sT1vB5dF7gH8jK. → High confidence · 2eb894fa → Low confidence

    High confidence means the format is either distinctive (a $2b$/$6$ prefix) or overwhelmingly the most common source at that length (a bare 40-hex digest is almost always SHA-1). Medium means a genuine tie: Windows NTLM password hashes are also 128-bit/32 hex chars. Identical format to MD5, genuinely indistinguishable without knowing where the value came from (e.g. a SAM/NTDS dump vs. a file hash). And Low means the string is too short or generic to mean much on its own: 32-bit: consistent with a CRC32 checksum, but 8 hex characters is short enough to also just be a truncated ID or unrelated string.

    Read more: Try it in the Hash Calculator

  13. The exact same 32-character hex string, 21232f297a57a5a743894a0e4a801fc3, turns up in four different places during an investigation. Sort each occurrence by what it most likely is, given where it was found.

    Answer: An antivirus engine's file-hash lookup flags a sample by this value: 21232f297a57a5a743894a0e4a801fc3 → MD5 · Pulled from a dumped NTDS.dit database, sitting in the same row as a username: 21232f297a57a5a743894a0e4a801fc3 → NTLM · Recovered from the LM-hash column of a legacy, pre-2000-era Windows SAM dump: 21232f297a57a5a743894a0e4a801fc3 → LM hash (legacy) · Pasted into a ticket with no other context at all: 21232f297a57a5a743894a0e4a801fc3 → Ambiguous, needs more context

    Format alone can't tell these apart. 128-bit: the most common source of a bare 32-hex-char digest. Windows NTLM password hashes are also 128-bit/32 hex chars. Identical format to MD5, genuinely indistinguishable without knowing where the value came from (e.g. a SAM/NTDS dump vs. a file hash). Legacy Windows LAN Manager hash. Same length/format, now rare outside old dumps. A file-hash-lookup context points to MD5 (the overwhelmingly common use of a bare 32-hex digest); a dumped NTDS.dit database means the value is a Windows password hash, i.e. NTLM (or, if it's specifically from the legacy LM-hash column of a pre-2000-era SAM dump, the older LM format); with no context at all, the honest answer is that it's ambiguous, which is exactly the tie identifyHash() itself reports.

    Read more: Try it in the Hash Calculator

Back to the drill