BREAK IT · the Liveware ingest gateway
A secure ingest gateway for the records you take in from partners and devices. It proves
who sent each record, in what order, in exactly what shape, on the raw bytes, before any
software parses it. Every refusal becomes an antibody, a repeat attacker pays proof-of-work
for every new look, an independent referee watches the naive app behind it, and the whole
thing runs on a machine you own and sends nothing out. White-box: reach the app with
anything malicious and you win.
The live page runs the repository's own gated kernels in your browser: the real feed (180,000
payment records), the real gate, immune system, sentinel, app and referee. Nothing is a mock.
The Liveware Pilot: sealed first, measured second, failures kept
One real node (startNode, as node run.mjs runs it) as the ingest gateway for a partner's
payment feed: the 180,000 records of the UCI Default of Credit Card Clients dataset
(DOI 10.24432/C55S3H, CC BY 4.0), with six known attack shapes injected mid-feed. The claims
were committed (pilot/claims.json @ c75c903) before the measuring code existed;
pilot/measure.mjs refuses to run if a claims file differs from its seal.
| role | claim | measured | |
|---|
| COO | every record admitted, none refused or lost | 180,000 admitted, 180,000 in the ledger, 0 refused | HELD |
| COO | the books equal the feed exactly | equal on all 210,000 keys, 30,000 accounts | HELD |
| COO | ≥ 100 records/s, each signature-checked and fsync'd first | 194.6 records/s (925 s), Intel i7-1255U laptop | HELD |
| CISO | 0 outbound attempts of any kind (as sealed, DNS included) | 1: Node's own dns.lookup('127.0.0.1') for its bind address | FAILED, kept |
| CISO | listens on 127.0.0.1 only | 127.0.0.1 | HELD |
| CISO | 0 outbound attempts once listening (addendum, sealed before the full run) | 0 | HELD |
| Security | six attack shapes refused at the gate, then dropped on sight | replay → counter; flip, unpinned key, no domain → signature; truncated → size; out-of-range → schema; all six then recognised | HELD |
| Security | the referee finds 0 breaches; its fold matches | 0 breaches, 180,000 checked, fold matches | HELD |
| Security | the red-team battery reproduces its receipt | 79 cases, all held | HELD |
| Regulator | every refusal explained; the ledger re-derivable offline | 12/12 answers and 12/12 journal records explained; the chain verifies; head = the offline derivation | HELD |
Receipt: receipts/pilot.json, including the attempts that went wrong
on the way. CI runs node pilot/check.mjs: the ledger head and the books re-derived from the
feed alone, the judge re-run on the receipt's facts, and a metered real node re-run on the
first 3,000 records. The CFO's case is arithmetic on dated list prices and your own volumes
(src/cost.mjs, gated; prices in costs/sources.json), run on the page.
node pilot/measure.mjs # the whole pilot on your own machine: your rate, your egress meter, your books
node pilot/check.mjs # what CI checks
node tools/serve.mjs # the live page locally, http://127.0.0.1:8892
Supplied by AI Native Solutions. MIT, no licence fee.
Powered by the Konomi architecture, created by Thomas Frumkin.
The rule
A tiny app sits behind the gate. It is naive on purpose: it trusts every message it is
handed and does no checking of its own. The only thing between the network and that app
is the gate. You win if the referee ever sees one of these:
- the app acted on a message the gate never admitted (bypass), or
- the gate admitted a packet an independent grammar validator rejects (a schema escape), or
- the app's action did not match its ledger entry, or
- the app's whole state stopped being a replay of the ledger (state corruption).
If you cause any of those, the node mints you a signed trophy bound to the exact
packet you sent — anyone can re-run it against the published gate and watch the referee
condition fire. The trophy proves its own story.
Run it
node run.mjs # one node on 127.0.0.1:8787 + a legit client sending real, signed traffic
node run.mjs --mesh 3 # three nodes, each pinned to the others — attack one, watch the others go immune
Then point the attack kit at it:
node attack-kit/forge.mjs --op set --key name --value hi --send # forge (random key)
node attack-kit/replay.mjs --from-captured 0 --times 50 --parallel 50 # the replay race
node attack-kit/fuzz.mjs --n 20000 # mutation fuzzer
node attack-kit/redteam.mjs # our own battery, every vector
Watch what it learns: GET /referee /immune /loot /journal /state /pubkeys.
What is defending
A packet's path, each stage refusing more than the last, nothing decoded until every
raw-byte check has passed:
HTTP limits → known-attack recognition (on sight) → THE REBOUND LAW (cost) → THE GATE (verify before parse)
→ SENTINEL (behaviour) → LEDGER (fsync'd) → the naive APP → the REFEREE (did anything get through?)
- The gate —
size → magic → schema → sender → signature → counter, in order, on the
raw bytes. Ed25519 over a domain-separated header+payload; one algorithm, no algorithm
field; an exact per-sender counter (last + 1, inside the signed bytes — no window, no
gaps, no rollover, and a malleated signature cannot make a replay fresh). It parses
only after all of that, and the parsed message is frozen and tagged admitted.
Canonical wire format: for every byte string the gate accepts, encode(parse(b)) === b
— there is exactly one encoding of any message, so a packet cannot be read two ways.
여기까지가 README 앞부분입니다. 나머지는 원문에서 읽을 수 있습니다. README 전문 보기 ↗
