russell@unturf.com
efe58242e0
Wine scan: hot paths use hash tables (module lookup), red-black trees (font families, shader cache), binary search (registry), bounded lists (FBO<=64, sampler<=16, MUI<=8). wine-0001 covers loader dependency dedup. No additional CWE-407 defects. MOADs 0002-0005 CLEAN: loader_section is by design, no request-scoped TLS leakage, kerberos logs only auth_data pointer (not value), all caches protected by critical sections. WireGuard-go scan: peers.keyMap is hash map O(1), AllowedIPs is radix trie O(32). Private key and PSK are never logged (only "Updating X" labels). Device struct has per-sub-struct sync.RWMutex with no thundering herd patterns. MOADs 0002-0005 CLEAN: well-decomposed Device struct, no goroutine-local leakage, proper sync.
87 lines
3.8 KiB
Markdown
87 lines
3.8 KiB
Markdown
CLEAN — WireGuard/wireguard-go — all 5 MOADs scanned 2026-03-31
|
|
|
|
Repository: https://github.com/WireGuard/wireguard-go
|
|
Version: HEAD (depth=1 clone)
|
|
Language: Go
|
|
Size: ~40 Go source files
|
|
|
|
Note: wireguard-tools (C userspace tools) was scanned previously and is CLEAN.
|
|
This entry covers wireguard-go (pure Go userspace WireGuard implementation).
|
|
|
|
## MOAD-0001 (CWE-407): CLEAN
|
|
|
|
Hot paths scanned:
|
|
|
|
device/device.go: peer lookup uses peers.keyMap (map[NoisePublicKey]*Peer) — O(1)
|
|
hash map per peer lookup. No linear scan of peer list in the packet path.
|
|
|
|
device/allowedips.go: AllowedIPs uses a radix trie (256-ary, one level per bit).
|
|
IP-to-peer lookup is O(32) for IPv4 or O(128) for IPv6 — bounded and constant.
|
|
Not a linear scan. CLEAN.
|
|
|
|
device/receive.go: ReceiveIPv4/ReceiveIPv6 batch processing loops are O(batch_size)
|
|
with no inner membership scans. Handshake queue processing dispatches by index table
|
|
(IndexTable, which is map[uint32]*indexTableEntry). CLEAN.
|
|
|
|
device/uapi.go: UAPI config parsing scans device.peers.keyMap for peer lookup —
|
|
O(P) configuration-time only, not per-packet. P = number of peers (bounded by
|
|
WireGuard protocol limits, typically < 10,000). CLEAN.
|
|
|
|
## MOAD-0002 (Intertangle): CLEAN
|
|
|
|
Device struct (device/device.go) is well-decomposed into named sub-structs:
|
|
state (atomic + Mutex), net (RWMutex + bind/port/fwmark), staticIdentity
|
|
(RWMutex + privateKey/publicKey), peers (RWMutex + keyMap), rate, pool, queue,
|
|
tun. Each sub-struct owns its own mutex.
|
|
|
|
No god-object pattern: cryptographic handshake (noise-protocol.go) is isolated
|
|
from packet routing (allowedips.go), session key management (keypair.go), and
|
|
rate limiting (ratelimiter/). Subsystems communicate through channel queues
|
|
(device.queue.handshake, device.queue.encryption, device.queue.decryption),
|
|
not shared mutable global state.
|
|
|
|
## MOAD-0003 (Leaked Context): CLEAN
|
|
|
|
No goroutine-local state beyond sync.Pool buffers (byteBufferPool). Go does not
|
|
have goroutine-local storage; the design relies on explicit context propagation.
|
|
|
|
context.Context is used only in ipc/namedpipe (Windows IPC) and tun/netstack
|
|
(virtual network stack) — both pass context explicitly, not via goroutine-local
|
|
storage. No request-scoped identity leaked across goroutine boundaries.
|
|
|
|
## MOAD-0004 (Logged Secret): CLEAN
|
|
|
|
device/uapi.go:
|
|
- private_key handling: device.log.Verbosef("UAPI: Updating private key") — logs
|
|
label only, never logs the key value. The key bytes come from sk.FromMaybeZeroHex(value)
|
|
and are passed to device.SetPrivateKey(sk). Value is never interpolated into
|
|
any log call. CLEAN.
|
|
- preshared_key handling: device.log.Verbosef("%v - UAPI: Updating preshared key", peer.Peer)
|
|
— logs peer identifier and label only. Key bytes from peer.handshake.presharedKey.FromHex(value)
|
|
are never logged. CLEAN.
|
|
|
|
device/noise-protocol.go: no log calls that reference key material. Handshake state
|
|
transitions logged as enum values (ConsumeMessageInitiation: handshake replay, flood).
|
|
No Curve25519 private key, ChaCha20-Poly1305 session key, or PSK ever interpolated
|
|
into log output.
|
|
|
|
CRITICAL CHECK PASSED: no private key or pre-shared key logging found anywhere.
|
|
|
|
## MOAD-0005 (Thundering Herd): CLEAN
|
|
|
|
device/device.go: all peer map access guarded by peers.RWMutex (readers use RLock,
|
|
writers use Lock). No check-null-compute-put pattern.
|
|
|
|
device/noise-protocol.go: handshake state uses handshake.mutex (sync.RWMutex).
|
|
Keypair rotation uses atomic operations (keypairs struct with Next/Current/Previous
|
|
protected by sync.RWMutex).
|
|
|
|
device/allowedips.go: AllowedIPs mutations protected by mutex (sync.RWMutex at
|
|
AllowedIPs struct level). Trie updates hold the write lock throughout.
|
|
|
|
device/keypair.go: keypair store uses sync.RWMutex for all access.
|
|
|
|
ratelimiter/: uses sync.Mutex for table access, time.Ticker for GC — properly
|
|
synchronized.
|
|
|
|
No unsynchronized cache get+null+compute+put pattern found in any hot path.
|