Bug bounty
Break the box. We pay if you do.
Endstop claims a small, proven boundary between code a language model writes and what that code can cause. We would rather you attacked that claim than took it on faith. There is a live target on the internet, everything about how it is built is disclosed, and there is money for getting past it.
The prizes
Four ways in, and the amount depends on what a win would prove.
| Target | Prize | What it proves |
|---|---|---|
| Steal Secret A from inside the board, by defeating the interpreter's bounds check | $1,000 | The formal memory-safety claim is wrong. The finding we most want. |
| Steal Secret A by any other route: the MCP server, the emulator, the broker machine, the host | $500 | The boundary was gone around, not through. Still a real bug in what surrounds it. |
| Steal Secret B, a file on the host outside both emulated machines | $500 | An emulator or harness escape that reaches the host. Off the board by nature, so it pays the off-board tier. |
| Halt the board so it stops answering | $300 | A denial of service the fuel bound and fail-closed design were meant to prevent. |
The line that sets the prize for a stolen Secret A is where the attack came from. Through the interpreter's bounds check, the property we prove, is the full amount. Around it, by breaking anything else, is half. You tell us the route, and the route decides the tier.
What you are attacking, disclosed
Two emulated machines on one host, wired the way the product describes. Guessing is slower than reading; the interpreter's whole source and its proofs are published.
- The board
An emulated RISC-V core under
qemu-system-riscv32, running a verified interpreter for a subset of eBPF with no operating system beneath it. "Bare metal" here describes the software, not the hardware: no OS, no allocator, no runtime. The machine underneath is emulated, not silicon. A program gets a 512-byte memory window, three capabilities (read state, propose a setpoint, a signing stub), and a fuel budget of 1024 steps; the interpreter clamps any run to a hard ceiling of 4096. Every memory access is bounds-checked. Its memory safety, its termination under fuel, and the confinement of its effects to the capability table are machine-checked with Kani. - The broker
The model-facing side: an MCP server reaching the board over a single serial line. It holds only the SHA-256 fingerprints of the secrets, never their bytes, so breaking the server does not hand you a secret. The board runs one program at a time.
- The frame reader
The serial link's framing is itself a proven total function now, after an earlier researcher hung the board with a truncated frame. That the perimeter is where the last defect was, and the proven core held, is the point of the exercise.
Call the mission tool at the endpoint first; it discloses the objectives, the
machine, and the assembly language, then submit_program runs a program and
shows you exactly what happened.
The secrets, committed in advance
Published here before anyone attacked, so we cannot move the goalposts after a win. Each
secret is 16 random bytes rendered as ENDSTOP-CANARY-A- or
-B- followed by 32 hex characters: 128 bits of entropy, so grinding the hash
is not a shortcut. The only way to the plaintext is out of the box.
Secret A len 49 sha256 = 1062b93c221d221aa33dd7797c433ef02df636ad6b36d12c280396b7fce58220
Secret B len 49 sha256 = 8dc59365feaa79409a8701a0e5c7b1ce65ee7559000a63fdc348692b4a5de38eVerify a candidate against the raw bytes, no trailing newline:
printf '%s' 'ENDSTOP-CANARY-A-...' | sha256sumHow a claim works
A claim needs both halves, because either alone is not evidence.
- The plaintext. Bytes whose SHA-256 matches a hash above. We verify
with
sha256sumover the raw bytes. - A repeatable attack. The method, in enough detail that we reproduce it. A secret without a reproducible route does not pay: we cannot tell a real break from a leak we caused ourselves, and the point is to learn the vulnerability.
The automated WIN flag in the tool output is a convenience, not the arbiter.
The hash and the reproduction are. A partial exfiltration that never trips the flag still
pays if the plaintext and the method are sound.
Scope, and a safe harbour
In scope: the endpoint and everything behind it: the MCP server, the board and its emulator, the broker machine, the serial link, and the host file that is Secret B.
Out of scope: the Cloudflare edge and the worker in front of the endpoint; this marketing site; the cloud account and its console; any denial of service against infrastructure other than the board itself; social engineering; and anything aimed at a person rather than the box. Do not attempt to reach other tenants, other hosts, or the cloud control plane.
Every attempt is recorded and will be published, the failures included, because a boundary nobody attacked is not evidence. Submitting to the endpoint is consent to that, so send nothing through it you would not want public.
Good-faith research inside the scope above is authorised, and we will not pursue anyone who stays within it. Step outside it, into the cloud account, other hosts, or people, and that protection ends.
One payment per distinct vulnerability, to the first reproducible report; variations on one root cause are one finding. We may pause or retune this programme and will say so here when we do, honouring claims already made under the terms they were made.
Claiming
Send the plaintext, the hash it matches, and the reproduction, and we will confirm receipt, verify, and publish the finding with credit unless you ask otherwise.