wire / wire-format / red-team-findings

Red team findings: Wire Substrate + Stack

Red team analysis of the Wire Substrate and Stack design. Identifies 8 critical weaknesses, 6 performance concerns, and 4 practicality issues. Each finding includes severity, impact, and proposed mitigation.

wire-format kind wire-format status standard verification verified tier B wire-format@1

aka: Red team findings: Wire Substrate + Stack

wire format

spec: Red team analysis

Red team analysis of the Wire Substrate and Stack design. Identifies 8 critical weaknesses, 6 performance concerns, and 4 practicality issues. Each finding includes severity, impact, and proposed mitigation.

fieldsizemeaning
F1: capability check latencyperformanceEvery memory access requires a capability check (bounds, permissions, tag). CHERI adds 2-5% overhead. For a system that checks EVERY access (not just pointers), this could be 10-20%. Mitigation: capability caching in TLB (cache the last N capability checks per page). Lazy checking (check on page fault, not every access). Hardware-accelerated tag check (single-cycle, pipelined).
F2: content-addressing in RAMperformanceHashing every write (SHA-256) is too slow for main memory. 100ns per hash vs 10ns memory access = 10x slowdown. Mitigation: content-addressing only for persistent storage, not RAM. RAM uses traditional addresses. Content-addressing is applied at the storage layer (like a content-addressed filesystem on top of traditional RAM).
F3: deterministic replay storagepracticalityRecording every non-deterministic input (I/O results, timer values, randomness) requires huge storage. A busy server generates GB/s of I/O. Mitigation: record only inputs (not outputs). Use compression. Accept that replay is for debugging, not production. Ring buffer (last N seconds of recording).
F4: tagged memory overheadhardware1 bit per 8 bytes = 1.5% memory overhead. Plus hardware complexity (tag bit in every cache line, tag propagation through the pipeline). Mitigation: use CHERI's approach (tag bit per capability, stored in a separate tag memory). Tag memory is 1/64th the size of data memory (1 bit per 64 bits = 1/64).
F5: capability explosionscalabilityEvery pointer is a capability. A process with millions of objects has millions of capabilities. Need GC for capabilities. Mitigation: epoch-based reclamation (capabilities are revoked when their epoch expires). Capability tables (like file descriptor tables) with reference counting.
F6: no existing softwarecompatibilityAll software must be recompiled. No existing binary runs. Mitigation: binary translation layer (like Rosetta 2 for ARM). Translate x86-64/ARM binaries to Wire ISA at runtime. Performance: 10-30% overhead for translation, near-native for hot code (JIT). Or: run legacy OS in a VM (like WSL).
F7: side channelssecurityCapabilities don't prevent timing attacks (Spectre, Meltdown, cache side channels). An attacker can infer data through timing without reading it. Mitigation: constant-time operations for crypto (already standard). Cache partitioning (each security domain gets its own cache ways). Speculative execution barriers (LFENCE, fence instructions). These are software mitigations, not hardware.
F8: complexitymaintainability12 capability operations, tag management, sealing, monotonicity, bounds checking. The runtime is 50K lines. Total 90K lines. Is this actually simpler than Linux (30M lines)? Yes, 300x smaller. But is it simple enough for one person to understand? The capability system alone is ~5K lines. Mitigation: reduce to 6 operations (load, store, derive, seal, unseal, check). Remove CGETBASE/CSETBASE/CGETLEN/CSETLEN (fold into derive).
F9: I/O latencyperformanceCapability-gated I/O adds a permission check on every I/O operation. For high-throughput I/O (10Gbps network, NVMe), this adds latency. Mitigation: cache capability checks in the I/O subsystem. Pre-validate capabilities at channel creation (check once, not per-operation). Use DMA with capability-checked regions.
F10: consensus scalabilityscalabilityRaft doesn't scale beyond ~7 nodes for writes (single leader bottleneck). For large systems, need sharding (each shard has its own Raft group). But cross-shard transactions are complex. Mitigation: use Spanner-style TrueTime for global ordering. Or use CRDTs for eventually consistent data. Accept that strong consistency has a cost.
F11: deterministic replay overheadperformanceRecording all non-deterministic inputs requires storage proportional to I/O rate. A busy server generates GB/s. Mitigation: record only inputs (not outputs). Use compression (zstd). Ring buffer (last N seconds). Accept that replay is for debugging, not production. Or: record only on demand (when a bug is reported).
F12: capability revocationsecurityIf a capability is leaked (e.g., to an untrusted process), how do you revoke it? Capability revocation requires tracking all derived capabilities. Mitigation: epoch-based reclamation (capabilities expire after N epochs). Revocation via C-list (capability list) indirection (revoke the C-list entry, all derived capabilities become invalid). Or: accept that capabilities are not revocable (like file descriptors — you can't un-open a file).

example:

00 00 00 00

Red team findings (placeholder)


provenance

agent: curl -H 'accept: application/json' wire.phall.io/wire-format/red-team-findings or /wire-format/red-team-findings.json