[canesin]

Description

Closes the remainder of the open issues after v0.8.0 (#22).

• Compressed stream budget (bug in v0.8.0, completes Raw stream decoding permits unbounded wire-driven allocations (compress.Buf and per-node fields decoded before any cap) #21). readStream capped the whole connection read at the 40 MiB plaintext limit. Senders compress stream messages whether or not that shrinks them, and LZW expands incompressible input (measured 1.37×; provably at most 1.5× plus clear and end codes), so a legitimate push/pull of ~29–40 MiB with incompressible content was refused. A compressed message is now read against maxCompressedStreamBytes (the largest valid LZW form of a maxDecompressedBytes payload, ~60 MiB) — the derivation Raw stream decoding permits unbounded wire-driven allocations (compress.Buf and per-node fields decoded before any cap) #21 asked for — while plaintext messages keep the 40 MiB cap through a limited source. Decompression stays capped at 40 MiB.
• Raw stream decoding permits unbounded wire-driven allocations (compress.Buf and per-node fields decoded before any cap) #21 regression tests. A stream whose compress.Buf declares 60 MiB, or a node's Meta 1 MiB — within the field limits, so only allocation that grows with received bytes saves memory — but carries 1 KiB is refused with under 4 MiB / 512 KiB allocated. Mutating the decoder to allocate the declared size up front fails both (62.9 MB / 1.06 MB). (The bounds themselves shipped in v0.8: std-only module, hardened wire path, owned codec, slog/metrics, synctest #22.)
• Encrypted sender limit. Receivers refuse encrypted stream messages above 20 MiB of ciphertext (upstream parity); senders now fail with ErrMessageTooLarge instead of writing a message that is dropped (RED: SendReliable of 20 MiB returned read/write on closed pipe after a 10 s timeout). TestEncryptedStreamSenderLimit derives the exact boundary: the largest message whose ciphertext is exactly 20 MiB is delivered, one byte more is refused.
• Oversize push/pull states. A push/pull state with user state above 20 MiB or a plaintext message above 40 MiB fails with ErrMessageTooLarge (before: an unwrapped error, or nothing for the user state), and a responder whose state is too large answers the initiator with that error, so Join reports the cause instead of EOF (RED: push/pull error EOF).
• Compress only when smaller. Stream messages go out compressed only when the compressed form is smaller, as packets already do, so incompressible state no longer grows by up to 1.5× on the wire.
• Node.State on Members()/LocalNode() results is always StateAlive (shadowed by nodeState.State) #16 regression test. LocalNode().State reports StateLeft after Leave (the shadowing itself was removed in v0.8: std-only module, hardened wire path, owned codec, slog/metrics, synctest #22).
• Port upstream docs: security model (#367), contributing guide (#375) #18 remainder. CONTRIBUTING.md and the PR template adapted from upstream docs: Add contributing guide and LLM PR template link. hashicorp/memberlist#375 (the security model was ported in v0.8: std-only module, hardened wire path, owned codec, slog/metrics, synctest #22).

Fixes #21. Fixes #18.

How has this been tested?

RED before the fix — TestReadStreamAcceptsIncompressibleCompressedState, a 32.7 MB state (20,000 nodes with 512 random meta bytes plus 20 MiB random user state) compressed to 43.7 MB:

net_test.go:1414: compressed stream of 43704906 bytes (32680445 decompressed): unexpected error: compress.Buf: msgpack: truncated input

GREEN after. TestReadStreamBoundsPlainMessage still refuses a >40 MiB plaintext message. The large-state test skips under the race detector (no concurrency; 16 s there).

Review loop: round 1 (independent reviewer) verified the LZW bound (Go's writer: ≤ 1.5N + 1.5N/3838 + 5 bytes; 40 MiB → ≤ 62.93 MB ≤ maxCompressedStreamBytes 63.02 MB; measured worst practical input 1.409×) and every stream path, and requested the discriminating #21 tests and the encrypted sender limit above. Round 2 requested an exact-boundary sender test, a plaintext cap edge test (TestReadStreamPlaintextCapEdge: exactly 40 MiB accepted, +1 refused) and compress-only-when-smaller. Mutation checks: sender limit on plaintext length, >= for >, plaintext cap +1 and always-compress each fail their test. Round 3 (verdict MERGE) confirmed every stream form and upstream interop (upstream accepts plaintext streams whatever its compression setting) and raised three Low findings, fixed: the initiator's bare EOF, the inconsistent error identity, and no test pinning maxCompressedStreamBytes to the LZW worst case (TestCompressedStreamBudgetCoversLZWWorstCase: 62,930,968 needed ≤ 63,021,056; mutating the budget to 45 MB or 1.5N+1 fails it). Mutating out the error response or the user-state check fails its test. Round 4 (verdict MERGE, delta review) verified nothing is written before any ErrMessageTooLarge return, that upstream initiators already handle errMsg, and the LZW arithmetic against compress/lzw (clear every 3,838 data codes; comment and test corrected); README notes that Mori refuses to send user state above 20 MiB, which upstream receivers accept. make ci passes (fmt, go fix, vet, lint, cross, deps, tidy, tests on amd64 and 386, race, bench smoke).

Checklist

• make ci passes.
• Behavior changes have tests, docs (SECURITY.md bounds table) and a CHANGELOG entry under Unreleased.