Merge branch 'fix/third-review-h1-h2-m1-m6'

Third security review (docs/third-review.md) plus its remediation.

Fixed and verified:
- H1  moderator could grant admin / hard-revoke  → handler split by field
- H2  unauthenticated 2-report global blocklist  → auth + distinct reporters
      + rate limit + refused when public groups are off
- M1  registration reCAPTCHA was inert           → gate unconditional; the
      desktop client's CSP allows the widget
- M2  QUIC chat/stream handlers lagged WebRTC    → brought to parity; the QUIC
      listener is now off by default ([node] quic_enabled)
- M3  link-preview SSRF gaps                      → rate limit + port allowlist
      + connect-address re-check + decompression-bomb guard
- M4  federated peer over-trust                   → source bound to the signer,
      push capped, revocation prunes the peer's own entries, replay rejected
- M5  no CSP / security headers on the SPA        → middleware; verified against
      the live app with no violations

Withdrawn:
- M6  add_group_member accepting node tokens is deliberate (commit 0443cf8,
      the CLI invite flow). The "fix" broke that flow on the deployed hub and
      was reverted.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011pG75yGK3NthNfyjH74omG

3 files changed, 141 insertions, 2 deletions

diff --git a/packages/meshbay-node/tests/test_link_preview_request.py b/packages/meshbay-node/tests/test_link_preview_request.py
index d975f91..fe7dec6 100644
--- a/packages/meshbay-node/tests/test_link_preview_request.py
+++ b/packages/meshbay-node/tests/test_link_preview_request.py
@@ -34,9 +34,10 @@ def _clear_cache():
     webrtc_server._link_preview_cache.clear()
 
 
-def _session(media_cache):
+def _session(media_cache, ctx=None):
     s = WebRTCPeerSession.__new__(WebRTCPeerSession)
-    s._ctx = {"media_cache": media_cache}
+    s._ctx = ctx if ctx is not None else {"media_cache": media_cache}
+    s._peer_id = "t"
     s.sent = []
     s._send = s.sent.append
     return s
@@ -79,6 +80,51 @@ async def test_unfurlable_failure_is_ok_false(media_cache, monkeypatch):
     assert "image_thumb_hash" not in resp
 
 
+async def test_rate_limit_per_connection(media_cache, monkeypatch):
+    """A member firing many previews is bounded; over the ceiling the reply is
+    a plain `ok: false` (bare link) and no outbound fetch is made."""
+    monkeypatch.setattr(webrtc_server, "_LINK_PREVIEW_RATE_PER_CONN", 3)
+    calls = {"n": 0}
+
+    async def counting_preview(url, **k):
+        calls["n"] += 1
+        return {"url": url, "title": "x", "description": None,
+                "site_name": None, "image_url": None}
+    monkeypatch.setattr(linkpreview, "fetch_preview", counting_preview)
+
+    s = _session(media_cache)
+    for i in range(3):
+        await s._do_link_preview_request({"url": f"https://example.com/{i}"})
+    assert calls["n"] == 3
+    assert all(r["ok"] for r in s.sent)
+
+    await s._do_link_preview_request({"url": "https://example.com/over"})
+    assert calls["n"] == 3                 # not fetched
+    assert s.sent[-1]["ok"] is False
+
+
+async def test_rate_limit_is_node_wide(media_cache, monkeypatch):
+    """Two connections share the node-wide ceiling."""
+    monkeypatch.setattr(webrtc_server, "_LINK_PREVIEW_RATE_PER_CONN", 100)
+    monkeypatch.setattr(webrtc_server, "_LINK_PREVIEW_RATE_NODE", 2)
+    calls = {"n": 0}
+
+    async def counting_preview(url, **k):
+        calls["n"] += 1
+        return {"url": url, "title": "x", "description": None,
+                "site_name": None, "image_url": None}
+    monkeypatch.setattr(linkpreview, "fetch_preview", counting_preview)
+
+    ctx = {"media_cache": media_cache}
+    a, b = _session(media_cache, ctx), _session(media_cache, ctx)
+    await a._do_link_preview_request({"url": "https://example.com/a"})
+    await b._do_link_preview_request({"url": "https://example.com/b"})
+    await b._do_link_preview_request({"url": "https://example.com/c"})
+
+    assert calls["n"] == 2
+    assert b.sent[-1]["ok"] is False
+
+
 async def test_second_request_for_the_same_url_is_served_from_cache(media_cache, monkeypatch):
     calls = {"n": 0}
 
