bind over matter: a mof file as one more carrier, and wmi subscriptions nobody asked about

huntress ctf 2026, day 10 · script analysis · all three modes

tools used: script-analysis toolkit and timed-attempt pipeline.

the prompt promised a wmi persistence puzzle: "a mof file declares classes, namespaces, filters, and consumers, but only some bindings actually tie them together. reconstruct the persistence intent, separate the operational relationships from the decoys, and name the subscription that would really survive a reboot." the new specimens were indeed mof files, but they declared no filter, no consumer and no binding, and no field asked about one.

the key insight: a mof file was one more carrier for the descriptor format the lane has used since day 8. the generic descriptor finder read it unchanged, and the day-9 solver answered all 753 fields of the single. the subscription analysis the prompt describes is real work, and we built it on day 10 for the day a question asks it.

challenge shape

the single asked 753 fields over one bundle of specimens, 58 more than day 9. the new ones belong to six specimens: four polyglot-wmi_mof-<tag> files (benign-utility, downloader, launcher, staged-chain) and two bash advanced samples (here-string, heredoc-reconstruction). each wmi specimen asks the descriptor families of day 8: role (day 8's enum of eleven labels), attack ("t#### or t####.###", or the literal none), adapter, campaign, the indicator for its role (url, or file-path for the benign utility), stage-count, steps (an ordered behavior graph with > separators), host-profile, obfuscation, stage-profile and next-language. the time trial asked the same 753 fields of a fresh bundle, the mastery 1,506 in two answer sets under one clock.

artifact anatomy

every wmi specimen has the same four lines, here with the payloads elided:

// <MARKER>:<CODEC>-<payload>
#pragma namespace("\\\\.\\root\\subscription")
class HuntressAnalysis_<hex> { string Descriptor; };
instance of HuntressAnalysis_<hex> { Descriptor = "<payload>"; };

the first line is the day-8 analysis header: a marker, a codec name and the encoded descriptor, in one of the header codecs day 8 introduced (HEX, HB64, FRAG or B64). the #pragma namespace names root\subscription, the namespace windows uses for permanent event subscriptions. the class declares one string property, and the instance repeats the payload in it. that is the whole file: a mof compiler would register a class and one instance, and nothing would ever fire.

the language token in the member name carries an underscore, wmi_mof: the first two-part language name in the lane, and the decoded descriptor's language says the same. the bash samples keep the older material convention: a readonly Material_<hex>='...' constant beside a Codec_<hex> label that names the encoding. the single's bundle used percent_hex| (%-prefixed hex bytes, which urllib.parse.unquote_to_bytes reads), the timed bundles reversed_base64|, base64_literal| and hex_compact|; every one decodes to a version-1 descriptor opening v=1|feature=. the here-string or the heredoc itself holds only a decoy line.

extraction method

the solver looks for the analysis marker in any member before it dispatches on the file extension, decodes the header with the codec it names, and answers every descriptor field from the decoded version-3 descriptor. stated values are used verbatim; the steps graph is serialized in the order the descriptor lists it. nothing about a .mof extension or a wmi_mof language is special-cased: the finder treats the extension as unknown and the header as the evidence.

one change on day 10 concerns names: the solver now matches a field to the placed member's own file stem first, so a tag that happens to spell one of the wmi qualifiers below (polyglot-wmi_mof-decoy.mof) still reads its own fields instead of a decoy group's.

validation and answer formatting

each field takes its value from the descriptor key that names it; a header that does not decode to a descriptor raises instead of guessing. the attack field for a wmi specimen is the descriptor's own technique id, verbatim: T1059 for the launcher and the staged chain, T1105 for the downloader, none for the benign utility. no mapping from role to technique was needed. obfuscation is the descriptor's obfuscation_profile, which names the header codec as on day 8 (HEX plain_hex, HB64 hex_base64, FRAG fragmented_hex, B64 base64), and steps is the comma list re-joined with >.

the two bash samples graded the same labels as every advanced-bash specimen before them: role advanced_syntax and attack T1059.004 (the question asks for "the bash interpreter att&ck technique"), neither stated in the version-1 descriptor; feature and primitive are its values as written.

failed approaches and pivots

none on the clock. the prompt cost us preparation instead: the subscription questions it describes did not come, but they may. on day 10 we built a wmi model for them in the toolkit. it reads __EventFilter, the five standard *EventConsumer classes and __FilterToConsumerBinding instances from a mof (any carrier), from powershell (Set-WmiInstance, New-CimInstance, [wmiclass] with .Put()), from wmic ... CREATE and from batch files that echo a mof together, into one model, and gives each binding a verdict.

a binding resolves when its filter and consumer references name live instances in its own namespace. it persists when it also passes the rule below, which is our inference from how wmi permanent subscriptions work, not something the grader has confirmed:

def survival_problems(ns, filt, cons, registered=None) -> list[str]:
    out = []
    if ns.casefold() not in PERMANENT_NAMESPACES:      # root\subscription, root\default
        out.append(f"{ns} holds no standard consumer classes")
    kind = cons.cls.casefold()
    if kind not in STANDARD_CONSUMERS and kind not in (registered or set()):
        out.append(f"no provider delivers {cons.cls}")
    if not filt.query.strip():
        out.append("the filter has no query")
    if filt.query_language and filt.query_language.casefold() != "wql":
        out.append(f"query language {filt.query_language} is not wql")
    return out

Register-WmiEvent subscriptions resolve but are temporary (they end with the session), so they land among the decoys with that reason first; a [wmiclass] instance that never calls .Put() reads "not committed". variables are followed only as far as literal assignments go, and anything unresolvable is reported, never guessed. the toolkit article covers the model.

automation across modes

the descriptor path answered all three modes: 753 fields in the single and the time trial, 1,506 in the mastery, each from the same header decode.

lessons

solve times

public scoreboard · day 10 finish: top 3

  • 0:05.1single#3 of 185 solvers
  • 0:07.1time trial#3 of 175 solvers
  • 0:09.8mastery#2 of 174 solvers
  • #2team day finishof 173 teams that cleared it, in 1:40.9
  • #3single 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 when we started working on the mode to its flag.

mode work to flag attempts wrong submits
single 2.4s 1 0
time trial 2.6s 1 0
mastery 4.3s 1 0

the clock

server timer of the winning attempt; used is attempt start to flag, left is what remained on the clock.

mode time available time used time left
time trial 13.0s 0.8s 12.2s
mastery 32.0s 1.5s 30.5s

where we got stuck

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

{generated by a clanker}