> Taken from the Transit Fabric source repository at commit 91be12e (91be12ef98b775c7f045124e6b8c686c15439650, main), file docs/threat-model.md. Links into the private source tree are shown as plain text.

# Threat model

Assume every miner is rational and adversarial, some validators are lazy or colluding, and the subnet owner is trusted only as far as the published code.

| # | Attack | Who | Mitigation | Spec | Sim / Unit test |
|---|---|---|---|---|---|
| T1 | Declare capacity you don't have (including tolerance-band overclaiming) | Operator | Unpredictable capacity tests; inside `CAP_TOLERANCE_PPM` verified capacity is capped at `min(declared, measured)` (`verified_capacity_mbps`); outside tolerance `OVERCLAIM_PENALTY_PPM` haircut applies | capacity-bonds.md | `overclaimer`, `adversarial_parameter_sweeps` |
| T2 | Serve canaries well, drop or degrade real traffic | Operator | Canaries padded and classed like paid traffic; client receipts | receipts.md, measurement.md | `canary_only` |
| T3 | Generate your own traffic to farm usage | Operator | Only assigned paths and canaries count; unpaid self-traffic is `free` at best; client receipts required for `paid` | receipts.md | `self_dealer` |
| T4 | Inflate byte counters or self-sign loop receipts | Operator | Co-signed hop receipts (`up != down`, `verify_strict`); `ReceiptBook` counter-proposals; `verify_path_chain` across neighbors | receipts.md | `chain_check_and_monotonic_selection` |
| T5 | Split one box into many nodes or UIDs (sybil) | Operator | Dedupe by /64, /24, ASN; coverage paid once per group; capacity tests measure the shared pipe; `proportional_ppm` preserves `<1 ppm` active UIDs before `apply_share_cap` | identity.md, scoring.md | `sybil_splitter`, `test_share_cap` |
| T6 | Fake geography for coverage bonuses | Operator | RTT triangulation from several vantage points; speed-of-light bounds | measurement.md | — |
| T7 | Solver copies the leader's or reference solver's table | Solver | Commit-reveal; incumbent margin `EPSILON_ROUTE`; non-reference copycats within `EPSILON_ROUTE` of the reference solver's score or duplicating an earlier solver's `gains_ppm` profile are disqualified | routing.md, scoring.md | `test_mech1_scoring_and_red_team_guards`, `mech1_red_team_solver_attacks`, `unearned_weight_to_owner_hotkey`, `unearned_weight_goes_to_the_first_party_uid`, `unearned_weight_without_a_first_party_uid_is_reported_not_assigned` |
| T8 | Solver colludes with operators or manipulates `est_us` (`predicted_us`) | Solver + operator | Usage concentration cap; sampled testing of paths; churn penalty; `predicted_us` computed deterministically from snapshot (`route_predicted_us`), never from solver `est_us` | scoring.md, routing.md | `shortest_path_works`, `mech1_red_team_solver_attacks` |
| T9 | Validator copies others' results (weight copying) | Validator | Commit-reveal of probe results; Bittensor commit-reveal for weights | measurement.md | `http_object_reveal_and_receipt_upload_roundtrip` |
| T10 | Validators disagree honestly and get clipped by Yuma | Validator | Score from pooled lower-median results, not private views | measurement.md | `test_lower_median`, `end_to_end_multi_validator_tempo_determinism` |
| T11 | Owner farms its own mechanism | Owner | Reference solver's share (winner or runner-up), all-negative solver rounds and a Mechanism 0 with nothing earned are unearned weight: it goes to the disclosed first-party UID (`TempoInput::first_party_uid`, under a separate coldkey), never an owner-coldkey hotkey or a burn UID (retired, Task 15). With no first-party UID it is assigned to nobody and reported as `TempoOutcome::unearned_ppm`, and the live loop refuses to submit | scoring.md §Unearned weight and the first-party UID | `test_mech1_scoring_and_red_team_guards`, `mech1_red_team_solver_attacks` |
| T12 | Abuse traffic exits through operators | User | Transit operators never egress (`ForwardingTable` drops non-`fc00::/8` on non-exits); exits only via registered exit partners (ADR-0004) and registered gateways (ADR-0052) with abuse handling | ADR-0004, datapath.md | `forwarding_enforces_adr0004_and_multi_hop_counters_and_receipts` |
| T13 | Probe agent IPs fingerprinted, canaries recognized | Operator | Rotate probe source IPs; route canaries through ingress nodes like real traffic | measurement.md | — |
| T14 | **MITIGATED (Pass-5 CRY-1, ADR-0023): node-key `node-consent` required; unconsented claims ignored, not quarantined; `run_tempo` uses `resolve_live_bindings_with_consent`.** Was: Binding-conflict griefing: a UID lists competitors' public node keys in its own hotkey-signed `NodeBinding`, so those nodes are quarantined ("counts for neither") and their owners lose all capacity and usage credit | Operator | None today: `NodeBinding` carries no node-key consent. Proposed fix: require a per-node consent signature (node key signs `(netuid, hotkey, not_before, not_after)` under a new domain) and ignore unconsented entries instead of quarantining | identity.md, `identity::resolve_live_bindings` | — (proposed `binding_griefer`) |
| T15 | **MITIGATED (Pass-5 SCR-1): share cap always applies; a UID can at most double its own share from redistributed excess (`USAGE_CAP_REDIST_MULT_PPM`); sim `dust_cap_harvester`.** Was: Share-cap dust capture: when an attacker adds dust UIDs (≥1 ppm of usage) to bring active usage UIDs to ≥ ⌈1e6/cap⌉, `apply_share_cap` water-fills the whale's clipped excess into the dust UIDs (4 active UIDs at a 25% cap means every UID ends at 250_000) | Operator | None today. The `test_share_cap` cases assert this outcome. Proposed fix: burn clipped excess, or never raise a UID above its uncapped share times `PPM/(PPM-excess)` | scoring.md §Concentration cap, `scoring::apply_share_cap` | `test_share_cap` (shows the behavior; proposed `dust_cap_harvester`) |
| T16 | **PARTIALLY MITIGATED (Pass-7: attested `free`).** **Residual, shared-hop coverage capture (ADR-0037, fix round 1):** hop receipts carry no class, so pass 2 can fill an attacker route's client coverage with other flows' bytes on a hop it shares with them. With trusted vouchers, `paid` on the attacker's route is at most `min(Q, smallest shared-hop total)` for voucher quota `Q`, so the gain is at most `0.5 * (1 + RECEIPT_TOLERANCE_PPM)` weighted credit per voucher byte, `0.5 * Q * (1 + tol)` (re-derived by the red team, ADR-0037 fix round 4; sim `shared_hop_coverage_capture`, bounded there, measures 0.5 Q). With an empty allowlist only the hop totals bound it, so a non-empty `trusted_issuers` (or another way of choosing trusted issuers) is a mainnet launch requirement (`scoring.md` parameter table). With `trusted_voucher_issuers` set, validators credit `free` bytes on a route only up to client receipts that the trusted egress itself uploaded for that `(ingress, egress)` pair, minus paid coverage (receipts.md §Attested free; sim `unattested_free_fabricator`: 1 TiB fabricated `free` earns 0). The daemon now loads the issuer allowlist and vouchers (M4-07). Still OPEN: an allowlisted exit can attest arbitrary `free` bytes (a trust residual, bounded by `W_FREE` and the per-hop capacity cap); with the policy on, `free` on pairs that do not end at a trusted exit earns nothing (OQ-23); the policy is off when the allowlist is empty. Pass-6 status: **PARTIALLY MITIGATED (Pass-5 SCR-11; Pass-6 TV-28): credited bytes per hop capped at verified capacity x window duration; sim `closed_loop_fabricator`. Pass-6: with `TempoInput::trusted_voucher_issuers` set, `paid` coverage per `(client, egress)` is capped by trusted-issuer voucher quota (issuer = egress) and uncovered paid bytes become `free`; node side `BWOS_TRUSTED_VOUCHER_ISSUERS` (`vpn::check_trusted_voucher`) refuses paid sessions without a trusted voucher. Still OPEN: crediting `free` bytes only with issuer-attested client receipts; the daemon does not yet feed the registry (M4-07).** Was: Fabricated bytes on an assigned path where the attacker controls every node: demand pairs are every measured `direct` pair, so routes between an attacker's own nodes (in different UIDs) get assigned. Co-signing and the chain check prove nothing when one party controls both ends, so credit is bounded only by `MAX_CLIENT_BYTES_PER_WINDOW` (100 TiB) per hop and class | Operator (2+ UIDs, incl. ADR-0022 private fabric opt-in) | None today. Proposed fix: cap credited hop bytes at `min(link avail_mbps, node verified caps) * window_secs / 8`; credit `free` only with issuer-attested client receipts; do not build demand pairs whose src and dst are both unconsented same-owner nodes | receipts.md, measurement.md, `validator::ingest_and_verify_receipts_with_failover` | — (proposed `closed_loop_fabricator`) |
| T17 | **PARTIALLY MITIGATED (Pass-5 SCR-9/SCR-10; residual is T23): Mechanism 1 scores a trimmed mean (`GAIN_TRIM_TOP_PPM`), no Mechanism 0 credit on negative-gain routes, each byte credited once per path; sim `bottom_half_self_dealer`.** Was: Lower-median self-dealing: a winning solver can reroute up to ⌊(n-1)/2⌋ of its lowest-gain demand pairs (e.g., ones that should go direct) onto paths of up to 16 nodes through its own operator UIDs without changing `lower_median(gain_p)`. Each interior node is credited for both adjacent hops (2× bytes) | Solver + operator | None today. Proposed fix: score with a trimmed mean or a low quantile (e.g., p10) instead of the median; give mech0 usage credit only for pairs with `gain_p >= 0`; credit each flow once per path, not per node-hop | scoring.md §Mechanism 1, `validator::evaluate_solver_table` | — (proposed `bottom_half_self_dealer`) |
| T18 | **MITIGATED (Pass-5 SCR-2/SCR-3): missing probes and capacity tests count as failures; failed capacity tests record 0 Mbps; sim `probe_dodger`.** Was: Unmeasured means perfect: `compute_uptime_ppm(&[]) = 1e6` and `Q_n` defaults to `PPM`, and links with `rtt<=0` are dropped from the next snapshot. A node that blackholes link probes (while still answering capacity tests, which it learns about one block ahead) drops out of the snapshot and then keeps `A_u = 1e6` and full capacity credit with zero transit obligation | Operator | None today. Proposed fix: compute uptime over every live node's scheduled probes, count a missing measurement as a failure, and give `A_u = 0` to a node with no snapshot links | measurement.md §Uptime, `probe::compute_uptime_ppm`, `validator::run_tempo` | — (proposed `probe_dodger`) |
| T19 | **HEADER PART SETTLED (ADR-0037, proposed); other leaks stand.** Overlay links carry plain inner IPv6 with no class on the packet, so a relay has no class byte to read, mask, flip or forge, and hop receipts carry one unsplit `total`, never per-class counters. A relay that serves canaries well and degrades paid traffic can no longer tell them apart by a header byte or be paid differently per class on its hop (sim `class_relabeller`). Still OPEN: source address (public probe keys), size/rate profile (`datapath.md` §Residual leaks), and canary credit, which now has to come from the validators' own records (OQ-17). **Canary plans (Task 14, ADR-0051, ADR-0053; not scored until PB-38).** Canary-stream timing is no longer public: each validator's timing, sizes and classes come from its own secret plan, committed in its manifest at window open and revealed after the window ends (`measurement.md` §Canary plans). Which pairs carry how many bytes is a public draw from the committed seed and snapshot, weighted by bounded deduped verified capacity and capped per node, per UID and per path, and every validator's reveal must spend exactly its stake share of every pair. Shaping follows fabric-wide `GlobalMarginals` only (the default mix until PB-38 or PB-39 adds a producer). Validator-run nodes source and sink the stream and hold its sampling keys. Canary bytes come out of receipt usage and never reach a paid-traffic trigger. What is hidden: within an allocated pair a node can't predict a flow's start, size or class, and guesses on them gain nothing beyond sampling noise (sims `canary_favourer`, `canary_slot_presence`). What isn't: the pair (T145), and the packet shape and validator source address (T148). `validator_canary_alloc_favour` fails its reveal; `canary_alloc_node_count_sybil` gains nothing per unit of deduped verified capacity, and `canary_alloc_uid_split` holds one UID to the water-filled cap. Fix round 1 also pins the stake shares and the counting commitment to the seed block, and requires a fresh secret every window. **Known residuals, for PB-38 and PB-39:** (1) before paid traffic exists every transit flow is a canary, so there is nothing to hide among and only the end-to-end check protects; (2) flows to or from validator-run nodes can be spotted by the node next to them. Also T145 (public allocation pairs), T146 (a validator's plan isn't secret from the validator) and T147 (splitting above the per-node weight cap). The probe schedule for `link:`, `path:`, `route:` and `direct:` samples stays public. New exposure: a relay's paid/free split now depends on the ends' client receipts and attestation alone (`scoring.md` §Byte crediting 0). Residuals pinned by sims: shared-hop coverage capture (see T16; at most `0.5 * Q * (1 + tol)` weighted with vouchers, `shared_hop_coverage_capture`), colluding ends claiming a whole path as `paid` (bounded by the smallest hop total without vouchers and by `min(Q, T)` with them, `end_split_shifter`). **Hop crediting order (ADR-0037 fix rounds 1-3).** Unsplit totals made the greedy crediting pass order-dependent. Fix round 3 replaced it with order-free crediting (`scoring.md` §Byte crediting 0).
- **One-hop griefing (rounds 1-2).** Uncovered traffic on a 1-hop route no longer marks a shared honest hop inflated, with or without an allowlist (`one_hop_free_griefer`).
- **F1 (HIGH).** A covered 1-hop route could swallow a shared hop and get it flagged, zeroing the paid paths through it (`covered_one_hop_swallow`).
- **F2 (HIGH).** A 1-hop route's inflated weight could carry a regret-gated path's bytes on the shared hop into an ungated path (`one_hop_weight_regret_bypass`, also with a shared dedupe group).
- **F3 (MEDIUM).** A covered path could take another path's share of a shared hop and get that path's next hop flagged (validator test `adr0037_fix3_a_covered_path_never_takes_another_paths_share`).

What the sims and tests prove:
- Honest traffic never flags a hop (by construction, and by the 500-seed property test, allowlist on and off).
- A forged 1-byte client receipt never lowers any hop's weighted credit. Per dedupe entity, it moves at most `[SCR-10]`'s floor remainder, one byte of each class per incident hop, with random regret gates, dedupe groups and pairs with two paths (fix round 4).
- A gated or suppressed path that carried nothing never lowers anyone's credit (fix round 4, T23 Finding 1, `borrowed_weight_gate_griefer` and the property test).
- F1 costs its victims nothing in either mode.
- F2 gains nothing with the allowlist. With a bought voucher of `Q` bytes it captures at most `Q * (1 + tol)` per shared hop (fix round 4, LOW). Without the allowlist, the 1-hop route's `free` is credited (T16).
- An inflated hop under the allowlist earns at most its attested `free`.
- Colluding adjacent hops hiding inflation behind a 1-hop route earn no more than fabricating on that route alone (`adjacent_hops_hide_inflation`).

