First | KOM Cloud Service

Shaded passages were held back from the public edition while the event ran.

Two days ago we were our own denial of service, 19th on the day. On Wednesday we won Day 21, and we went to the top of the whole event.

The night before

Tuesday night the robot built the web techniques I had predicted were coming, and every one got a miss budget: when a probe gets no confirming signal, it stops within 6 requests and hands off to an agent, one of the AI helpers on standby for each lane. A fast hand-off beats a sloppy solve. None of it fired on Wednesday, because Day 21 brought three web techniques that were not on my list.

The morning checks passed in 8 seconds. At 08:55 I made sure the binary lane on the VM and the web hand solvers were up. Fifty minutes before launch the robot was ready, and so was I.

09:00

The robot saw the release 0.9 seconds after 09:00.

Under Pressure (warmups): the new layer was Base64 over gzip. Single Solve CORRECT at 2.0 seconds, all three modes by 6.6.
Debug Me If You Can (mobile): all three by 6.2.
Actions Speak Louder (script): all three by 10.2.
Package Deal (metadata): the file was an Android app, and the robot had no reader for its manifest. All three by 33.1.
Shared Custody (binary): the archive held several programs and each question named which one to read. All three by 43.1.

All 15 file-lane checks in 43.1 seconds. On Day 19 that number was 293.

Package Deal and Shared Custody needed agents, who read the answers by hand while their patches, small code fixes the robot picks up live, caught up.

Then came something I had been waiting two days to see. On the binary Time Trial, two agent patches came in that would have changed 10 answers the grader had already accepted. That was Monday’s failure exactly, a fix fitted to one day’s file names. The judge we built Monday night, the automatic test every patch must pass before it goes live, refused both, took the patch that fit every file, and the Time Trial was CORRECT 1.6 seconds later. Nobody had to look.

The web

Three web challenges, each with a live target of its own, and the robot knew none of the techniques:

Reflect Upon This: reflected cross-site scripting.
Stored for Later: stored cross-site scripting, where your script sits on the site until a simulated moderator opens it.
Session Impression: session fixation.

So the whole web half ran on agents, and it worked. Session Impression’s Single Solve was CORRECT at 50.6 and Reflect Upon This at 58.5, and both were done with all three modes by 95 seconds.

The agents read each proof off the live target and posted the Single Solve by hand, and once a patch was live it carried the Mastery with no ticket at all (the ticket is the short report the robot writes when it cannot answer, and it is what wakes an agent). On the way, the safety classifier stopped three agents while they were writing the cross-site scripting payloads. Each was replaced on the spot with the same ticket, twice by Mythos and once by Opus 4.6. Tuesday’s fallback fix, doing its job with nobody touching it.

Stored for Later was the last wall. Its Single Solve landed at 98.2 and the Time Trial at 143.5. Then the Mastery’s second target had renamed every route, so what worked on the first target had nothing to point at. And a stored payload only pays out when the moderator comes by to read it. A second agent round found the new routes, the patch went live at 212.1 seconds, and the last check of Day 21 was CORRECT at 213.4.

I had been cheering it through the whole web half, and at 09:03 I got to type “You got it! Well done! 1st place!” The scoreboard took a minute to catch up. When it did, it said the same thing.

The record

From the public scoreboard, Day 21, all 24 checks:

Wizdumb 213.4 seconds, 1st of 86 teams that finished everything.
crash 218.7, NyaSEC 287.1, Frostbyte 326.8, twistpoint 346.3.
First blood on 12 of 24 boards: the warmups Single Solve and Time Trial, the script Single Solve, the mobile Mastery, and 8 of the 9 web boards.
Every web Mastery board is ours. crash beat us to Reflect Upon This’s Single Solve, the one web board we did not take.

We beat crash on the day by five point three seconds. And on the overall board:

1st of 1,457.

85 teams have every point there is, 1,150 each. When points tie, the board goes to whoever banked their last flag first. Ours landed at 09:03:33, crash’s at 09:03:38. First by 5.3 seconds.

