framework roulette: a vary header names the winning slot

huntress ctf 2026, day 31 · web exploitation · three modes

tools used: live web target capture, saved web inspection, and timed attempt pipeline.

the target presented itself as a blazor server analyst workspace with one isolated inspection route. the clue response named the feature route and the caller's role, and the inspection route answered 403 twice over: once for the gateway context, once for a topology proof nobody could name. every 403 carried a vary header naming the exact request header its gate keyed on — including the second gate's, a header that appears in no body anywhere.

challenge shape

the challenge was released on day 30 and was not solved that day; it returned on day 31 as one of the day's two web assignments. single and time trial each assigned one temporary target and one answer. mastery assigned several targets and answer ids. each assignment rotated the feature route, the component route and the host. the answer for each target was the proof string the target itself returns once the right claims cross both gates.

artifact anatomy

the useful artifact was the saved sequence of http responses. the home page linked a clue document that named the framework, the current feature route (/inspect-958dc2 on the captured instance), a component route (/blazor) and the caller's role (analyst). a plain get of the feature route answered 403 with gateway_context_rejected and an evaluated_client address, and its vary header read X-Forwarded-For. the component page said it plainly: the edge forwards a client address to the gateway, staff requests also carry a role claim, and the question is which of those claims the server trusts. a get that cleared the first gate answered a different 403, topology_proof_rejected with a staff_only policy, and that response's vary header named a header nobody had sent: x-arena-aed56f.

extraction method

the first gate is the gateway context. the evaluated client is the leftmost X-Forwarded-For entry, defaulting to the edge address, and the gate accepts exactly the loopback address 127.0.0.1 — a second chain entry is ignored, and every other value or form of forwarding header keeps the first 403.

the second gate is the staff role claim, and its trusted header name rotates per instance: on the captured instance it was X-Arena-Aed56f, whose six hex digits match the feature route's suffix. the name is disclosed only by the stage-two 403's vary header. sending the observed name with the value staff beside the loopback address claim crosses both gates and returns the proof.

def capture(c):
    c.get("/api/clues")
    route = c.rows[-1].json["feature_route"]
    ctx = {"X-Forwarded-For": "127.0.0.1"}
    c.get(route, headers=ctx)
    arena = None
    for row in c.rows:
        if row.status == 403 and "topology_proof_rejected" in row.body:
            for name in row.headers.get("vary", "").split(","):
                if name.strip().lower().startswith("x-"):
                    if "forwarded" not in name.lower():
                        arena = name.strip()
    for value in ("staff", "staff_only", "Staff", "administrator"):
        c.get(route, headers={**ctx, arena: value})
        if c.proof():
            return

the route, the arena header name and the proof all rotate with the host, so the name is read from the current target's own denial rather than carried between assignments.

validation and answer formatting

every request stayed on the assigned origin. the first 403's vary header naming X-Forwarded-For separates the two gates cleanly: a response echoing gateway_context_rejected means the address claim did not clear, and a topology_proof_rejected means it did and only the role claim is left. the proof had to appear in this target's response before it was submitted for this target's answer id.

failed approaches and pivots

the standard forwarding-header sweep and every spelling of a role claim — fifteen role header names across four values, a role cookie, json post bodies, ?role= and ?claim= query keys, and forged alg:none bearer tokens with both the plain and the microsoft role-claim uris — left the stage-two 403 unchanged, because none of them was the instance's renamed claim header. two timed runs ended with a capture that held no proof because the solver carried the single instance's header name to a fresh timed target, where the name had rotated. reading the name out of the current target's own vary header broke the stall on the third run.

automation across modes

the solver reads the feature route from the clue document, sends the loopback address claim, then takes the stage-two 403's vary header and uses its first x- header name that is not a forwarding header as the instance's claim header, sweeping the role values under it with and without the address claim. the same code resolved single, time trial and mastery targets without a per-instance edit, because the only instance-specific value is read from the target itself.

lessons

solve times

public scoreboard · day 31 finish: below top 10

  • 9:22.4single#32 of 108 solvers
  • 10:43.8time trial#34 of 102 solvers
  • 10:51.3mastery#22 of 90 solvers
  • #14team day finishof 90 teams that cleared it, in 10:51.3
  • #7single orderof the day's 7, by our flag time

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

the table measures from the first local work on the mode to recorded team completion.

mode work to flag local attempts wrong submits
single about 560s 1 0
time trial about 77s 3 0
mastery about 6s 1 0

the clock

the winning timed attempts' assignment deadlines were not preserved in the local record.

mode time available time used time left
time trial not recorded not recorded not recorded
mastery not recorded not recorded not recorded

where we got stuck

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

{generated by a clanker}