diff --git a/packages/meshbay-node/tests/test_linkpreview.py b/packages/meshbay-node/tests/test_linkpreview.py
index 0dd951a..a14b173 100644
--- a/packages/meshbay-node/tests/test_linkpreview.py
+++ b/packages/meshbay-node/tests/test_linkpreview.py
@@ -48,6 +48,30 @@ def test_safe_url_refuses(url):
         safe_url(url)
 
 
+@pytest.mark.parametrize("url", [
+    "http://example.com:22/x",       # SSH
+    "http://example.com:3306/x",     # MySQL
+    "http://example.com:6379/x",     # Redis
+    "http://example.com:9200/x",     # Elasticsearch
+    "http://example.com:5000/x",     # a common internal admin port
+])
+def test_safe_url_refuses_non_web_ports(url, resolves_public):
+    with pytest.raises(UnsafeURL):
+        safe_url(url)
+
+
+@pytest.mark.parametrize("url", [
+    "http://example.com/x",          # implicit 80
+    "https://example.com/x",         # implicit 443
+    "http://example.com:80/x",
+    "https://example.com:443/x",
+    "http://example.com:8080/x",
+    "https://example.com:8443/x",
+])
+def test_safe_url_allows_the_web_ports(url, resolves_public):
+    assert safe_url(url) == url
+
+
 def test_safe_url_accepts_a_public_host(resolves_public):
     assert safe_url("https://example.com/some/page") == "https://example.com/some/page"
 
@@ -153,3 +177,19 @@ async def test_fetch_image_downscales(resolves_public):
     assert jpeg and jpeg[:2] == b"\xff\xd8"        # JPEG SOI
     with Image.open(BytesIO(jpeg)) as im:
         assert max(im.size) <= linkpreview._IMAGE_MAX_DIM
+
+
+async def test_fetch_image_refuses_a_decompression_bomb(resolves_public, monkeypatch):
+    from io import BytesIO
+
+    from PIL import Image
+    # A tiny file that reports enormous dimensions from its header alone.
+    monkeypatch.setattr(linkpreview, "_MAX_IMAGE_PIXELS", 1_000_000)
+    buf = BytesIO()
+    Image.new("RGB", (2000, 2000), (0, 0, 0)).save(buf, format="PNG")  # 4 MP > cap
+    bomb = buf.getvalue()
+
+    def handler(request):
+        return httpx.Response(200, headers={"content-type": "image/png"}, content=bomb)
+    async with _client(handler) as c:
+        assert await linkpreview.fetch_image("https://example.com/x.png", client=c) is None
diff --git a/packages/meshbay-node/tests/test_quic_enabled.py b/packages/meshbay-node/tests/test_quic_enabled.py
new file mode 100644
index 0000000..c0c1568
--- /dev/null
+++ b/packages/meshbay-node/tests/test_quic_enabled.py
@@ -0,0 +1,53 @@
+"""
+The QUIC MNP listener is off unless the operator turns it on.
+
+No shipping client speaks QUIC (browser and desktop use WebRTC; the hub-less
+`group://` sidecar is unbuilt), so a node that started it by default would only
+be exposing a UDP port. `daemon.py` gates `QuicChunkServer` on
+`self._config.node.quic_enabled`; these follow the value down the config path.
+"""
+
+import textwrap
+from pathlib import Path
+
+from meshbay_node.config import load_config
+
+
+def _cfg(tmp_path: Path, body: str):
+    p = tmp_path / "node.toml"
+    p.write_text(textwrap.dedent(body))
+    return load_config(p)
+
+
+def test_off_by_default(tmp_path):
+    cfg = _cfg(tmp_path, """
+        [node]
+        quic_port = 19010
+    """)
+    assert cfg.node.quic_enabled is False
+
+
+def test_the_operator_turns_it_on(tmp_path):
+    cfg = _cfg(tmp_path, """
+        [node]
+        quic_enabled = true
+    """)
+    assert cfg.node.quic_enabled is True
+
+
+def test_the_environment_can_force_it_on(tmp_path, monkeypatch):
+    monkeypatch.setenv("MESHBAY_QUIC_ENABLED", "1")
+    cfg = _cfg(tmp_path, """
+        [node]
+        quic_enabled = false
+    """)
+    assert cfg.node.quic_enabled is True
+
+
+def test_the_environment_can_force_it_off(tmp_path, monkeypatch):
+    monkeypatch.setenv("MESHBAY_QUIC_ENABLED", "false")
+    cfg = _cfg(tmp_path, """
+        [node]
+        quic_enabled = true
+    """)
+    assert cfg.node.quic_enabled is False