A week ago, after Day 14, we were 35th. After Day 20 we were 7th. This is my third Huntress: the first one my team finished top 50, and last year was a DNF. I said I was here to win this one. Ten days to go.

The afternoon

That morning I told the robot what I had watched: the hand solvers carried web, so lean into that. I gave the go on its fixes a few minutes later, and they were in before lunch. The three new web techniques are robot code now, the metadata engine reads Android manifests, and the binary engine reads the member the question names. Any agent may post a hand answer, every web slot has a second hand solver, and a patch that reproduces the hand answer carries straight to the next target. The permission classifier balked at the live proof, so I ran it myself: every fresh Time Trial and Mastery CORRECT, no tickets.

Then I noticed the API had grown a new operation, reset, a fresh web target on the same attempt. The robot uses it now so a broken target never leaves us floundering, and the morning check notices when the API changes.

How we built it: the Day 21 dev log

Why any agent may answer by hand. Watching the web half, the first agent to read each proof was usually a patch agent, not the hand solver. It knew the answer and sat on it while it wrote code, and the later modes waited 21 to 45 seconds for that code. Letting every agent post the answer it already has costs nothing and closes the wait.

Why a second hand solver. A replacement for a stopped agent starts from zero. A second hand solver per web slot is already reading the target when the first one is stopped. In the free test it posted no winning line and got stopped once itself, so it has yet to prove itself.

Why “no gain” was the wrong verdict on web. The judge used to shelve a patch that only reproduced an answer already accepted. On web that is wrong: the next mode brings a fresh target, and code that reproduces the hand answer is exactly what that target needs.

Measuring it honestly. The before-and-after run had a hole: no run of the race-day code under the same conditions to compare against, and only Stored for Later clearly improved. What it did show was where the time went: about 35 seconds from ticket to first hand answer, almost all model turns, many spent re-reading pages the robot had already fetched. So tickets now carry those pages and the requests already sent, and ticket to first hand answer went from 36.5 seconds to 17.9 on one challenge and 34.1 to 22.4 on another.

Probe before you trust. Before the robot relied on reset, we probed it live on a free run, an untimed practice run that spends no ranked attempt: same attempt, new address, and a solved attempt refuses it. Only then did it go in, as a fallback.

What we left open. A patch written against the Time Trial’s target can still hard-code that target’s routes, and a Mastery target that renames them costs a second round. Stored for Later did exactly that on Wednesday.

Tech tips

Reading an Android manifest without Android

An APK is a zip, and its AndroidManifest.xml is not text: it is Android’s binary XML, a string pool plus a stream of start-tag and end-tag chunks that point into the pool by index. Walk those chunks and the package name, versions, SDK levels, permissions and components come straight out, with no Android tools installed.

On Wednesday an agent read the package name by hand at 20.5 seconds; the new reader does it in milliseconds.

Read the member the question names

Shared Custody’s archive held several programs, and each question said which one to read. Read the right fields from the wrong program and every answer is wrong for a reason that looks right.

Our config reader was already right; it was reading the wrong file. The fix narrows the archive to the member the question names before any reader runs, which turned 28 open answers into accepted ones on the recorded attempts and moved none of the old ones.

A patch must not move what is already right

Monday night’s fix earning its keep. Before a patch goes live, the judge replays it over the attempt it was written for, and if it changes any answer the grader already accepted there, it is refused. On Wednesday’s binary Time Trial that is what kept 10 accepted answers accepted.

Stored payloads need a reader

Reflected cross-site scripting comes straight back in the response to your own request. Stored cross-site scripting sits on the site until someone else opens it, here a simulated moderator. So you post the note, find where it lives, and wait for the visit: the proof is whatever the visit leaves behind.

The robot’s solver polls for the moderator’s visit for up to 20 seconds, and finds the routes from the site itself rather than a fixed path, because the Mastery’s second target renamed every one.

Carry the hand answer forward

When an agent read a web proof by hand and its patch reproduced that value, the judge used to call the patch “no gain” and shelve it, so the next mode’s new target waited for another hand read. Now, on a web lane with no live patch yet, a patch that matches the accepted answer goes live and runs on the next target the moment it exists.