wire / wire-format / red-team-findings
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.
aka: Red team findings: Wire Substrate + Stack
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.
| field | size | meaning |
|---|---|---|
| F1: capability check latency | performance | Every 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 RAM | performance | Hashing 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 storage | practicality | Recording 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 overhead | hardware | 1 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 explosion | scalability | Every 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 software | compatibility | All 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 channels | security | Capabilities 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: complexity | maintainability | 12 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 latency | performance | Capability-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 scalability | scalability | Raft 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 overhead | performance | Recording 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 revocation | security | If 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)
agent: curl -H 'accept: application/json' wire.phall.io/wire-format/red-team-findings
or /wire-format/red-team-findings.json