Tactical LogHuntress CTF 2026 // team archive

Days / Day 02 / Metadata Forensics / Looks Can Be Deceiving

DAY 02//LANE: METADATA FORENSICS//STATUS: CORRECT x1

Looks Can Be Deceiving

SSTTMM Modes reported CORRECT in this write-up

Challenge

  • Event: Huntress CTF 2026, Day 02
  • Category: Metadata Forensics
  • Game Master ID: metadata-forensics-day-02-looks-can-be-deceiving (plus /time_trial, /mastery)
  • Modes: Single Solve, Time Trial, Mastery
  • Answer format: a lowercase hex string (the first 16 bytes of the assigned file). Not a flag{...} wrapper.

The assigned artifact is a ZIP containing a plausible-looking forensic "evidence note". The note is written to make the reader believe the case identifiers in its text are the evidence. They are the deception named in the title: the grader scores the raw leading bytes of the assigned file, not anything parsed from the note's prose.

Artifacts

Local sample (one attempt's copy; the Game Master assigns fresh bytes per attempt):

  • looks_can_be_deceiving.zip (challenge artifact, not published) - 287 bytes, SHA-256 c356020d0dafda86d80d000b3e3e1c0524f3a0c1a84ade856a74959047c1be67
  • extracted/evidence-note.txt - 126 bytes, the single ZIP member

Sample note contents (decoy):

Huntress Metadata Forensics evidence note
Case marker: CASE-52F88184C9D3
Endpoint: WS-8ADC1123
Collected sequence: 5558590970

Triage

  • Theme "Metadata Forensics" + title "Looks Can Be Deceiving" -> the note text is almost certainly a decoy; the real channel is file bytes/metadata.
  • This is the Day 02 sibling of Day 01 "You Must Be This Hash to Ride", which used the same evidence-note.txt shell and also scored the file's own bytes (hashes), never the note's prose.
  • Specialist lane: deterministic Game Master solver (no deep RE needed); the owning session drove it with GPT-6 Luna inside the AI Homebase VM, which is where the Game Master is reachable.

Investigation

The decoy was confirmed by exhausting the "note text encodes the flag" hypothesis and getting nothing:

  • ZIP container metadata is clean and self-consistent (one member, matching local/central headers, no archive comment, plain 2026-01-01 00:00 DOS time and matching UT extended timestamp). The container is not the channel.
  • The three identifiers (52F88184C9D3, 8ADC1123, 5558590970) were swept through hex/base32/ base64/base85, int-in-base-{10,16,32,36,58,62}, little/big-endian, reversals, every concatenation order, single-byte and known-plaintext repeating-key XOR (forcing flag{ only yielded garbage tails), and recursive base decoding. No flag{, no huntress, no readable plaintext. The decoded hex bytes are high-entropy, i.e. they were never meant to be decoded.

The actual task comes from the Game Master start response: report the hex of the first 16 bytes of the assigned file. The deception is that a reader fixates on the note's "case markers" while the grader only ever looks at file[:16].

Deterministic check on the local sample:

$ head -c16 extracted/evidence-note.txt | xxd -p
48756e7472657373204d657461646174          # ASCII "Huntress Metadat"

$ head -c16 looks_can_be_deceiving.zip | xxd -p
504b03041400080008000000215c0000          # the PK\x03\x04 local-file-header

So for any assigned file the answer is just its leading-16-byte signature rendered as lowercase hex - the ZIP/member magic, not the human-readable claims inside it.

Flag Recovery

Per-attempt flow (run inside the Homebase VM where http://[ip]/huntress-ctf-proxy is reachable, one HTTP session):

  1. start the challenge -> receive the answer_ids and the capability/download reference.
  2. Download the assigned file for that attempt.
  3. Read its first 16 bytes and hex-encode them (lowercase).
  4. Submit that hex under the attempt's answer_id; the Game Master validates and auto-completes the matching CourseStack question.

Because each attempt is assigned different bytes, the submitted value is computed live from the attempt's own file - never reused from another attempt or from this local sample.

Flag

This challenge has no flag{...} token; each mode's answer is the computed first-16-byte hex of that attempt's assigned file, submitted via the Game Master. Example value, computed from the local sample evidence-note.txt:

  • Token48756e7472657373204d657461646174

Outcome (owning session, verified in CourseStack): Single Solve, Time Trial, and Mastery all CORRECT -> SUBMITTED_ACCEPTED, 3/3 (10 pts).

Minimal Reproduction

# Given an assigned file F from the Game Master:
head -c16 F | xxd -p        # -> lowercase hex of F's first 16 bytes = the answer

Then submit that hex string under the mode's answer_id through the Game Master proxy (reachable from inside the Homebase VM), which auto-completes the CourseStack question.

Lessons Learned

  • "Looks can be deceiving" / "evidence note" is a decoy pattern: the human-readable identifiers are there to burn your time. Confirm the real channel (here: file[:16] bytes) before decoding prose.
  • This is the direct sibling of Day 01 "You Must Be This Hash to Ride" - same evidence-note shell, same "score the bytes, not the labels" idea. Recognizing the family immediately short-circuits the encoding rabbit hole.
  • A fast falsification sweep (bases, XOR, known-plaintext, recursion) is worth a minute: a uniformly high-entropy result is itself evidence that the values are not an encoding and the answer lies elsewhere (the raw bytes / Game Master task).
  • Keep the solve deterministic and per-attempt: start -> download assigned bytes -> hex(file[:16]) -> submit in one run beats any hard-coded value, which is essential for the timed Time Trial / Mastery modes.