Attack vectors¶

An attack vector is one avenue into the system that somebody wants probed — “a session token the device was never issued”, “the firmware update path” — together with the loop that keeps probing it.

The loop turns what the analyser suspects into tests that try to prove it, and repeats until the tests stop learning anything new. Each step of that already exists in Midair as something a person does by hand: run an analysis, read the findings, decide what is worth testing, write the test, run it, read the log, decide what to write next. The vector is the thread between those steps.

Open Vision, then Attack vectors. It sits under Vision rather than under Testing because the question it answers is Vision’s question — what to worry about next. That the answer comes out of a test run is a detail of the answer.

What one iteration does¶

Analyse: Midair forks a run from the analysis template and starts it with the suspicious-places mode on, whatever the template says. Findings state what is wrong; suspicious places state what decides something and has not been read. See Suspicious places.
Plan: The suspicious places, the findings, and everything the earlier iterations learned go to the AI provider. It answers with a plan: the hypotheses to attack, a spec for the test suite, and a norm for the Delta agent.
Write the tests: The plan’s spec goes to Claude Code or the Codex CLI, which updates the test suite repository in place and pushes it. The suite’s own spec prompt is left alone. See Testing.
Run: Midair forks a run from the test template, pinned to the branch that was just pushed, and starts it. When a device is attached, Delta is told to collect, and it watches the machine while the suite runs.
Judge: The verdicts of the run and the drift that Delta reported go back to the provider. It answers with the findings the run settled, the hypotheses it could not reach, and whether another iteration would learn anything new.

The answer to the last question is the input to the next iteration’s plan. A suite that passed everything is evidence about the hypotheses it covered and about nothing else, and the gaps it reports are why the next round exists.

What the loop never does¶

It does not change the code under test. A loop that could change what it is testing would eventually make the test pass rather than make the system safe.

It does not decide that something is a vulnerability. The record accumulates findings with the evidence for each, and marks each one as demonstrated by a run or merely suspected. A person confirms them.

Configuration¶

Open Attack vectors, and add a record.

Name: The avenue, named. The lists show it.
What to prove: What you are actually worried about, in your own words. It rides every request to the provider. “Find vulnerabilities” on its own is not a question that anyone can answer well.
Workspace: The project this avenue is into. It also narrows the pickers below.
Analysis template: Forked each iteration.
Test template: Forked each iteration, pinned to the branch that the generator pushed.
Test suite: The repository that the assistant edits. See Testing.
Delta device: Optional. The agent that watches the machine under test while the suite runs. See Monitoring.
Iterations at most: The loop stops here even if it is still learning. It also stops on its own the moment another round would learn nothing new.
Suspicion categories: What the analysis is asked to notice. A new vector selects security.

The three records must belong to one project. A vector that names a template from another project has nothing to relate its results to.

Running one¶

The Run screen holds the loop. Start begins the first iteration and resets the iteration log and the findings; the configuration stays. Stop ends the loop where it stands.

A stop leaves the runs that the loop started to finish. They are real runs with real results, and a loop that killed an analysis half way through would throw away work that is worth keeping.

The screen shows:

Where it is: The stage of the loop, the iteration, and links to the analysis run and the test run of this round.
What it found: Every finding, with its evidence, the hypothesis it settles, and whether a run demonstrated it or the provider merely suspects it. The demonstrated ones come first.
What it is trying: The hypotheses of the current plan.
Rounds: One row for each finished iteration: the counts, the links to its runs, and the hypotheses it could not reach.

The loop advances on the server’s own clock, not in the browser. Closing the page does not stop it, and a restart of the server resumes it rather than starting it again — every stage is written on the record before the step that follows it begins.

A stage that does not move for six hours ends the loop and says so. That is not a timeout on the work: an analysis of a large tree, a code generator editing a repository and a full suite run are each measured in tens of minutes. It catches the other thing — a run record that will never reach a terminal state because the process behind it is gone.

The test suite it writes¶

The generated suite is a Test Environment suite in C. The spec tells the generator to use the tsf-cybersec TAPI:

tapi_binscan: How a binary on the agent was built: NX, PIE, RELRO, the stack canary, fortify, the libc flavour and the toolchain.
tapi_netexpose: What the agent listens on, and what of it is reachable from elsewhere.
tapi_egress: What the agent talks to, against what it is allowed to talk to.
tapi_sniffrules: Ready-made rules over captured traffic for the usual protocol mistakes.

Each scanner appends to a report rather than failing the test itself, and the test decides what is worth failing over. Each generated test names, in its verdict text, the hypothesis that it settles, so that the next round can read the verdicts back against the plan.

What Delta contributes¶

The plan may carry a norm: the policy that the agent checks the host against. Midair sends it to the device as a reconfigure command, and the agent applies it on its next sync.

Midair records the device’s cycle counter when the run starts. The drift from that cycle onwards is what belongs to this iteration; anything older was already there and is not attributed to the suite.

A norm can forbid a behaviour class — module, ptrace, bpf, kexec, memexec, network — and can set the thresholds for ports, processes and memory. See Monitoring.

Over the API¶

An assistant reaches a vector through the MCP endpoint: midair_list_attack_vectors, midair_get_attack_vector, midair_attack_vector_report, midair_start_attack_vector and midair_stop_attack_vector. midair_analysis_suspicions reads the suspicious places of one analysis directly. See MCP endpoint.

Starting or stopping one needs a developer seat on its project, because the loop starts an analysis, a code generation and a test run — and each of those needs one on its own.