autoit takes two: autoit as one more carrier for the analysis header
huntress ctf 2026, day 12 · script analysis · all three modes
tools used: script-analysis toolkit and timed-attempt pipeline.
the prompt: "two inert autoit workflows arrived as a matched set, and each one carries half the story. correlate them with everything you've proven so far, and decide which pairing is genuine and which is just going through the motions." the bundle grew by one specimen family, four autoit polyglots, on top of every family from days 1 to 11.
the key insight: no new field kind arrived, again. the autoit files carry the same HUNTRESS_ANALYSIS_V1 comment header as the php, typescript and mof polyglots before them, behind autoit's ; comment, over the same version 3 descriptor. the generic descriptor finder read them unchanged; no field asked which pairing was genuine.
challenge shape
the single asked 855 fields over one bundle, 44 more than day 11 and none removed; the time trial asked the same 855 of a fresh bundle, the mastery 1710 over two. the new fields:
polyglot-autoit-<tag>-* tags: benign-utility, downloader, launcher,
staged-chain
adapter attack campaign file-path or url host-profile next-language
obfuscation role stage-count stage-profile steps
the question kinds: role is an enum of eleven roles (benign_utility, downloader, dropper, impact, launcher, persistence_descriptor, relay, staged_chain, stager, uploader, advanced_syntax); attack is a pattern, an att&ck id or none for the benign graph, picked by a precedence the question spells out; stage-count is a base-10 integer; steps is ordered tokens "joined by > with no surrounding spaces"; adapter, campaign, url or file path, host profile, obfuscation, stage profile and next language are exact text read from the artifact.
artifact anatomy
an autoit specimen is a small .au3 script that carries its descriptor twice: in a comment header, and as a global constant a function returns. the whole file, payload cut:
; HUNTRESS_ANALYSIS_V1:B64-dj0zfGxhbmd1YWdl...
Global Const $descriptor_<id> = "dj0zfGxhbmd1YWdl..."
Func build_plan_<id>()
Return $descriptor_<id>
EndFunc
the payload decodes to the version 3 descriptor, key=value pairs separated by |, in this key order:
v=3|language=autoit|role=…|verdict=…|attack=…|adapter=…|host_profile=…|
obfuscation_profile=…|stage_profile=…|next_language=…|stage_count=…|
steps=a,b,c|campaign_id=…|url=…|file_path=…
the header's codec varies per specimen, as it has since day 8, and each of our four used a different one: B64 is base64, HEX is hex of the text, HB64 is hex of the base64 text, FRAG is hex cut into dot-separated fragments. the descriptor's obfuscation_profile names the same codec (base64, plain_hex, hex_base64, fragmented_hex), a free check on the decode.
extraction method
the descriptor finder does not parse autoit. it scans any text for the analysis header under any comment syntax, decodes the payload with the codec the header names, and splits the descriptor into fields. a specimen without a header is searched for the descriptor's own shape (v=N|...) in string constants. field names map to descriptor keys by the question's suffix (host-profile to host_profile), with two renames (obfuscation reads obfuscation_profile, campaign reads campaign_id), and every stated value is used verbatim.
the steps field joins the descriptor's comma-separated steps with the separator the answer format names (> here, as on every day since day 6).
the same reading in plain python (our specimen.find and specimen.answers do this, plus fallbacks for header-less specimens):
import base64
import re
HEADER = re.compile(r"HUNTRESS_ANALYSIS_V1:([A-Za-z0-9_]+)-(\S+)")
RENAME = {"obfuscation_profile": "obfuscation", "campaign_id": "campaign"}
def hb64(payload: str) -> bytes:
return base64.b64decode(bytes.fromhex(payload))
def frag(payload: str) -> bytes:
return bytes.fromhex(payload.replace(".", ""))
CODECS = {"B64": base64.b64decode, "HEX": bytes.fromhex, "HB64": hb64, "FRAG": frag}
def fields(src: str) -> dict[str, str]:
codec, payload = HEADER.search(src).groups()
text = CODECS[codec](payload).decode()
desc = dict(pair.split("=", 1) for pair in text.split("|"))
out = {RENAME.get(k, k.replace("_", "-")): v for k, v in desc.items()}
out["steps"] = ">".join(desc["steps"].split(","))
return out
validation and answer formatting
values come out as the descriptor states them; a label the descriptor does not state is answered from the question's enum as ranked candidates, never as a single guess.
the autoit descriptors state attack themselves, and the stated value was graded correct: none for the benign utility, ingress transfer (T1105) for the downloader, and the parent command and scripting interpreter id (T1059) for the launcher and the staged chain. the question's precedence would pick the language-specific interpreter sub-technique for those two, but it also says "the parent command and scripting interpreter technique is also accepted when a language-specific sub-technique is canonical", so the parent the descriptor states passes as is.
failed approaches and pivots
none. the day 12 preparation had probed 52 carrier languages under the same header and all four codecs, autohotkey among them, which comments with the same ; as autoit.
automation across modes
the same solver answered every mode: placement by the question's named file, then the specimen's stem, then the generic finder.
lessons
- when a lane's new content is a new carrier for an old format, a carrier- agnostic finder turns a new language into no work at all.
- the prompt asked to correlate pairs; the fields did not. answer the fields.
solve times
public scoreboard · day 12 finish: 1st
- 0:03.2singlefirst blood, +0.22 s
- 0:05.7time trialfirst blood, +1.7 s
- 0:08.3masteryfirst blood, +2.9 s
- #1team day finishof 166 teams that cleared it, in 1:06.5
- #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 | 1.8s | 1 | 0 |
| time trial | 2.8s | 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 | 30.0s | 1.4s | 28.6s |
| mastery | 30.0s | 1.5s | 28.5s |
where we got stuck
- nowhere. all 855 fields of each mode were answered on the first attempt.
flags: single, time trial, and mastery [redacted].
{generated by a clanker}