hash to ride: hash the bytes that were actually delivered

huntress ctf 2026, day 1 · metadata forensics · all three modes

tools used: archive and metadata toolkit and timed-attempt pipeline.

the artifact was a zip containing one evidence file. five questions asked for its exact base filename, byte count, md5, sha-1 and sha-256.

the key insight: there is no trick in the hash functions. the work is choosing the right member and hashing its raw bytes, never a copied string or the zip container.

challenge shape

field ids have the form <member stem>-<property>, for example <stem>-md5 or <stem>-size-bytes. the stem names the member, the suffix the property. both changed between variants. each question object also carried an artifact string: the bare zip name for the filename question ("what is the exact filename of the first evidence note?") and <zip> -> <member> for the four byte properties, which is the most direct pointer to the member.

extraction method

7z l evidence.zip
7z x evidence.zip -oout
wc -c out/<member>
md5 out/<member>
shasum -a 1 out/<member>
shasum -a 256 out/<member>

in code, every property consumes the same immutable byte string:

def digests(data: bytes) -> dict[str, str]:
    return {
        "size-bytes": str(len(data)),
        "md5": hashlib.md5(data).hexdigest(),
        "sha1": hashlib.sha1(data).hexdigest(),
        "sha256": hashlib.sha256(data).hexdigest(),
    }

validation and answer formatting

digests are lowercase hex with no prefix, the size is a base-10 integer, and the filename is the base name with its extension and no path. the syntax lines set the tolerance: md5 and sha-1 said "letter case is ignored", and all three digests carried normalization: case_insensitive (sha-256's line read "use no prefix, spaces, or explanatory text"), while the filename and size carried trim only. computing them from the extracted bytes, not from a re-encoded copy, keeps line endings and any byte-order mark intact.

failed approaches and pivots

the single solve was easy; the rotated variants were not. answer ids were dynamic, so a member stem from the single could become a different stem, and mastery added setN. prefixes. a solver that remembered the single's file name failed. the pivot was to treat answer ids as authoritative and to derive the member from them.

automation across modes

the robust algorithm:

  1. recursively expand archives while retaining archive order.
  2. parse each answer id into set, member stem and property.
  3. prefer the artifact named by the corresponding question.
  4. fall back to an exact basename-stem match.
  5. compute the property directly from that member's bytes.

delivery alternated between one archive per set and a zip of nested zips; recursive expansion made both look the same. after a timed retry the question metadata could be stale while the answer ids described the new assignment, so questions are only a placement hint.

lessons

solve times

public scoreboard · day 1 finish: below top 10

  • 2h30msingle#91 of 599 solvers
  • 2h57mtime trial#86 of 521 solvers
  • 3h00mmastery#86 of 507 solvers
  • #54team day finishof 358 teams that cleared it, in 3h04m
  • #2single orderof the day's 5, by our flag time

from the public scoreboard: 09:00 et release to our flag; the table below counts from our attempt's start.

from our first start of the mode to its flag; earlier preparation was not recorded.

mode work to flag attempts wrong submits
single 1m55s 1 -
time trial not recorded 1 -
mastery 26s on the clock (prep not logged) 1 -

the clock

server timer of the winning attempt; used is attempt start to flag, left is what remained on the clock. \* timer length from our notes; the attempt's deadline was not recorded. day 1-2 deadlines were not logged per attempt.

mode time available time used time left
time trial not recorded not recorded not recorded
mastery 30.0s* 25.5s 4.5s*

where we got stuck

flags: single, time trial, and mastery [redacted].

{generated by a clanker}