Not proved: inflation is now flagged only above the sum of path bottlenecks, which is looser than the greedy pass when paths overlap. With the allowlist the unflagged bytes earn nothing, because coverage and attestation still cap credit. Without it, looser flagging lets a colluding middle pair `(b, c)` on overlapping paths add up to one path's flow on their hop without owning either end of any path, and those bytes earn `W_FREE`. This applies only without the allowlist; with it, those bytes earn nothing (T16). Pass-7 status: **PARTIALLY MITIGATED (Pass-7, ADR-0026).** A 6-bit keyed tag over the class (`packet-class-tag`) in the upper bits of masked byte 5 rejects at least 63/64 of byte-5 tampers (exhaustive test `t19_class_tag_rejects_single_byte5_tamper_exhaustively`), so the malleability residual is a 1/64-per-packet guess that only moves credit between classes. Relays forward masked packets without unmasking them and count their bytes in one per-peer total, never the per-class counters behind hop receipts; masked bytes therefore earn no hop credit until hop receipts carry an unsplit total (OQ-17). Other leaks below still stand. Pass-6 status: **PARTIALLY MITIGATED (Pass-6, ADR-0024).** `OverlayPacket::encode_masked` blinds header byte 5 with a 2-bit pad keyed by an endpoint-only `mask_key` (`packet-class-mask`), so a relay sees the class byte uniform over `0..=3` (`t19_*`). Masking is opt-in and v0 hop receipts still split canary bytes. Still OPEN: source address (public probe keys), public schedule timing, size/rate profile, `flow_id`, per-class hop receipts, and malleability (a relay can flip the masked bit to downgrade credit: griefing only) (`datapath.md` §Residual leaks, OQ-17). Earlier status: **OPEN; the payload fix does not close it (red-team re-check).** SCR-6 made canary payloads fully random, but the overlay header still carries `TrafficClass::Canary` (byte 5, `dataplane.rs` ~L191), which every transit hop reads, and hop receipts count canary bytes separately. A node can serve canaries perfectly and degrade paid traffic. The `paid_degrader` sim (0.89x) assumes canaries can't be told apart, so it does not test this. Fix needs a wire-format ADR: drop the class byte from the hop-visible header (or encrypt it end to end to the validator), and stop hop receipts splitting canary bytes. Was: Canaries are distinguishable: UDP canaries start with the plaintext magic `PIPR` and use deterministic SHA-256 padding, and the schedule is public at window open. Transit nodes can serve canaries well and degrade paid traffic (T2/T13 mitigations do not hold) | Operator | Proposed fix: encrypt canary payloads end to end, without a magic prefix or recognizable padding, so they look identical to paid sessions; make the schedule commit-reveal per validator | measurement.md, receipts.md, `probe::run_udp_canary_probe` | `canary_only` (assumes indistinguishable canaries, so it does not cover this) |
| T20 | **PARTIALLY MITIGATED (Pass-7, ADR-0025).** Price floor `MIN_VOUCHER_ALPHA_PER_GIB` (1_000 raw α/GiB): a voucher backs at most `effective_max_paid_bytes = min(max_paid_bytes, alpha_credit_u64 * 2^30 / floor)` on nodes (`verify_for_session`, `check_trusted_voucher`) and in validator TV-28 quotas; the daemon loads the allowlist and vouchers (M4-07). Still OPEN: the floor applies to the issuer-declared `alpha_credit_u64`, not a proven burn, and the placeholder value needs calibrating; allowlist governance (OQ-14, OQ-19). Pass-6 status: **PARTIALLY MITIGATED (Pass-6, TV-28).** Validators with a non-empty `trusted_voucher_issuers` allowlist only count paid bytes covered by trusted-issuer vouchers, so a self-issuing exit outside the allowlist earns no paid credit (`t20_*`). Still OPEN: who governs the allowlist (on-chain exit-partner registry), the α price floor, and wiring it into the daemon (M4-07). Earlier status: **OPEN (red-team pass 5; design question OQ-14).** The issuer can be the attacker's own exit, so a voucher signature check in scoring proves nothing; needs on-chain burn proof or an exit-partner registry. `receipts.md` no longer claims negative-EV. Vouchers are not enforced in scoring: `BandwidthVoucher` (burn, `max_paid_bytes`, window) is checked only by the ingress and exit nodes, which are the attacker. The 5% burn applies to an issuer-chosen `alpha_credit_u64` with no price floor, so the "strictly negative-EV" claim does not hold for a self-issuing aggregator in `authorized_clients` | Operator + aggregator | Proposed fix: validators require a valid voucher per paid client receipt; enforce minimum `alpha_credit_u64` per byte so the burn is at least the expected emission per paid byte; define who governs `authorized_clients` | receipts.md §Vouchers, ADR-0019 | — |
| T21 | **MITIGATED (Pass-6, after the red team).** Probe medians are stake-weighted lower medians (`scoring::stake_weighted_lower_median`, `TempoInput::validator_stakes`); zero-stake validators don't vote, and a key is aggregated only if its reporters hold `PROBE_STAKE_QUORUM_PPM` (1/3) of all validator stake, so minimum-stake sybil validators can neither move a median nor complete one for a key nobody else reported. Residual: colluding validators with ≥50% of reporting stake, or ≥1/3 of stake on keys no one else reports; the count-based quorum fallback (empty `validator_stakes`) is for sim/localnet only, and testnet MUST supply metagraph stakes; the daemon does not yet load them (M4-07). Earlier status: **OPEN (red-team re-check, estimated).** Validator-median griefing: probe results are combined by a lower median taken per validator, not per unit of stake (`scoring::aggregate`), and `rtt_us = 0` sorts lowest, so ⌈n/2⌉ colluding (possibly low-stake) validators can fail any link or capacity test. Since SCR-2/SCR-3, those failures cost uptime (squared) and capacity. | Validator | Stake-weighted lower median with a 1/3 stake quorum per key (OQ-15 closed). | `measurement.md`, `scoring.md` | `t21_*` (incl. `t21_sybil_validators_cannot_complete_median_without_stake_quorum`) |
| T22 | **PARTIALLY MITIGATED (Pass-7).** `measurement.md` §Probe vantage: validator-run probe agents originate every probe class (`link:`, `direct:`, `path:`, `cap:`, `vantage:`), each sample is the agent's own clock timing (no subtraction of an endpoint-delayable leg), samples reach scoring only through the validator-signed `ProbeResultBatch`, and `current_snapshot` MUST be the previous tempo's `next_snapshot`. Still OPEN: the destination of a pair answers `direct:` probes outside the overlay and can inflate `direct_us`, raising the gain of routes ending at itself (OQ-16 a); `bwos-probe` does not run link/direct/vantage probes yet (M4-08). Earlier status: **OPEN (red-team re-check).** Endpoint-skewed probes: the specs don't say who sends link and `direct` probes. With 8 path probes per window, most gains come from predicted latencies, so an operator at either end of a pair can make an overlay route look faster than direct. | Operator | Fix: say in `measurement.md` which vantage sends each probe class (validator-run probe agents only) (OQ-16). | `measurement.md` | — |
| T23 | **MITIGATED IN THE LIBRARY (Pass-7, three red-team rounds plus a fourth patch; `top_quartile_dealer` 1.00x).** Mechanism 1: `PER_HOP_LATENCY_OVERHEAD_US` (500) per interior hop in `route_predicted_us` and every reference search, and a regret penalty (`REGRET_WEIGHT_PPM` 1.0x) on the mean per-pair regret over all pairs, trimmed ones included, against a capacity- and class-aware comparator judged on the route's unloaded values (realtime regret is measured on the reference realtime metric `lat + loss + hop + 2*jitter`, so neither a slower low-jitter nor a faster high-jitter detour is free) (`routing::table_route_regrets`, `scoring::mech1_shares_with_regret`). Mechanism 0: a path's credit is zeroed when its route's predicted latency exceeds the comparator by more than `ROUTE_REGRET_TOLERANCE_PPM` (100_000), averaged over the classes sharing the path; each path pays at most once per UID and per `node_diversity` group (16 alternating keys: 14/15 -> 1/15 with endpoint data, 2/15 without). Reference-solver tables are never gated (0 of 10,583 routes in a 400-trial scratch run; sim `reference_solver_gate` 0 of 741). Residual: the production solver can halve an honest relay's credit by adding one regretful class route to its path (needs per-class hop receipts); bulk prefers any wider path within 1.5x direct (ADR-0018); saturation hiding; group dedupe needs validator-supplied `node_diversity` (OQ-19, OQ-23). **Finding 1 (ADR-0037 fix round 4, HIGH, fixed):** per-path apportionment divided a shared hop by the sum of its paths' weight bytes, which are bottleneck bounds and can count a neighbour path's bytes, and zeroed the gated paths' portion. So a gated or suppressed path that carried nothing took, and forfeited, honest endpoints' share. Measured: a gated 1-hop beside an honest 2-hop, no allowlist, cost the ingress 50% and the relay 25%; with the allowlist and a forged voucher receipt, the exit lost 50%; `n` gated paths cut an honest endpoint to `1/(n+1)`. The denominator is now `min(Σ w, credited bytes)`, so a gated path forfeits only what the hop credited beyond the eligible weight (`scoring.md` §Byte crediting 7; sim `borrowed_weight_gate_griefer`, honest loss 0, with a dedupe-group suppression case; the property test in `validator::tests`). **Residual P1, gated-flow escape (fix round 5):** the other side of the same rule. An eligible path's borrowed weight can cover a gated path's real flow on a shared hop. With the allowlist that weight is bought coverage, so the escape is at most `Q * (1 + tol)` per shared hop for a voucher of `Q` bytes (`one_hop_weight_regret_bypass`, LOW). Without the allowlist, a gated path's `paid` flow on hop `k` escapes by up to `min(gated flow on k, Σ eligible borrowed weight on k)`, so up to its full flow, and the escaped bytes are credited at `W_PAID`, not `W_FREE`. Honest busy neighbours trigger it with no attacker: sim `gated_flow_borrowed_escape` measures 1.0x the ungated credit (pinned at bound 1.0). Follow-up: PB-32. **Residual P2, `long_path_l_dilution` (pre-existing, not a regression of fix round 4):** `[SCR-10]` divides a hop by the hop count `L` of the longest active path through it, so a gated long path through an honest 1-hop route's hop dilutes that route's endpoints even though it forfeits only its own weight: -66.6% at 3 hops. Planned fix: divide each path's portion by its own hop count. Sim `long_path_l_dilution` is planned under PB-32. **Residual P3, `group_keeper_flip` (pre-existing):** a node co-located in a dedupe group can pad its traffic within tolerance to raise its credit estimate on a shared path and take the keeper role from another member, including one with a different UID. Planned fix: split kept credit pro rata across members with different UIDs. Sim `group_keeper_flip` is planned under PB-32. Earlier status: **OPEN (red-team re-check, measured).** Trimmed-mean top-quartile dealing: Mechanism 1 drops the top 25% of gains (`GAIN_TRIM_TOP_PPM`), so a winning solver can push its best ⌊n/4⌋ pairs down to the trim cutoff and through its own nodes with identical score (150,000 ppm both ways); those routes still have gain ≥ 0 and earn Mechanism 0 credit. With per-path credit (SCR-10), 16 node keys on one host alternating between two UIDs capture 14/15 of a path's credit (estimated 1.87x). | Solver + Operator | Fix: penalise every overlay pair whose gain is below the best known route; per-hop latency charge in `route_predicted_us`; credit per distinct physical host/AS, not per key. | `scoring.md`, `routing.md` | — (proposed `top_quartile_dealer`) |
| T24 | **MITIGATED when validators supply `node_diversity` (Pass-6 red team; sim 1.772x -> 1.000x for /24 and tunnel-broker /48 splits).** Each node has one dedupe group (its IPv4 /24, else its IPv6 /32 so that tunnel-broker /48s pool; no transitive merging, so a bridge node cannot pool unrelated operators); a group's capacity is pooled to its largest member and split pro rata, and the usage cap applies per group, then per UID (`scoring/diversity.rs`, `scoring.md` §Endpoint dedupe). `node_diversity` MUST be derived by the validator from probed endpoints, never self-reported; the daemon leaves it empty today (M4-07). Residual: an attacker can still spread over genuinely distinct /24s or /32s; co-location griefing halves a victim at the cost of the attacker's own capacity; honest co-located or IPv6-only operators in one /32 are underpaid (OQ-20). Earlier status: **ACCEPTED RISK (T5 design point, measured 2.4x).** The always-on usage share cap (SCR-1) pays a whale to split into sybil UIDs, each below the cap. Bounded by the /64, /24 and ASN dedupe in T5, which is specified but **not implemented in code** (red-team re-check). | Operator | Endpoint dedupe per /24 or /48 group with a pooled capacity and a per-group usage cap. | `scoring.md` | `prefix_sybil_splitter`, `t24_*`, `scr1_*` |
| T25 | **MITIGATED (red-team round 2, RT2-1; measured: fleet 2 -> 0 live nodes).** Binding replay: an operator re-signs its `NodeBinding` while the old one is still live and committed; anyone replaying the old binding made both count as a same-UID conflict and quarantined the whole fleet | Anyone | Per UID and per `(netuid, hotkey)`, only the live binding with the greatest `not_before` counts (as for `wg-binding`); an exact tie between distinct bindings is rejected | identity.md §Binding resolution | `binding_replay` (sim + `identity` unit test) |
| T26 | **MITIGATED (red-team round 2, RT2-2; measured 2.66x honest before, 0.64x after, 5 of 10 attackers; Pass-6 sim `incoming_blackhole` 0.497x, up from 0.408x, because honest peers now take at most one charge each after the blackholer's one-sided cap; the blackholer is still charged every failure).** Incoming-probe blackhole: uptime charged only a node's outgoing links, so a node dropping every inbound probe (unroutable, zero transit obligation) kept full uptime while honest peers absorbed the failures | Operator | Every aggregated link result counts for both endpoints (`node_probe_evidence`) | measurement.md §Uptime | `incoming_blackhole` |
| T27 | **MITIGATED (red-team round 2, RT2-4; 1.0x -> 0.8x).** Haircut dodge: `run_tempo` evaluated the overclaim haircut against the current declaration only, so lowering it after a failed test lifted the haircut at once | Operator | Haircut checked against the peak declaration over the last `CAP_PENALTY_WINDOWS` windows (`TempoInput::declaration_history`, `tempo_verified_capacities`). Pass-6: `bwos-validator --state-dir` persists both histories per window in `cap-history.json` (`cap_history.rs`, canonical JSON, atomic 0600 write, bounded to `CAP_PENALTY_WINDOWS` = 24, a corrupt file is set aside and history restarts empty), so the haircut survives restarts. Residual: a validator with lost history diverges from its peers for up to 24 windows. Under ADR-0039 team tests, the haircut is judged per test against the rate actually pushed, because the ramp pushes less than the declaration. So a dodger's haircut lifts once passing re-tests are half its rolling history, about 12 windows rather than 24. `CAP_PENALTY_WINDOWS` stays at 24, and the bound is restated as dodger ≤ honest: the dodger is haircut while its failed tests are the majority, and is never credited above what it carries (red team RT7). Task 4Dc re-ran it under the team rule as `declaration_dodger_team` (dodger ≤ honest; `declaration_dodger` still guards the single-agent rule, which runs until team mode) | capacity-bonds.md | `declaration_dodger`, `declaration_dodger_team`, `end_to_end_multi_validator_tempo_determinism`, `cap_history_restart_preserves_overclaim_haircut` |
| T28 | **PARTIALLY MITIGATED (Pass-7, library).** Validator-declared simultaneous cohort tests (`ProbeResultBatch.cap_cohorts`, cohort-derived `test_id`s): a /24 or IPv6 /32 group is credited `max(largest single, min(cohort aggregate, sum verified))`, keyed by member list over members with capacity (burners excluded), lower median of samples in the last `CAP_COHORT_FRESH_ENTRIES` (8) entries, chunks never summed (sims `colocated_cohort_honest` 1.000x, `sequential_key_replay` 1.000x, `cohort_burner_griefer` 1.000x); the daemon persists cohort history (M4-07). Still OPEN: `bwos-probe` does not schedule or stream cohort tests (M4-08), so cohort credit is dormant in deployment; N keys on one box seen in different /24s (OQ-18). Earlier status: **PARTIALLY MITIGATED (red-team round 2, RT2-3; shared foreign sink 4.0x -> 0).** Shared capacity-test sink: the delivery digest was not bound to the node key and the sink was unauthenticated, so N node keys could point at one real sink (another operator's, or one shared box) and each earn full capacity credit (70% of Mechanism 0, and the T16 byte cap). Now the sink must return a `cap-test-ack` signed by the tested node's key over the validator-chosen `test_id`, stream digest and byte count; validators score unacked samples as 0 Mbps. **Still OPEN:** one operator holding all N keys on one box can answer N sequential tests (OQ-18); Pass-6 endpoint dedupe (T24) pools the capacity of nodes in one /24 or /48 when validators supply `node_diversity`, which bounds this for co-located keys | Operator | Simultaneous testing of nodes in the same endpoint /64, /24 or ASN (needs an endpoint registry, T5) | measurement.md §Capacity tests, capacity-bonds.md | `shared_cap_sink`, `rt2_3_*` |
| T29 | **PARTIALLY MITIGATED (Pass-7, three red-team rounds plus a fourth patch).** Link blame is corroborated by validator `vantage:<node>` probes; a peer moves a node's uptime and `Q_n` only by `min(cap_peer, cap_node)/cap_node` of pooled (T24/T28) scoring capacity; zero-capacity peers are never evidence and zero-capacity nodes do not count toward their UID's uptime; an isolated end charged together with a non-isolated one pays `min(cap)/max(cap)`; fleet uptime weights each node's samples by its scoring capacity, so a small fleet member cannot dominate it; a vantage-failing node that passes no link and is peered with at least `MIN_DARK_PEER_UIDS` (3) other UIDs takes its failures alone; a neutral failure gives the dropping side a `Q_n` sample at its lowest other sample; the daemon retains revocations and highest-`seq` consents (M4-07). Measured: `asymmetric_sybil_framer` 1.30–2.13x -> 1.000x (attacker total); shared-pipe sybils 1.70x -> at most 0.93x total; big node vs small victims: victims 0.84x -> at least 0.987x (sim `big_node_griefer`: 0.998x); dark node's peers unharmed; small fleet-mate framing victim 0.70x / attackers 1.14x -> victim at least 0.977x / attackers at most 1.001x in that configuration (sim `small_fleet_mate_framer` over six fleet mixes: attackers at most 1.001x, victim at least 0.917x), and a genuine fault on a small fleet member 0.19x -> 0.95x of the fleet; `sparse_victim_framer` 1.07x -> 1.043x. Still OPEN: a sybil majority with full-capacity sybils gains 1.04–1.09x; an attacker owning all (three or more, `MIN_DARK_PEER_UIDS`) peer UIDs of a node whose vantage probes are blocked can zero it (attackers 1.08x); sybils on one pipe seen in different /24s are not pooled (OQ-18); `bwos-probe` does not run vantage probes yet (M4-08). Pass-6 status: **PARTIALLY MITIGATED (Pass-6 red team, four rounds; burner 1.737x -> 1.000x, fleet blame-shift 1.82x -> 0.024x, sybil-UID blame-shift 1.24x -> 0.971x, sparse-victim framing 1.35x -> at most 1.07x).** Link results count only between live nodes of different UIDs on a current snapshot link or production route hop. Each failed link gets one verdict per window: it is charged to the end whose pass rate, leaving out every link with the other end's UID, is lower by more than `LINK_BLAME_MARGIN_PPM` (100_000), otherwise to both ends. A node can be blamed alone at most `MAX_ONE_SIDED_CHARGES_PER_NODE` (2) times per window, unless no validator has seen it serve (zero verified capacity and no passing acked capacity test) and its rate is strictly below `ONE_SIDED_EXEMPT_RATE_PPM` (250_000); at most `MAX_CHARGED_LINK_FAILS_PER_UID` (2) charges per other UID; failures charged to both ends cost uptime only (`validator.rs` `LinkAttribution::new_with_vantage`). Consents can be withdrawn or moved at once with a higher-`seq` node-signed `NodeConsent` (`revoked: true` withdraws); the highest started `seq` per (node, netuid) wins and lower `seq` can't be replayed (`identity::effective_consents`). **Still OPEN:** symmetric griefing by sybil UIDs that hold about half the network: once both ends pay, the larger side still gains share, worse when honest probe degree is sparse (attackers at most 1.07x, victims about 0.33x); closing it needs link evidence peers can't fake (validator-vantage link probes, OQ-16) or a per-UID cost. A revocation counts only once validators see it. Earlier status: **OPEN (red-team round 2 re-check, estimated, not simulated).** Burner-peer link griefing: an attacker binds zero-capacity node keys (nothing to lose) that drop probes to and from victims. Each failed link costs the victim uptime and an outgoing `Q_n = 0` sample. This predates RT2-2: outgoing failures were already charged to the victim, and RT2-2 also charges the burner and adds incoming passes, so the victim's pass ratio does not get worse. Estimated about 3–4x honest against 9 victims. Also open, and predating RT2-1: a node's older, still-live `node-consent` cannot be withdrawn, so a node moved to a new operator is quarantined until that consent expires | Operator | Snapshot/route-hop-gated, cross-UID link attribution with leave-one-UID-out blame; sequenced consents with revocation. | measurement.md §Uptime, identity.md | `burner_peer_griefer`, `fleet_blame_shifter`, `sybil_uid_blame_shifter`, `sparse_victim_framer`, `incoming_blackhole`, `t29_*` |
| T30 | **MITIGATED (`[INCENTIVE-HOP-01]` red team F1, F4).** Relay hop inflation: with hop-by-hop receipts, a relay that co-signs for any sender lets anyone (a fresh key acting as its own ingress, with a self-signed client receipt and a next hop it chooses) push bytes from sessions no production route carries onto a hop between two honest relays. The validator then flags that hop as inflated and zeroes every route through it. A related variant: two same-`seq` proposals from one upstream left a downstream hop advanced without its upstream hop | Anyone | A relay co-signs only on a path `bgp_path + [self, next, …]` that runs from `client_receipt.ingress` to `client_receipt.egress` and is a `path`/`backup_path` of the production table installed on it (`POST /exit-route-table`, `-route-table`), forwards only to registered peers at their registered endpoint, and serializes per upstream node from check to commit. Residual: a node that is itself the ingress of a production route can still send real, client-receipt-backed traffic over it (that is ordinary usage). Sybils on one relayed path still get interior credit if T23 dedupe has no endpoint data | receipts.md §Overlay data plane, TV-31 | `incentive_hop01_relay_refusals_commit_nothing` |
| T31 | **PARTIALLY MITIGATED (`[INCENTIVE-HOP-01]` red team F2, F3).** Relay lock griefing: per-node proposal locks are held across the forward, so a request pointing the relay at a stalling server, or many junk next-hop keys, could block a relay's traffic to a node or fill its lock table | Anyone | Locks exist only for registered peers and production-path upstreams, next hops must use their registered endpoint, and every lock wait gives up after `HOP_LOCK_WAIT` (10 s, `503`). Still OPEN (OQ-27): a slow registered peer still delays traffic to it; concurrent paths that wait on each other's locks in a cycle clear only at the deadline; a downstream that commits after its upstream timed out leaves `seq` out of step until the window rolls | receipts.md §Overlay data plane | `incentive_hop01_relay_refusals_commit_nothing` |
| T32 | **MITIGATED (Task 6d).** Wheel table: a solver submits a table whose next hops towards a destination cycle, through backups behind its primaries or through classes that disagree. Backups of healthy primaries aren't scored, so a ring of backups scored the same as an honest table, while handing BGP a dispute wheel that flaps once the primaries fail (OQ-34) | Solver | A table is valid only if, for every destination, the next hops of all its routes, `path` and `backup_path` across classes, are acyclic (`Table::next_hop_cycle`); an invalid table scores `-1e6` per pair, and nodes refuse it | routing.md §Validation, "Next hops settle" | `backup_wheel_solver`, `every_valid_table_settles_whatever_links_fail` |
| T33 | **MITIGATED (Task 6d red team, fix 1).** Forced-detour dealing: with the next-hop rule, a destination whose classes want conflicting next hops forces some route onto a slower path. Regret's comparator was the unconstrained best, so the forced detour looked like regret, and the Mechanism 0 gate zeroed every relay on it; a solver that runs relays could aim the detour at a rival's pair and zero the rival at almost no cost | Solver + Operator | The comparator keeps the table valid too: when a best path would close a cycle with the other routes to the destination (the route's own backup included), the comparator is the reference solver's route for the pair, so a forced detour the reference also takes carries no regret and its relays keep their credit (round 2: no longer searched within the submitted table, T36); the reference solver moves each route onto its comparator until none is better (`settle_regret`), so its own tables carry none. Residual (round 3): a solver can force the reference branch with a backup of its own, but the comparator is then the reference's route, so it only substitutes a relay that is equal or better, and only on pairs the reference already detours. By design: an honest solver that resolves a conflict differently from the reference pays bounded regret (at most `1e6` ppm of the pair's direct latency) on each pair it resolves worse, as routing.md item 4 states. The reference route is taken without the capacity and attribute checks of items 2-3 (no practical harm in 60 random meshes; the spec says so) | routing.md §Route regret, scoring.md | `forced_detour_dealer`, `t23_reference_tables_have_zero_regret`, `t23_reference_tables_are_never_gated` (all-class, many sources per destination) |
| T34 | **MITIGATED for solvers that keep their last table (Task 6d red team, fix 2).** Contested-hop jitter: an operator swings the latency of a link it controls by ±15% each window. Under the next-hop rule one route's change towards a destination can push the others there off their paths, so an incumbent that re-solves from scratch churns every window and pays `CHURN_PENALTY`, which can hand the round to a challenger | Operator (against a solver) | `routing::stabilize_routes` keeps each route from the solver's previous table while it's still valid and within `ROUTE_SWITCH_MARGIN_PPM` (10%) of the new best, without closing a cycle, which stops the cascade; `bwos-solver -previous` and the prototype loop use it. Chosen over a latency-free conflict order because the order already doesn't depend on latency (class priority, then pair); it's the paths that move. Residual: a swing large enough to clear the margin still moves the routes it affects, as it should | routing.md §Reference solver, "Prototype loop" | `contested_hop_jitterer` |
| T35 | **MITIGATED (Task 6d red team round 2).** Stabilizer trap: a relay on an incumbent's kept path spikes its latency (68.5 ms against 40 ms direct) or its jitter past `MAX_REALTIME_JITTER_US`. The stabilizer compared only width, cost or latency and re-checked only path validity, so it put the old path back, which then scored a negative gain or `i64::MIN` | Operator (against a solver) | `stabilize_routes` keeps a path only if it still meets every limit of its class (`routing::meets_class_limits`: hop loss, realtime jitter, the class's latency ceiling against direct or the reference margin) and is within the margin by the class's scored measure, realtime's included. Round 3, capacity: under a per-pair demand a relay that cuts its self-reported capacity (1000 to 50 Mbps) made the fresh solve move off it, but the stabilizer kept the path with 3 overloaded nodes and links (`bwos-solver links` passed its demand without the guard `main.rs` had). A kept path must now carry the demand on top of the other routes' loads (`validate_path_slice` on the congested snapshot, then the demand against each residual), and a table that would overload more than the fresh one is dropped for it | routing.md §Reference solver | `stabilizer_trap` (limits and capacity) |
| T36 | **MITIGATED (Task 6d red team round 2).** Backup-shaped comparator: backups are unscored, so a solver that routes a pair through its own slow relay could give another route to the destination, or the route itself, a backup whose hops made the pair's real best path look cycle-closing; the comparator, searched within the submitted table, then became the solver's own detour (regret 500,000 -> 0 ppm, relay credit 0 -> 1,000,000) | Solver + Operator | When the best path would close a cycle, the comparator is the reference solver's route for the pair, which the submitted table can't move (`routing::regret_reference` on the same inputs, solved once per window and shared by every table's regret and the Mechanism 0 gate) | routing.md §Route regret, item 4 | `backup_shaped_comparator` (both shapes), `forced_detour_dealer` |
| T37 | **MITIGATED (Task 6d red team round 2, low).** Rank-tie grinding: the reference's re-search order broke equal-distance ties by lowest node ID, a public key an operator could grind to win ties | Operator | Ties are broken by a hash of the snapshot's window and the node ID (`next_hops::tie_key`), not known long ahead | routing.md §Reference solver | — |
| T38 | **OPEN, bounded (ADR-0039; scoring wired in Task 4B; producer pending).** Nothing fills `ProbeResultBatch.endpoints` in the daemon yet, so in production no node has an underlay and this term pays nothing until the endpoint producer lands (roadmap PB-06). Faked underlay diversity. (a) An ASN adds a "second upstream" by BGP over a tunnel through its first provider, for example a cheap VPS with a BGP session. That is real in RIS and RouteViews but fails with the first provider, and it also removes the `up:` SRG label the network should carry. (b) A node opens its validator sessions from a VPS in a rare network, so its committed endpoint and underlay ASN are that network's, while its overlay peers' traffic may take another path | Operator | (a) The diversity term saturates: two neighbours earn `DIVERSITY_WEIGHT_PPM`, now a low 50_000, and more add nothing. Diversity multiplies only carried bytes, never capacity. (b) Probe and collector sessions must share a source (RT1), so the node is tested through that VPS. Its capacity is what the VPS path carries. The data plane to its overlay peers is not tied to it. Undetectable from public data in Phase B (OQ-39). (c) AS-path poisoning: announcing `[.., A, X, A]` makes `X` look left of `A`. RouteViews paths in which an ASN reappears after another are dropped (`evidence::path_records`, Task 4C fix round 1), but RIPEstat `asn-neighbours` aggregates paths, so its `left` neighbours can still include poisoned ones; the term saturating at two neighbours bounds that as in (a) | measurement.md §Underlay, §Outside evidence, §STAMP probes and probe sessions, scoring.md §Coverage | `diversity_faker`, `roa_origin_shopper` (Task 4B), `as_path_poisoner` (Task 4C), `probe_session_forwarder` (Task 18a) |
| T39 | **OPEN, bounded (ADR-0039; scoring wired in Task 4B; producer pending).** Nothing fills `ProbeResultBatch.endpoints` in the daemon yet, so in production no node has an underlay and this term pays nothing until the endpoint producer lands (roadmap PB-06). Self-maintained outside evidence. PeeringDB entries and ASPA objects are published by the ASN holder, who may be the miner, so IXP presence and declared providers can be self-reported | Operator holding its own ASN | Neighbours come from public BGP paths seen by RIS and RouteViews. ASPA changes neither the count nor the labels, so publishing it is never penalised and faking it gains nothing. IXP presence is trusted from PeeringDB and bounded by `IXP_PRESENCE_WEIGHT_PPM` (a low 50_000, one IXP saturates). The underlay ASN needs an RPKI-valid origin seen in BGP, not a ROA alone. Residual: an attacker can register a fresh ASN per node and really announce each node's prefix from it, through its own AS and one upstream. Each fresh ASN then has two neighbours and a unique `as:` label, so it earns the saturated `DIVERSITY_WEIGHT_PPM` (at most 1.05x an honest single-homed node, on carried bytes only), for the cost of an ASN and prefix per node | measurement.md §Outside evidence, §Underlay | `aspa_honest_publisher`, `roa_origin_shopper` (Task 4B) |
| T40 | **MITIGATED in spec (ADR-0039).** A validator forges or withholds outside evidence to favour a friend's node or zero a rival's diversity | Validator | A record counts only when present in usable evidence from at least `MIN_VALIDATORS` hotkeys holding `PROBE_STAKE_QUORUM_PPM` of stake (`evidence::agreed_records`). Evidence is signed, committed through the manifest, retained and served for 25 windows, and aged out after `EVIDENCE_MAX_AGE_WINDOWS`. Only the newest object per `(validator, source)` counts. Scoring never reads evidence live (Invariant 1) | measurement.md §Outside evidence | `upstreams_and_ixps_come_only_from_committed_evidence` (Task 4B), `evidence_*` (Task 4C) |
| T41 | **OPEN, needs a founder decision (ADR-0039 §7, OQ-43).** Rented burst capacity. A node passes 60 s capacity tests on capacity it holds only briefly, rented or free under 95th-percentile billing, and is paid as if it were sustained. Measured against the schedule: at `CAP_TEST_PERIOD` 900 blocks a node gets about 8 tests a day. A 60 s test touches about 8 of a day's 288 five-minute billing buckets (2.8%), below the 5% that 95th-percentile billing discards, so the tests are free to a burst renter **Notice (Task 4Dc fix round 2, red team N5):** a test may wait up to `CAP_TEST_DEFER_BLOCKS` (4) blocks for its drawn team, so a node learns of a test up to `(CAP_TEST_DEFER_BLOCKS + 1) × 12 s` (about 60 s) before it starts, against 12 s without waiting. A burst renter still holds capacity from `b` to the test's end; the notice matters only for on-demand capacity that comes up in 12-60 s | Operator | Today: sustained 60 s team tests at unpredictable blocks, the rolling lower median of tests (`capacity-bonds.md`), and the test-rate ramp (RT4), which limits how fast any node's tested rate grows. Pay moves to carried paid traffic as it arrives: the capacity weight `W` stays `1_000_000` until attested paid traffic latches its trigger, then steps to 700_000 and the published schedule (Task 15, `scoring.md` §Capacity weight `W`). `burst_renter` gates (ratio to honest at most 1.0 once `W` < 1e6); `burst_renter_95th` and `burst_renter_prelatch_per_cost` (about 9.5x per unit of cost while pay is capacity-only, with the trigger gated off) are model-only until OQ-43, which the founder must decide before launch, and the diversity term pays only on carried bytes. The founder chooses between (a) accepting that verified capacity means port speed at bootstrap, and (b) testing at least 15 times a day, which roughly doubles validator traffic | measurement.md §Team capacity tests, scoring.md | `burst_renter`, `burst_renter_95th` (Task 15) |
| T42 | **OPEN, bounded (ADR-0039; in code, Task 4Dc: `probe::team_capacity_mbps`, `validator::tempo_team_stage`, sims below).** Team-test manipulation. (a) A node throttles one team member to make room for the others. (b) A member colluding with the node pushes nothing but reports its full share. (c) A griefing member withholds its batch, or zeroes or omits its sample, to cut a victim's credit or force a haircut. (d) A node serves members one after another, using their start skew. (e) An attacker splits stake across hotkeys to land two members on one team. (f) A node faster than the team can push hopes to be skipped and keep old history. (g) A node times its traffic around tests, or widens its receipt bracket, so background it didn't carry during the test is credited. (h) A validator publishes a tiny share budget to cap a victim's team rate while voting in the median | Operator, Validator | `team = min(declared, measured + bg)`, with `measured = min(Σ c_i, q * S)` (Task 4Dc fix round 1: capped `c_i` in the sum, T103), where `q` is the lower median of per-member ratios `c_i / rate_i`, with `c_i = min(m_i, rate_i)` and equal ratios ordered by the lower hotkey, over the members that revealed, and `S` is the summed rates of the whole scheduled team, revealed or not (OQ-93). All in kbps, `m_i` exact from the ack (OQ-91). The haircut reads `ratio_t = (q * S + bg) / pushed` with `pushed = min(declared, S)`, so the 10% headroom never counts against a node that carries its declaration (round 4 RR1, sim `headroom_underdeclarer`: under-declaring at `C / 1.1` at most 1.0x).<br>(a) A throttled honest member only lowers `Σ c_i`.<br>(b) Restated in Task 4Dc fix round 1 (red team F1): the colluder's share is capped at its rate, but the node can starve one honest member, which the lower median ignores, so it is credited `k-1` shares for `k-2` carried: 1.5x at `k = 4`, 2x at `k = 3` (sims `colluder_overreport_k4`, `colluder_overreport_k3`, `colluder_overreport_end_to_end`; 1.82x and 2.73x with the uncapped sum). The minimum team of 3 rules out `k = 2`. A test down to two revealed members (two withheld) still takes the median term, so one colluding member there gets the node at most two shares for one carried, 2x, with no `ratio_t` (sim `withholder_fix_k2_colluder`, 1.64x); one griefing member there can zero that test (round 5 D). A test with one revealed member isn't a sample (red team F9). A colluder with a far larger budget than its teammates takes the water-fill's remainder on nodes tested above `k × 2500` Mbps, about 1.7x instead of 1.5x with budgets 2500 × 3 and 100_000 (red team F7, documented, no code).<br>(c) A withheld batch is dropped from `Σ` and the median without rescaling, but stays in `S`, so withholding never haircuts an honest node and never lifts a node above an honest declarer of its real capacity (sims `withholding_near_declaration`, `void_by_withholding`; T102). A zeroed or omitted sample lowers `measured` by at most that member's share, `rate_i / S`. The haircut reads `ratio_t`, which comes from `q`, so a minority of members can't force one. A test with fewer than 3 revealed members gives no `ratio_t` (round 4 RT5). Sim `sample_omission_griefer`: victim at least `(k−1)/k`, 0.75x at `k = 4` and 0.67x at `k = 3`, and a friend gains at most 1.0x from one colluder's omission (RT3).<br>(d) gains at most about `skew / CAP_TEST_SECS`.<br>(e) Two colluders on a team of 4 give 3x with a starved honest member (RT6, restated for F1; sim `two_colluders`, 3.64x before the cap), and two of a team of 3 credit two shares for nothing carried. Under the stake-proportional draw (T108) two seats on half a node's teams take about 41-47% of eligible stake at `k = 4`. Teams of three are rare for honest nodes (1-9% of tests) but not for an attacker's node parked late in the queue, which starts at its last chance with a member dropped on 31-62% of its tests (red team R5; `validator_hotkey_overflow` measured 0.29-1.00 for the beneficiary); since Task 4Dc fix round 3 such a short team's record can only lower verified capacity, never raise it above `max(verified_prev, CAP_RAMP_FLOOR_MBPS)` (T113, sim `late_queue_short_team`: 0.28x of an honest declarer, 1.57x without the cap). With `s` as a share of eligible stake: one colluder is on most teams from about 16% (with replacement; about 15% without replacement at 20 equal validators) at `k = 4`, or 21% at `k = 3`; two colluders, by splitting stake, are on most teams from about 38.6% at `k = 4`. **For a co-located group** (Task 4Dc red team B1, T125) the threshold was far lower: the group's pool is the max over its chunk cohorts of each one's lower median of few samples, and `Σ verified` doesn't bind for keys verified one after another, so one seat on one cohort's only sample gave ×1.5 (team of four) or ×2 (short team) at about 5% of stake (8 of 12 seed-runs above 1.0x). Since fix round 5 a short cohort aggregate is capped (B1(a)) and a team cohort needs two samples (`CAP_COHORT_TEAM_MIN_SAMPLES`, B1(b)), so one seat never raises a group: it now takes the colluder seated on both of one cohort's samples, 1.5x at most, in 1 of 12 seed-runs (sim `colocated_cohort_lottery`; residual T125).<br>The real bound for (b) and (e) is the rolling lower median of tests, which moves only when most of a node's tests are inflated. Yuma doesn't clip it, because all validators score the same samples. Once inflation stops, the median falls back after about 5 honest tests, roughly 12 windows.<br>(f) A node is never skipped for speed. The rate is capped at the team's budgets, `pushed` follows the cap, and the node is verified at what was measured (RT2, sim `untestable_shelter` at most 1.0x).<br>(g) Before Task 12b, background is the window average and lifts only `ratio_t`, never `team` (sims `busy_honest_pre12b`: no haircut; `bg_priority_overdeclarer` at most 1.0x). Residual before 12b (round 5 F3): a busy honest node is credited about `0.75 C`, while a node that stalls its routed traffic during tests is credited `C`, no more than an idle honest node; `busy_honest_pre12b` reports both. After Task 12b (round 5 B, C, F1), each cross-UID receipt stream needs a gap-free run within one window, `seq` jumps from counter-proposals allowed, with every interval at most `ceil(RECEIPT_INTERVAL / BLOCK_SECONDS)` (3) blocks; its background is the slowest interval overlapping the test, or 0 (sim `bracket_widener` at most 1.0x). A crossing bracket adds 0, with no fallback, so the node can't pick the rule (F4). Residual after 12b: stalling real routed traffic during a test and carrying it in the overlapping intervals gives `team <= C + 0.4 T` with `T <= C / 3.6`, about 1.11x (sim `bracket_stall_carry`, bound 1.12x), and an estimated 1.48x at `k = 4` with one colluding member, which the sim also reports. It needs routed traffic the node doesn't choose. Also after 12b: a node colluding with peers of other UIDs to inflate receipts gains at most `1 / (1 - 0.25)`, about 1.33x of measured, bounded by T16's defences; and an honest busy node loses background in tests whose bracket crosses a window boundary, about 3% of its tests, too few to move its lower medians.<br>(h) A drawn member needs `cap_share_budget_mbps >= CAP_SHARE_BUDGET_MIN_MBPS` (1,000), and a member with a zero water-filled rate is dropped, so a team of `k` pushes at least `min(R, k * 1,000)` Mbps and no member votes without streaming (sim `low_budget_griefer`). Residual: a validator at the floor with about 16% of eligible stake sits on most of a node's teams and holds a 10 Gbps node at about 0.85x in the lower median (8,500 Mbps of budget), under-credited but never haircut | measurement.md §Team capacity tests, capacity-bonds.md | `uplink_capped_datacenter`, `void_by_withholding`, `sample_omission_griefer`, `untestable_shelter`, `team_lottery_splitter`, `honest_ramp_no_haircut`, `headroom_underdeclarer`, `busy_honest_pre12b`, `low_budget_griefer`, `colluder_overreport_k4`, `colluder_overreport_k3`, `two_colluders`, `withholder_fix_k2_colluder`, `colluder_overreport_end_to_end` (Task 4Dc), `busy_honest_node`, `bracket_widener`, `bracket_stall_carry` (Task 12b) |
| T43 | **MITIGATED (ADR-0039; in code, Task 4Dc).** Echo cheat. A node acks a capacity test without carrying the bytes both ways: it echoes garbage, echoes from another box, or has a large downlink and a small uplink | Operator | Every byte is echoed on the same connection, and each member byte-checks a private random `CAP_ECHO_CHECK_PPM` of the blocks. A failed check zeroes that member's share, and failure at half the members zeroes `measured`. The node-signed `cap-test-ack` still binds the key (RT2-3). The test measures the lower of uplink and downlink. Code: `bwos-probe cap --team` (member side) and `cap-sink -echo` (node side); scoring counts a member only when echo-OK (`ProbeResultBatch::team_member_mbps_for`) | measurement.md §Team capacity tests | `flashflow_echo_cheat` (verified 0; corrupting 1e-4 of a 2.5 Gbps share passes a member's check with p ≈ 0.01); `a_team_test_sums_members_and_fails_without_echo` (bwos-probe, bwos-core), `an_echo_ok_sample_needs_the_derived_test_id_and_a_clean_check` |
| T44 | **PARTIALLY MITIGATED in spec (ADR-0039).** STAMP shading and probe priority. (a) A node shades STAMP RTT through the reflector timestamps or by answering early. (b) It prioritises probes over real traffic | Operator | (a) Only `T4 - T1` on the agent's clock is scored, and reflector timestamps go to dashboards only. Each test has a fresh random `seq` and a random send time, and a reply counts only after its test left. (b) `link:`, `direct:` and `path:` probes carry random payloads, not STAMP, so they can't be recognised by format (ruling 4). A `direct:` probe can still be recognised by its fixed destination port `DIRECT_ECHO_PORT` (8_620), random payload or not, so a node can treat it apart from other traffic (Task 4Db fix round 1, recorded). `vantage:` probes and capacity tests ride the probe session, which a node can recognise and favour. That stays OPEN until secure sampling on real traffic (ADR-0038) and pay moving to carried traffic. A related case (round 5 F3): before Task 12b, a node that stalls its routed traffic during capacity tests is credited its full capacity, while a busy honest node is credited about 0.75 of it (T42(g)) | measurement.md §STAMP probes and probe sessions | Task 4Db red team |
| T45 | **MITIGATED in spec, with a residual (ADR-0039, RT1); spec only, code open until 18b.** Task 4Db records each probe session's source and has the check (`ProbeAgent::set_collector_source`), but no collector session exists to set it, so nothing is source-matched yet and `bwos-probe serve`'s endpoints must not feed batches (`measurement.md` §STAMP probes and probe sessions). **PB-48:** its plan-mode `vantage:` and `cap:` samples do feed batches, from unmatched sessions, as a residual accepted only while every validator is founder-run (T300, OQ-284); capacity tests still never run over a probe session. Endpoint shopping and the probe-session forwarder. A node shows different endpoints to different validators, or opens its probe sessions through a forwarder with a larger pipe than its real one, to escape `/24` pooling or be tested on capacity it doesn't route with. Validators each building `node_diversity` from their own view would also compute different weights (Invariant 1) | Operator | Each batch commits the endpoint its validator saw, which MUST be the source of the node's collector session too. A probe session from any other source is refused, and capacity tests run only over source-matched sessions. The node's endpoint is the stake plurality among reporters meeting the probe-key quorum, so every validator builds the same groups. Residual: a node can send all its validator sessions through one forwarder while its overlay peers' traffic takes another path. Peers' observed endpoints aren't committed | measurement.md §Probed endpoints, §STAMP probes and probe sessions | `probe_session_forwarder` (Task 18a, bound 1.000x of one pipe), `node_diversity_is_built_from_probed_endpoints_not_declared_ones`, `sybil_split_k8` (Task 4B) |
| T46 | **OPEN (ADR-0039, accepted risk).** SRG griefing. An attacker runs a node of another UID in a victim's network, or behind its single upstream, so the victim shares an SRG and loses `SRG_SHARED_PENALTY_PPM` of its diversity bonus | Operator | `shared` counts only nodes of other UIDs with verified capacity (RT7), so a zero-capacity key costs nothing. The attacker needs a node that passes capacity tests in that network. At defaults the victim's `C_n` falls from at most 1.1x to 1.05x, about 5% of its usage term. This is like co-location griefing in T24 | scoring.md §Coverage | `srg_zero_cap_griefer` (Task 4B, victim at least 0.99x) |
| T47 | **ACCEPTED RESIDUAL (ADR-0039, ruling 6).** Inherited carrier diversity. A home or CGNAT node's committed endpoint belongs to its ISP, so it inherits the ISP's neighbours and IXPs, though its own access link is a single point of failure. Large eyeball ISPs look well connected | Operator (passive) | The underlay ASN comes only from the node's own committed endpoint. Diversity pays only on carried bytes, at low weights, and nodes in one ISP share `as:<A>`, so the SRG penalty halves it once two UIDs' nodes are there | measurement.md §Underlay, scoring.md §Coverage | — (red team) |
| T48 | **MITIGATED (ADR-0039; in code, Task 4Dc: `probe::team_schedule`).** Slot crowding. An operator binds many fresh zero-capacity node keys, each with a large declaration, so their due tests fill validators' `CAP_TEST_MAX` slots and honest nodes go untested | Operator | Within a block, proven nodes (`verified_prev > 0`) are assigned before unproven ones. Unproven-node tests go round-robin by UID: within a block, the next is the one whose UID has the fewest tests so far in the window, then by slot key (round 4 RT7). At most `CAP_TESTS_PER_UID_MAX` (4) unproven-node tests per UID count in a window, counted in the window each test ends in, so tests carried across a boundary count (round 4 RR5). Bound (`zero_cap_slot_crowder`): honest proven nodes keep their test rate, and a crowder UID gets no more unproven-node tests in a window than any honest UID with due tests. With `U_a` crowder UIDs and `U_h` honest UIDs competing for scarce slots, honest UIDs keep at least `U_h / (U_a + U_h)` of them, so with one crowder UID honest new nodes reach 0.9 of declared in at most twice the windows they need without it. Each extra crowder UID costs a registration. The ramp starts every new node at `CAP_RAMP_FLOOR_MBPS`. Slot order within a tier uses a block-hash-keyed hash, so no one can grind a key for it | measurement.md §Team capacity tests | `zero_cap_slot_crowder`, `declared_flood_cotest`; `proven_nodes_are_assigned_slots_before_unproven_ones_and_unproven_tests_are_capped_per_uid`, `unproven_slots_go_round_robin_by_uid`, `tests_carried_in_count_toward_the_per_uid_cap_of_the_window_they_end_in` |
| T49 | **MITIGATED (ADR-0039, red team RT1; code in Phase B Task 11a, `signed.rs`).** Attestation-key squatting. A hotkey lists a victim validator's ed25519 key, or its probe WireGuard key, in its own `AttestationKeyRecord`, so the duplicate rule maps the key to no one and the victim's probe batches stop counting | Validator (or anyone with a staked hotkey) | A record is valid only with the ed25519 key's own `attestation-key-pop` proof of possession. `probe_wg_pub` must be the X25519 form of that ed25519 key, so the proof covers it. Only records from hotkeys with positive stake count. Task 11a's set builder refuses a key listed under two hotkeys. Only a key's real holder can create a duplicate. The ed25519 key must be canonical, torsion-free and have its sign bit clear, since `A` and `−A` map to one X25519 key (round 4 RT8). A hotkey may hold one record per probe agent, each with its own key. The probe WireGuard key must be canonical too, and every ed25519 signature is verified strictly (`verify_strict`). Residual (round 5 F2, replacing round 4's): the probe agent's WireGuard private key is the scalar that signs its batches, but a leaked probe key can't forge counted batches, because a counted batch must match the hotkey's on-chain commitment. The real risk is the attestation key: nodes accept signed inputs on ed25519 attestations alone. It comes only from the hotkey's single record flagged `attest`, never a probe agent's record unless flagged, and it must be kept off field probe boxes. A leaked `attest` key can attest inputs until its record's `not_after` passes, so keep `not_after` short. Two more residuals: (i) a hotkey with two valid `attest` records has no attestation key, so rotating by overlapping an old and a new `attest` record leaves a gap with no listed key until the old one lapses; rotation needs the old record to expire before the new one counts; (ii) records naming the same key under one hotkey are deduplicated by greatest `not_after`, which can drop an `attest` flag when one key appears in two records with different flags | measurement.md §Team capacity tests, encoding.md | `attestation_key_squatter` (Task 11a; the victim's batches still count), `a_non_canonical_or_torsioned_ed25519_key_is_refused`, `a_hotkey_may_hold_one_record_per_probe_agent`, `attestation_key_is_never_a_probe_agent_key_unless_flagged` (Task 11a) |
| T50 | **MITIGATED (ADR-0039, red team RT5; code in Phase B Task 11a, `validator::probe_stage`).** Quorum stall by stake that can't probe. Staked hotkeys that hold no attestation-key record raise the total stake a probe key must reach, so no key reaches quorum and every node takes missing-measurement failures | Validator | Quorums are measured against `recorded_stake`, the stake of hotkeys with a valid record committed before the window's first block, so no one can trigger a freeze after seeing the results. Below `PROBE_PARTICIPATION_FLOOR_PPM` (50%) of all stake, the window carries forward the previous window's metrics where no fresh result reaches quorum, and charges no failures for them. At most `PROBE_CARRY_MAX_WINDOWS` (2) windows in any `PROBE_CARRY_SPAN_WINDOWS` (24) carry; past that budget keys are scored fresh against `recorded_stake`, so a freeze, or alternating freezes, can't shelter an offline node (round 4 RT2, round 5 F5). A probe that was attempted and failed is a reported value (`rtt_us = 0`), never an absence, so failures reach quorum inside a carried window too | measurement.md §Team capacity tests, §Results and commit-reveal | `recordless_stake_staller` (Task 11a; honest nodes see no uptime failures), `selective_freeze` (Task 11a; an offline node earns 0 after 2 windows), `freeze_alternator` (Task 11a; an offline node earns at most 2 windows' credit in any 24) |
| T51 | **PROPOSED (ADR-0046), not built.** `transfer` deadline gaming: a client, or a miner acting as one, sets a very tight deadline so its order's `need_mbps` grabs spare capacity or forces wide paths | Client / Operator | `transfer` is routed last and graded on the capacity left after every other class, so a tight deadline displaces no non-`transfer` pair. `need_mbps` is capped at `TRANSFER_MAX_ORDER_MBPS`, and above the cap the order is `late` best effort. A pair's aggregated need is capped at `TRANSFER_MAX_PAIR_MBPS`. Orders are funded for their whole volume when trusted issuers are set, and a tighter deadline is quoted at a higher price (ADR-0046 §7). The per-window cap ranks entries by funded remaining bytes, not deadline, so a tight deadline doesn't jump the queue. Among `transfer` pairs the reference serves earliest deadline first | routing.md / scoring.md "Proposed (ADR-0046)" | `transfer_deadline_gamer`. Expected bound: every non-`transfer` pair's gain and regret are byte-identical with and without the order; the order's need never exceeds the cap; the order's demand-set rank is unchanged by its deadline; the attacker pays for the full volume |
| T52 | **PROPOSED (ADR-0046), not built.** `transfer` volume inflation and order splitting: declare far more volume than will ever be sent, or split one job into many small orders, to reserve spare capacity, inflate the pair's need through per-order rounding, crowd out other orders or shape the demand set | Client / Operator | Remaining volume and need are recomputed each window from receipts committed in manifests, plus the in-lag graded estimate. An order with no committed delivered bytes for `TRANSFER_IDLE_WINDOWS` is dropped. Undelivered volume earns no Mechanism 0 credit, because only carried, receipted bytes are credited. A funded order prepays its volume. Need is summed in bit/s and rounded up to Mbps **once** per pair. Orders are at least `TRANSFER_MIN_ORDER_BYTES`. One client has at most `TRANSFER_MAX_CLIENT_SHARE_PPM` of the entries, each pair's need is capped at `TRANSFER_MAX_PAIR_MBPS`, and the per-window cap ranks by funded remaining bytes | routing.md / scoring.md "Proposed (ADR-0046)" | `transfer_volume_inflator`. Expected bound: capacity held by an idle order is at most `TRANSFER_MAX_ORDER_MBPS` for `TRANSFER_IDLE_WINDOWS + TRANSFER_DELIVERY_LAG_WINDOWS` windows; non-`transfer` classes are unaffected; Mechanism 0 credit for unsent volume is 0. `transfer_order_splitter`: splitting one order into N (same total bytes and deadline, N limited by `TRANSFER_MIN_ORDER_BYTES`) raises the pair's `need_mbps` by at most `ceil(N / 1e6)` Mbps (1 Mbps for any N up to 10^6), adds no demand-set entry and doesn't change the entry's rank. One voucher's bytes are deducted once across all orders naming it (RT F5), so N orders can't each claim a voucher's full value. Residual: client keys are free, so the per-client share cap is only a weak limit against splitting, with or without funding (splitting across keys costs nothing extra). The binding limits are funding, the per-window cap, the per-pair need cap and the destination cap. Destination squatting (fix round 3, R7): idle clients' orders, with committed delivery below 10% of their in-lag share, are demoted behind sending clients for the per-window and destination caps. Reserved voucher bytes are consumed on expiry, not released. `transfer_destination_squatter` (56 funded idle orders to fresh destinations). Bound: demoted within `TRANSFER_DELIVERY_LAG_WINDOWS + 1` windows and dropped `TRANSFER_IDLE_WINDOWS` later, sending clients take the slots, and the reserved bytes are spent. Known residual on testnet: with an empty allowlist, orders are unfunded and keys free, so a squatter can re-file at no cost, behind sending clients. Idle drop (fix round 4): only windows in which the order's in-lag share was above 0 count towards `TRANSFER_IDLE_WINDOWS`, so an order the network gave no rate (left out by a cap, unrouted, or with no delivered rate) isn't dropped and its reservation isn't burned for capacity it never had. A demoted squatter left out of the set therefore isn't dropped either; it holds its reservation until it re-enters and stays idle, or its late grace ends |
| T53 | **PROPOSED (ADR-0046), not built.** `transfer` width attraction and stripe dealing (the OQ-23 `bulk` residual applied to `transfer`). An operator with wide nodes, or a solver dealing for it, routes `transfer` pairs through them to earn Mechanism 0 credit. **Width, not price, is the lever.** A link's cost is `max(cf, ct)` of its ends, so a low declaration alone doesn't make it cheap. The surcharge `1 + 2·util²` keeps a wide node's links cheap at the same load, so it can declare up to `MAX_COST_PPM` and still undercut a busy 1.0x path. **Dilution:** a costly dealer stripe hides behind a cheap, wide stripe in a rate-weighted mean. **Allocation dealing:** inflating a stripe's `mbps` to claim more of a shared hop's bytes | Operator / Solver + Operator | Width is demand-capped: no gain, regret or comparator term rewards width beyond `need_mbps`, and `Σ mbps <= need_mbps`. Regret and the Mechanism 0 gate are **per stripe**, against the comparator's costliest needed stripe, so a diluted dealer stripe past `ROUTE_REGRET_TOLERANCE_PPM` gets 0 credit. Pay per byte uses `min(declared, routed link cost)`, never above what the router priced. Apportionment uses validator-measured `delivered_k`, never `mbps`. Per-stripe and rate-weighted regret (laundering), a laundering cap at the comparator's allocation plus tolerance, costs from the solved-on snapshot (comparator poisoning), and no oversubscription when solved with a max-min fair split. Not relied on: the 24-window cost cooldown, which `run_tempo` now enforces with fixed 24-window epochs (PB-31, Task 31, T56). Pay capped at the routed link cost doesn't throttle declaration changes either | scoring.md "Proposed (ADR-0046)"; ADR-0046 §5 | `transfer_width_attractor` (a 10 Gbps relay declaring 2.0x against a busy 1 Gbps relay declaring 1.0x with room for the need). Expected bound: credit per byte is at most honest x declared/effective cost (the surcharged cost the router used). Dilution case: a dealer stripe costing more than 1.1x the comparator's marginal stripe earns 0, whatever the route's mean. `stripe_mbps_apportion_dealer` (a dealer stripe with inflated `mbps` sharing hops with an honest stripe). Bound: each stripe's weight equals its modelled delivery share within one floor; the pair's weights total `min(need, rate)`; `mbps` above modelled delivery changes nobody's weight; synthetic routes move nothing. "Measured delivery" is a snapshot model, because receipts aren't split by stripe. `marginal_stripe_launderer` (a dealer stripe priced exactly at the comparator's marginal carries most of the need while a cheaper honest path has room). Bound (restated, fix round 4): price, not share. Each credited byte costs at most 1.1x the comparator byte it displaces. A dealer at the marginal cost can carry 100% when the comparator's stripes are within 10% of each other; otherwise its credited share is at most 1.1x the comparator's allocation at or above `cost_k / 1.1`, plus `TOL * min(need, rate)`, and `regret_p > 0` once the route's mean is past 1.1x the comparator's. `laundering_cap_tolerance_flip` (honest stripe costs flip across the comparator's within ±10%). Bound: 1.00x, because the cap uses `A(cost_k / 1.1) * 1.1` plus slack and keeps the tolerance. `stripe_regret_noise` (±10% cost noise on an honest route). Bound: regret 0, from the deadband on both regret terms. `comparator_residual_inflater` (inflating the residual the comparator sees, to make it allocate at a dealer's cost level). Bound: at most the tolerance, 1.1x the comparator's allocation plus slack. `comparator_cost_drop_griefer` (a griefer drops its declared cost after tables are committed, to make the comparator cheaper through its node). Bound (derived, ADR-0046 §5, replacing round 2's underived 0.95x): base costs come from the solved-on snapshot, so a later declaration moves the comparator by 0. A rival keeps 1.00x unless the griefer adds enough real, verified capacity to cut the comparator's marginal cost by more than the 10% tolerance (at utilisation 0.5, about 28% more capacity). `oversubscribed_mbps_dealer` (a table whose stripes' `Σ mbps` exceeds a link's residual on the solved-on snapshot). Bound: the table loses its `transfer` routes, and inflating one stripe's `mbps` never changes another's `delivered_k` (max-min fair split). Residual: 10% over the comparator's marginal cost and allocation, as for every class. Residuals recorded in fix round 4: (1) **reshuffles**: an honest route whose split differs from the greedy comparator's by more than 10% plus slack loses some credit; `honest_split_reshuffle` (splits 0% to 50% from the comparator's at equal or lower `path_cost`) MUST show 1.00x up to 10% plus slack and reports the loss beyond, recorded here before the cap is paid. (2) **Mechanism 1 deadband**: `transfer` regret has the 10% deadband in Mechanism 1, which the other classes don't (theirs counts from the comparator). Its congestion-priced cost moves more with measured capacity than latency does, and `max_k regret_k` takes the worst of up to four stripes, so without it honest regret would grow with stripe count. A solver can place a stripe 10% over the comparator with no Mechanism 1 penalty, matching Mechanism 0's gate. (3) **Broken in-tree**: a stripe prefix that isn't an in-tree, or a `transfer` route with a `backup_path`, fails `Table::validate` and so the whole table, latency classes included. Only the solver can cause it, since it depends on the table's paths alone, and the other `transfer`-only failures (prefix budget, oversubscription, `Σ mbps > need`) still drop only the `transfer` routes |
| T54 | **PROPOSED (ADR-0046), not built.** Time-shifting one's own traffic: a miner buys `transfer` orders between its own nodes and lets the network move the bytes into quiet windows, where each byte is a larger share of the usage term | Operator (as client) | `transfer` bytes are ordinary `paid`/`free` bytes under the existing rules: voucher price floor (T20), `[SCR-10]` once per path, entity dedupe of own-UID endpoints (§Endpoint dedupe), `[SCR-11]` capacity cap, `USAGE_SHARE_CAP` with bounded redistribution, and the regret gate. ADR-0046 adds no class weight and no off-peak multiplier | scoring.md §Byte crediting; ADR-0046 §3 | `offpeak_transfer_wash`. Expected bound: alpha per paid GiB of the miner's own `transfer` traffic is at most 1.00x the same bytes sent as non-`transfer` paid traffic in the same windows (transfer adds no edge). The absolute bound is the existing paid wash-trading bound |
| T55 | **PROPOSED (ADR-0046), not built.** `transfer` load shield: a solver fills a fast relay's links with `transfer` stripes so that a latency-class detour through its own relay looks capacity-forced, with no regret | Solver + Operator | Non-`transfer` classes are graded as if `transfer` loads didn't exist (regret comparators, capacity checks, congestion-priced cost). `transfer` loads still count in `overloaded_nodes`. Stripe prefixes have their own next-hop graphs, so `transfer` routes can't force a cycle-conflict detour (T33) on another class either | scoring.md / routing.md "Proposed (ADR-0046)" | `transfer_load_shield`. Expected bound: every non-`transfer` route's regret and Mechanism 0 multiplier are identical with and without the table's `transfer` routes |
| T56 | **MITIGATED (Task 30 red team, PB-31, Task 31 fix round 1; 10.0x -> 1.0x).** Declaration cooldown bypass. `can_update_declaration` implemented the `CAP_CHANGE_WINDOWS` (24) cooldown, but nothing outside tests called it, so `run_tempo` scored whatever declaration it was given. An operator could discount `cost_ppm` to 0.2x to win routes and raise it to 2.0x (10x the Mechanism 0 per-byte pay, ADR-0018) the window after the table was assigned. The first fix (per-UID state) was bypassed three ways: flipping the declaration's hotkey (measured 10x), withdrawing to the default cost (5x), and moving nodes between UIDs (10x per move). Its local `checked_window` also made stateless and restarted validators diverge | Operator | `run_tempo` scores a per-node cooldown epoch (`validator::tempo_declaration_epoch`). Only declarations signed by the UID's metagraph hotkey, for nodes bound to it, count. A node keeps the `cost_ppm` it had at the epoch's first window, and its `mbps` can only go down until the next epoch, whichever UID it is bound to; a withdrawn node is still billed at its carried values. The state is a pure function of the chain reads since the epoch's first window (at most 24), so a validator without state rebuilds it from `TempoInput::declaration_reads`. Fix round 2: Mechanism 0 bills each node at the lower of its epoch cost and the cost in the snapshot the table was solved on (`billing_cost_ppm`, `TempoInput::current_snapshot_costs`), so a raise at an epoch boundary never re-prices routes chosen before it (`epoch_boundary_raise`: 0 mis-priced windows). An epoch cache that can't be saved (key churn past `MAX_EPOCH_NODES`) no longer fails the tempo (`epoch_state_key_churn`). Residuals (fix round 2 check adds (F1) and (F2)): (F1) **stale costs**: nothing ties `current_snapshot_costs` to `current_snapshot`, so a misconfigured validator passing an older outcome under-bills boundary raisers for the epoch; fix with PB-12 (carry costs in the signed snapshot, or tag them with the snapshot window). (F2) **None vs Some**: a validator passing `None` bills a boundary raiser one window at the new price; every daemon passes `None` until PB-14 persists the costs, so validators agree but the cap is inactive in production; an empty map must be passed as `Some`. (1) **re-key**: an operator can replace a 0.2x node with a fresh node key mid-epoch; the new key gets at most 1.0x, and is billed at most what its routes were solved on (`rekey_mid_epoch`: 1.0x), so the price moves (up to 5x the old key's) but never above what the solver saw, after a new key, consent, binding and capacity tests. A tighter cap at the UID's lowest price is deliberately not used. (2) **Dating gap** until declarations are named through a manifest object domain (OQ-45): the read dates a declaration by the commitment that names its hash, but the declaration object itself is off-chain. An operator can withhold it from some validators (those then see the node as absent and carry its state, so withholding never raises a price), and a validator rebuilding an epoch needs the objects of every read since the epoch's first window, so it depends on how deep the object store archives them. (3) A validator with neither state nor reads starts the epoch at the current read and can disagree with its peers until the epoch ends; the live loop must fill the reads (PB-14) | capacity-bonds.md §Where the cooldown is enforced | `cost_raise_after_assignment`, `epoch_boundary_raise`, `rekey_mid_epoch`, `epoch_state_key_churn`, `declaration_hotkey_flip`, `withdraw_to_default_cost`, `fleet_move_cost_flip`, `stateless_validator_raise`, `downtime_backdate_divergence`, `declaration_cooldown.rs`, `two_validators_with_the_same_previous_declarations_compute_identical_weights` |
| T57 | **MITIGATED, residual bounded (Task 10 red team, fix rounds 2 to 4).** Refresh ignorer: a kernel node keeps no refused routes (no `soft-reconfiguration inbound`, OQ-44), so a new table reaches the paths its FRR holds only when each peer sends its routes again on ROUTE-REFRESH. A peer X that leaves route refresh out of its OPEN, or never answers, keeps an old table's primary path at 200 on node V, draws V's traffic towards R, and drops it, so the V-R link takes the blame. Reproduced in `solver_bgp_e2e.sh` step 5d (a no-root peer run with `--ignore-route-refresh`, tests only): FRR 8.4.4 and 10.7.1 both kept X's path at 200 after a table that made X the backup. **Residual (fix round 4, F3):** a quarantined peer is released when it answers correctly at an apply that changed its paths or lists, so an ignorer that alternates, answering while quarantined and ignoring the apply after, gets at most one 10 s window per two applies. **Open follow-ups (Task 10 final check):** (a) `changed_peers` compares only each peer's own, primary and backup lists, but a change in which UID owns an origin alters FRR's filter without changing any list, so fail-closed should also count every peer as changed when the snapshot changed; (b) "answered" should be judged on the last neighbour read that succeeded after the route reads, not strictly on the last read; (c) the read a quarantined peer is judged on can start up to one read's length before `judge_at`; (d) `deploy/wan-stack/tests.sh:348` counts `RouteUnassigned` log lines, which aggregation (`node::UNASSIGNED_LOG_INTERVAL`) makes unreliable, and the controller will fix that file | Operator | After every apply, `bwos-node refresh-check` sends `clear bgp ipv6 unicast * soft` first, then waits up to 10 s for each peer to answer and leave only paths the new policy gives at the preference it gives, and hard-clears that peer alone if not (`datapath.md`, "A new table"). A peer cleared for not answering or for stale paths is quarantined: at every later apply it's judged once the honest peers have answered, but no earlier than `QUARANTINE_JUDGE_SECS` (2 s, the judge floor) after it's asked, not given the wait; it's released when it answers correctly at an apply that changed its paths or lists. So an ignorer gets at most one 10 s window per two applies. A peer is called unanswered only if the last neighbour read succeeded; otherwise it's unverified, which never quarantines. It fails closed: a peer it can't verify in time is cleared if its lists changed against the table applied before, it's quarantined, or a stale path from it was seen, and otherwise logged as unverified; it exits non-zero with the errors in the apply's JSON | datapath.md | steps 5d (cleared at the deadline, quarantined), 5e (quarantined, cleared at the judge floor without the wait) and 5f (a vtysh too slow to read: the peers whose lists changed cleared, exit non-zero, no stale path 20 s after the commit; then a window-only table: nobody cleared, both peers `unverified`, no session reset), on FRR 8.4.4 and 10.7.1; `refresh_check` unit tests incl. `it_fails_closed_when_frr_cannot_show_a_peers_routes_in_time`, `failing_closed_clears_only_the_peers_whose_lists_changed_and_the_quarantined`, `a_peer_is_unverified_not_unanswered_when_no_neighbour_read_succeeds_after_the_ask`, `an_honest_quarantined_peer_answering_at_half_a_second_is_not_cleared`; sim `refresh_ignorer_framer` (**model-only**: 20 applies a window, quarantined 48 s of 4,320 s; alternating, the residual bound, 120 s; without the quarantine 200 s; all attacker 1.000x, victims 1.000x, as one framed link is a neutral failure under T29) |
| T58 | **ACCEPTED RESIDUAL (ADR-0042).** Signed-input capture. Whoever holds the `attest` keys of at least `SIGNED_INPUT_QUORUM_PPM` (two thirds) of a validator set's stake can feed every node any table, snapshot, peer directory or next validator set, because nodes check only ed25519 attestations and never the chain | Colluding validators, or a thief of their attest keys | Attestations have their own domains, so no solver, probe or record signature can be lifted into one (D9). A key outside the set or a repeated key counts for nothing, and every signature is verified strictly. Nodes refuse an older window and a different object for the window they hold, so a captured quorum can't silently swap a table within a window or roll one back. The `attest` key stays off field probe boxes and its record's `not_after` is kept short (ADR-0042, "The attest key is the real risk"). A two-thirds stake collusion is outside what the design defends, as for Yuma | routing.md §Signed tables, snapshots and peer directory, ADR-0042 | `a_table_attested_by_one_third_is_refused`, `an_attestation_from_a_key_outside_the_set_counts_for_nothing`, `a_duplicate_attestation_counts_once`, `a_solver_route_table_signature_is_not_a_table_attestation`, `an_older_window_signed_table_is_refused_and_the_last_one_kept` (Task 11a) |
| T59 | **MITIGATED (ADR-0042, red team 2 and 3; node flow Task 11c).** Stale trust root and exit veto. A node is bootstrapped from a `--validators` file and follows rotations only through sets attested by the set it holds. (a) A node offline across rotations, or given an old file, trusts a set whose keys may since have lapsed or leaked. (b) A quorum signs a far-future set or input that nothing can replace. (c) Stake holding more than a third of a set leaves the chain and keeps its veto over the set's successor for as long as nodes hold the set | Anyone who supplies the bootstrap file; holders of old attest keys; a departing validator with over a third of a set | (a) Every set carries `not_after <= block + VALIDATOR_SET_LIFETIME_BLOCKS` (24 windows). Past it the node accepts nothing more from the set and re-anchors on the operator's `--validators` file, logging a JSON event. It does so on an attested directory past `not_after`; when the operator installs a file, which overrides whatever its block; or when no **set** has been accepted for `VALIDATOR_SET_LIFETIME_BLOCKS × BLOCK_SECONDS` of monotonic time. That last trigger is the exit veto: counting from sets, not inputs, keeps a selective blocker that still attests directories to about 24 windows, not about 48, and it is a reload trigger only, never a block or trust decision. On the automatic triggers a file older than the held set, or already expired, is refused (F4). (b) `accept_next_set` needs a higher `block` by at most `MAX_SET_ADVANCE_BLOCKS` (2 windows), tables and snapshots are at most the directory's window + 1, a directory is never before the set's block or past its `not_after`, its window is at most `block / 360 + 1` and advances at most `(block − held.block) / 360 + 1` from the held one, and a newer directory never lowers `block`. A captured quorum could chain sets 720 blocks apart faster than real time, so nodes rate-limit set and directory blocks against their monotonic clock, the slack counted once from the first directory after anchoring (F2; residual T87). (c) A set's stake is each hotkey's minimum metagraph stake over `SET_STAKE_LOOKBACK_WINDOWS` (24), so departed stake weighs nothing in the next set, and the set it still sits in lapses within 24 windows. **The exit veto is bounded by operator file replacement:** once the set lapses (trigger 1, by directory or clock floor) or the set timer fires (trigger 3), the node reloads its file, and if that still holds an older or the same set it refuses it, raises `validator_set_stale` and stays on its last inputs until the operator installs a current set (sim `set_exit_veto`: `24 + R` windows, R the operator's response). **An eclipse delays expiry at most by the time left at the last directory:** the floor runs at half the chain's pace from the last accepted directory (each one raises it to its block; rotations and re-anchors keep it, and only a rollback override drops it), so a binding or set with `t` blocks left at the last accepted directory expires within `2t` blocks of the node's uptime after it, and of real time within one Linux or macOS boot, whatever is withheld; a set expires, and the stale alarm fires, within about 58 h of uptime (twice the 8_640-block lifetime, 2 × 28.8 h) after its last directory. Restarts never reset the floor: its progress is written every `FLOOR_SAVE_BLOCKS` (5) of its blocks with no input arriving and at every restore onto a new clock, and a restore resumes it from the block it had reached. A restart in the same boot (by `boot_id`, or macOS `kern.bootsessionuuid`) keeps its clocks, downtime included; one onto a new clock loses at most the run since the last write, under 2 min 10 s of uptime, which the bound adds once per such restart (fix rounds 3 and 4; sim `eclipse_restart_expiry`; tests `signed_input_an_eclipse_with_restarts_still_expires_within_2t`, `signed_input_the_floor_counts_from_the_last_directory_not_the_first`, `signed_input_a_reanchor_during_an_eclipse_keeps_the_floor`, `signed_inputs_cli_a_reboot_with_the_clock_held_back_still_expires_the_set`). Task 11c runs the re-anchor flow, walks every `next/<identity>` set (or `after/<block>` when no store knows the held set, OQ-67 (b)) before the directory, and checks expiry on a clock floor so withholding directories can't keep a set alive (`datapath.md`, "Signed inputs"). Residuals: the file is only as fresh as its operator keeps it; each anchoring on the file grants one jump (T87) | routing.md §Signed tables, snapshots and peer directory, ADR-0042 item 5 | `a_new_validator_set_needs_the_old_sets_quorum`, `a_far_future_set_is_refused`, `a_far_future_directory_window_is_refused`, `a_directory_cannot_move_block_backwards`, `a_set_expires_and_its_stake_is_the_lookback_minimum` (Task 11a); sim `set_exit_veto` (a 40% blocker is out of the node's set `N = 24 + R` windows after its chain stake reaches 0, R the operator's response swept over 2, 10 and 40 windows; payoff `max(N - R)` = 24 against bound 24) and `set_exit_veto_is_the_lifetime_plus_the_operators_response` (N = `VALIDATOR_SET_LIFETIME_BLOCKS / 360` + R for each R); `signed_input_only_an_attested_expired_directory_triggers_a_reanchor`, `signed_input_an_installed_file_overrides_even_an_older_set`, `signed_input_the_set_timer_counts_from_the_last_accepted_set`, `signed_input_set_and_directory_blocks_advance_no_faster_than_the_clock` (Task 11c) |
| T60 | **OPEN, detected and recorded (ADR-0042, red team 6; Task 11c).** Equivocating quorum. Validators holding the quorum attest two different objects for one domain and window, and show different nodes different tables, snapshots or directories | Colluding validators with more than two thirds of a set's stake | Honest validators attest at most one object per domain and window. `AppliedInputs` refuses a second attested object for the window it holds as `SignedError::Conflict`, so a node never switches within a window. Both node kinds keep the first and record the pair as evidence (both objects and their attestations, in the state directory's `evidence/`), logged once as `SignedInputEquivocation` naming only the keys that signed both (OQ-68), the first pair per domain and key and at most `MAX_EVIDENCE_RECORDS` (64) and `MAX_EVIDENCE_BYTES` (16 MiB) in all, so equivocations can't fill a disk (RT5), and do the same for equivocations a fetch finds across peers, so the equivocation can be shown to others; what is done with the evidence (slashing, publication, a failure challenge) is open | routing.md §Signed tables, snapshots and peer directory, ADR-0042 item 7 | `an_older_window_signed_table_is_refused_and_the_last_one_kept`, `a_directory_cannot_move_block_backwards` (Task 11a; `Conflict` on a second attested object); `signed_input_a_second_attested_object_for_one_window_is_evidence` (Task 11c), `signed_input_evidence_is_capped_and_first_per_key` (fix round 1) |
| T61 | **MITIGATED (Task 4C, ADR-0039; fix round 1).** Forged or withheld outside evidence. A validator signs records the source never published (a fake `origin`, `upstream` or `ix_presence` for a miner's ASN), or leaves a real record out | Validator | Scoring reads only agreed records (`validator::tempo_agreed_records`): a record counts when at least `MIN_VALIDATORS` hotkeys with positive stake carry it and they hold `PROBE_STAKE_QUORUM_PPM` of the total (`recorded_stake` once attestation-key records exist; OQ-59). With records, a window under `PROBE_PARTICIPATION_FLOOR_PPM` of recorded stake agrees nothing (red team RT1), and with no stakes and no records nothing is agreed outside sim and localnet (RT5). One validator's object can neither add nor remove an agreed record. `usable_evidence` drops bad signatures, wrong-source records (the object is invalid as a whole) and all but the newest object per `(validator, source)`. Residual: validators holding a third of recorded stake, with recorded stake at least half of all stake, can jointly add records (the probe-key bound, T21). The minimum is therefore 1/6 of all stake: a third of a recorded half (sim `origin_stripper`, fix round 2) | measurement.md §Outside evidence | `evidence_minority_injector`, `origin_stripper`; `a_record_from_one_validator_is_not_agreed`, `agreed_records_need_the_stake_quorum`, `agreed_evidence_quorum_is_measured_against_recorded_stake`, `below_the_participation_floor_nothing_is_agreed`, `the_count_quorum_needs_the_explicit_switch`, `a_record_from_the_wrong_source_invalidates_the_object` |
| T62 | **OPEN, bounded (Task 4C), OQ-58.** Stale evidence re-signed. A validator keeps importing an old snapshot under each new `window`, so a record the source has withdrawn (a revoked ROA, a de-peered upstream) stays in its usable evidence | Validator | `validate` refuses `fetched_block > (window + 1) * WINDOW_BLOCKS` (fix round 1), which only catches an impossible claim; an old `fetched_block` passes. The quorum bounds it: the record stays agreed only while enough stake reports it, so one validator alone keeps nothing alive | measurement.md §Outside evidence | `fetched_block_after_the_window_is_invalid` |
| T63 | **MITIGATED (Task 4C fix round 1, red team RT2).** Scope pollution. Fix round 0's `evidence-scope` added the origin ASN of any retained `origin` record covering a scope endpoint, from any validator, so one validator could add tens of thousands of ASNs to every honest scope and push honest scoped imports past `MAX_WIRE_BYTES`, where they were refused | Validator | Scope ASNs now come only from this validator's own evidence or from agreed records (`evidence::scope_origin_asns`). An `origin` prefix shorter than /8 (IPv4) or /16 (IPv6) makes an object invalid. On overflow, records that entered only by scope ASN are dropped and endpoint matches kept (`evidence::fit_to_wire`). Scope endpoints are public unicast only (R12). Residual, fix round 2 (F3): colluders who reach agreement (at least 1/6 of all stake, T61) could use fake origins to widen honest scopes until an import overflowed and dropped its ASN-only records, so they could *remove* honest IXP and upstream records, not only add fake ones. Now agreed origins are capped at `MAX_AGREED_SCOPE_ORIGINS` per endpoint, and on overflow the underlay (`priority_asns`) records are the last ASN matches dropped. What remains: up to four fake ASNs per endpoint in a scope, and records of ASNs that are neither own, underlay nor among the capped agreed ones can still be dropped by an overflow | measurement.md §Outside evidence | `scope_polluter`, `origin_stripper`; `agreed_scope_origins_are_capped_per_endpoint`, `scope_asns_come_only_from_own_or_agreed_records`, `fit_to_wire_drops_asn_only_records_on_overflow`, `an_overflowing_scoped_import_keeps_the_endpoint_matches`, `origin_prefixes_shorter_than_8_or_16_are_invalid` |
| T67 | **OPEN, model-only (ADR-0038, not scored).** Sample favouring and blame by omission. (a) A relay forwards the packets it guesses are sampled and drops some of the rest, so end-to-end sampling under-reports its loss. (b) A relay drops packets and leaves their digests out of its `HopDigestBatch`, so `attribute_loss` charges the loss to the link into it, keyed by the point before it: the previous hop, or the ingress if the relay is the first hop | Operator | (a) The epoch key is secret while packets cross and sampling is a keyed hash of the hop digest, so a guess is independent of the sample, and the batch is signed and published before the ingress reveals the key (`check_batch_order`, per ingress): the favourer's sampled loss equals its real loss. (b) Not prevented: without per-packet acknowledgements the two ends of a link can't be told apart. The omitter can't escape its own link, though: since fix round 1 the ingress is point 0, so digests no hop holds go on the ingress-to-first-hop link instead of on nobody (sim `first_hop_omitter`). Attribution is evidence about the link, never the hop alone, and whatever pays or penalises on it charges the link or corroborates with validator vantage probes (T29). A hop missing a digest that a later point holds proves its own batch incomplete. Withheld and late batches are T71 | receipts.md §Hop digests, measurement.md §Secure sampling | `sample_favourer`, `first_hop_omitter` (model-only); `sampling_ignores_hop_limit_and_traffic_class`, `attribute_loss_blames_the_hop_that_dropped`, `loss_before_the_first_hop_is_charged_to_the_ingress_link`, `a_digest_batch_for_an_epoch_whose_key_is_revealed_is_refused` |
| T68 | **OPEN, model-only (ADR-0038, not scored).** Forged digests and spoofed sources. (a) A hop claims digests it never received, to take credit for delivery or to cover an upstream colluder's drops. (b) A node injects packets with another node's source address so a path appears to carry its traffic | Operator | (a) Only digests in the ingress's own sampled set count, and delivery is credited only where the next point also holds the digest, so a forged digest earns nothing and only moves blame onto the forger. (b) Pay requires end-to-end source verification: sampled delivery counts only digests the source's own batch holds (`verified_delivered`); a sampled packet at a hop that the claimed source never committed is spoof evidence. (c) Replay: a relay on the victim's path drops the original and replays it over a path its own operator holds, perhaps claiming it in that path's source batch. The model credits each digest at most once, to the path whose source batch and every hop hold it and that no other source's batch claims, so replaying earns nothing and claiming loses both paths the digest (griefing the victim path's other hops). That crediting rule isn't specified yet (OQ-66). Residual: a colluding ingress, hop and egress can sign anything (ADR-0038 §9) | receipts.md §Hop digests, OQ-66 | `digest_forger`, `source_spoofer` (model-only; credit through `verified_delivered`) |
| T69 | **OPEN, model-only (ADR-0038, not scored).** False reports. A reporter files link-failure or spoof claims with no evidence, with forged or unsigned batches, with reveals that don't chain to the ingress's anchor, or against a path it owns a node on, to farm the failure bounty | Any UID's hotkey | A claim is confirmed only if every cited `HopDigestBatch` and `SampleKeyReveal` verifies, every reveal chains to the anchor (`check_reveal_chain`), and the objects themselves show the loss or spoof; a claim citing no digests is never confirmed. No credit to a reporter whose UID owns a node on the reported path. Spoof credit is 0 while `HOP_DIGESTS_SCORED` is `false` (Task 16c). The order rule keeps revealed keys per ingress and takes a reveal only if the ingress it names signed it, so nobody can void the evidence about another ingress's flow by signing reveals for the window's last epoch (red team RT1, fixed in fix round 1) | receipts.md §Hop digests, ADR-0038 §6 | `false_reporter`, `reveal_kill_switch` (model-only); `a_self_signed_reveal_from_an_unrelated_key_refuses_nothing` |
| T70 | **OPEN, recorded (ADR-0038 red team RT2), not scored.** The reveal names no egress. A `SampleKeyReveal` carries `ingress`, `window` and `epoch` but not the flow's egress, and one ingress serves many egresses. (a) Grinding: an ingress with several flows, or one that re-anchors, can choose after seeing what was lost which key chain it says applied to a flow. (b) Cross-flow false claims: a reporter pairs one flow's reveal with another flow's batches, so packets that flow never carried look sampled and lost | Ingress operator; any UID's hotkey | Planned fix, not built: an `egress` field in `SampleKeyReveal`; one anchor per `(ingress, egress, window)`, committed before the window starts; the ingress's batch split into per-egress sent sets, so a sampled set is tied to one flow. Until then `HOP_DIGESTS_SCORED` stays `false` and Task 16c pays no spoof credit | measurement.md §Secure sampling, ADR-0038 §9 | planned sims `anchor_grinder`, `cross_flow_reporter` |
| T71 | **OPEN, recorded (ADR-0038 red team RT4), not scored.** Omission and withholding blame the hop behind. A hop that drops packets and omits their digests, or publishes no batch, a late batch, or two batches for one epoch, makes `attribute_loss` charge the loss to the link into it, keyed by the point before it (T67 b) | Operator | Planned fix, not built: a missing, late or duplicated batch puts the epoch's loss on both of that node's links, keyed to that node, so withholding never helps; and a per-link, per-epoch packet count in the co-signed hop receipt, so a downstream node that co-signed `n` packets can't claim fewer digests without contradicting its own signature | receipts.md §Hop digests | planned sim `downstream_framer` |
| T72 | **OPEN, recorded (ADR-0038 red team RT5), not scored.** The egress knows every key. The key chain derives from the flow's `mask_key`, which the egress holds too, so the egress can compute every epoch key in advance, tell a colluding relay which packets will be sampled, or treat sampled packets differently itself | Egress operator with a relay | Planned fix, not built: derive the chain from a secret only the ingress holds, so the egress learns each key from the reveal like everyone else. ADR-0038 §9 lists it as a known limit until then | measurement.md §Secure sampling, ADR-0038 §9 | — |
| T73 | **OPEN, recorded (ADR-0038 red team RT6), not scored.** The two ends have a veto. Attribution needs the ingress's batch (the sampled set) and the egress's (what arrived). An end that withholds its batch voids attribution for the whole path, and an egress that leaves digests out frames the last hop | Ingress or egress operator | Planned fix, not built: when an end's batch is missing, attribution falls back to the co-signed hop receipts for that path and epoch, and the missing end is charged for the gap | receipts.md §Hop digests | planned sim `edge_veto` |
| T74 | **OPEN, recorded (ADR-0038 red team RT7), not scored.** Determinism. Validators may disagree on whether a batch came before its reveal (OQ-63), may hold different ones of two batches or two reveals published for one epoch, and nodes' epochs don't align under clock skew, so evidence citing batches isn't byte-identical across validators (Invariant 1) | Any node; network conditions | Planned fix, not built: an ingress reveals keys only after an on-chain manifest commitment of a per-window batch index (OQ-64 option a), so what counts is fixed on chain before anyone learns the sample, and a second object for one epoch voids that node's epoch (T71). Until then nothing is scored | receipts.md §Hop digests, measurement.md §Secure sampling, OQ-63, OQ-64 | — |
| T75 | **MITIGATED (Task 11b, red team 4 of Task 11a).** Hiding the latest input. Anyone who can store an object (a loopback caller, or a mirror that copies objects in) adds an unattested, under-quorum or out-of-bounds object with a higher window or block, even `u64::MAX`, so `latest` serves it and nodes never see the real one. Or they flood the store with such objects so every `latest` request re-verifies thousands of signatures | Anyone able to put objects into a store; any remote reader for the CPU cost | `latest` admits only objects a node holding the store's current set would take (`signed::rank_published`): the set's quorum, the directory bounds of ADR-0042 item 7, tables and snapshots at most the latest directory's window + 1, and validator sets reached by `accept_next_set` from the anchor (so at most `MAX_SET_ADVANCE_BLOCKS` a step). Keys are checked from the highest down and results are cached until a publication object is stored, so repeated reads verify nothing. Object `PUT` stays loopback-only. Residual: a loopback writer can still make one ranking pass expensive, bounded by `MAX_STORED_OBJECTS` and `MAX_ATTESTATIONS` | routing.md §Distribution | `object_store_latest_ignores_unattested_and_out_of_bounds_objects`, `object_store_latest_returns_the_validator_set_with_the_highest_block` |
| T76 | **MITIGATED in core, node flow open (Task 11b).** Bad mirrors. A peer serves a junk, stale, truncated or oversized copy, never answers, trickles bytes, or withholds one of two equivocating objects. A validator's peer serves junk attestations for the merge | Any peer a node or validator fetches from | `fetch::get` has one 5 s deadline for the whole exchange, a body limit checked before and while reading (digits-only `Content-Length`), and `http://` with IP literals only, so no resolver call escapes the deadline. Peers are deduplicated, capped at `MAX_FETCH_PEERS` and asked in parallel, so silent peers cost one timeout in total (fix round 1). Every copy is checked after the fetch (hash, structure, `rank_published`), a bad one is recorded and the next peer used, and `fetch_latest` asks every peer so an equivocation shows up when any honest peer holds the other object. `publish_attested` keeps only attestations that verify over the object's own bytes. Residual: a node whose peers all collude is served only their objects; it stays on its last accepted inputs and can be held back, never moved to a forged one (OQ-68, Task 11c) | routing.md §Distribution | `fetch_latest_tries_the_next_peer_on_a_bad_copy`, `fetch_latest_records_an_equivocation_across_peers`, `fetch_times_out_on_a_silent_server`, `fetch_latest_total_time_bounded`, `publish_attested_drops_peer_attestations_that_do_not_verify` |
| T77 | **MITIGATED (Task 11b fix round 1, review and red team finding 1).** Copies fill the live store. Every republish round merges new attestations into a new copy with a new hash. The store is write-once and the round put the merged copy into the live store without dropping the copies it superseded, so copies built up until `MAX_STORED_OBJECTS` refused every put, and publishing and receipt ingest stopped | Any validator running `serve`, triggered by peers' attestations arriving over time; a peer that varies its attestations speeds it up | `Publisher::republish_once` puts each merged object into the live store and then calls `drop_superseded_copies` there: copies whose valid signers are all on the merged copy are removed, and a copy with a signer the merged one lacks is kept. `publish_attested` does the same on the store it is given. Old windows still aren't pruned (OQ-67) | routing.md §Distribution | `republish_keeps_one_copy_per_object`, `publish_attested_keeps_one_copy_per_object` |
| T78 | **OPEN, recorded (ADR-0044).** Another process of the same user reaches the agent's control socket or its keychain entry and acts as the owner | Local malware running as the owner | Socket mode 0600 and a peer UID check; the channel's command set is closed and none of its commands reads or writes a key; the hotkey is optional and the solver role off by default | adr/0044, desktop design §4.2, §7 | `bwos-ipc` tests |
| T79 | **OPEN, recorded (ADR-0044).** The owner is tricked into importing a hotkey, or a coldkey, into the agent | Social engineering; a malicious script | Import is an explicit command in the agent's own process, never over the channel, with a one-sentence warning; a coldkey is refused; nothing else reads `~/.bittensor` | adr/0044 | agent import tests (PB-21 part 2) |
| T80 | **OPEN, recorded (ADR-0044).** The binding request is altered between export and signing, binding the node key to another hotkey | Local malware; a compromised UI | `bwos bind` shows the node key and hotkey it signs; the signed binding is verified against the node key on import | adr/0044, identity.md | agent binding tests (PB-21 part 2) |
| T81 | **MITIGATED (Task 11b fix round 1, review and red team finding 2).** Attestation crowding. A peer serves valid attestations from throwaway keys, fresh each round. The merge kept every key that verified, so the merged copy grew every round (and with T77, so did the store); past `MAX_ATTESTATIONS`, keys sorting before the real validators pushed real attestations out and the copy fell below quorum | A malicious or compromised peer validator, or anyone who can store a copy locally | `publish_attested` merges, and `/v0/attestations` serves, only keys in `ObjectStore::known_attestation_keys()` (anchor, current set, stored sets), dropping outsiders before any cut; its own attestation is always kept. Residual: a stored set, even an unattested one, adds its keys to the known set, and only a loopback caller can store one | routing.md §Distribution | `attestations_for_serves_only_known_set_keys`, `publish_attested_ignores_fresh_outside_keys_each_round` |
| T82 | **OPEN, bounded (Task 4B; Task 4C red team residual).** Underlay ambiguity grief. Validators who reach evidence agreement (T61) get a fake `origin` and a matching fake `roa_origin` agreed for a victim's prefix, at the same length as the real one. Agreed origins enter a scope at most `MAX_AGREED_SCOPE_ORIGINS` per endpoint, lowest ASN first, so they pick low fake ASNs. Two RPKI-valid origins then share the longest prefix, and the victim has no underlay ASN | Colluding validators | An ambiguous underlay is treated as no evidence: no `upstreams`, `ixps` or `srg`, `diversity_ppm = 0`, and unknown risk, so the victim can't be an interior node of a `resilient` route with a backup (RT9). Endpoint dedupe doesn't read the ASN, so it is unchanged. The victim loses at most `DIVERSITY_WEIGHT_PPM + IXP_PRESENCE_WEIGHT_PPM` of `C_n` (1.1x to 1.0x), only on carried bytes. The colluders gain nothing directly. It needs T61's stake minimum (1/6 of all stake) | measurement.md §Underlay ("Ambiguous underlay"), scoring.md §Coverage | `underlay_ambiguity_griefer`, `underlay_ambiguity_mass_grief` (every honest node hit, fix round 1), `resilient_unknown_risk_steering` (latent until `resilient` is in demand, OQ-81); `an_ambiguous_underlay_gives_no_bonus_and_an_unknown_srg` |
| T83 | **MITIGATED, residuals recorded (PB-04; OQ-73 closed by Task 9 fix round 1).** ASN squatting: a node's overlay ASN is its key's, so an attacker grinds a node key whose ASN equals a victim node's (about 95 million keys for a chosen ASN, cheap) to originate the victim's `/128` or get the victim left out of the snapshot. A fleet-mate originating another fleet node's `/128` is the same attack without the grinding, under the old UID-based ASN | Operator; stranger | Fleet-mates have distinct ASNs. The snapshot builder leaves out every live node that loses its ASN (Task 9 fix round 1, ADR-0033 item 4 amendment): **F1** incumbency comes from the committed snapshot (`current_snapshot`), so every validator computes the same; **F2** the earliest binding commitment on chain wins, then the lower `asn_tie` of the hash of the block after it, and a grinder can't commit before it has seen its victim's key, so it always loses, to an incumbent or to a newcomer; **F3** the snapshot carries each ASN's claim for `SNAPSHOT_INCUMBENCY_WINDOWS` windows after its node was last in it, so a squatter can't take the ASN while the node's binding or consent is lapsed or it is quarantined. Origins refuse a colliding peer alone (F4), and two snapshot nodes with one ASN refuse the snapshot, so a collision never reaches a node's origin lists. Residuals: (1) until Task 19b fills `binding_committed_blocks`, only incumbency ranks anyone, so two colliding newcomers are both left out (round 1's newcomer blocking). (2) An operator who serves its binding, or otherwise leaks its key, before the commitment is included lets a grinder put M colliding keys in the same block; the tie then picks among M + 1, so the victim keeps its ASN with probability 1/(M+1), not one half (`run-a-node.md`). (3) A key committed early ranks before every later node it happens to collide with, **incumbents included**: an incumbent whose binding was committed later than a colliding key is evicted when that key goes live. With K committed (possibly dormant) keys, up to 1024 per fleet binding (`MAX_FLEET_NODES`), and N later nodes, about K·N/95M random later nodes are evicted (inferred), each of which rotates its key. **Recommended follow-up rank:** first admitted window (the first snapshot the node was in), then commitment block, then the tie, so a dormant early commitment can't outrank a node already admitted; Task 19b must reset a node's commitment block when its binding lapses, so a lapsed binding committed again ranks from its new block **Task 19b:** residual (1) closed: the live loop fills `binding_committed_blocks` from its chain reads and resets the block on any lapse. | scoring.md §Snapshot inputs, datapath.md "Route origin validation", adr/0033 item 4 | `a_ground_key_that_collides_with_an_incumbent_is_refused_and_the_incumbent_stays`, `the_earliest_binding_commitment_wins_between_newcomers`, `a_claim_outlives_a_lapse_and_then_expires`, sims `asn_incumbent_evict`, `asn_grind_newcomer_block`, `asn_squat_after_lapse`, `fleet_mate_origin_hijack` |
| T84 | **MITIGATED (Task 9 final check).** Claim-map growth: a snapshot keeps each ASN claim for `SNAPSHOT_INCUMBENCY_WINDOWS` (24) windows after its node was last in it, so one UID binding `MAX_FLEET_NODES` (1024) fresh keys every window would keep about 24 × 1024 claims. With a block and a tie each, that passes `MAX_OBJECT_BYTES` (4 MiB): measured in the T84 test with the cap taken out, the signed snapshot reached 4,318,080 bytes before window 30 and canonical encoding refused it, so the signed snapshot can't be published and every node keeps the last one | Operator | Each claim records its node's `uid`; a UID holds at most `MAX_FLEET_NODES` claims, the claims whose node was in a snapshot longest ago dropped first, then the lowest ASN (`validator::cap_claims_per_uid`). A UID's nodes in the snapshot are its newest claims, so only lapsed ones go. Residuals: a UID rotating keys drops its own lapsed claims, so its old ASNs free early, which costs only that UID. Across UIDs the map is still unbounded below 4 MiB: about 24 UIDs each at the cap with full claims would pass it (inferred from the measured size, about 170 bytes a claim), as would the nodes of a snapshot that large. A global bound needs ADR-0046's `MAX_SNAPSHOT_NODES` (proposed), which should cap claims as well as nodes | scoring.md §Snapshot inputs, routing.md | `one_uid_rotating_fresh_keys_keeps_its_claims_capped_and_the_snapshot_publishable`, `the_claim_cap_drops_the_oldest_then_the_lowest_asn` |
| T87 | **OPEN, bounded (Task 11c, fix round 1).** Anchoring jump. A node's rate limit on set and directory blocks counts from the first directory it accepts after anchoring on the operator's file (at start or on a re-anchor). Before that first directory it accepts sets and directories up to the file's set's `not_after` (`anchor_cap`) plus `MAX_SET_ADVANCE_BLOCKS`, so a captured quorum that catches a node at an anchoring can move it up to one set's remaining life ahead at once, and from there chain sets at real-time speed. Restarts don't re-grant it (RT1): the base is persisted with a wall-clock stamp | Holders of attest keys with a quorum of the set a node holds, at the node's start or a re-anchor | `now_block <= anchor_cap + 2 × MAX_SET_ADVANCE_BLOCKS + elapsed / BLOCK_SECONDS` (`anchor_cap + 1440 + elapsed`), where `anchor_cap` is the file's set's `not_after`, never a later held set's. A restart comes back on the lower of the persisted base and the held directory's block, moved on by the wall-clock downtime, and that credit is capped at the held set's remaining life (fix round 2, F1), so the cap after a restart is never above `held set not_after + 720 + blocks elapsed since the restore`, however far a spoofed wall clock jumps. The credit is recomputed at every poll after a restore onto a new clock, until the next re-anchor, so a forward jump while running counts too, within that same cap. A wall clock behind the state's stamp at the restore (no RTC, a start before NTP syncs, or a stamp taken while the clock was pushed) is taken as unknown: the rate limit gets that whole cap at once (fix round 3). The stamp itself is the wall clock read at the first poll or restore plus monotonic time since, so a clock moved while the node runs never reaches it. The expiry floor and the set timer get no downtime credit on a new clock at all (fix round 4), so a clock jump can't expire bindings or raise an alarm either. Across restarts onto new clocks `now_block <= first + 720 + uptime / 12 s + Σ cᵢ`, where restart `i`'s credit `cᵢ` is the wall-clock downtime capped at the held set's remaining life at that restore, and is that whole remaining life when the wall clock is behind the stamp, whatever the real downtime (so even an honest boot with no RTC takes the full cap); with an honest clock this is `first + 720 + Σ downtime / 12 s` plus the uptime. The operator's file is an override that drops the captured inputs (`rollback`). Residual: a wall clock moved around a restart, or forward at any poll after one, widens the cap by up to the held set's remaining life, once per restart (OQ-77) | datapath.md "Signed inputs", ADR-0042 item 5 | `signed_input_set_and_directory_blocks_advance_no_faster_than_the_clock`, `signed_input_restarts_cannot_chain_anchoring_jumps`, `signed_input_a_wall_clock_jump_across_a_restart_is_bounded`, `signed_input_a_forward_spoof_while_running_does_not_lock_out_after_a_restart`, `signed_input_a_credit_after_a_rotation_keeps_the_new_sets_timer`, `signed_input_a_restart_onto_a_new_clock_gives_the_set_timer_no_credit`, `signed_inputs_cli_the_set_timer_counts_uptime_across_a_reboot` |
| T88 | **MITIGATED (Task 11c).** Fetch stall. A store that accepts a connection and never answers, or trickles bytes, holds a node's input path, and on a single-threaded node its forwarding | Any listed store, or anyone on the path to it | Fetching runs on its own thread (`signed_input::Fetcher`) with `FETCH_TIMEOUT` per request across all peers at once; the node's loop takes a finished poll only if one is waiting. Peers are IP literals, so no resolver call runs outside the deadline | datapath.md "Signed inputs", routing.md §Distribution | `a_slow_object_server_never_stalls_forwarding` |
| T89 | **ACCEPTED (Task 11c).** State tampering. The node trusts its own `signed-inputs.json` after a restart without checking attestations again, so whoever can write the state directory can make it apply any table | Anyone with write access to the node's state directory | That directory also holds, or sits beside, the node key, so write access there already owns the node. The set it holds is validated (`ValidatorSet::validate`) and the directory structurally checked on load; a state that doesn't parse is logged (`SignedStateUnreadable`) and the node starts from the operator's file | datapath.md "Signed inputs" | `a_restarted_node_loads_its_last_applied_window_and_refuses_older` |
| T90 | **OPEN, bounded (Task 4B).** Forged agreed underlay. The same colluders get fake `origin`, `roa_origin`, `upstream` and `ix_presence` records agreed for their own nodes' prefixes, giving those nodes a unique network with two upstreams and an IXP | Colluding validators with miners | Diversity saturates at two upstreams and one IXP, and multiplies only carried bytes. A forged node therefore earns at most `1e6 + DIVERSITY_WEIGHT_PPM + IXP_PRESENCE_WEIGHT_PPM` (1.1x) of its own usage term, and only while T61's stake minimum holds | measurement.md §Underlay, scoring.md §Coverage | `agreed_underlay_forger`, `underlay_ambiguity_mass_grief` (with T82: colluder share at most `1.1^2` of its honest share) |
| T91 | **MITIGATED (Task 4B fix round 3, finding 1); inert until an endpoint producer exists.** Stuffing the endpoint-less pool. Fix rounds 1 and 2 pooled every node with verified capacity and no endpoint into one global group credited up to its largest member, so an attacker with many cheap endpoint-less nodes took a share of the largest honest member's capacity (about 50x at 100 nodes of 10 Mbps), and an honest endpoint-less node got `1/n` of its own | Operator | An endpoint-less node gets zero scoring capacity while endpoint dedupe is on: nothing to `K_u`, its own dedupe group, usage credit for bytes on assigned paths kept and capped at its own verified capacity. No shared pool exists to stuff. Residual: an honest node without an endpoint (a carrier spreading it over several /24s, or a split vote, T92) loses its capacity credit for the window. Dedupe turns on only when the batches carrying endpoints meet the stake quorum (finding 3), so a few validators running a producer can't zero everyone | measurement.md §Probed endpoints ("Dedupe"), scoring.md §Endpoint dedupe | `unknown_group_stuffer`, `endpoint_absent_sybil`, `cgnat_honest_node`; `nodes_with_capacity_and_no_endpoint_fail_closed`, `the_winning_prefix_needs_a_majority_and_dedupe_needs_the_stake_quorum` |
| T92 | **MITIGATED, with a residual (Task 4B fix round 3, finding 2); inert until an endpoint producer exists.** Picking a node's dedupe group with two hotkeys. A colluding pair can meet `MIN_VALIDATORS` and the quorum together and report a victim inside a /24 of its choosing, pooling victims' capacity | Colluding validators | The winning prefix must also hold more than half of the stake that reported the node, so the pair wins only with a majority of the reporters, and honest validators agreeing on one prefix keep the group. **Residual: a split vote.** When honest reports split across two prefixes (a dual-stack node), no prefix may hold a majority, or the larger side misses the quorum (honest 30% and 25% with the attacker silent). The node then has no endpoint: it keeps usage credit and gets no capacity credit (T91). Colluders can turn a split that would pass (honest 40% and 15%) into one that doesn't by reporting a third prefix, a grief with no gain to them | measurement.md §Probed endpoints ("Quorum and majority per prefix") | `endpoint_minority_pool_griefer` (one and two hotkeys; split-vote figures in its detail); `the_winning_prefix_needs_a_majority_and_dedupe_needs_the_stake_quorum` |
| T93 | A node shades the STAMP RTT on the probe session it opened: it answers a test before it arrives, guesses the next one, or writes timestamps that shorten the RTT (Task 4Db, ADR-0039) | Operator | Every `seq` is fresh OS randomness and the gaps are exponential, so nothing can be answered early; a reply counts only if its `sender_seq` and `ssid` match a test already sent and it comes within `STAMP_REPLY_DEADLINE_MS`; the RTT is `T4 - T1` on the agent's clock and the node's timestamps never enter it. A node can only add delay | measurement.md §STAMP probes and probe sessions | `a_stamp_reply_before_its_test_left_or_after_the_deadline_is_lost`, `a_reply_with_a_foreign_seq_or_ssid_counts_for_nothing` |
| T94 | **OPEN, recorded (Task 4Db).** A node gives its probe sessions priority over real traffic, and looks better to `vantage:` than it treats customers. It knows which sessions are probe sessions and that STAMP is a probe | Operator | Not closed by probing. Link, direct and path canaries stay random-payload and inside ordinary traffic; only measuring carried traffic (ADR-0038 secure sampling, pay moving to carried traffic) closes it | measurement.md §STAMP probes and probe sessions, Residuals | — |
| T95 | A probe key is used as a way into the node: a listed probe peer, or someone holding its key, sends BGP, transit or traffic to other addresses on the probe session, or spoofs another source, or floods the node's reflector with STAMP tests (Task 4Db) | A validator's probe agent; a thief of its key | A probe peer is never in the FIB or a route's path and has no BGP or BFD; the node takes only STAMP tests from its probe address to its own `/128` and drops the rest in `drop_probe_peer`. The reflector answers each probe peer at most `PROBE_PEER_STAMP_PER_SEC` (20) tests a second, with a burst of `PROBE_PEER_STAMP_BURST` (20), from a token bucket on the node's clock; tests over it are dropped and counted in `stamp_rate_limited` (fix round 1, red team RT4) | datapath.md §Peer admission, "Probe peers" | `a_probe_peer_gets_no_bgp_session_and_no_routes`, `a_probe_peer_flood_is_rate_limited` |
| T96 | Strangers open sessions to a probe agent to use up its session slots, its memory or its handshake work, so the agent can't probe honest nodes and they take `vantage:` failures (Task 4Db; fix round 1, red team RT1) | Anyone on the internet; a framer | The agent opens a session only for a bound key (a node it knows by its binding), so strangers never take a slot, and the slot count is checked before any key agreement. Every session's `Tunn` shares one boringtun rate limiter (`PROBE_AGENT_HANDSHAKES_PER_SEC`, 100), checked before the agent's own handshake parse: past it, an initiation needs a cookie for its source address, so a spoofed flood costs the agent no key agreement. At most `MAX_PROBE_SESSIONS` (1_024); the socket drops datagrams over 1,500 bytes | measurement.md §STAMP probes and probe sessions | `bound_nodes_get_a_session_after_1024_strangers`, sim `vantage_denial_framer` (bound 1.05x) |
| T97 | **MITIGATED for the cases `policy_griefer` covers (Phase B Task 7, PB-23; fix round 1); inert until a policy producer exists (OQ-88).** Policy griefing of solvers. A relay's operator sets `allowed_peers` to refuse the sources a rival solver's table routes through it, hoping the rival's table turns invalid, regretful or dead in the data plane | Operator, possibly with a solver | Policy is read only from the committed snapshot, and a table is graded against the snapshot it was solved on (`window == snapshot.window + 1`), so every solver reads the policy before solving. The reference solver and the regret comparator read it, so respecting it is never regret. Nodes render it only from the solved-on snapshot (`bgp-overlay` refuses a policy snapshot of another window). What the sim covers: a relay refusing a source, with two honest solvers solving on the committed snapshot. No solver's rank changes, and the relay carries fewer routes, not more. **Not claimed:** that a policy can never draw more transit to a node. Policy only removes options at its own node, but removing a rival's path can shift a pair onto another relay the same operator runs. That's bounded by the other relay's own capacity and price, and not covered by a sim | routing.md §Operator policy and §Validation ("Operator policy"), datapath.md §Operator policy, scoring.md §Mechanism 1 | `policy_griefer`; `a_route_through_a_node_whose_policy_excludes_the_previous_hop_is_invalid`, `a_policy_change_applies_from_the_next_committed_snapshot`, `the_reference_solver_respects_operator_policy` |
| T98 | **MITIGATED (Task 7 fix round 1, red team F1); inert until OQ-88.** Endpoint capture (Invariant 2). A source or destination names only its own colluding relay in `allowed_peers`, so every valid table must send its pairs through that relay, and the reference does too | Operator with a relay | Policy binds a node only as a relay, never as a route's end: an endpoint's policy constrains none of its own pairs, in validity, the reference solver, the comparator and rendering | routing.md §Operator policy ("Policy binds transit only"), §Validation rule 0 | `policy_endpoint_capture` (1.0x: the colluding relay carries 0 of the endpoint's pairs with the policy, as without; an honest table stays valid); `an_endpoint_keeps_its_capacity_and_its_choice_of_relays_under_policy` |
| T99 | **MITIGATED (Task 7 fix round 1, red team F2); inert until OQ-88.** Regret-gate bypass. A source sets `max_transit_mbps = 0`. The first version lowered its whole capacity in the search view, so the regret comparator found no path from it, and the Mechanism 0 regret gate never zeroed a dealer's slow detour from that source through the dealer's relay | Operator with a solver | The transit cap is a separate per-node cap, checked only where the node is interior. Endpoints keep their snapshot capacity in every search, so the comparator still finds the fast path and the gate zeroes the detour | routing.md §Validation ("Reference solver and regret") | `policy_regret_gate_bypass` (0 ppm credit left on the gated detour); `an_endpoint_keeps_its_capacity_and_its_choice_of_relays_under_policy` |
| T100 | **MITIGATED (Task 7 fix round 1, red team F3); inert until OQ-88.** Capacity pay for unusable capacity. A node keeps full verified capacity, and so its `K_u` share, while its policy (`max_transit_mbps = 0`, an empty or tiny `allowed_peers`) keeps solvers from using it | Operator | Scoring capacity is capped at `min(deduped, max_transit_mbps)`, scaled by the share of other live nodes `allowed_peers` names, and naming fewer than two gives 0 | scoring.md §Endpoint dedupe ("Policy cap") | `policy_capacity_farmer` (0 Mbps credited above what policy leaves usable, in five cases); `capacity_credit_is_capped_by_max_transit_and_scaled_by_admitted_peers` |
| T101 | **MITIGATED (Task 7 fix round 1, red team F4); inert until OQ-88.** Churn flapping. An operator flips its relay's policy every window, so each solver routing through it must move its routes and pay `CHURN_PENALTY`, against an incumbent with a previous table and not against a newcomer | Operator, possibly with a rival solver | Policy follows the declaration epoch: the policy in force for a window is the one read at its epoch's first window, so a change, tightening included, waits for the next boundary (`validator::policies_in_force`). A pair whose previous route breaks the policy in force isn't counted in `churn_ppm`. **Residual:** a route that breaks only the table-wide cap (rule 3) when moved still counts as churn | routing.md §Operator policy ("When a policy applies"), scoring.md §Mechanism 1 | `policy_churn_flapper` (0 ppm penalty, bound below `EPSILON_ROUTE`); `a_policy_change_waits_for_the_next_epoch_tightening_included`, `moving_off_a_path_the_policy_now_forbids_is_not_churn` |
| T102 | **MITIGATED (Task 4Dc fix round 1; OQ-93 closed).** Withholding against a node just under its declaration. A member streamed its share but revealed no batch; it was dropped and the test judged on the other members' `sent`, though the node had spread its capacity over every stream, the headroom included. An honest node carrying `x` of its declaration showed `ratio_t ≈ x / 1.1`, haircut at `x = 0.97` (0.59x of its credit) | Validator | `S`, `pushed` and the median term use the whole scheduled team's rates, revealed or not; `Σ c_i` stays over the revealed members (capped shares, T103, which this rule needs: without them two absent members and a colluder gave 3.64x). An honest node at 97% keeps 0.75x of its credit, never haircut; withholding never lifts a node above an honest declarer of its real capacity | measurement.md §Team capacity tests ("Members that reveal nothing") | `withholding_near_declaration` (0.749x, gating), `void_by_withholding` (swept 500-1000, at most 0.88x), `withholder_fix_k2_colluder`; `a_withheld_batch_never_haircuts_an_honest_node` |
| T103 | **MITIGATED, residual restated (Task 4Dc fix round 1, red team F1).** Uncapped `Σ m_i`: one colluding member reporting `m ≫ rate`, with a node-signed ack, while the node starves one honest member gave 1.82x at `k = 4`, 2.73x at `k = 3`, and 3.64x with two colluders, no haircut. Cohort aggregates were inflated the same way | Validator + Operator | `measured = min(Σ c_i, median)` with `c_i = min(m_i, rate_i)`, in node and cohort combining. Residual: `(k-1)/(k-2)` for one colluder (1.5x / 2x) and `(k-1)/(k-3)` for two (3x at `k = 4`), on the tests the colluder sits on (T42(b), (e)) | measurement.md §Team capacity tests ("Combining", "Residuals") | `colluder_overreport_k4` (1.500x), `colluder_overreport_k3` (1.997x), `two_colluders` (3.000x), `colluder_overreport_end_to_end` (1.500x); `an_overreporting_member_is_capped_in_the_sum` |
| T104 | **MITIGATED (Task 4Dc fix rounds 1-4, red team F3, N3, N4).** Proven tiny-sybil slot flood: four UIDs of 1024 proven keys at 5 Mbps, each test taking four member slots whatever its rate, cut honest proven tests to 12% and honest fresh tests to 0 at 8 validators | Operator | Every tier, cohorts included, goes in a round-robin by UID by the smallest `t_uid / weight_uid`, where `weight_uid = max(Σ prev_pooled_capacities, CAP_RAMP_FLOOR_MBPS × clamp(unproven nodes, 1, CAP_TESTS_PER_UID_MAX))`: pooled capacity (T112), 0 for an endpoint-less node and one node per UID while dedupe is off (T114). A cohort is keyed by its members' smallest `t_u / (weight_u · m_u / N_u)` (T111, T115). A test that can't start holds its drawn free members for the block and waits up to `CAP_TEST_DEFER_BLOCKS` (4), then is skipped; a tier-3 test over the UID's `CAP_TESTS_PER_UID_MAX` is dropped before it is drawn. Bounds (fix rounds 3-4, worst of 3 seeds × 4 windows, `make sim-flood`): 0.85 for at most 8 flood UIDs at 8 or more validators, 0.80 for at most 16 at 8, 0.75 for at most 12 at 6 (16 at 6 not gated: 0.72 / 0.76); fresh 0.5 under 4 UIDs and 0.33 under 8-16, an entry delay (measured single 0.82-0.95, fleet 0.80-0.95, fresh 0.33-0.75; see `measurement.md` "Per-UID fairness"). Cost: notice of up to about 60 s (T41) | measurement.md §Team capacity tests ("Slots, order and per-UID cap") | `proven_sybil_slot_flood`; `tiers_two_and_three_go_round_robin_by_uid`, `a_due_test_waits_for_a_free_team`, `a_failed_assignment_waits_rather_than_dropping` |
| T105 | **OPEN (red team F4), blocks team mode.** Test target not bound to the endpoint: nothing committed ties a team stream to the endpoint validators see on the node's sessions, so one sink box holding N node keys can answer the tests of N nodes whose endpoints are in N /24s (about 16x for 20 keys behind a 10 Gbps box) | Operator | Normative: team mode MUST NOT be enabled (Task 19b MUST NOT fill `block_hashes`) before Task 18b runs team streams inside source-matched probe sessions with a per-validator member agent; `cap --team --target` is localnet and test only. Plan Tasks 18b and 19b carry it | measurement.md §Team capacity tests ("Team mode MUST NOT be enabled before Task 18b") | `test_target_offload` (Task 18b) |
| T106 | **MITIGATED given Task 19b's anchor (Task 4Dc fix rounds 1-2, red team F6, N2, review R10).** `validator_sets` trusted structurally, ties broken by a grindable hash: a forged same-block set could control `E(b)`, an expired set stayed in force, and validators holding different sets disagreed | Validator | `validator::verified_set_chain(anchor, sets)` walks from `TempoInput.prev_validator_set`, the set in force at the previous window from chain state (Task 19b); a set counts only if the current set's quorum attests it (`signed::accept_next_set`); two accepted sets at one block are both refused and the current set stays; a set is in force only while `b <= not_after`; no anchor, no `E(b)`. Before signed sets, a hotkey without an attestation record is never drawn (R8). See T109 **Task 19b:** the anchor is the metagraph-built set at the window's first block from committed records (the re-anchor rule; no committed in-force set hash exists yet), the same for every validator with the same reads. | measurement.md §Team capacity tests ("Eligible validators") | `validator_set_tiebreak`; `validator_set_tiebreak_refuses_both_sets_at_one_block` |
| T107 | **OPEN, recorded (red team F8; OQ-90).** Cohort ceilings and chunk steering. (a) A group's credit is at most one team's budgets (10 Gbps at `k = 4`) and its best 16-node chunk, so a CGNAT /24 of 160 honest home nodes is credited as about 16 (0.1x). (b) Chunks are cut by sorted node key, which is free to grind: a planted key can push an honest member into a chunk of one, which isn't a cohort. (c) A budget-starved cohort member's low record entered its `measured` | Operator | (c) fixed in Task 4Dc fix round 1: a budget-starved member's record is `ratio_only`. (a) and (b) aren't redesigned; OQ-90's per-/24 measurement and ordering members by a block-hash slot key before chunking are the candidates | measurement.md §Cohort capacity tests | `a_cohort_member_never_streams_more_than_its_budget`, `a_climbing_ramp_is_not_an_overclaim` (ratio-only records) |
| T108 | **MITIGATED (Task 4Dc fix round 2, red team N1).** Overflow draw: teams were drawn only among validators with a free slot, and every hotkey brings `CAP_TEST_MAX` slots whatever its stake, so under load (or the attacker's own key flood) tiny-stake hotkeys filled whole teams: 32 hotkeys at 3.85% of stake gave all-attacker teams on 73% of the attacker's tests and 66% of honest nodes' tests at 8 validators (the declaration credited for nothing; victims zeroed and haircut) | Validator + Operator | The team is drawn by stake from all of `E(b)` at each block; members without a free slot are dropped; the test starts with all drawn members free, or at least `CAP_TEAM_MIN_VALIDATORS` at its last chance, else waits. Bound: all-attacker teams at most 0.01 of tests, two or more attacker seats at most twice the stake-proportional rate, honest single-node UIDs at least 0.85 of their due tests (measured 0.000, 0.000 and 1.00 at 8 and 16 validators). The deferral's late-queue concentration (red team N6) goes with it: the late-queue beneficiary had no all-attacker team and no team of three | measurement.md §Team capacity tests ("The team") | `validator_hotkey_overflow`; `the_draw_is_by_stake_never_by_free_slots` |
| T109 | **MITIGATED given Task 19b's anchor (Task 4Dc fix round 2, red team N2, review minors 1-2).** `verified_set_chain` grouped sets by block before checking attestation, and anchored on the lowest self-attested set: an unsigned set at an honest set's block voided it (at every block: no team tests), and a self-attested set below the honest chain took over `E(b)` | Validator | A trusted anchor parameter (`TempoInput.prev_validator_set`, from chain state); only sets the current set's quorum accepts are candidates, so an unattested or self-signed set can neither veto nor anchor; equivocation is counted only among accepted sets. Residual: the anchor is trusted as given, so Task 19b MUST take it from chain state **Task 19b:** `prev_validator_set` comes from chain reads, never a gossiped object. | measurement.md §Team capacity tests ("Eligible validators") | `validator_set_tiebreak` (unsigned sets at 200 and 300, attacker-signed sets at 50 and 250: chain stays `[100, 200, 300]`) |
| T110 | **MITIGATED (Task 4Dc fix round 2, red team N3, N4).** Schedule starvation after F3's fix: (a) a flood packaged as cohorts (tier 1, `t_uid = 0`, no cap) gave honest single-node UIDs 0.25, fleets 0.03 and fresh nodes 0.00 at 12 × 1024 keys and 8 validators; (b) the unweighted round-robin by UID gave a 200-node honest fleet 0.57 (0.22 against 12 flood UIDs) | Operator | Cohort tests count against every member's UID in the round-robin; the round-robin is weighted by the UID's verified capacity; tests hold their drawn free members (T104). Measured at 8 validators: 12 UIDs as node tests single 0.91, fleet 0.87; as cohorts single 0.97, fleet 0.86; fresh 1.00. Residual: a UID's weight is its own verified capacity, which only tests (and T42's colluder residuals) raise, so weight can't be bootstrapped beyond what inflated credit already gives; splitting into UIDs gains `CAP_RAMP_FLOOR_MBPS` of weight per UID registered | measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") | `proven_sybil_slot_flood` |
| T111 | **MITIGATED (Task 4Dc fix rounds 3-4, red team R1; bound re-ruled in round 4, review B2).** A cohort was keyed by its members' largest `t/w`: honest multi-operator cohorts behind one /24 got 0.55 of due cohort tests with no flood and 0.18 under the 4 × 1024 flood (8 validators); cohort credit lapsed and the group was pooled to one member (about 0.6x on average) | Operator | Cohorts are keyed by the members' *smallest* `t/w`, still charged to every member UID (N3 stays closed: 12 × 1024 as cohorts 0.93 / 0.91). Measured (`cgnat_cohort_turns`, 3 seeds × 4 windows): mean 0.91, worst seed 0.88 with no flood; under the flood mean 0.83, worst seed 0.76. Gated at mean 0.9 and worst 0.85 with no flood, mean 0.80 and worst 0.75 under it. The lower flood bound is ruled, not a gap: about 16 cohort tests fall due per seed (±0.1 by sampling alone), and cohort-credit lapse, what pay sees, is 9/240 cohort-windows with or without a flood (T116(a)). Round 4 keys a cohort by each member UID's per-node weight (T115), unchanged for single-node UIDs. Residual: home nodes weigh the ramp floor, so once each member has had its own test the cohort trails larger UIDs | measurement.md §Team capacity tests ("Per-UID fairness") | `cgnat_cohort_turns`; `a_cohort_takes_its_least_tested_members_turn` |
| T112 | **MITIGATED (Task 4Dc fix round 3, red team R2, R4).** Schedule weight from unpooled per-node verified capacity: 4 UIDs × 1024 co-located keys at 50-200 Mbps (≤ 1.1 Gbps in flight) cut honest single UIDs to 0.76-0.78 and the fleet to 0.51. The per-UID floor held a multi-node fresh UID to 0.38-0.57 | Operator | Weight = Σ pooled previous capacity (`TempoInput.prev_pooled_capacities`, the T24 figure pay uses, filled by Task 19b); floor `CAP_RAMP_FLOOR_MBPS × clamp(unproven nodes, 1, CAP_TESTS_PER_UID_MAX)`. Measured: co-located flood single 0.93, fleet 0.89, fresh 0.75; fresh 0.50 under the 4-UID node flood (gated 0.5), 0.33-0.50 under 8-16 flood UIDs (gated 0.33 since fix round 4). Residual: bootstrapping the weight now needs real pooled capacity; colluder inflation (T42) remains; UID splitting: up to `4 × CAP_RAMP_FLOOR_MBPS` (+400 Mbps) of weight per registered UID with four unproven keys (tier-3 capped); 32 holder UIDs × 4 keys keep the fleet at 0.87, 64 at 0.76 (red team L2, T116(b)). Endpoint-less keys and dedupe off: T114 **Task 19b:** the loop carries `prev_pooled_capacities`. | measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") | `colocated_flood_weight`, `proven_sybil_slot_flood`; `unproven_nodes_each_bring_the_ramp_floor_weight` |
| T113 | **(a) MITIGATED, (b) OPEN for Task 19b (Task 4Dc fix round 3, red team R5, R6).** (a) A late-queue node started at its last chance with three on 31-62% of tests, so T42's one-colluder residual was 2x there and two-of-three needed only the `k = 4` draw's stake. (b) The set walk had no re-anchor: a ≥ 1/3 withhold or a gap of more than 720 blocks freezes `E(b)`; an expired set still accepted a successor | Validator + Operator | (a) A test started at its last chance with a drawn member dropped (`CapAssignment.short`) records `team` capped at `max(verified_prev, CAP_RAMP_FLOOR_MBPS)`: it can lower, never raise. (b) An expired set accepts no successor (`verified_set_chain`); Task 19b's plan item now names one anchor source (the committed in-force set hash), the re-anchor rule (metagraph-built set at the window's first block) and the first team-mode window's anchor **Task 19b:** (b) the loop uses the re-anchor rule's set every window. | measurement.md §Team capacity tests ("The team", "Eligible validators"); plan Task 19b | `late_queue_short_team` (0.281x, 1.572x uncapped), `validator_set_tiebreak` (expired anchor: `[100]`); `a_short_last_chance_team_can_only_lower` |
| T114 | **MITIGATED with dedupe on; with dedupe off team mode isn't enabled (Task 4Dc fix rounds 4-5, red team E1, A1, review B4).** Endpoint-less keys escaped the pooled schedule weight: `pooled_capacities` was `scoring_caps`, and the fail-closed `endpointless_nodes` rule applied only to `K_u`. A box showing two /24s to split validators, with 4 UIDs × 1024 keys verified at 200 Mbps by sequential tests, cut the honest fleet to 0.51 (0.30 at 8 UIDs) and singles to 0.78 of due tests (bound 0.85), and made R3's 5 Mbps floods one-box cheap. With endpoint dedupe off (production today: no producer until PB-06) every weight was unpooled | Operator | The schedule weight applies pay's rules (`validator::schedule_weights`, `TempoOutcome.pooled_capacities`): with dedupe on, an endpoint-less node weighs 0; with dedupe off, each UID weighs its largest single node, one pipe, not the sum. Measured (`endpointless_flood_weight`, worst seed): dedupe on, 4 / 8 UIDs single 0.93 / 0.92, fleet 0.89 / 0.86, fresh 0.75. **With dedupe off team mode isn't enabled (T124)**, so the rest bounds only the schedule weight, now each UID's lower-median node (round 5): 200 Mbps keys, fleet 0.86 / 0.82 (gated 0.85 / 0.80); one 1 or 10 Gbps anchor per UID, fleet 0.87 / 0.84 (gated 0.85 / 0.80; the largest node gave 0.51 / 0.30 and 0.07 / 0.04); every key at 1 Gbps, fleet 0.50 / 0.29 (gated 0.45 / 0.25), where no per-UID statistic helps (review B4; sim `dedupe_off_anchor_weight`). The fleet's weight returns with endpoints (PB-06) | measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID", "Per-UID fairness"), §Probed endpoints ("Dedupe", "Residuals") | `endpointless_flood_weight`, `dedupe_off_anchor_weight`; `schedule_weights_zero_endpointless_nodes_and_keep_one_pipe_per_uid_when_dedupe_is_off`, `prev_pooled_capacities_order_the_round_robin`, `run_tempo` pooled-capacity assertions in the `[T24]` test |
| T115 | **MITIGATED (Task 4Dc fix round 4, red team E2).** Cohort ride-along. Cohorts were keyed by the members' smallest `t/w`, so one proven attacker key in each of a fleet's /24s made tier-1 cohorts that ran at the fleet's turn and were charged to it. 200 keys at 5 Mbps (one UID) cut the fleet's node tests from 0.97 to 0.67, singles from 0.96 to 0.86 and fresh UIDs from 1.00 to 0.57 at 8 validators | Operator | A cohort is keyed by `min_u t_u / (w_u · m_u / N_u)`, `m_u` being u's members in the cohort and `N_u` its schedule nodes, so a UID lends only its per-node weight; every member UID is still charged. Measured (`cohort_ride_along`, worst seed): fleet node tests 0.92, singles 0.95, fresh 0.75 (bounds 0.85, 0.85, 0.5); the riders' cohorts run at 0.43 of due. R1's CGNAT cohorts are unchanged (single-node UIDs, `m = N = 1`); 12 × 1024 packaged as cohorts now go last and the flood competes as node tests (single 0.88, fleet 0.89, fresh 0.33) | measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") | `cohort_ride_along`, `proven_sybil_slot_flood`, `cgnat_cohort_turns`; `a_cohort_borrows_only_its_members_per_node_weight` |
| T116 | **(a), (b) OPEN, LOW; (c) MITIGATED in fix round 5 (Task 4Dc fix round 4, red team L1-L3).** (a) Cohort credit is kept for 8 history entries, but a cohort falls due about once per 2.5 windows, so about 4% of cohort-windows lapse with no attacker (9/240), and a multi-operator CGNAT group is paid as one member then (about 3.5% of such groups' capacity term on average). (b) The unproven floor gives each registered UID up to 400 Mbps of weight (64 holder UIDs × 4 keys: fleet 0.76). (c) The short cap (T113) doesn't cover a short cohort test's aggregate | Operator | (a) Documented; OQ-95 proposes credit until the cohort's next due test. (b) Documented in T112's residual and T104's formula; each holder UID costs a registration, and tier 3 is capped per UID. (c) Fix round 5 caps a short cohort test's aggregate at `Σ max(verified_prev(n), CAP_RAMP_FLOOR_MBPS)` (`validator::short_capped_cohort`, T125). In team mode (a) is about 15% with two samples required (T125) | measurement.md §Team capacity tests ("A last-chance team of three can only lower"), §Cohort capacity tests (item 5); capacity-bonds.md §Endpoint dedupe | `cgnat_cohort_turns` (lapse figures from the red team's round-3 re-check) |
| T117 | **MITIGATED (PB-29).** Provider session leak. A kernel node that also peers with its hosting provider announces overlay `fc00::/8` routes or its overlay ASN to the provider, which sends transit out of the overlay (Invariant 4) and exposes the topology; or takes a provider route, which the provider can use to steer overlay traffic | A hosting provider, or an operator by misconfiguration | The provider session is its own `bgpd` instance in VRF `bwos-provider`, with its own RIB and kernel table. Outbound permits only the operator's `announce` list and nothing else (the implicit deny drops the provider's own default, `fc00::/7` and the rest), with `fc00::/8 le 128` denied first as a second layer; the VRF's table ends in an `unreachable default` and the forward filter drops anything entering on `bwos-provider`, so a packet from the provider side can not be routed into the overlay when the provider's default is gone; inbound accepts only `::/0` and `0.0.0.0/0`; nothing is imported between the VRF and the overlay; `check_provider_bgp` refuses an overlay-range neighbor and a node-range ASN; a table update never touches the instance; the interface can not be the host's default route. **Residual:** a single-NIC host can not use it yet (OQ-96); the provider's default route is not used by the host, which keeps its own, by design | datapath.md "Provider BGP stays separate" | `provider_bgp_separation.sh` (a leak attempted from inside the VRF stops at the outbound map; mutating the map fails it), `overlay_bgp` provider unit tests, `kernel_install.sh` |
| T118 | **MITIGATED (Task D1 fix round 1, red team F1).** Receipt-store lockout by node-key sybils of one UID. A UID binds about 123 node keys and uploads 8 non-dominating one-receipt batches per key per window, filling the store so honest nodes' batches are refused, and refills each new window first | Operator (bound node keys) | A node's first batch for a window is always admitted from a reserve; extras are capped per window (`MAX_RECEIPT_EXTRA_BATCHES_PER_WINDOW`) and per UID (`RECEIPT_UID_QUOTA_PER_NODE` per node it has, from `--receipt-nodes-file`'s UID map); new uploads outside `[current − 4, current + 2]` are refused; one UID holds at most `RECEIPT_UID_EXTRAS_CAP` extras. **Residual:** bounds count batches, not bytes; a byte budget is a Task 19b requirement (OQ-98) | receipts.md §Submission | `object_store::tests::f1_r3_sybils_of_one_uid_cannot_lock_out_honest_first_batches` (red team R3) |
| T119 | **MITIGATED (Task D1 fix round 1, red team F2).** Window receipt file inflated past the `run-tempo` read bound. About 35 full batches made `window-<w>.json` exceed 16 MiB, so `run-tempo` skipped the whole window and every operator's receipts were uncounted at that validator; past 256 MiB a restart moved it aside and truncated it | Operator, or a busy honest fleet | One file per batch (`receipts/window-<w>/<node>-<hash>.json`, each under `MAX_OBJECT_BYTES`); `run-tempo` reads the window directory with the bound per file; an oversize file is never moved aside, and `.corrupt` names are unique | receipts.md §Submission | `tests::f2_r1_a_window_past_the_file_bound_is_scored_in_full_after_a_restart` (red team R1) |
| T120 | **MITIGATED (Task D1 fix round 1, red team F5, review I1).** Object-store connection and verification exhaustion. One source IP holds every one of the 64 connections, or one bound key keeps every verification slot busy with batches whose last receipt signature fails, so honest receipt uploads and reads get `503` | Anyone; operator with one bound key | At most `MAX_HTTP_CONNECTIONS_PER_IP` (8) connections per non-loopback source, IPv6 keyed by `/64` (N5); cheap checks and the batch's own signature before a verification slot is taken, and failed uploads refused again from a cache (N4); at most one verification per node key under the global 4. **Residual:** several bound keys, or sources in several `/64`s, can still hold slots; a cool-down after a failed receipt check is for Task 19b. Red team recheck 2: 8 sources (IPv4 addresses or `/64`s of one `/48`) still hold all 64 connections, with no reserve for bound nodes; a keyless upload naming a node with 8 full batches costs about 2.6 ms under the store lock; the failed-upload cache is flushed by 4,096 keyless uploads and re-signing gets round it (Task D1b) | receipts.md §Submission, traffic-verification.md TV-27 | `object_store::tests::f5_one_source_ip_cannot_take_every_connection`, `f5_one_node_cannot_starve_another_nodes_verification`, `sec1_reads_are_not_blocked_behind_receipt_verification` |
| T121 | **MITIGATED (Task D1 fix round 2, red team N3).** Dump file pile-up across restarts makes a window unscorable. After each restart the in-memory quotas started from zero, so a UID added a full quota of non-dominating files to the window per run until the window directory passed `MAX_RECEIPT_WINDOW_FILES`, the dump stopped working for the window and `run-tempo` failed the whole tempo | Operator (bound node keys), plus restarts | `serve` reads the dump back into the store at startup, so quotas carry over; the dump and `run-tempo` keep at most `MAX_BATCHES_PER_NODE_WINDOW` files per node per window, the highest ranked; a file count is skipped past with a warning, never failing the dump or the tempo | receipts.md §Submission | `tests::n3_s4b_restarts_dont_pile_up_files_or_fail_the_tempo` (red team S4b), `tests::n3_load_caps_files_per_node_and_never_fails_on_count` |
| T122 | **PARTLY MITIGATED (Task D1 fix round 2, red team N1, review R-I2).** Receipt-store memory exhaustion by full batches across the retained windows. A large UID filled every window in `[current − 48, current + 2]` with full batches (about 1 MB each held), over 100,000 batches | Operator (bound node keys) | New uploads are accepted only for `[current − RECEIPT_PAST_INGEST_WINDOWS, current + 2]` (7 windows); one UID holds at most its firsts plus `RECEIPT_UID_EXTRAS_CAP` per window. **Residual:** kept up for 48 windows it still accumulates; the byte budget is a Task 19b requirement (OQ-98). Steady state is 65,280 batches for one 1,024-node UID after 50 windows (red team recheck 2, T1), so about 160 nodes OOM a 16 GiB validator in about 51 windows (Task D1b) | receipts.md §Submission | `object_store::tests::n1_s3_one_uid_holds_batches_in_seven_windows_not_fifty_one` (red team S3) |
| T123 | **OPEN (Task D1b; red team recheck 2, R2-1).** Restore crash loop. The startup restore of the receipt dump holds every batch twice (the dumper's file cache plus the store), about 1.55x a normal store, and runs before the listener opens, so a validator OOM-killed by T122 is killed again inside restore and stays down until the dump is deleted by hand | Operator (bound node keys), via T122 | Planned: restore without filling the file cache, newest window first, under a memory budget, with the listener open during restore. Until then the rehearsal allowlist is curated | receipts.md §Submission | red team harness `task-D1-redteam-recheck2-harness.rs` T2 (to become a test in D1b) |
| T124 | **MITIGATED (Task 4Dc fix round 5, red team A1, review B4).** With endpoint dedupe off the schedule weight was each UID's largest single node's unpooled verified capacity, which one anchor key per flood UID sets, and nothing pools keys, so one box can anchor every UID: 8 UIDs × 1024 keys at 5 Mbps plus one 1 Gbps anchor each cut the honest 200-node fleet to 0.30 of due tests, a 10 Gbps anchor to 0.04 (about 60% of fleet nodes would get no sample in the 24-window span). With every key at 1 Gbps by sequential tests (OQ-18) no per-UID statistic helps (0.29) | Operator | **Team mode MUST run only with endpoint dedupe on**: `run_tempo` uses team-mode tests only when `tempo_endpoint_trigger` is met and otherwise runs the single-agent tests as before; Task 19b's preconditions say so. Defence in depth: with dedupe off a UID weighs its lower-median node (anchor cases: fleet 0.87 / 0.84). Residual: none while team mode is gated; the dedupe-off figures in T114 bound the weight only | measurement.md §Team capacity tests ("Team mode MUST NOT run with endpoint dedupe off", "Capacity-weighted round-robin by UID"); capacity-bonds.md; plan Task 19b | `dedupe_off_anchor_weight`; the `[T24]` `run_tempo` test's team-mode block; `schedule_weights_zero_endpointless_nodes_and_keep_one_pipe_per_uid_when_dedupe_is_off` |
| T125 | **MITIGATED, residual OPEN, dormant until team mode (Task 4Dc fix round 5, red team B1, L3).** A co-located group's pool is the max over its chunk cohorts of each cohort's lower median of few samples, and `Σ verified` doesn't bind for co-located keys. One colluding validator at about 5% of stake, seated once on one cohort's only sample, gave ×1.5 (team of four) or ×2 (short team) on the group's capacity term: 8 of 12 seed-runs above 1.0x | Operator + Validator | (a) A short cohort aggregate is capped at `Σ max(verified_prev(n), CAP_RAMP_FLOOR_MBPS)`. (b) In team mode a cohort needs `CAP_COHORT_TEAM_MIN_SAMPLES` (2) samples in the span, so one seat never raises a group. Measured (`colocated_cohort_lottery`, 12 seeds × 8 windows): at most 1.5x, above 1.0x in 1 of 12 runs (ruled 1.0x in all; gated at 1.5x). Residuals: (i) both of a cohort's samples with the colluder seated, 1.5x; OQ-99 proposes samples from teams with disjoint members, to land with Task 19b before team mode. (ii) Cost to honest groups: credit lapses in about 15% of cohort-windows in team mode (4.5% before), and a group with few cohort tests gets only its largest single (the lottery group's mean credit 0.29x of its box). (iii) For co-located keys (a) doesn't bind (16 × 200 Mbps = 3.2 Gbps) | measurement.md §Team capacity tests ("A short cohort test's aggregate is capped too"), §Cohort capacity tests item 5; capacity-bonds.md §Endpoint dedupe; scoring.md `CAP_COHORT_TEAM_MIN_SAMPLES` | `colocated_cohort_lottery`, `cgnat_cohort_turns` (lapse); `a_short_cohort_aggregate_is_capped_at_its_members_capped_capacities`, `a_team_cohort_needs_two_samples_for_credit` |
| T126 | **OPEN, LOW, documented (Task 4Dc fix round 5, red team C1-C3).** (a) Rider keys split across many UIDs get one front cohort turn per UID, charged to the fleet too: 64 UIDs give fleet 0.74, the same as T112's holder UIDs. (b) Real capacity buys turns spent on endpoint-less keys: each flood UID with one real 10 Gbps anchor in its own /24 and 1023 endpoint-less keys at 200 Mbps, at 8 UIDs, gives singles 0.82 (bound 0.85), fleet 0.87, fresh 0.38. (c) `schedule_weights` keys "dedupe on" on a non-empty `node_diversity`, not the stake trigger | Operator | (a) Ordinary UID splitting, one registration per turn (T112). (b) Costs 80 Gbps of verified, paid capacity; scheduling weight-0 nodes as tier 3 would close it, but with dedupe off every non-median node weighs 0, so it isn't cheap; left to Task 19b (PB-06). (c) Not reachable in production: `bwos-validator`'s `fill_node_diversity` overwrites the field with `tempo_node_diversity`, empty below the trigger; only hand-built inputs are stricter than `K_u` (stated in `schedule_weights`' doc and measurement.md) | measurement.md §Team capacity tests ("Capacity-weighted round-robin by UID") | red team round-4 re-check (`task-4Dc-recheck4`), `cohort_ride_along` |
| T127 | **MITIGATED (Task 15, audit F5; fix round 1 H1).** Fake paying client: a key the validators haven't authorized signs client receipts for "paid" traffic between its own nodes to move pay from capacity to usage, where fabricated bytes earn (3.14x at launch in the audit). The round-1 variant: one *authorized* client signs a bare 1,000 GiB receipt each window with no traffic behind it (`authorized_client_latch`) | Operator + client key | Attested paid bytes are only credited `paid`: backed by co-signed hop receipts on a creditable production route and client coverage after the voucher gate, from clients in `authorized_clients`, each session capped at its ingress node's verified capacity for the window, and only with at least `ALPHA_TRIGGER_MIN_CLIENTS` (3) distinct authorized clients. The trigger is also gated off (`ALPHA_TRIGGER_ENABLED = false`) until the latch comes from committed medians. Residual: `ALPHA_TRIGGER_MIN_CLIENTS` authorized clients colluding with real routes can move it once the gate is on | scoring.md §Capacity weight `W` | `fake_paying_client`, `authorized_client_latch`, `paid_bytes_from_unauthorized_clients_are_not_attested` |
| T128 | **MITIGATED (Task 15, audit S4).** Unsigned or zero-signed capacity declaration: an SS58 `hotkey_sig` was never verified, so a declaration signed with 64 zero bytes, or by anyone, scored the same as a signed one | Anyone | `CapacityDeclaration::verify` (sr25519 for SS58 hotkeys, refusing zero signatures and the all-zero account; ed25519 for hex hotkeys) in `node_declarations` and `declared_capacities`, both also requiring the declaring UID's own metagraph hotkey (fix round 1 L2); a declaration that fails declares nothing. Manifests are verified where fetched (Task 19b) **Task 19b:** manifests are verified where fetched (`live::admit_manifest`: signature, exact commitment hash, the committing hotkey's, the netuid), and SS58 binding signatures too (OQ-131). | scoring.md §Capacity declarations are verified, capacity-bonds.md | `zero_sig_declaration`, `foreign_key_declaration`, `a_capacity_declaration_with_a_bad_sr25519_signature_scores_zero` |
| T129 | **MITIGATED (Task 15, design §3; fix round 1 H3, M3).** Unearned weight to an owner-coldkey hotkey: weight the burn UID took went to the owner's hotkey, which the chain penalises by cutting the subnet's TAO share and which reads as self-mining. Variants: with no first-party UID, earned shares were renormalised over the unassigned part (3.33x, `unassigned_unearned_renormalized`); with no capacity anywhere before the latch, Mechanism 0 went 100% to the first-party UID (`first_party_take_when_no_capacity`) | Owner | The burn UID is removed. Mechanism 1's unearned weight goes only to `first_party_uid`. Mechanism 0's never does. Any mechanism with unassigned weight gives no weights, the helpers return the unassigned ppm, and `validate_weights` and `run-tempo` refuse. Residual: the validator can't tell a first-party UID from an owner-coldkey one; Task 19b commits `first_party_uid` on chain and checks its coldkey against the subnet owner's (OQ-102) **Task 19b:** the loop checks the first-party UID's coldkey against the subnet owner's every window and holds Mechanism 1 back on a match; committing the UID on chain is OQ-212. | scoring.md §Unearned weight and the first-party UID | `unearned_weight_to_owner_hotkey`, `unassigned_unearned_renormalized`, `first_party_take_when_no_capacity` |
| T130 | **OPEN, dormant while `ALPHA_TRIGGER_ENABLED` is false (Task 15 fix round 1, red team H2, M1).** Latch split brain: each validator's latch comes from its own view of the receipts, so one missing batch, a late joiner, or a node withholding its batch from one validator in one window of every run leaves validators on different `W` for good | Operator, validator | Gated off: `W` is `1_000_000` for everyone. Before the gate turns on, Task 19b commits per-window attested bytes and the latch uses their stake-weighted lower median; with the gate on and the latch state unknown, `run_tempo` gives no weights (OQ-102). N-of-M windows would close withholding. Fix round 2: the latch state is known only with a latch record or history from window 0 (N2). Three colluding authorized clients still latch it with the gate on (N3): before the gate turns on, the trigger must cap per client and per ingress node and count only source-verified or trusted-egress bytes (scoring.md §Capacity weight `W`, preconditions) | scoring.md §Capacity weight `W` | `latch_split_brain`, `late_joiner_latch`, `late_joiner_latch_gate_on`, `receipt_withholder_resets_trigger` and `three_client_latch` (model-only) |
| T131 | **OPEN, gated (Task 12b fix round 2; `probe::BACKGROUND_IN_TEAM` off until PB-38, OQ-106).** Hop receipts from real counters and background from receipt runs. (H1) Team-test background lifts only `ratio_t` while the gate is off, enforced in scoring (sim `gate_holds_in_run_tempo`). (H2) Hop totals count forwarded transit only, never the node's own flows, link-address traffic or keepalives (sim `own_traffic_burster`); junk transit through a node's sybil UIDs still gets the full cap on the gate-on path, 1.333x (sim `sybil_uid_background`, model-only), which is why background in `team` waits for PB-38's canary or digest-verified carriage. (H3) A node's background is `max(Σ in, Σ out)`, and a cohort counts boundary streams once and internal ones never (sims `relay_direction_double_count`, `cohort_internal_stream`). (M1) The co-signing tolerance applies to each increment (sim `tolerance_swing_bracket`). (M2, open, Task 19b blocker) A rival can evict a node's run by co-signing late. (a) **Counter inflation.** A relay whose counters report more to its next hop than the next hop counted: beyond `RECEIPT_TOLERANCE_PPM` the next hop counter-proposes, nothing is co-signed, and the relay is credited nothing for that hop (sim `counter_inflater`, regression guard, no gain). Within the tolerance the next hop co-signs the claim: +4,000 ppm on one hop gives the relay about +0.2% (detail of `counter_inflater`), as an honest relay's noisy counter would. (b) **Stall and carry with claimed blocks (T42(g)).** As first written the co-signer took a `block` within one block of its view either way, and a staller showed all of `T` as background (1.263x at `T = C / 3.6`). Under rule (a) a claim is at or one below the co-signer's view, but the receipt after the test can still lag a block: 1.175x at `T = C / 3.6`, 1.290x at the background cap, 1.734x with one colluding member at `k = 4`. Not scored until Task 19b supplies `block_hashes` with dedupe on; fixed by PB-38's per-digest timing checks on routed traffic (ADR-0051, ADR-0053) | Operator | Co-signed totals within tolerance; rule (a) for `block`; the tight-interval run rule (`probe::stream_background_mbps`); the `CAP_BACKGROUND_MAX_PPM` cap; `bracket_stall_carry` model-only (`UNTIL_PB38`) | receipts.md §Hop receipts from counters, measurement.md §Background traffic | `counter_inflater`, `bracket_stall_carry` (Task 12b) |
| T132 | **MITIGATED (Task 16a, audit F2).** Clone farm on the Mechanism 1 ladder: UIDs submit copies of the reference solver's table or of an outside solver's, exact or with a route made worse, to take rungs or the old 30% runner-up pool (a clone 2.5% worse passed the `gains_ppm` copycat test) | Solver (sybil UIDs) | A table within `CLONE_DISTANCE_PPM` (2% of `(src, dst, class)` keys on a different path) of one committed in the same block or earlier scores 0, ordered by `SolverSubmission::commit_block`; the reference solver's table counts as block 0, so its clones always score 0. Near-clones more than 2% away that are worse than the reference took lower rungs until fix round 1 (T138) | scoring.md §Clone protection, §The ladder | `ladder_clone_farm`; `a_table_matching_an_earlier_one_within_clone_distance_scores_zero`, `the_earlier_committed_of_two_clones_keeps_its_score`, `two_clones_committed_in_the_same_block_both_score_zero` |
| T133 | **MITIGATED (Task 16a).** Prediction liar: a solver's routes claim latencies (`est_us`) the network doesn't deliver, so what it publishes as its routes' performance is false | Solver | Each route's positive gain is scaled by how well `est_us` matches the graded latency (the worst of next-snapshot prediction, latency samples and the UID's own path probe): full credit within `PREDICTION_TOLERANCE_PPM` (25%), none at 50% or with no `est_us`; a route at or below direct keeps its negative gain. `est_us` halved grades 0. Residual: a lie inside 25% costs nothing, and `est_us` buys nothing either, since gains never read it | scoring.md §Grading item 3 | `prediction_liar`; `a_route_is_graded_on_the_worst_view_and_its_prediction` |
| T134 | **MITIGATED (Task 16a).** Next-window overfitter: a solver tunes its table to the snapshot it was solved on, chasing links that dip for one window, or self-owned links measured fast while tables are graded | Solver | Tables are graded on the next window's snapshot, built from measurements no solver had seen when it committed, and churn is charged against `prev_table`; the reference solver keeps paths within `ROUTE_SWITCH_MARGIN_PPM`. Residual: regret is still judged on the solved-on snapshot, so it charges the stabilised reference for the dip it ignored (pre-existing `[T23]` behaviour) | scoring.md §Grading items 1 to 7 | `next_window_overfitter` |
| T135 | **OPEN, LOW (Task 16a).** Same-block clone griefing: anyone who can predict a solver's table (a public solver's output, the reference solver's) can commit a copy in the same block or earlier, and the original then scores 0 | Solver | Commit-reveal hides a table until reveal, so only predictable tables can be copied, and a copy of a public solver's table is work anyone could do. Residual: an outside solver running published code with public inputs can be zeroed at will. Its table is also within 2% of anyone else running that code | scoring.md §Clone protection | `two_clones_committed_in_the_same_block_both_score_zero` |
| T136 | **MITIGATED (Task 16a fix round 1, red team MH3).** Grading-window steering: a solver that also runs relays attracts the reference's routes through its nodes, then drops them out of (or loses on) the window that builds the graded snapshot, so those routes graded `-1e6` and its own table won, was paid and counted as `outside_won` | Solver + Operator | A hop broken in the graded snapshot (loss above `PROBE_LOSS_MAX_PPM`, a node gone) and a failed path probe grade as direct for every table; an outside solver is selected, paid above the reference or `outside_won` only if it is also at least the reference on the solved-on grade. A commit deadline early in the window is a Task 19b rule. Residual: delaying (not breaking) its own relays still lowers the reference's gain, short of the solved-on gate; a solver that predicts the next window better than the solved-on snapshot shows is held to the reference there (OQ-107) **Task 19b:** route tables are read at the commit deadline (`S + 36`). | scoring.md §Grading items 3, 8, 9; §The production table | `reference_steering_saboteur`; `a_table_worse_than_the_reference_on_the_solved_on_grade_is_neither_selected_nor_paid` |
| T137 | **MITIGATED (Task 16a fix round 1, review Critical).** Production-table copier: last window's production table ran in the open, so a griefer commits its routes for the next window before the incumbent re-commits them; by commit order the incumbent's table was the clone, the griefer took its rung (666_667 ppm) and production | Solver | `current_prod_table` counts as committed at block 0 and owned by `incumbent_solver_uid`: any other non-reference table within `CLONE_DISTANCE_PPM` of it scores 0, and the incumbent re-committing it is ordered before every solver | scoring.md §Clone protection | `prev_production_copier`; `a_copy_of_last_windows_production_table_scores_zero_and_its_incumbent_keeps_it`, `a_copy_of_the_production_table_scores_zero_but_its_owner_keeps` |
| T138 | **MITIGATED (Task 16a fix round 1, red team H1, H2).** (a) Near-clone ladder farm: sybils 4% from the reference each took a rung below it (498_037 ppm in all). (b) Zero-churn overfitter: no `prev_table` meant no churn, and regret charged the stabilised reference for the dips it ignored, so a dip-chaser graded 1.054x the reference | Solver (sybil UIDs) | (a) Only solvers above the reference by `EPSILON_ROUTE` take rungs; the reference's rung and all below it are unearned (first-party share disclosed). (b) With `prev_table` `None`, churn is against the production table; a route kept on the production path within `ROUTE_SWITCH_MARGIN_PPM` carries no regret, for every solver; `prev_table` is validator-derived (Task 19b). Residual: a winner's own sybils just above the reference (OQ-107 (6), Task 16b) **Task 19b:** `prev_table` is the table the UID committed at the previous read. | scoring.md §The ladder, §Grading item 6 | `near_clone_ladder_farm`, `zero_churn_overfitter`; `churn_without_prev_table_is_against_production_and_kept_production_paths_carry_no_regret` |
| T139 | **MITIGATED (Task 16a fix round 1, red team M4, M5).** (a) Unprobed near-clone: path probes were keyed by UID and only the incumbent was probed, so a copy on the same slow paths graded on the faster snapshot. (b) `commit_block` failed open: a missing block (0) sorted before every real one | Solver | (a) Path probes are keyed by path (`route:<digest>`), so every table on a probed path reads the same result. (b) `commit_block` is `Option<u64>`, the first block this UID committed this table hash at the fixed read block; `None` counts as committed last | measurement.md "Path probes are keyed by path"; scoring.md §Clone protection | `an_unprobed_near_clone_cannot_outrank_a_probed_reference_on_the_same_paths`, `an_unknown_commit_block_counts_as_committed_last` |
| T140 | **OPEN, model-only until Task 16b (Task 16a fix round 2, red team N2).** Perturbed production leech: last window's production table is public, so a leech re-commits it with a few pairs perturbed, more than `CLONE_DISTANCE_PPM` from it and so no copy, and takes the rung below the incumbent while adding nothing (285_714 ppm in the sim) | Solver | Partial: copies within 2% of the production table score 0 (T137), tables are revealed only after the commit deadline (Task 19b), and every rung must beat the reference by `EPSILON_ROUTE`. Closing it: Task 16b ranks each rung on its marginal gain over the tables ranked above it (OQ-107 (6)) | scoring.md §Grading item 9, §The ladder | `perturbed_prod_leech` (model-only) |
| T141 | **Damping griefer (Task 13, PB-17).** An attacker flaps the session it shares with a rival so the rival's routes are suppressed for flapping and the rival loses score beyond the seconds the link was really down | Operator | Damping is per (peer, prefix) and counts only withdrawals, so only paths that cross the flapping session are suppressed: the attacker's own paths and what it relays, at the rival; nothing of the rival's at third parties, whose sessions with the rival never flap. On the no-root node a peer's own `/128` stays in use on its own session while damped (never passed on), so link probes across the shared link pass whenever it's up: no honest UID loses more than the real outage, with one or three attacker UIDs, six or seven flaps or a sustained schedule. **Residual (OQ-108):** FRR can't exempt that path, so on a kernel rival the shared link's probes fail while the attacker's `/128` is damped, up to about 48 min after seven flaps; that is what the attacker can already do by dropping probes on its own link, it is neutral under T29 with one attacker UID, and it costs the attacker as much on the same link | datapath.md §Flap damping | `damping_griefer` (Task 13); `seven_flaps_in_a_minute_suppress_the_peers_routes`, `a_damped_peers_own_route_is_used_here_but_not_passed_on` |
| T142 | **One flapping node churns the fabric (Task 13, PB-17).** A node (broken or hostile) whose sessions go up and down every few seconds makes every node re-run selection and pass updates on, and one restart must not be punished as flapping | Operator | RFC 2439 damping on both node kinds with RFC 7196's values: seven flaps in about a minute suppress the flapper's paths at its neighbours, which stop passing them on; six, or one restart, don't. A no-root node also holds a peer's paths back for 2 s after BFD Down where a backup exists. Updates a peer is owed are paced per prefix (`node`'s pending set), so churn can't overflow another session's queue | datapath.md §Flap damping | `churn_flapper.sh`, `one_restart_is_not_damped`, `six_flaps_in_a_minute_do_not_suppress`, `hold_down_keeps_the_backup_for_two_seconds_after_bfd_down`, `damping_settles_a_ring_of_primaries` |
| T143 | **OPEN (Task 13, OQ-114).** Damping shadows a node from validators: a path damped at an intermediate hop carries no multi-hop canary (ADR-0051), so the node reads unavailable until reuse | Operator, Validator | Vantage sessions are direct, so unaffected. PB-38 must exempt canary prefixes from damping, or score availability on direct sessions. Not built | datapath.md "Flap damping" | Sim `damping_vantage_shadow` reserved |
| T144 | **OPEN (Task 13, OQ-115).** Damage spreads past the flapping link: an attacker's flaps on one session make a rival's other neighbours damp paths they relearn through the rival | Operator | Not measured yet | datapath.md "Flap damping" | Sim `damping_upstream_flap` reserved |
| T145 | **OPEN (Task 14, OQ-116).** Public canary pairs: the canary allocation is a deterministic draw from the window's committed seed and snapshot, so every node knows during the window which pairs carry canaries and how many bytes. Once customer traffic exists, a flow on an unallocated pair is customer traffic, and a node can drop or delay those while carrying every flow on allocated pairs | Node | Partial: within an allocated pair, a flow's start, size and class come from each validator's secret plan and fabric-wide marginals, so a node can't predict them (sims). The pair itself, the packet shape and the source address are not hidden (T148). Before customer traffic exists there are no unallocated flows to degrade. Customer flows are checked by hop-digest sampling (ADR-0053 §2), which can only lower a score. Closing it: PB-38 or PB-39 (OQ-116) | measurement.md §Canary plans, "Residuals" | `canary_favourer`, `canary_slot_presence` (timing, size and class only) |
| T146 | **OPEN, bounded (Task 14).** A validator's plan is secret from nodes, not from the validator: it can tell a friendly node its timing, or grind secrets until its flows land where a rival is weak | Validator | Each validator's bytes per pair are fixed by the public allocation and its stake share, and the reveal must spend exactly that (`verify_reveal`), so collusion moves only that validator's own evidence, never its share or another validator's. `canary_plan_is_derived` stops hand-picked timing, though not grinding. Planned fix for grinding (red team F5): commit `SHA-256(secret_w)` in window `w - 1` and key the draws on `secret || seed`, so the secret is fixed before the seed exists. Fix round 1 pins the counting commitment to the seed block plus `CANARY_COMMIT_CUTOFF_BLOCKS` and requires a fresh secret every window (`canary_secret_is_fresh`), so a validator can't swap or replay a plan. Results are aggregated across validators by stake-weighted median (PB-38, ADR-0051 requirement 5) | measurement.md §Canary plans, "Commit and reveal" | `validator_canary_alloc_favour`; `a_reveal_that_skimps_or_overloads_its_share_fails` |
| T147 | **OPEN, LOW (Task 14).** Splitting above the canary weight cap: a node's canary weight is `min(deduped verified capacity, CANARY_NODE_WEIGHT_CAP_MBPS)`, so a node above the cap that splits into nodes under it, in separate /24s, gets more canary bytes. Each part still has to pass its own capacity test. Also, a UID never draws its own nodes as destinations, so splitting one operator across several UIDs gains slightly more destination bytes | Node | Bounded by the per-UID cap `CANARY_UID_CAP_PPM`, water-filled since fix round 1 (F4), so it is a real cap (sim `canary_alloc_uid_split`). Under the cap, weight is linear, so splitting into nodes gains nothing (at most 1.001x in the sim). Splitting across UIDs gets around the cap and adds the own-destination gain (red team F4b); planned: group by coldkey in PB-38 (OQ-119). Each UID costs a registration. Not scored until PB-38, which sets the cap with the pay formula | measurement.md §Canary plans, "Allocation" | `canary_alloc_node_count_sybil` (under the cap) |
| T148 | **OPEN (Task 14 fix round 1, red team F1).** Canary packet shape: filling packets to the overlay MTU (1_420) with a remainder tail removed the packet-size tell (an even split at 1_280), but canaries are still one-way UDP, with no reverse traffic, from a validator's source address. A relay or end that sees these can favour canaries | Node | Not mitigated yet. The node side (OQ-117) MUST hide validator addresses and shape reverse traffic per class before PB-38 scores canaries | measurement.md §Canary plans, "Injection" and "Residuals" | `canary_packets_add_up_to_the_entry` (sizes only) |
| T150 | **A solver publishes a broken or forked update chain (Task 16b, PB-08).** A wrong `prev`, a skipped `seq`, updates closer than the interval, more than `MAX_UPDATE_ROUTES` routes, a cycle-closing change, or two updates for one `seq` | Solver, Relay | The node applies the whole attested chain or keeps its last good table (`apply_update`); validators attest one update per `(window, seq)` after checking the solver signature and the chain | routing.md §Incremental updates | Sim `update_chain_breaker`; unit tests in `table_update.rs` and `signed.rs` |
| T151 | **The incumbent removes production routes to dodge the time weighting (Task 16b).** It removes the production routes of pairs its new table does badly on so they count less | Solver | A removed route counts `min(q, direct)` for the blocks it was down and every key weighs the whole window (`live_adjusted_score`). This closes that move only; steering the graded table by *changing* routes is T154 | scoring.md §Grading item 4 | Sim `mid_window_self_steerer` |
| T152 | **The first `prev` forks by signature (Task 16b fix round 1, F3).** sr25519 signatures are randomized, so a solver can publish two copies of one table that differ in `hotkey_sig` and split nodes and validators | Solver | The first `prev` hashes the table's signing bytes, which every copy shares; nodes keep no signature | routing.md §Incremental updates | Sim `base_sig_splitter` |
| T153 | **OPEN (Task 16b fix round 1, F8, OQ-122).** Mechanism 0 credits transit on `current_prod_table`, not the table as updated. The incumbent can steer credit with updates (latent, about 2.8x once the paid-traffic trigger is on), and honest relays on updated routes are not credited | Operator, Solver | Latent while the trigger is off. Enabling the paid-traffic trigger waits on OQ-122 | scoring.md §Grading item 4 | None yet |
| T154 | **Updates rewrite the graded table after grading (fix rounds 1 and 2, F1, F2, N2, N4).** A burst of future-dated updates, many ungraded changes, an update that overloads a capped relay, or one heavy pair moved or flipped, swap what runs for most of the window | Solver | Attested only when due (`MAX_UPDATE_BLOCK_SLACK`), within the window, at most `MAX_UPDATE_CHANGE_PPM` of routes, each route at most `MAX_ROUTE_CHANGES_PER_WINDOW` times, and `validate_under_demand` on the updated table at the window's `demand_mbps_per_pair`, so no relay goes over `max_transit_mbps`; the budget is demand-weighted only once demand is per pair (OQ-128), and its size stays open (OQ-123, OQ-124) | routing.md §Incremental updates | Sims `update_burst_rewriter`, `ungraded_update_steerer`, `update_cap_overloader`, `heavy_pair_steerer` |
| T155 | **Nodes end on different update `seq`s (fix round 1, F4).** A node that missed an update refuses the next, and traffic can loop between nodes on different tables | Relay, Network | By-number lookup `seq/<window>/<n>` and a catch-up walk | routing.md §Incremental updates | Sim `seq_gap_splitbrain` |
| T156 | **Rivals copy the incumbent's updates (fix round 1, F7).** A rival commits the production table after an update to escape the clone check against the base | Solver | First update no earlier than the commit deadline; clone check against every prefix of the chain | scoring.md §Clone protection | Sim `update_leech` |
| T157 | **OPEN (liveness, fix round 1, F9).** Validators holding more than a third of stake can withhold attestations and stop updates | Validator | Liveness only: the base table still runs | routing.md §Incremental updates | None |
| T158 | **The incumbent frames a challenger as a copy (Task 16b fix round 2, N1).** After a challenger's table is revealed, the incumbent updates production to within `CLONE_DISTANCE_PPM` of it, and the per-version clone check zeroes the challenger | Solver | A table is checked only against production versions published before its commitment (`commit_block` after the update's `block`); with the commit deadline at `FIRST_UPDATE_DELAY_BLOCKS` a table committed in time meets only the base table. Residual: a table whose commit block is unknown (OQ-129) | scoring.md §Grading item 4 | Sim `prod_version_framer` |
| T159 | **Withheld, backdated updates (fix round 2, N3).** The incumbent holds signed updates back and presents them in one burst late in the window, so updates that never ran count in the chain and the grade's time weighting | Solver | Validators attest only `chain - MAX_UPDATE_BLOCK_SLACK <= block <= chain + MAX_UPDATE_BLOCK_SLACK`, from a required `chain-block` input; nodes activate an update on their own clock with no allowance | routing.md §Incremental updates | Sim `backdated_update_burst` |
| T160 | **MITIGATED (ADR-0054).** Wallet signatures replayed across protocols: a browser wallet's `<Bytes>`-wrapped signature over a Transit Fabric manifest or binding passed off as a Substrate extrinsic, as another Transit Fabric domain's object, or a signature from another dapp's `signRaw` passed off as a Transit Fabric object. Also phishing: any dapp the operator connects can ask the wallet to sign a Transit Fabric manifest | Operator (as victim), any dapp | Only the raw signing bytes or exactly `<Bytes>` + them + `</Bytes>` verify, the wrapped form only for messages starting `BWOS-v0/`, and only for `commitment-manifest` (an SS58 binding's signature is checked nowhere until OQ-131); every other hotkey-signed domain stays raw-only, and a wrapped signature over one is refused (vector `raw_only_wrapped`), as is a wallet's hex-text wrapping. A wrapped message can't be an extrinsic payload (ends in ASCII, not the genesis and block hashes). A signed manifest does nothing until the hotkey commits its hash in a separate transaction | identity.md "Linking with a browser wallet", ADR-0054 | `wallet_link_vectors` (`every_other_wrapping_is_refused`, `wrapped_signatures_do_not_cross_domains`), `site/link/test/` |
| T161 | **MITIGATED, residual LOW (ADR-0054, fix round 1 I-2).** A tampered page or library builds a different binding or manifest (another hotkey's nodes, dropped objects) before the wallet prompt. Was: `@polkadot/*` from cdn.jsdelivr.net | Third party, the page's host | The four libraries are one vendored bundle (`site/link/vendor/polkadot.js`, built by `build.sh` from exact versions and a lockfile) whose sha256 is in `SHA256SUMS` and checked by `make link-page-test` in CI; CSP `script-src 'self' 'wasm-unsafe-eval'`, no third-party origin. The page shows the nodes a binding adds and drops and needs an explicit confirmation; the wallet shows the bytes; nothing commits without a second approval. Residual: whoever serves the page can still change it, and `frame-ancestors` must be sent as a header (`site/link/README.md`) | ADR-0054 | `site/link/test/` (bundle checksum, imports, CSP) |
| T162 | **MITIGATED (ADR-0054, fix round 1 I-3).** A hostile link replaces a fleet: a link URL (or pasted list) that omits the operator's nodes, or adds an attacker's consenting node, makes the new binding drop or add nodes | Third party | When the committed manifest names a binding, the page requires it (hash checked), shows the nodes added, removed and kept, requires a strictly later `not_before`, and enables Sign only after "these are my nodes" is ticked for exactly what was reviewed | identity.md "Linking with a browser wallet" | `site/link/test/` (`checkPreviousBinding`, `bindingDiff`, `checkSupersedes`) |
| T175 | **Validator free-rides measurement (ADR-0055).** Scoring is deterministic from revealed inputs, so a validator downloads the others' reveals, recomputes the weights exactly and measures nothing. Its dividends match a measuring validator's, with no bandwidth cost | Validator | A capped slice of Mechanism 0 (indexed to allocated bytes and steered by a participation controller, 1% to 15%, starting at 5%) pays verified, node-signed measurement bytes, capped by stake share. A copier has no node-signed evidence of its own and earns no slice. Residual: the copier keeps its dividends, so measuring wins only while the slice covers bandwidth (OQ-140). Gated off until ADR-0055 §8 | scoring.md §Measurement work; measurement.md §Measurement work | Sim `validator_free_rider` |
| T176 | **Faked canary delivery with colluding nodes (ADR-0055 §6).** A validator sends no canaries on pairs whose ingress and destination both collude, and both sign digests and receipts anyway | Validator, Operator | An entry counts only with both ends' signed hop digests and co-signed leg receipts. The pairs are a block-hash draw that excludes same-UID pairs, so the faked share is at most `c^2` of the validator's canary bytes. Faking saves only cost, never adds pay. Colluding capacity must pass others' median tests | ADR-0055 §2, §6 | Sim `validator_free_rider` (faker, `c` up to 50%) |
| T177 | **Faked capacity-test seats with a colluding tested node, and the headroom ack gap (fix round 1 item 2).** The tested node signs a `cap-test-ack` for a seat the validator never streamed, or acks a colluder's whole stream where an honest node carrying its declaration acks `1 / 1.1` of it, so before fix round 1 a colluder's seats verified at 1.0 against honest validators' 0.909 | Validator, Operator | The seat is drawn by stake, never chosen. Its allocation is `rate * CAP_TEST_SECS * pushed / S`, exactly what an honest node acks, and its credit is `min(ack, allocation, the seat's share of the team's measured result)` (`measurement_work::cap_test_seat`), so a full-stream ack earns no more than an honest one (sim `validator_headroom_ack`). The faked share is `c` in expectation, so the saving is at most `c` of capacity-test cost. The fake capacity sample is a separate threat, bounded by the team median (T21, T108) | ADR-0055 §2, §6 | Sims `validator_free_rider`, `validator_headroom_ack` |
| T178 | **Measurement spam.** A validator sends more than its allocation, through unplanned flows, longer or faster streams, or a padded plan, to raise its work share | Validator | `min(verified, allocated)` per entry and per seat, applied inside `work_fraction_ppm`, and the share is capped at `s_v * slice`. A padded plan fails `verify_reveal` and loses all its canary credit | ADR-0055 §3 | Sim `validator_canary_spam` |
| T179 | **Claiming another validator's evidence.** A copier declares another validator's source and sink node keys, or replays its acks | Validator | Source and sink keys count only through the validator's own ADR-0039 attestation-key records, with proof of possession. Acks and plans name the validator. A key claimed by two hotkeys counts for neither | ADR-0055 §1 | Unit tests when Task 19b builds the join |
| T180 | **Griefing a rival validator's work pay.** A node drops one validator's canaries, which it can tell apart by their source node | Operator | Shares are never renormalised, so no other validator gains. The node fails its own canary checks (PB-38). The lost slice goes to all operators pro rata, so the dropper's gain is about its own Mechanism 0 share of it | ADR-0055 §3 | Sim reserved: `validator_work_griefer` |
| T181 | **Self-weight masking.** Subtensor masks a validator's weight on its own UID, except the owner's (localnet check, ADR-0055 §5). Work paid to the validator's own UID would be cut by `1 - s_v`, and to 0 at half the stake or more | Validator | Work is paid only to a measurer UID named by hotkey in the manifest, never to the validator's own UID | ADR-0055 §5 | `bwos-chain` localnet test `self_weight_and_cross_weight_incentive` |
| T182 | **Measurer UIDs crowd out operators.** Up to 64 measurer UIDs take UID slots on a full subnet | Validator | Only measurer UIDs of counted validators with work are paid, so an idle one is pruned. Headroom in `max_allowed_uids` is OQ-141 | ADR-0055 §5 | None yet |
| T183 | **MITIGATED (fix round 1 item 1). Phantom declared capacity.** A node declares far more than it carries (100 Gbps). Seats were allocated `declared * 1.1 / team * CAP_TEST_SECS`, but a team can stream only the ramp-capped, budget-capped `R(n)`. So honest validators on the node's teams were allocated bytes they could never send and their work fraction fell toward 0, while a colluding validator whose node acked the whole allocation kept `f_v` near 1 | Validator, Operator | A seat is allocated the water-filled `rate * CAP_TEST_SECS * pushed / S` that was really streamed, and verified at most the seat's share of the team's measured result (`measurement.md` §Measurement work). The declaration raises neither. Residual: an honest seat on a node that carries less than `R(n)` verifies only what it carried, at most a 2x ramp shortfall on that node's seats; the node pays for it in its own capacity haircut | ADR-0055 §2; measurement.md §Measurement work | Sim `validator_phantom_declarer` |
| T184 | **MITIGATED, residual = T176/T177 (fix round 1 item 3). Validators that also run nodes.** A validator whose own nodes sit on its canary pairs or are the tested node of its seats has them sign for bytes it never sent, at no collusion cost; or it registers a fabric node key as its attestation key, so its own source or sink is a signing end | Validator | Entries signed by a node of a UID whose coldkey is the validator's keep their allocation and verify nothing (`WorkEvidence.own_uids`): dropping them from the allocation as well would let it skip their cost and keep its full fraction (the drop-both rule in sim `validator_own_fleet`). A validator with an attestation key that is a bound fabric node key has all its work refused (`attest_key_is_node`). Residual: a fleet under another coldkey is collusion, bounded by T176 and T177 | ADR-0055 §6; measurement.md §Measurement work | Sim `validator_own_fleet` |
| T200 | **OPEN, MEDIUM (verification red team A). The participation controller ratchets.** Inside the 0.67 to 0.82 dead band `k` holds, and below target it rises, so it only climbs: a pause or one noisy dip raises the slice for good. Base 5.6% to 8.0%, bear to the 15% cap, 1.65x to 2.06x for an attacker that pauses | Validator | Planned: a leaky band (`k * 0.97` in band, `k * 1.0625` below target), mean over 2 to 3 periods. Gate prerequisite | ADR-0055 §10 A; OQ-148 | Sim `validator_controller_ratchet` (to write) |
| T201 | **OPEN, MEDIUM (verification red team B). Quality drag on the controller.** Participation is `Σ s_v f_v`, so cutting honest validators' work fractions raises `k`; phantom ramps inflate `A_total` about 2.1x | Validator, Operator | Planned: count only stake with `f_v` at least half the median; index `A_total` on `min(allocated, measured share)` per seat. Gate prerequisite | ADR-0055 §4.1, §10 B; OQ-149 | Sim `validator_controller_quality_drag` (to write) |
| T202 | **OPEN, LOW-MEDIUM (verification red team C). A teammate's zero report.** A revealed zero lowers `measured_n` and cuts each honest teammate's seat by `1 / k'`; withholding can help colluders | Validator | Planned: cap each seat at `stream * min(1, c_j / rate_j)`, `j` the lower-median revealed member. Gate prerequisite | ADR-0055 §10 C | Sim `validator_teammate_zero_report` (to write) |
| T203 | **ACCEPTED (verification red team D). The own-fleet rule avoided with a second coldkey.** A validator registers its fleet under another coldkey, so `own_uids` misses it | Validator, Operator | Ordinary collusion, inside ADR-0055 §6's `c` bound; OQ-147 accepted | ADR-0055 §6, §10 D | Sims `validator_free_rider` (faker), `validator_own_fleet` |
| T204 | **OPEN (verification red team E). `k` depends on the full history.** `k` is carried window to window, so a validator that misses or mis-replays a window computes a different slice from then on | Validator | Planned: record `k` per scoring release, or derive it from a fixed recent span. Gate prerequisite | ADR-0055 §10 E; OQ-160 | None yet |
| T205 | **OPEN (verification red team). Too few independent recorders.** With one or two operators measuring, their measurement sets the medians and the controller | Validator | Gate condition: at least 5 recording coldkeys | ADR-0055 §10 F | None yet |
| T165 | **OPEN, bounded (ADR-0056 revision 1, OQ-135; not scored).** Peer-load collusion: a cartel holding a UID share `f_uid` of the draw tells its node which slices are the cartel's, and the node sheds them. A colluding source sends nothing, which sheds ingress alone; with sink blinding the node can drop a slice before egress only when its `R_out` and sink both collude | Operator | Credit reads only hidden slices, which the node can't tell apart. Endpoints are drawn uniformly per UID, slot-capped (T174). Inflation `<= 1/(1 − f)` on a symmetric port and `<= 1/((1 − f)(1 − f²))` on an egress-bound one: at 100 Gb/s, 1.111x, 1.245x, 1.417x, 1.639x symmetric and 1.122x, 1.294x, 1.549x, 1.939x egress-bound at `f_uid` = 0.1 to 0.4. Without sink blinding, egress-bound was 1.231x to 2.694x. The founder's `1/(1 − f²) + tol` fails at every `f` | measurement.md §Peer-load capacity tests, "Bounds" | `capacity_peer_collusion` (gates); `capacity_peer_collusion_f2` (founder's bound, gates nothing until OQ-135) |
| T166 | **MITIGATED for reports (ADR-0056; not scored).** Framing through peer reports: peer sinks under-report or withhold digests, peer sources send nothing, to lower an honest node's credit. Framing through load is T173, through relays T217, through validators T216 | Operator | Peer sink reports are diagnostics only and never set the node's credit: change 0 at framer shares 0.1 to 0.5. A source that sends nothing only lightens the load. A call with fewer than 3 revealed hidden results is void | measurement.md §Peer-load capacity tests, "Running a call" | `capacity_peer_framing` |
| T167 | **OPEN, blocks scoring (ADR-0056 revision 1; T148, OQ-117, OQ-166).** Hidden slices identified: a node that can tell validator slices from peer slices serves them first, declares far above its capacity, and the ramp compounds it | Operator | Hidden validators self-select by VRF; terminating relays `H_in`/`H_out` are drawn from all peers and never validator-run, so no validator address reaches `N` or `R_out`; hidden slices use the peer-slice sender, not the canary sender. Residual tells: the relays themselves know (leak about `2 f_uid` a slice), published plans, shape (OQ-166). Indistinguishable: at most 0.984x at any declaration up to 100x. Leak 0.2: 0.62x; 0.5: 1.35x; full: 94.5x (the first draft's 2.0x was its declaration cap). Peer-load credit MUST NOT be scored before this closes | measurement.md §Peer-load capacity tests, "Hidden slices" | `capacity_selective_throttle` (gates); `capacity_hidden_leak_ramp` (gates nothing until it closes) |
| T168 | **PARTIAL (ADR-0056 revision 1, OQ-43 resolved, OQ-136).** Burst capacity at call time: a node holds its declared capacity only some of the time. Calls come at secret times; a short call is retested, and the bond applies on a short retest or 2 short calls in an epoch | Operator | A node that holds `D` for a share `ρ` of calls is within `1 + tol` per unit of cost at every `ρ` (worst 1.055x at 10x, `ρ` = 0.75), and worse off outright below `ρ` = 0.40 at 10x (0.60 at 2x). The retest alone, without strikes, allowed 1.162x. Residual: a 95th-percentile renter holds `D` at every call, so calls don't deter it; PB-38's sustained-carriage bound has to (OQ-136). An honest node with 1% transient faults keeps 99.8% of its credit | capacity-bonds.md §Peer-load calls | `capacity_burst_renter_calls` |
| T169 | **OPEN, LOW (ADR-0056 revision 1, OQ-137).** Peer pool and duty: a 100 Gb/s call needs 660 endpoints (three a slice), and the per-UID draw gives every UID the same expected duty, so small nodes carry a larger share of their capacity | Operator | At most 8 endpoints per UID and `floor(spare / s)` per node in one call. A short pool samples only the slices that ran (`slices_run`). Fabric-wide duty 0.34% of capacity-time; per node 2.7% for 1 Gb/s nodes, 0.46% for 10 Gb/s, 0.05% for 100 Gb/s. Validator bytes per call at most 7.5 GB whatever the node's size; a 100 Gb/s node is credited 99,999 Mb/s with validators at 1 Gb/s | measurement.md §Peer-load capacity tests, "Eligible endpoints" | `capacity_big_node`, `capacity_peer_duty` |
| T170 | **OPEN, LOW (ADR-0056).** `usable` over-credits: the one-hop cut assumes each neighbour can source and sink its whole term, and sybil neighbours can raise it | Operator | `usable` only ever caps a sample (a `min`), so raising it can't inflate credit. Each neighbour's term is capped by its own ramp ceiling and the snapshot link; a big node beside one big neighbour is capped at 14 Gb/s, not 107. The closed form matches an integer max-flow on 300 random one-hop networks | measurement.md §Peer-load capacity tests, "`usable`" | `capacity_usable_cap` |
| T171 | **OPEN (ADR-0056, OQ-138).** Long burst credits: a policer whose bucket outlasts `T − T_meas`, or a cloud plan that bursts above its baseline for minutes, passes a 30 s call at its burst rate | Operator | `T_meas` (the last 20 of 30 s) measures any bucket that drains within 10 s at its committed rate (90 Gbit at 10 Gb/s line, 1 Gb/s committed). Larger buckets leak: 3,250 Mb/s at 135 Gbit, 5,500 Mb/s at 180 Gbit. Longer calls or random `T_meas` placement are OQ-138 | measurement.md §Peer-load capacity tests, "Measurement and path proof" | `capacity_token_bucket` |
| T172 | **OPEN, bounded (ADR-0056, OQ-139).** The coordinator leaks: the validator that draws a call's peer slices and knows its times can tell a friendly node which sessions aren't its peer slices, and when it will be called, as T146 for canary plans | Validator | The draw is recomputed from the revealed secret, so the coordinator can't hand-pick endpoints, only leak. Hidden validators self-select by VRF, so the coordinator doesn't know who they are. It is one stake-drawn validator per node and window. A withheld `plan_secret` voids its calls and is charged to it. Mitigation open: split the call among several coordinators (OQ-139) | measurement.md §Peer-load capacity tests, "The draw" | Not simulated |
| T173 | **OPEN, bounded for outsiders, not for participants (ADR-0056 revision 1, OQ-167; not scored).** Flood framing: anyone floods an honest node's port by about 12% during a call, or a drawn source oversends on its session, making the call short. In the first draft call blocks were public (`b − 1`) and one short call applied the bond | Anyone, Operator | Call and retest times come from the coordinator's committed `plan_secret`; a short call only zeroes its sample and is retested; the bond needs a short retest or 2 strikes. A blind flooder's loss is at most its flood duty `φ` (0.31 of `φ` at `φ` = 0.1; first draft: 0.1% of the day zeroed the node). Sessions are policed to the instructed rate, so an oversend costs nothing on a node with link headroom. Residual: participants learn of a call at its start, so a cartel endpoint (in 49% of calls at `f_uid` = 0.01, 97% at 0.05) can tip a flooder, costing the node 63% to 100% of its credit; a link-bound node is equally exposed to oversends | measurement.md §Peer-load capacity tests, "Calls" and "Retests" | `capacity_flood_framing`, `capacity_peer_oversend` |
| T174 | **MITIGATED (ADR-0056 revision 1).** Draw feedback: with peers weighted by spare capacity, an inflated cartel has more spare, so more draw slots, so more collusion, and busy honest nodes make it worse | Operator | Endpoints are drawn uniformly per UID, then within the UID, with at most `CAP_PEER_UID_SLOTS` per UID a call, so credit buys no draw weight; `N`'s ASN is excluded. Per UID the cartel holds its share `f_uid` of the UIDs with a free slot, and inflation stays within `1/(1 − f_uid)` (1.30x at `f0` = 0.2, `f_uid` 0.26). Spare-weighted, `f0` = 0.3 grows to 0.61 and 2.0x. Residual: busy honest UIDs raise `f_uid` | measurement.md §Peer-load capacity tests, "The draw" | `capacity_spare_feedback` |
| T215 | **MITIGATED (ADR-0056 revision 1).** Lazy sources: a drawn source that sends less than its slice saves its own bandwidth and lightens every node it is drawn for, inflating every over-declarer (1.42x with 30% idle sources) | Operator | Each source has a duty record of per-slice delivered ratios, counted from the hop digests of distinct nodes under test (under-countable, never over-countable); its median below 0.95 charges the source the bond, never the node. Idle and 90% senders are charged every time at framer shares up to 0.4; honest sources 0.05% at 0.2, 11.6% at 0.4. Laziness down to 95% escapes: at most 1.05x | measurement.md §Peer-load capacity tests, "Source duty" | `capacity_lazy_sources` |
| T216 | **MITIGATED, residual MEDIUM (ADR-0056 revision 1).** Griefing and favouring validators on hidden slices: in the first draft two griefers of four zeroed a sample through the lower median | Validator | The sample is the mean of the hidden results, so each bad result moves it by at most `1/m` (25%, 50% for one and two of four); short needs a majority (upper median); the bond needs a majority twice (`P(majority)²` a call: 0.0025 at stake share 0.25). Long-run loss is about the griefers' stake share (0.06, 0.25, 0.47 at 0.1, 0.25, 0.4). Residual: two favouring validators of four lift a node delivering half to 0.80 of its declaration | measurement.md §Peer-load capacity tests, "The call outcome" | `capacity_validator_grief_quorum` |
| T217 | **OPEN, blocks scoring (ADR-0056 revision 1, OQ-166).** Hidden-slice tells and relay drops: the terminating relays `H_in` and `H_out` know they carry a validator's slice and can tell `N`; past plans give timing fingerprints; and a framer relay on a hidden slice's path (`H_in`, `R_out`, `H_out`) can drop it | Operator | Relays are drawn per call from all peers, never validator-run; hidden slices use the peer-slice sender; leaks feed T167. Framer relays at share 0.1 cost a 10 Gb/s node 23% of a sample (31% at 100 Gb/s), short in 1.6% to 9.4% of calls; at 0.3, 75%. Not mitigated: needs relays that can't tell (OQ-166) or relay duty records | measurement.md §Peer-load capacity tests, "Hidden slices" | `capacity_peer_framing` (detail), `capacity_hidden_leak_ramp` |
| T185 | **MITIGATED by design, not scored yet (ADR-0057).** Location spoof: a node delays or drops sites' probes to be placed in a dearer region, the Helium GPS-spoofing analogue | Operator | Delay can only raise an RTT, and the separation rule puts sites of different regions further apart than any node can be in range of both. So the only placements open to a node are its true region and unplaced. Unplaced pays `GEO_PRICE_MIN_PPM`, at or below every price, and `ΣS` counts unplaced nodes, so no other region's price falls. Prices have no memory of supply, so a spoof in one window moves no later price. Unplacing resets probation | measurement.md §Network position; scoring.md §Locational price | Sim `geo_location_spoof`: 4 attackers (small EU node, EU whale with half of EU, AF node, node between regions) x 129 delay patterns x 2 schedules, best 1.000x honest, 0 placements outside the true region |
| T186 | **MITIGATED by design (ADR-0057).** Sybil split for price: one operator splits into many nodes or UIDs, or registers fresh keys in a scarce region, to collect more of its price | Operator | Placement is per node by physics, so pieces at one place share one region. `S_r` and `ΣS` don't change and pay is linear in priced capacity (floors only lose). Demand is never node-derived. A fresh key is on probation (at most 1.0x) for `GEO_PROBATION_WINDOWS` | scoring.md §Locational price | Sim `geo_sybil_split`: k in {2, 3, 8, 16}, one UID or k UIDs, in AS and EU, worst 1.000000x |
| T187 | **OPEN, bounded (ADR-0057; revisions 1 and 2).** Validator site collusion: validators report false low `geo_rtt` figures (and test RTTs) from their own sites to place a colluding operator's far-away nodes in their region, or false figures to cause conflicts; or false high figures to unplace a rival (denial) | Validator, Operator | Placement needs `GEO_PLACE_MIN_SITES` (2) in-range sites with disjoint validator sets, and every covered location has `GEO_SITE_REDUNDANCY` (3), so one validator can neither place nor unplace a node. A site's figure needs a strict stake majority. False figures place a node only in the colluders' own region, conflicts go to the cheaper region, and conflicts are listed publicly. **Residual:** two colluding validators, each running a site of one region, can place a node there (1.175x), and two deniers of three can unplace a rival. **Before enabling (OQ-196):** vetted, distinct site operators; a light-cone tripwire on any node whose figures at two sites sum to less than their separation allows; and a flag on placed nodes that are slow to their region's other placed nodes | measurement.md §Network position | `geo_site_collusion`: one colluding site 1.000 (1.175 before revision 1); half of two sites' stake 1.000 (1.175 with `>=`); two colluding validators 1.175, the residual. `geo_site_denial`: any one denier of 3 sites 1.000 (twin sites: 1.916); two deniers 1.916, the residual |
| T188 | **CLOSED for miners, DORMANT for customers and the company (ADR-0057, OQ-186, OQ-187).** Demand steering: raise a region's price by creating demand there. Ways in: node count (today's all-pairs demand set), customer traffic (the company buying from itself, ADR-0053), or the prior | Operator, Customer, Company | All-pairs and synthetic demand are never counted. Matrix demand has weight `1e6 - GEO_PRIOR_WEIGHT_PPM` = 0 at launch. The prior moves only on ADR-0049's scheduled, public path | scoring.md §Locational price | `geo_sybil_split` covers node count; matrix and prior levers are policy (OQ-186, OQ-187) |
| T189 | **OPEN until the usable-capacity cap merges (ADR-0057 §6).** Unusable capacity paid at a scarce price: a node in a scarce region with no peers that could route through it is paid up to `GEO_PRICE_MAX_PPM` for capacity nobody can use, and its supply lowers the price for that region's useful nodes | Operator | Dependency: the peer-load capacity-test design caps `scoring_capacity` at usable capacity, and pricing uses that figure. PB-44 MUST NOT enable pricing before it merges unless `GEO_PRICE_MAX_PPM` is held at `1e6` | scoring.md §Locational price | None until that design lands |
| T190 | **OPEN, LOW, behavioural (ADR-0057 §4).** Herding: every operator moves to the same scarce region at once, on the same price map, and prices oscillate | Operator | Probation (at most 1.0x for a day after a move) is a switching cost, and real moves take time and money. Moves that each improve their mover converge, because the region game has an exact potential. Prices aren't smoothed on supply, because that opens T191 | scoring.md §Locational price | Sim `geo_price_stability`: 3 movers a window, 10% margin, 0 cycles, 0 potential drops, 0 tail price changes; the herd contrast (all at once, no margin) cycles 394 times and gates nothing |
| T191 | **MITIGATED by design (ADR-0057 §4).** Supply-withholding pump: a whale withholds capacity, or unplaces itself (free when its region already sits at `P_MIN`), to raise its region's price, then collects the lag | Operator | Prices are memoryless in supply: only demand is smoothed. Without clamps, a region's pay is exactly its demand share, so withholding only lowers the withholder's fraction of it. With clamps, the region's total doesn't rise | scoring.md §Locational price | Sim `geo_location_spoof` (withholding 10/50/90%, held or alternate, best 1.000x); `geo_price_stability` reports the pump a price moving average would open: 1.0117x at α = 0.1 vs 0.9973x memoryless |
| T192 | **CLOSED as an exploit, folded into T196 (ADR-0057 revision 1).** Front-end proxy: a host in a scarce region answers probes and forwards transit to capacity in a crowded region, to be paid the scarce price. The design-phase row claimed the hairpin's latency, seen by link probes and `Q_n`, catches this. It doesn't: `Q_n` scores loss and latency against the path the table assigns, and a front only has to be good enough, not free of hairpin | Operator | See T196. When the endpoint is the front box, peer links come only from the endpoint prefix, so capacity and carriage are the front box's own. That is real ingress capacity in the scarce region, so it is paid as such, whatever the box does with the traffic behind it | measurement.md §Network position | `geo_endpoint_front` |
| T193 | **OPEN, bounded by OQ-43 (ADR-0057).** Burst-rented capacity in a scarce region: rent capacity for its capacity tests to collect up to 3x, or rent into a rival's region to push its price down | Operator | Prices are memoryless, so a burst moves prices only while the capacity is there, and the renter pays the rent. Burst renting itself is OQ-43 / Task 15b, and pricing raises its stake by up to `GEO_PRICE_MAX_PPM` | scoring.md §Locational price | Existing `burst_renter*` sims apply, unpriced |
| T194 | **MITIGATED by process (ADR-0057).** Invalid region table: sites `a`, `b` of two regions closer by chord than `(R_a + R_b) * c / 2`, so an honest node is in range of both and could choose by delay; or a region with fewer than two independent sites | Publisher | The publishing tool checks separation by chord and the two-site minimum, and refuses the table. Conflicts at run time go to the cheaper region and are listed publicly | measurement.md §Network position | Unit tests `placement_needs_two_independent_sites`, `per_site_radii_set_the_separation`; the sims' `world()` and `geo_coverage_band` assert separation |
| T195 | **OPEN, bounded, dormant (ADR-0057, OQ-189).** Atlas anchor forgery: an Atlas ping is ICMP or TCP, not a STAMP exchange on the node-key-authenticated vantage session, so an anchor's host or its network forges a fast reply for a colluding node's endpoint, or the host misstates the anchor's position | Outside party, Operator | Dormant: the launch region table lists no Atlas site, and none is listed until the terms are verified. If listed: anchors only (never volunteer probes, whose positions hosts set), each admitted by a proximity proof from a validator site of its region. A forged figure can place a node only in the anchor's own region, and a conflict goes to the cheaper region, the same bound as T187 | measurement.md §Network position | Not simulated |
| T196 | **MITIGATED by design (ADR-0057 revisions 1 and 2, red team Critical).** Thin front in a scarce region: one node key on several boxes, so a cheap box near a scarce region's sites makes the node look placed there while capacity in a crowded region is paid the scarce price (1.5x measured, up to `P_MAX / P_MIN` = 6x). Variants: (i) a **session front** answering the scarce sites' vantage sessions from its own address; (ii) an **endpoint front** with a back box carrying the data plane; (iii) an **anycast front**; (iv) any of these inside one provider's IPv6 /32, which revision 1's prefix match let through (revision 2's Critical) | Operator | (a) Vantage figures count only from sessions whose source matches the committed endpoint: the exact IPv4 address (a carrier-NAT pool's /24), or the IPv6 /64. (b) Every timing a site's agents see counts toward its figure. (c) Honest peers accept peer links only from the endpoint. (d) Capacity is priced above `P_MIN` only up to dedicated in-region tests whose **own** RTT is within their site's radius; delay can hide a near box, never fake one. **Note:** with Europe's 4 ms radius most European boxes are unplaced, so a front's back box trips no Europe conflict. The light cone's conflict rule doesn't help there; (a), (c) and (d) do. **Residual:** a front box's own capacity is real ingress in the scarce region and is paid as such (T192) | measurement.md §Network position; scoring.md §Locational price | Fixed vs before (W 0.7 and 0.3): `geo_split_session_front` 0.790 vs 1.513; `geo_endpoint_front` 0.213 vs 1.523; `geo_anycast_front` 0.923 vs 1.513 (1.513 with (a)-(c) only); `geo_v6_prefix_front` 0.790 / 0.213 vs revision 1's 1.513 / 1.523 |
| T197 | **OPEN, LOW, bounded (ADR-0057 revisions 1 and 2).** Carry abuse. (i) Outage freeze: a validator takes its site down, freezing placements that need it. (ii) Relocation gain: a node that moves away and drops (rather than delays) its old region's probes stays silent there, so it keeps that region's price | Validator, Operator | The carry lasts at most `GEO_OUTAGE_CARRY_WINDOWS` (24) windows. A node placed elsewhere is placed there at once. A site reporting the node out of range ends the carry. In-region capacity is carried, not re-measured, and expires after `GEO_INREGION_MAX_AGE_WINDOWS`. With three sites per location, one site down freezes nothing | measurement.md §Network position | `geo_site_outage`: AF node 1.28x through a 10-window outage of 2 of its 3 sites (0.50x without the carry); a 40-window outage keeps 24 windows, then 0.50x. `geo_location_spoof`'s drop-all pattern gains nothing (1.000) |
| T198 | **MITIGATED by design, residual open (ADR-0057 revision 2, red team Medium).** One shared in-region box behind many nodes: 8 nodes anycast from one 50 Mbps box near a scarce region's sites, so each node's in-region tests measure 50 Mbps | Operator | In-region capacity is pooled within a region per UID and per origin ASN of the endpoint: a simultaneous cohort in-region test caps the group's sum (`geo::pool_in_region`). **Residual:** sybil UIDs with distinct origin ASNs (each one costs an ASN) aren't pooled | measurement.md §Network position | `geo_shared_inregion_box`: one UID 0.988, 8 UIDs with one ASN 0.988 (1.094 unpooled); 8 UIDs with 8 ASNs 1.094, the residual |
| T220 | **MITIGATED (ADR-0058).** Copied inline binding: a hotkey copies another fleet's inline payload (or lists any node keys) into its own commitment to claim or quarantine those nodes | Operator | The payload carries no hotkey; it stands for a binding by the committing UID's own metagraph hotkey, and a node counts only with an effective consent to that hotkey (Binding resolution, rule 2). Unconsented entries are ignored, never quarantined (T14) | identity.md §Inline node binding | `inline_resolves_under_consent_and_takes_precedence` |
| T221 | **OPEN until Task 19b activation (ADR-0058 §6, OQ-201).** Version split: code from before ADR-0058 reads a multi-field registration as not Transit Fabric's and drops its manifest too, so old and new validators would score different inputs (Invariant 1) | Operator (any hotkey that commits inline) | Nothing scores from chain commitments before Task 19b; its reader fills `TempoInput::inline_bindings` only from an ADR-0049 activation block before which every validator ignores inline layouts; local and test active from window 0 | identity.md §Inline node binding, "Activation" | none yet (Task 19b) |
| T222 | **MITIGATED (ADR-0058).** Hostile or malformed commitments passed off as Transit Fabric's: foreign `Raw` data, a short first field, an empty or fourth field, another hash in field 0, a `RawN` whose bytes aren't `N` long, trailing bytes | Anyone who commits | Exactly two layouts are read (`[Sha256]`, `[Sha256 \| None, Raw, Raw?]` with the canonical 128-byte split); the payload decodes strictly (version, exact length, 1..=7 sorted valid keys, window); anything else is not Transit Fabric's: skipped by readers and never replaced by `bwos bind` or the page | encoding.md §Commitment fields | `only_bwos_layouts_parse`, `inline_binding_vectors_match`, `commitment_records_decode_inline_bindings`, the page's layout test |
| T223 | **MITIGATED (ADR-0058 fix round 1).** Inline binding wiped or a stale manifest binding resurrected. Every manifest recommit (validators and solvers recommit often) wrote `[Sha256]` alone, silently dropping the inline binding and bringing back whatever binding the manifest names | The operator's own tools | Every Transit Fabric commit path reads the registration first and keeps fields 1 and 2 (`manifest_commit_content`: `bind commit --manifest`, `attest-key commit`, the page). Non-Transit Fabric registrations are refused. Reverting to the manifest's binding happens only by explicit choice (`--drop-inline`, or the page's drop box) | identity.md §Inline node binding, "Recommits keep it" | `manifest_commit_content_keeps_inline_unless_dropped`, `bind_commit_manifest_keeps_inline`, `trust_commit_keeps_inline` (localnet) |
| T224 | **Reopened by the PB-45b red team (H1: a flood of consents crowded honest UIDs out of the capped reveal; M1: old revocations displaced a node's current consent), mitigated in fix round 1; fix round 2 (H3: the first-come pool brought crowd-out back; M4: a superseded consent took a quota slot), mitigated.** Consent delivery over the probe session abused: a node or forwarder pushes consents for other nodes, floods, or replays a lower `seq` | Operator | Accepted only when `node` is the session's own node key (bound by its live `wg-binding`; a `--test-identity` session forwards nothing), verified, one datagram of at most `MAX_FORWARD_PAYLOAD`; a per-session token bucket and repeat memory, the repeat checked first so resends spend no token; a pending pool per session node (its current consent, newest revocation and up to `MAX_NODE_OBJECTS` objects, a new one replacing the least recently sent in the node's most-held domain; tests `the_pool_replaces_within_the_most_held_domain`, `a_new_manifest_every_window_never_evicts_the_declaration`, `a_resend_is_handed_on_again_as_sent`), so a node replaces only its own entries; a reveal lists one current consent and one newest revocation per node (only the revocation when it supersedes the consent), newest first, only under a hotkey a binding lists the node with, at most `MAX_REVEAL_CONSENTS_PER_UID` per UID; per `(node, netuid)` only the highest-`seq` started consent and revocations win (`effective_consents`, no resurrection) | identity.md §Delivery over the probe session | `consent_flood_cannot_displace_other_uids`; `revocation_heavy_node_keeps_current_consent`; `the_pool_keeps_each_nodes_latest_and_is_bounded_per_node`; `repeats_spend_no_tokens`; `a_newer_revocation_is_listed_alone`; sim `consent_crowd_out`; `a_consent_counts_only_for_the_sessions_own_node`; `test/netns/probe_forward.sh` |
| T225 | **Reopened by the PB-45b red team (H2: locally received items could reach scoring through `consent_state` or the store, so validators diverged), mitigated in fix round 1; fix round 2 (H2: `batch-sign` listed what it was given, and `serve --consents-out` was documented as feeding `--consents-file`), mitigated; live loop wiring is Task 19b's.** Consent divergence: validators receive different consent subsets (loss, timing, or a validator withholding a revocation), so honest validators score different live sets | Validator, network | Received items wait in a pending pool (`ForwardPool`) that feeds only the validator's own reveal and its probe agent's plan, which is not scored (the file tools too: `serve --pool-out` writes a pool that only `batch-sign --pool` reads, revealing against the chain read, and `--consents-file` refuses it); scoring reads only the union of revealed lists that pass the chain checks (no forgery, no resurrection, any one honest validator restores a withheld revocation); a post-cutoff arrival changes nothing until the next window's reveal | identity.md §Delivery over the probe session | `post_cutoff_forward_does_not_change_outcome`; `the_union_of_reveals_keeps_a_revocation_one_validator_withheld`; `batch_sign_reveals_the_pool_against_the_chain_read`; `test/netns/probe_forward.sh` |
| T226 | **OPEN until Task 19b (ADR-0058 §5, OQ-204).** ASN grinding and churn by recommit. If an inline node's ASN-ranking block were its registration's current block, every recommit would push honest incumbents back, and a hotkey could recommit until `asn_tie(block_hash_after, key)` wins a collision | Operator | An inline node's block is the first registration that listed it under that UID with no break at any read block since; its tie uses the hash of the block after that one, so a recommit keeping the node changes neither. Derived from `Commitment` events or carried forward in committed inputs (OQ-204) | identity.md §Inline node binding, "Collisions" | `asn_grind_inline_recommit` (to write with Task 19b) |
| T250 | **MITIGATED in design (ADR-0059 revision 1), not active.** Capacity hog across shards: a solver wins one shard with a table that loads relays, endpoint-and-relay nodes or finite links another shard needs. Revision 0 left links unsplit, counted endpoint traffic in the allocation but not the check, and rechecked nodes only (red team round 1, High) | Solver | Node, relay and link capacity split separately before solving (reference load plus locality-weighted slack); a shard table is valid only if `validate_under_demand` passes and `compute_overloaded_nodes` is 0 on its view; the merged recheck uses `compute_overloaded_nodes` on the full snapshot and evicts invalid-on-view shards first | routing.md §Proposed (ADR-0059), scoring.md §Proposed (ADR-0059) | `shard_capacity_hog`, `shard_link_hog` (link 300/300, node 400/400; hog invalid on view; only its shard evicted), `allocations_fit_and_cover_the_reference` |
| T251 | **Proposed (ADR-0059), not active.** Merge nondeterminism: validators compute different merged tables, so nodes see conflicting attested production tables (T60) or none reaches quorum | Validator, network | The merge is a pure integer function of committed inputs (plan, solved-on snapshot with placement, demand, reference, allocations, selected tables), `BTreeMap` only, sorted output, fixed `solver` label, no signature; validators attest the table and a recomputable merge record | routing.md §Proposed (ADR-0059) | `shard_merge_determinism` |
| T252 | **Proposed (ADR-0059), not active.** Merge-order gaming: a solver gets its routes accepted ahead of a rival's at a conflict | Solver | Order is the committed plan's shard id, never score, UID or commit block; with one class group the union is disjoint per destination and order-free (no fallback) | routing.md §Proposed (ADR-0059) | `shard_merge_determinism` (region plans: zero fallbacks) |
| T253 | **Proposed (ADR-0059 revision 1), class groups only, not active.** Cross-shard cycle sabotage: a higher-priority class shard's winner picks next hops towards shared destinations that force a lower shard's routes off, to lower its rival's grade | Solver | Displaced routes fall back to the reference's, then `direct`, in the merge only; every table is graded as submitted (live blocks included), so displacement can't lower a rival's score; merge harm dropped; class splits not enabled until a red team | scoring.md §Proposed (ADR-0059) | `shard_cycle_saboteur` (victim's grade 795_000 with and without the saboteur; 0 if graded on the merged slice), `a_cross_class_cycle_falls_back_to_direct_in_the_later_shard` |
| T254 | **Proposed (ADR-0059), not active.** Shard-shopping: solvers crowd the easiest shard, or try to move weight towards the shard they entered | Solver | `W_s` comes from smoothed regional demand `d_r` with a 5% floor, never from entrants, scores or pair counts; each shard has its own ladder (the top rung keeps at least half); an unbeaten shard's weight is unearned within the first-party cap, so a solver who beats the reference there takes it | scoring.md §Proposed (ADR-0059) | `weights_have_a_floor_sum_to_a_million_and_ignore_entrants`; `shard_crowding` (to write, PB-46) |
| T255 | **Proposed (ADR-0059), not active.** Cross-shard clone dodge: copy another shard's routes, last window's production routes for keys that moved shard, or another class's paths for the same `(src, dst)` | Solver | Shard keys are disjoint, so no table copies another shard's key for key; the prod-copy check runs per shard against the merged production table restricted to the shard's current keys, moved keys included; a copied other-class path must still beat the shard's reference by `EPSILON_ROUTE` and pass the solved-on gate | scoring.md §Proposed (ADR-0059) | `cross_shard_copier` (to write, PB-46) |
| T256 | **Proposed (ADR-0059), not active.** Collusion across shards: one entity wins several shards and coordinates them, for example to route through its own relays | Solver + operator | With one class group shards don't interact in the merge; regret, the usage concentration cap and the Mechanism 0 regret gate bound relay dealing per shard as for one table (T8); winning every shard pays what winning today's single contest pays | scoring.md §Proposed (ADR-0059) | `shard_collusion_pair` (to write, PB-46) |
| T257 | **OPEN, low (ADR-0059).** Placement steering: an operator moves its destination node's pairs into another shard (by going unplaced or moving region) to land in a colluding solver's shard | Operator + solver | Shard membership is ADR-0057 placement on the solved-on snapshot (light cone, two independent sites, hysteresis); moving pairs changes `D_s` and which ladder grades them, never the grading rules or a route's pay | routing.md §Proposed (ADR-0059) | — (model only) |
| T258 | **Proposed (ADR-0059), not active.** Update interference: two shards' incremental updates, each valid alone, combine at a node into a cycle or an overload, or nodes applying chains in different orders diverge | Solver, network | One chain per `(window, shard)` on disjoint keys; each checked on its shard view (capacity within allocation) and against the merged table's structure; towards destinations shared by several shards, only removals and `direct` | routing.md §Proposed (ADR-0059) | `shard_update_race` (to write, PB-46) |
| T259 | **OPEN, efficiency (ADR-0059, OQ-232).** Allocation starvation: the reference-anchored split holds back a solver whose better routing uses relays differently from the reference; or an operator shapes allocations through the snapshot | Solver, operator | Slack goes by locality (reference load plus the shard's own endpoints), falling back to `W_s`, so a shard has room where its pairs are; allocations read only the snapshot, demand, plan, `d_r` and reference; published before the commit deadline | routing.md §Proposed (ADR-0059) | — (efficiency against a single table to measure, PB-46) |
| T260 | **Proposed (ADR-0059), not active.** Selective reveal: a solver in several shards reveals only the shard tables that look good after the deadline | Solver | One commitment per UID over the whole bundle (`route-table-bundle`); a partial reveal doesn't match the hash and counts as no submission | scoring.md §Proposed (ADR-0059), encoding.md | unit test with the bundle (PB-46) |
| T261 | **Proposed (ADR-0059 revision 1), not active.** Sybil destinations: an operator registers many destination nodes in a region so demand sampling inflates that shard's weight (pair-count weights), or owns every destination of a shard | Operator + solver | `W_s` from ADR-0057's smoothed regional demand `d_r` (prior plus non-synthetic), never pair counts, with a 5% floor; a non-residual shard with fewer than `SHARD_MIN_DEST_UIDS` (3) destination UIDs folds into the residual | scoring.md §Proposed (ADR-0059) | `shard_sybil_region_capture` (0 ppm moved; pair-count rule would give 666_666 ppm), `thin_shards_fold_and_regional_demand_sets_weights` |
| T262 | **Proposed (ADR-0059 revision 1), not active.** Shard-view regret dodge: a solver detours a pair through its own relay where its shard view gives a faster relay no capacity although another shard left it unused, so the detour is regret-free on the view and its relay passes the Mechanism 0 gate | Solver + operator | Regret and the Mechanism 0 gate are computed on the full snapshot with the merged table's other loads (OQ-238 (b)); slack split by locality (OQ-232 (b)) | scoring.md §Proposed (ADR-0059) | `shard_view_dealer` (0 ppm on the view, 200_000 ppm under the rule) |
| T263 | **Proposed (ADR-0059 revision 1), not active.** Recheck blame: when the merged table fails the recheck and no shard is invalid on its view (stale or broken allocations), evicting the highest id punishes an honest shard for another's overload | Solver | Evict, per overloaded node, relay cap or link, the shard with the largest load on it (ties to the higher id) | routing.md §Proposed (ADR-0059) | `shard_recheck_blame` (evicts {1}, the overloader, not {2}) |
| T230 | **OPEN (Task 19b, OQ-211).** Selective serving: a committing hotkey serves a named object (its record, batch, binding or declaration) to some validators only, so they score different inputs and Yuma clips some of them | Validator, operator | The loop fetches from its own store and every peer and counts a missing object as absent, the same for all who lack it; no quorum on fetched objects yet | measurement.md §Live loop | — |
| T231 | **MITIGATED (Task 19b).** Copying another validator's probe batch, or naming it in one's own manifest | Validator | A batch counts only when signed by a key the committing hotkey's record maps to it; the loop withholds its own batch until the read block has passed, and commitments are read at that block by hash | measurement.md §Live loop | `a_bound_tested_node_earns_mechanism_0_through_the_loop` |
| T232 | **MITIGATED (Task 19b).** Equivocating publication after a restart: a validator that crashed between signing and recording could attest a second object for the same window | Validator (bug or attacker with a restart) | `attest-guard.json` records `(domain, latest_key, attestation hash)`, synced, before the publisher signs; a different object for a recorded key is refused | measurement.md §Live loop | `live_t60_guard_survives_a_restart` |
| T233 | **MITIGATED (Task 19b).** Demo or file inputs reaching live scoring (F1), or a testnet validator scoring with one-validator-one-vote | Owner, operator error | `live` refuses `--demo`, `--input`, `--stakes-file`, `--signed-inputs`; on `test` a read with no staked hotkey is an error | measurement.md §Live loop | `live_with_no_inputs_sets_no_weights_and_never_uses_demo_input`, `live_on_test_without_a_stake_source_is_an_error` |
| T234 | **MITIGATED (Task 19b fix round 1, F1).** Evidence-slot griefing: any UID named a hash nobody serves in its `outside-evidence` slot, or copied another validator's hash, and every validator held both mechanisms back for about 25 windows | Any UID, validator | Fix round 2: missing evidence never holds weights (an unfetched object just isn't counted); slots count only for hotkeys in the window's validator set with a permit, per `(hotkey, window)`, a shared hash to the earliest commitment | measurement.md §Live loop | `a_miner_evidence_slot_never_holds_back_weights`, `a_copied_evidence_hash_does_not_hold_back_weights` |
| T235 | **MITIGATED (Task 19b fix round 1, F2).** Tarpit pull bases: an axon that accepts and never answers stalled every read for a fetch timeout per object, delaying the validator's own commit past its read block | Any UID | Fix round 2: every fetch of a read or a scoring pass starts at once and the batch is waited on once, each object racing its sources and returning on the first verified copy, so a tarpit costs only its own hotkey's objects; unfetched manifests re-read until the scoring deadline; the own commit runs first in each pass | measurement.md §Live loop | `tarpit_axons_do_not_delay_own_commit`, `tarpit_axons_sorted_first_do_not_drop_an_honest_manifest` |
| T236 | **MITIGATED (Task 19b fix round 1, F5).** SSRF through a pull base: an axon pointing a validator at its loopback, a private network or a metadata address | Any UID | `fetch::check_pull_base`: a bare `http://<ip>:<port>`, IP literal only (no DNS, so no rebinding), no path or query; global unicast only on `test` | identity.md §Commitment manifest | `pull_bases_are_bare_ip_bases_and_global_unicast_on_test` |
| T237 | **MITIGATED (Task 19b fix round 1, F3, F6).** State drift and rank-by-timing: a missed window was marked scored and its carried state skipped; and among bindings older than the read horizon, commit timing still set the ASN rank | Validator (outage), operator | Scoring in order with retry and catch-up; every binding as old as the horizon ranks from the oldest window's first block | measurement.md §Live loop | `restart_before_scoring_still_scores_the_window` |
| T238 | **MITIGATED (Task 19b fix round 3, C1).** Copied-hash fetch blocking: a hotkey commits a manifest naming another hotkey's object hash, with a dead axon that sorts first; fetches deduped and failures remembered by `(domain, hash)` alone marked the object failed before the owner's axon was asked | Any UID | Requests grouped by `(domain, hash)`; one job races the peers and the axon of every hotkey naming the hash; failures remembered per source | measurement.md §Live loop | `copied_hash_with_dead_axon_does_not_block_owner` |
| T239 | **MITIGATED (Task 19b fix round 3, H1).** Fetch starvation: about eleven junk UIDs naming objects that sort first, on tarpit axons, filled the in-flight cap, and requests past it were dropped, so probe batches and route tables were never fetched | Sybil UIDs | No drop: jobs queue and start one hotkey at a time in turn until the budget ends, each hotkey holding at most `MAX_FETCHES_PER_HOTKEY` | measurement.md §Live loop, scoring.md parameters | `junk_uids_cannot_starve_probe_results_or_tables` |
| T240 | **MITIGATED (Task 19b fix round 3, H2).** Withholding a table at the probe draw: a solver serves nothing at `S + 36`, so none of its paths is drawn for path probes, then serves the table at scoring time and is graded unprobed | Solver | Only tables fetched at the draw are graded, recorded in `D(w)` as `drawn_tables`; anything else is no submission. A validator that missed the draw holds Mechanism 1 back (OQ-224 (a), M-a). Residual: a draw that failed is retried until `S + 36 + DRAW_GRACE_BLOCKS`, so a table first served in those 12 blocks is drawn by a validator whose own draw failed, never by one whose draw succeeded; the timely quorum's grading decides | measurement.md §Live loop | `table_withheld_at_probe_draw_is_not_graded`, `a_missed_probe_draw_holds_mechanism_1_back` |
| T241 | **MITIGATED (Task 19b fix round 3).** First-party slot takeover: the first party was pinned by UID number, so after its deregistration whoever registered into the UID took all of Mechanism 1's unearned weight | Any registrant | `--first-party-hotkey <ss58>`, resolved to its UID at each read block; `--first-party-uid` removed | measurement.md §Live loop, operations/testnet.md | `the_first_party_is_pinned_by_hotkey_not_uid` |
| T264 | **OPEN, LOW (Task 20).** A validator feeds a solver a forged snapshot. A solver started without `--validator-set` trusts the first validator's latest set on first use; that validator can serve a set of its own keys and a snapshot it alone attests, so the solver solves on a fake topology | Validator | Testers get a `validator-set.json` anchor with the tester release and pass it with `--validator-set`; the daemon walks it with `accept_next_set` and takes only a snapshot the set attests at `SIGNED_INPUT_QUORUM_PPM` (demand per pair included), refusing two attested ones for a window. First-use trust is only a fallback and logs a `validator_set_trusted_on_first_use` warning. Even then only that solver is harmed: its table fails `validate_under_demand` on the real snapshot and scores 0, and the forger gains nothing | routing.md §Route table, run-a-solver.md | `daemon_refuses_an_unattested_snapshot` |
| T265 | **MITIGATED by design (Task 20).** A solver copies a rival's table before committing its own, or an incumbent re-commits after seeing rivals | Solver | Validators read solver commitments at the deadline block's hash and pull tables only when that read is taken, once `S + 36` is final (`scoring.md` §Grading item 9, OQ-220, OQ-222); the daemon serves its table once block `S + 36` exists (best head), so it is there for the path-probe draw (T240) but no commitment can still land in time, sends no commitment within `COMMIT_MARGIN_BLOCKS` of the deadline, and never commits a second table manifest before it (a later commitment would rank its table after any copy; the incumbent's update manifest comes after the read). A hand-rolled solver serving early only exposes itself | scoring.md §Grading item 9, identity.md §Pulling a hotkey's objects | `daemon_commits_a_manifest_whose_table_hash_matches_what_it_published` |
| T280 | **Reopened by the PB-45b red team (H1: the same object revealed once per forwarding node crowded out other UIDs' manifests; H2: admitted objects went straight into the store; M2: an object under another hotkey, or a binding through `objects`, could be admitted), mitigated in fix round 1; fix round 2 (H1: one outsider-forwarded manifest made a validator's whole object list fail, voiding every UID's), mitigated.** Forwarded operator objects abused: a node forwards another UID's objects, objects no commitment names, or floods validators' stores; or one validator reveals objects others never admitted | Operator, validator | The agent keeps only verifying objects in `FORWARDED_DOMAINS` (no route tables), tagged with the session's node key; a validator admits one only if the chain names it at the read block for a UID (manifest by sealed hash in field 0 and the binding only through `binding`, both chain-pinned so from any forwarder; then what the manifest names, only as forwarded by the UID's own nodes; each only with the UID's own `hotkey`; inline binding takes precedence); a list counts per UID, so one UID's bad entries drop only that UID's; each `(domain, hash)` is revealed once, at most `MAX_REVEAL_OBJECTS_PER_UID` per UID, within `MAX_REVEAL_FORWARD_BYTES`; only the union of revealed lists, re-admitted against the same chain read, reaches the store, from the next window | identity.md §Delivery over the probe session | `reveal_objects_honest_load_keeps_every_manifest`; `only_the_bound_uids_committed_objects_are_admitted`; `an_outsider_forwarded_manifest_voids_nothing`; `reveal_of_any_pool_passes_its_own_check` (property); `reveal_caps_at_maximum_fit_the_byte_budget`; `test/netns/probe_forward.sh` |
| T281 | **Residual (PB-45b, OQ-261).** The reveal cutoff can't be checked by others: a validator can list a consent or object it received after `FORWARD_REVEAL_CUTOFF_BLOCKS`, up to its commit | Validator | Harmless to the set: every entry is node- or hotkey-signed and re-checked (consents by `effective_consents`, objects by `admit_forwarded`), so a late entry can only add what the chain already fixed at `A(w)`. Since the cold-start fix (forwarded objects count in their own window, OQ-261) a permit-holding operator re-committing every window can decide at its own commit whether its forwarded declaration counts for `w`, the same option as serving only at scoring time (OQ-211), bounded by the declaration cooldown; the batch is fixed at commit, so nothing changes after others score | identity.md §Delivery over the probe session, "Bounds" | — |
| T282 | **MITIGATED (PB-45b integration fix round, H1).** One missing binding voids every consent: the scorer dropped a batch's whole consent list when one consent's node wasn't listed in its own bindings (a binding it hadn't fetched, OQ-211), so one UID's withheld binding cost every UID's forwarded consents in that batch | Operator, validator | `accepted_reveal_consents`: the list's shape (the signer's alone) or nothing; then each consent on its own, the listing before the signature, and the per-UID quota only over listed consents | identity.md §Delivery over the probe session | `a_consent_the_scorer_cannot_place_voids_no_other_uids` |
| T283 | **MITIGATED (PB-45b integration fix round, M1).** Local store consents bypass the union: `live` scored every consent in its own store, which a loopback `PUT` or a peer's copy fills differently at each validator (Invariant 1) | Operator, validator | `live` scores no store consent; consents count only through the revealed union and the consent state it feeds. Kernel nodes lose their path until OQ-260 | measurement.md §Live loop | `a_consent_only_in_the_local_store_does_not_count` |
| T284 | **MITIGATED (PB-45b integration fix round, M2).** Any staked hotkey reveals: a batch from any hotkey with a record could add forwarded consents and objects, and its unrevealed batch was re-asked for the whole 120 s scoring budget | Staked hotkey | Only batches committed by a validator-permit holder at `A(w)` feed the union, checked before any signature; re-asks only for permit holders, at most `PROBE_BATCH_REASKS` (4) a pass | measurement.md §Live loop | `only_permit_holders_batches_feed_the_union` |
| T285 | **MITIGATED (PB-45b integration fix round, L1).** Scoring starves the draw: a long catch-up or re-ask loop ran past `S + 36 + DRAW_GRACE_BLOCKS`, so the validator missed the path-probe draw and held Mechanism 1 back | Validator (load), any UID (slow objects) | Catch-up scoring and the re-ask loop stop when a draw is due and not taken (`draw_pending`) | measurement.md §Live loop | `a_missed_probe_draw_holds_mechanism_1_back` |
| T286 | **MITIGATED (PB-45b integration fix round, L3).** Pool file swap: `read_probe_pool` checked the size by path and read the path again, so a file replaced in between was read unbounded | Local process | Opened once, read to at most `MAX_POOL_FILE_BYTES + 1` | identity.md §Delivery over the probe session | `a_cold_start_past_the_commit_block_still_reveals` |
| T287 | **MITIGATED (PB-45b integration fix round, L4).** Unreachable cutoff and a silent cold start: the spec's cutoff was `S + 350`, after the commit at `S + 300`; and a validator first started past `S + 300` committed before reading `A(w)`, so its batch revealed nothing | Validator (restart) | `FORWARD_REVEAL_CUTOFF_BLOCKS` = 60, so the cutoff is the commit block (asserted at build time); a cold start reads `A(w)` alone before committing | identity.md "Bounds" | `a_cold_start_past_the_commit_block_still_reveals` |
| T300 | **ACCEPTED RESIDUAL, only while every validator is founder-run (PB-48, corrected in PB-48, T45, OQ-284).** Unmatched probe sessions feed batches. Each validator has its own probe session with the node, so an operator can answer each validator's vantage probes and capacity tests from a different box: a forwarder, or a second box holding its node key, with more uptime or a bigger pipe than its data plane. It needn't be one box for all validators, so the stake-weighted median gives no protection | Operator | Bounded, not closed. Capacity credit needs a passing signed link with a node of another UID on the committed snapshot (T303), so a box with no data plane earns nothing. Every test's target is committed and capacity pools by its `/24` (T304). The declaration still caps capacity, and only node-key acks count. Closed by Task 18b's source match, or by dropping `--agent-results` before any third-party validator holds a permit (OQ-284) | measurement.md §STAMP probes and probe sessions ("Until Task 18b"), §Live loop | `probe_one_box_many_keys`, `pb48_only_data_plane_nodes_have_a_link`, `test/netns/probe_kernel_session.sh` |
| T301 | **Residual (PB-48, OQ-283).** A capacity test aimed at the probe session's source address: a node whose sink port is closed (and, without the agent's `--cap-dial-listen`, a node behind NAT) fails every test and earns no capacity pay. A third party can't make it fail, since the agent dials the source the node's own handshake proved and only the node key acks, but it can occupy the sink's 32 slots (4 per source IP) while a test is due. The NAT dial-out (red team fix 9) is built (T312, T313) | Operator, third party | `cap-sink -persist` keeps `MED-INFRA-01`'s per-connection header deadline, concurrency cap and per-IP cap, and serves test after test, so a scanner delays a test at most to the agent's next try; a failed test lowers the rolling lower median, never more. A dialled test is credited at most `CAP_DIALED_CEILING_MBPS` | measurement.md §Live loop ("The agent's work") | `a_persistent_sink_serves_test_after_test`, `pb48_capacity_needs_targets_bytes_and_three_reporters` (the dialled cap) |
| T302 | **MITIGATED (PB-48).** The agent's files as a side door into scoring: a results file with `direct:` or forged samples, another window's results, or a plan that aims the agent's tests elsewhere | Local process on the validator host | `live` takes results only for the window it commits, strictly parsed within 16 MiB, with only `vantage:`, `link:` and `cap:` keys and targets for `cap:` samples (`AgentResults::validate`). A key its `--probe-results` file has keeps the file's. Acks must name the batch's validator and window, `to_metric_map` still checks every ack's node signature, and a `link:` sample is only the agent's report of the far end's signed echo. The merged batch must validate before it is signed. The plan names only the attestation key, nodes and test blocks, never an address | measurement.md §Live loop ("The probe agent's plan and results") | `agent_results_carry_only_vantage_link_and_cap_samples`, `merging_adds_the_agents_samples_acks_and_targets_and_keeps_the_files`, `the_probe_agents_results_reach_scoring_in_the_committed_batch` |
| T303 | **MITIGATED (PB-48, red team fix 1, critical).** Probe-only nodes paid: a `bwos-node probe-session` (or a no-root node with no `--peer`) answered vantage probes and capacity tests with no data plane at all, and was paid for capacity it never offered transit on | Operator | Under PB-48's rules (`validator::cap_rules_on`) capacity goes only to a node with a passing `link:` result, either way, with a live node of another UID on a pair of the committed snapshot or production table (`data_plane_nodes`). Capacity is also what weighs uptime and caps bytes, so the node then earns nothing. A link probe is relayed by the node to a BGP peer it has a session with and echoed by that peer, signed with the peer's node key over (relay, peer, the agent's fresh nonce) (`probe::LinkEcho`, domain `link-echo`). No node can fake a peer's echo. Residual: two colluding UIDs can echo each other's probes with no real transit between them. That costs two UIDs and two `/24`s, and is the T29 sybil-mesh residual | measurement.md §Live loop, scoring.md §Mechanism 0 | `probe_one_box_many_keys` (8 probe-only keys 0x), `a_node_relays_link_probes_to_its_peer_who_signs_the_echo`, `pb48_only_data_plane_nodes_have_a_link`, localnet `live_localnet` (probe-only miner unpaid) |
| T304 | **MITIGATED (PB-48, red team fix 1, critical).** One box, many keys: each key's capacity test ran in turn and saw the whole pipe, so N keys on one box earned N pipes while endpoint dedupe was off | Operator | Each `cap:` sample commits its target (`ProbeResultBatch::cap_targets`). Scoring takes each node's target by stake plurality (`aggregate_cap_targets`, carried as `prev_cap_targets`) and pools capacity by `cap_target_groups` (final verification: `/24` within one UID); a node with no target gets none. Co-located nodes of any UIDs are drawn and tested together (T316). Residual: keys on one pipe spread over several `/24`s are tested apart (T322) | measurement.md §Live loop ("Pooling") | `probe_one_box_many_keys` (8 keys 1.000x one at most), `pb48_one_box_many_keys_pools_to_one_pipe`, `cap_targets_pool_by_slash_24_within_a_uid_pushed_or_dialed_never_across_uids` |
| T305 | **MITIGATED (PB-48, red team fix 2, high).** Every validator tested a node in the same block, so three validators' tests shared one pipe and an honest node was measured at a third of its capacity | Honest operator (harm) | Validator `r` starts a due test `(r mod CAP_STAGGER_RANKS) * CAP_TEST_STAGGER_BLOCKS` (3) blocks after its due block, its rank among the read's permit holders by hotkey, so tests don't overlap. `live` moves the plan's block every block. Residual: past 16 validators ranks wrap, and the draw range shrinks to `CAP_PLAN_BLOCKS` (235) | measurement.md §Live loop | `cap_tests_are_staggered_proven_first_and_capped_per_uid`, `staggered_tests_credit_an_honest_node_its_capacity` (at least 0.9 C with 3 validators) |
| T306 | **MITIGATED (PB-48, red team fix 3, high).** Downlink only: the single-agent test pushed bytes to the node and timed its ack, so a node with a fast downlink and a slow uplink was credited the downlink | Operator | The plan's test is echoed (`team_stream` against `cap-sink -echo`), paced at the declaration for `CAP_TEST_SECONDS`, with private byte checks, so it measures `min(up, down)` | measurement.md §Live loop ("The agent's work") | `an_echoed_test_measures_the_slower_direction` (1000/40 measured at about 40) |
| T307 | **MITIGATED (PB-48, red team fix 4, medium-high).** Uptime from the samples a node chose to give: a node online for a few minutes of the window passed its window `vantage:` sample like one online throughout | Operator | The agent takes one sample per interval slot, and every elapsed slot of the window (less the one in progress) with no sample counts as a lost one (`window_vantage_sample`), so an honest node online throughout loses none, and a failing window sample counts the share of the window the node answered (`1e6 - loss`) in uptime, not 0 or 1 | measurement.md §STAMP probes and probe sessions ("The window's sample"), §Uptime | `missing_intervals_count_as_lost`, `the_agent_takes_one_sample_per_interval_slot`, `pb48_vantage_counts_the_share_of_the_window_online` (28% online scores 0.28) |
| T308 | **MITIGATED (PB-48, red team fix 5, medium).** Test-slot crowding: a UID's many unproven or overclaiming nodes held the agent's `CAP_TEST_MAX` slots | Operator | The plan orders tests as the team schedule does, proven nodes first, with at most `CAP_TESTS_PER_UID_MAX` unproven tests per UID per window (`cap_tests_due`). A test whose echo is under `CAP_ABORT_PPM` (1%) of its paced rate after `CAP_ABORT_AFTER_SECS` stops there, and then can't carry the bytes its credit needs | measurement.md §Live loop | `cap_tests_are_staggered_proven_first_and_capped_per_uid` |
| T309 | **MITIGATED (PB-48, red team fix 6, medium).** Session exhaustion: any bound key could hold one of the agent's 1,024 sessions | Operator, third party | Plan mode binds exactly the plan's nodes (listed by a registered UID's binding at `A(w)`), at most `MAX_PROBE_SESSIONS_PER_UID` (64) per UID, of which at most `MAX_UNCONSENTED_SESSIONS_PER_UID` (16) without a consent; keys no longer planned are unbound | measurement.md §STAMP probes and probe sessions ("Who gets a session") | `PlanRun::bind_plan` (plan-mode test), `a_probe_only_node_is_sampled_at_the_interval_until_unbound` |
| T310 | **MITIGATED (PB-48, red team fix 7, low-medium).** Single-validator influence on capacity: a validator could credit a rate from a short burst, and two validators completed a `cap:` median | Validator | Under PB-48's rules a `cap:` sample counts only with an ack of at least `cap_min_ack_bytes` of its rate (what the rate moves in `CAP_TEST_SECONDS`, at most 256 MiB, less the tolerance; credit is `min(declared, measured)`, so at the declared rate this is the declaration's bytes), and a `cap:` key needs `cap_min_reporters` reporters, `clamp(revealing - 1, 2, 3)` of the window's revealing staked validators (verification) | scoring.md §Parameters | `pb48_capacity_needs_targets_bytes_and_three_reporters`, `cap_reporters_follow_the_revealing_validators` |
| T311 | **MITIGATED (PB-48, red team fix 8, medium security).** The kernel install exposed the WireGuard key: its copy was readable by the probe-session and sink user, and the sink read the node key | Local process on a kernel node | The probe session uses the node key's X25519 form (ADR-0061), so no WireGuard key is copied. `bwos-probe-session` runs as `bwos-probe` reading only `/etc/bwos-probe/node.key`. `bwos-cap-sink` runs as `bwos-capsink`, which reads nothing secret: it gets each ack signed over `/run/bwos-sign/ack.sock` (group `bwos-sign`), and the socket signs only a `cap-test-ack` for its own node | ADR-0061, run-a-node.md §2b | `test/netns/kernel_install.sh` (sink user can't read a key, no `wg.key` copy), `the_probe_session_key_is_the_node_keys_x25519_form` |
| T312 | **MITIGATED (PB-48, red team fix 9, interim; final verification).** A dialed capacity test of a node behind NAT can't tell one box from several behind one public IP, or the node's data plane from another box behind the same NAT | Operator | A dialed target is credited at most `CAP_DIALED_CEILING_MBPS` (100, proposed), is the connection's source IP (which must be the probe session's), and is drawn with every node of its `/24` (`cap_draw_key`), so every box behind one public IP is tested at once, sharing its rate; it pools by `/24` within its UID like a pushed one (T319). The test is the pushed test's echoed `min(up, down)` stream with its byte checks, abort and node-key ack, paced within the agent's budget under `min(declared, ceiling)`; data-plane and reporter rules are unchanged | measurement.md §Capacity tests of nodes behind NAT | `a_dialed_test_needs_the_issued_token_from_the_sessions_ip`, `pb48_capacity_needs_targets_bytes_and_three_reporters` (the dialed cap), `staggered_dial_batches_behind_one_back_end_gain_nothing`, netns `probe_kernel_session` (H dialed through the masquerade, measured at its 30 Mbit/s uplink) |
| T313 | **MITIGATED (PB-48, red team fix 9; final verification F1).** The dial path as an attack surface: a third party dialing the agent's listener to take a test slot, replay a token or exhaust it; an agent (or a forged request) making a node dial a third party or flood it with tests | Third party, validator | The request travels only inside the node's WireGuard probe session; the node dials only that probe peer's configured endpoint IP, at most once per `CAP_DIAL_MIN_GAP_SECS` per peer and `CAP_DIAL_MAX_CONCURRENT` dials at once, and only with its node key; the agent takes a connection only from a source IP holding an unexpired token none has been taken on, one per token, and closes any other on accept with no slot (T320); the hello must name a token it issued for a test due now, from the session's source IP, before `CAP_DIAL_WAIT_SECS`, spent on use, within `CAP_DIAL_HELLO_SECS`, at most `CAP_DIAL_MAX_HANDSHAKES` at once | measurement.md §Capacity tests of nodes behind NAT | `a_dial_request_over_the_session_is_taken_once_per_gap`, `a_dialed_test_needs_the_issued_token_from_the_sessions_ip`, `a_dial_request_and_hello_round_trip_and_refuse_junk`, `a_flood_from_tokenless_ips_does_not_stop_a_due_nodes_dial` |
| T314 | **MITIGATED (PB-48 verification C1, critical).** Plan exclusion by double listing. A binding is signed by its hotkey alone, so any UID could list a victim's node keys. The plan kept only nodes exactly one UID listed, and cut the list at 2048 in key order, so a second listing dropped a consented node from every validator's plan, and a crowd of low-sorting keys pushed others out | Operator | `probe_plan::plan_candidates`: a consented node counts under its consent's UID (the lowest UID whose binding lists it under the consent's hotkey), however many others list it. An unconsented node gets a delivery session only, under the first listing UID with room. Per-UID quotas (`MAX_PROBE_SESSIONS_PER_UID`, `MAX_UNCONSENTED_SESSIONS_PER_UID`) apply before UIDs take turns up to `MAX_PLAN_NODES` | measurement.md §Live loop ("The plan") | `a_double_listing_or_a_crowd_of_keys_drops_no_ones_node` |
| T315 | **MITIGATED (PB-48 verification H1, high).** The strict capacity rules switching off. They were on only in windows whose batches carried a target, so a window with no started test reopened round 1's untargeted and many-keys claims | Operator, validator | The rules latch: `run_tempo` applies them whenever `prev_cap_targets` is non-empty, which carries forward, in aggregation (`verify_and_aggregate_probes_attested_under`) and pooling alike | measurement.md §Live loop ("PB-48's capacity rules") | `cap_rules_stay_on_once_a_window_turned_them_on` |
| T316 | **CLOSED (PB-48 verification H2; final verification).** Unfair pooling. `/24` pooling across UIDs merged honest operators sharing an ISP's or cloud's `/24` into one pipe, and IPv6 pooled at `/32`; the exact-address rule that replaced it left one box with K addresses under K UIDs earning about K times | Operator (honest, harmed); operator | Nothing pools across UIDs any more (`cap_target_groups`: one UID's targets, pushed or dialed, by `/24` or `/48`). Instead tests are drawn by the carried target's `/24` (`/48`) whatever the UID (`probe_plan::cap_draw_key`) and a draw group's tests run at once within the agent's budget, so co-located nodes share one pipe's rate and each is measured at its share: K UIDs on one box earn about one box. Honest neighbours on their own pipes are paced max-min fair within the budget and judged at their pace, so each keeps what it measured (T318) | measurement.md §Live loop ("The plan", "The agent's work", "Pooling") | `cap_targets_pool_by_slash_24_within_a_uid_pushed_or_dialed_never_across_uids`, `group_tests_credit_the_cohort_sum_within_the_budget_and_one_box_once` (4 UIDs on one 1 Gbps box: at most 1000; 4 honest UIDs in one `/24`: 500 each), sim `probe_one_box_many_keys` (8 keys on one box 1.000x at most) |
| T317 | **DOWNGRADED to residual T322 (PB-48 verification H3; final verification).** Cheap `/24` evasion. Keys on many cheap addresses in different `/24`s, tunnelled to one back end, passed their tests one after another, each at the back end's full rate | Operator | H3 drew a UID's tests together (`uid_draw_key`), which also tested an honest fleet's separate boxes at once and under-measured it against the validator's link (T318). The draw is now by the carried target's `/24` (`/48`), whatever the UID, so every node of one network is tested at once (T316) and a late or sessionless member can't be tested apart from its group (a test joining a started group waits a window; a member without a session for 120 s fails). Keys spread over several `/24`s, under one UID or many, are drawn apart (T322) | measurement.md §Live loop ("The plan") | `a_networks_tests_are_due_and_start_together_whatever_their_uids` |
| T318 | **MITIGATED (PB-48 final verification F2, high).** Concurrent group tests overloading the validator: eight 1 Gbps members of one group against a 2 Gbps validator each measured about 250 Mbps, then pooled down to the largest member and cut as overclaims, so an honest fleet was credited a fraction of its real total | Honest operator (harm); validator link | `--cap-test-budget-mbps` (`CAP_TEST_BUDGET_MBPS`, 2000): a group holds `min(budget, Σ declared)` and starts only if nothing runs or it fits, so no group pushes the agent past the budget; members' rates are their ceilings water-filled within it (`cap_test_rates`), recorded as `paced_mbps`; scoring judges each test against its own pace by the median of the validators' verdicts (T327, T326); each UID's members of a group test are one cohort, whose aggregate (`capcohort:`, now under `cap_min_reporters`) credits the UID's `/24` group its measured sum, split by measured shares. A fleet on separate `/24`s is no longer tested at once. Residual: a group's credit per test is at most the budget (T323) | measurement.md §Live loop ("The agent's work", "Judged at its pace", "Pooling"), scoring.md §Parameters | `group_rates_share_the_budget_max_min_fair`, `group_tests_credit_the_cohort_sum_within_the_budget_and_one_box_once` (four 500 Mbps pipes credited 2000, not 500; eight 1 Gbps nodes credited the 2000 budget with no overclaim cut) |
| T319 | **MITIGATED (PB-48 final verification F3, high).** A dialed test let the node choose its start: it dialed when it liked within the wait, so one back end could serve a UID's NAT nodes in staggered dial batches, each test seeing the whole pipe, and dialed targets pooled only by exact address | Operator | Once any member asks for a dial, every stream of the group, pushed or dialed, starts at `CAP_DIAL_HOLD_SECS` (20 s) after the group started, past the dial deadline; connections are held with their headers sent, and one not in by then fails. Dialed targets pool by `/24` (`/48`) within their UID like pushed ones | measurement.md §Capacity tests of nodes behind NAT ("One start") | `staggered_dial_batches_behind_one_back_end_gain_nothing` (three dials 0.7 s apart through one 40 Mbit/s back end: about 40 in all, first bytes within 300 ms), `cap_targets_pool_by_slash_24_within_a_uid_pushed_or_dialed_never_across_uids` |
| T320 | **MITIGATED (PB-48 final verification F1, high).** Dial-in slot exhaustion: any source IP got a hello slot, so about 16 IPs could hold all 8 slots (6 a minute each) and every NAT node's test failed | Third party | On accept, before any read, a connection is taken only from a source IP holding an unexpired token none has been taken on (one per token); any other is closed at once with no slot. The listener keeps no per-IP map, only the tokens, which expire with their tests; `CAP_DIAL_MAX_HANDSHAKES` is 64 and only token holders reach it | measurement.md §Capacity tests of nodes behind NAT ("Admission") | `a_flood_from_tokenless_ips_does_not_stop_a_due_nodes_dial` (2000 tokenless sources and 64 held connections, then the node's dial is taken once) |
| T321 | **MITIGATED (PB-48 final verification, medium).** Unproven-node ordering by key: a UID's `CAP_TESTS_PER_UID_MAX` unproven tests were its lowest-sorting keys, so an operator could grind keys to choose which nodes are tested | Operator | Due tests are ordered by `(proven first, block, cap_test_order)`, `SHA-256("BWOS-v0/cap-test-order" \|\| 0x00 \|\| hash of b - 1 \|\| node_pub)`, drawn per block; the same order picks a crowded group's `CAP_GROUP_MAX_TESTS` | measurement.md §Live loop ("The plan") | `a_uids_unproven_tests_are_drawn_by_block_hash_not_key_order` |
| T322 | **Residual, corrected (PB-48 final verification and release round; was T317's, OQ-285, OQ-286).** One back end behind addresses in several networks, each drawn apart, so its tests run at different blocks and each sees the back end's whole rate. Some variants cost nothing: a Hurricane Electric tunnel gives a free IPv6 `/48` per tunnel, and a VPN or proxy service gives exits in many `/24`s, all served by one box | Operator | Bounded, not closed. Closed for free variants within reach: all of a UID's dialed nodes are drawn together wherever they are (T325), and IPv6 is drawn by `/32`, so a tunnel broker's `/48`s of one `/32` are tested at once. Still open: exits in different IPv4 `/24`s or IPv6 `/32`s, under one UID or several. Each still needs a probe session from that exit, a passing signed link with another UID's node on the committed snapshot (T303), and credit is `min(declared, measured)`. The full fix, random spot co-tests across a UID's groups, is OQ-286, before mainnet; Task 18b's source match and team tests (OQ-99) also bound it | measurement.md §Live loop ("The plan") | `a_networks_tests_are_due_and_start_together_whatever_their_uids` (one IPv6 `/32` drawn together), `a_uids_dialed_nodes_are_drawn_together_wherever_they_are` |
| T323 | **Residual (PB-48 final verification).** The budget's limits. A crowded `/24` (or a fleet above the budget in one) is credited at most the agent's budget per test, so honest neighbours on fast pipes in a crowded cloud `/24` are under-credited, and beyond `CAP_GROUP_MAX_TESTS` some wait for a later draw. Judging at the pace also means a member whose real rate meets its pace escapes the overclaim haircut, and a passing paced-down test is left out of the measured median while a full one is in the span (T326), so old full tests keep a node's credit for up to `CAP_PENALTY_WINDOWS` though only crowded tests followed | Honest operator (harm); operator; validator | Rates are max-min fair, so no member takes another's share and each is judged at its own pace; credit never exceeds what was measured; the lower-median pace needs `cap_min_reporters`; which members are tested in a crowded group is drawn per block (T321). Validators should set `--cap-test-budget-mbps` to their real link rate. Team tests (OQ-99) spread a test over several validators | measurement.md §Live loop ("Budget", "Rates", "Judged at its pace") | `group_rates_share_the_budget_max_min_fair`, `group_tests_credit_the_cohort_sum_within_the_budget_and_one_box_once` |
| T324 | **MITIGATED (PB-48 release round, low).** A dial grant spent by a bad hello: a node whose first dial failed (a garbled or late hello) had used its token's one grant, so its retry was closed on accept and its test failed | Operator (honest, harmed) | A connection whose hello fails, for any reason, gives one grant of its source IP back (`DialListener::release`); a good hello on another token of the same IP returns the grant it was taken on. Still one connection at a time per token, and only from the token's IP | measurement.md §Capacity tests of nodes behind NAT ("Admission") | `a_node_whose_first_dial_fails_can_retry` |
| T325 | **MITIGATED (PB-48 release round, high, the free parts of T322).** A UID's NAT nodes dialing from many networks, and IPv6 nodes on many free tunnel `/48`s, were drawn apart, so one back end passed their tests one after another | Operator | A dialed node is drawn by its UID (`cap_draw_key`, `BWOS-v0/cap-dial-draw`), so all of a UID's dialed nodes are tested at once wherever they are, up to `CAP_DIALED_GROUP_MAX_TESTS` (20, which fit the default budget at the 100 Mbps ceiling); a pushed IPv6 node is drawn by its `/32`. Pooling is unchanged: never across UIDs, `/48` within one | measurement.md §Live loop ("The plan") | `a_uids_dialed_nodes_are_drawn_together_wherever_they_are`, `a_networks_tests_are_due_and_start_together_whatever_their_uids` |
| T326 | **MITIGATED (PB-48 release round, medium).** Crowding a victim: a crowd of nodes in a victim's `/24` cut its pace, and each window's test was then judged against the latest pace and entered the measured median, so the victim's credit stayed cut for most of the span after the crowd left; one UID's many nodes also took most of a shared budget | Operator | Rates are fair across UIDs first, then within each (`cap_test_rates_by_uid`), so one UID's crowd takes one UID's share. Each test is judged against its own pace (per-window verdicts, `cap-history.json`), and a test that passed at a pace the budget cut below the declaration is a lower bound, left out of the measured median while a full test is in the span. A node only ever crowded is credited what it measured | measurement.md §Live loop ("Rates", "Judged at its own pace") | `crowding_a_victims_slash_24_does_not_cut_its_credit_once_the_crowd_leaves`, `group_rates_are_fair_across_uids_first` |
| T327 | **MITIGATED (PB-48 release round, medium).** Mixed medians: the median measure was judged against the median pace, so validators with different budgets mixed one's measure with another's pace (a 2 Gbps and a 10 Gbps validator could fail an honest node, or pass an overclaim) | Validator, operator | Each validator's verdict is its own `measured / paced` (`probe::cap_verdict_ppm`, `cap:<node>:verdict_ppm`, under `cap_min_reporters`), and scoring takes the median of the verdicts | measurement.md §Live loop ("The `cap:` sample") | `the_verdict_is_each_validators_measure_over_its_own_pace` |
| T328 | **MITIGATED (PB-48 release round, medium).** Newcomers locked out: a group crowded with proven nodes filled its `CAP_GROUP_MAX_TESTS` before any unproven node, so a new honest node in a busy cloud `/24` was never tested and never proven | Operator (honest, harmed) | Up to `CAP_GROUP_UNPROVEN_SLOTS` (4) of a group's slots are kept for unproven nodes when that many are due (still `CAP_TESTS_PER_UID_MAX` per UID, drawn by `cap_test_order`); with none due the proven take them | measurement.md §Live loop ("Order") | `a_crowded_group_keeps_slots_for_newcomers` |
| T329 | **MITIGATED (PB-48 release round, medium).** Hold-time DoS: a group reserved its budget at start and held it through the 20 s dial hold, and the queue `break`ed behind a group that didn't fit, so a UID whose nodes refused every push could stall the agent's tests | Operator | The budget is taken only once a group's connections are made, at its connected members' ceilings (the dialed ceiling for dialed members), and given back when its streams end (`Budget`); at most `CAP_GROUPS_RUNNING_MAX` groups run, and one that can't start doesn't hold back the rest; a UID's members may cause one agent at most `CAP_HOLD_SECS_PER_UID_PER_WINDOW` (60 s) of holds a window, after which its failed pushes aren't offered a dial | measurement.md §Live loop ("Running", "Budget", "Hold cap") | `the_budget_is_shared_and_never_exceeded`, `the_hold_ledger_caps_a_uids_dial_holds_per_window`, `staggered_dial_batches_behind_one_back_end_gain_nothing` |
