weed-cli 1.2.8__tar.gz → 1.3.1__tar.gz

{weed_cli-1.2.8 → weed_cli-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.2.8
+Version: 1.3.1
 Summary: Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel
 License: MIT
 Keywords: p2p,video,censorship-resistant,discovery,dht,kademlia,nat-traversal

{weed_cli-1.2.8 → weed_cli-1.3.1}/discovery_relay.py

@@ -41,6 +41,22 @@ DATA_PATH = os.environ.get('WEED_RELAY_DATA',
 _events = []
 _lock = threading.Lock()
 
+# no real signed event (a handful of JSON fields: hashes, URLs, titles)
+# is anywhere close to this; it's purely a cap against a client claiming
+# a huge Content-Length and making this internet-facing server read an
+# unbounded amount into memory
+MAX_BODY_SIZE = 256 * 1024
+
+# bounds one identity's storage footprint on this relay -- signer_pubkey
+# is cryptographically bound to its event's signature (see
+# verify_attestation), so it can't be spoofed to blame someone else's
+# quota, and is genuinely what's exceeding the cap. Doesn't stop an
+# attacker from generating a fresh keypair per event -- Ed25519 keygen is
+# free -- but that's a fundamentally bigger attack (unlimited identities)
+# than "spam with one key," and defending against it needs proof-of-
+# work/stake, a bigger design decision than this PoC calls for.
+MAX_EVENTS_PER_SIGNER = 200
+
 
 def _load_events():
     if not os.path.exists(DATA_PATH):
@@ -62,6 +78,33 @@ def _append_event(event):
         f.write(json.dumps(event) + '\n')
 
 
+def _rewrite_events_file():
+    """Full rewrite instead of the usual cheap append -- only needed when
+    an entry was evicted from _events (see _evict_oldest_for_signer),
+    since dropping a line from a JSONL file means rewriting it."""
+    os.makedirs(os.path.dirname(DATA_PATH) or '.', exist_ok=True)
+    tmp = DATA_PATH + '.tmp'
+    with open(tmp, 'w') as f:
+        for event in _events:
+            f.write(json.dumps(event) + '\n')
+    os.replace(tmp, DATA_PATH)
+
+
+def _evict_oldest_for_signer(signer_pubkey):
+    """Caller must hold _lock. Drops that signer's own oldest event once
+    they're at the cap, making room for the new one -- an active
+    publisher keeps working, they just eventually lose their own oldest
+    entries first, same trade as any keep-last-N retention policy."""
+    if not signer_pubkey:
+        return
+    mine = [e for e in _events if e['payload'].get('signer_pubkey') == signer_pubkey]
+    if len(mine) < MAX_EVENTS_PER_SIGNER:
+        return
+    oldest = min(mine, key=lambda e: e['payload'].get('ts', 0))
+    _events.remove(oldest)
+    _rewrite_events_file()
+
+
 class RelayHandler(BaseHTTPRequestHandler):
     def log_message(self, fmt, *args):
         pass  # quiet — poc_discovery.py prints what matters
@@ -70,6 +113,13 @@ class RelayHandler(BaseHTTPRequestHandler):
         if self.path != '/event':
             self.send_response(404); self.end_headers(); return
         length = int(self.headers.get('Content-Length', 0))
+        if length > MAX_BODY_SIZE:
+            self.send_response(413)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            self.wfile.write(json.dumps({'ok': False,
+                                          'reason': f'body too large (max {MAX_BODY_SIZE} bytes)'}).encode())
+            return
         try:
             event = json.loads(self.rfile.read(length))
             ok, reason = verify_attestation(event)  # generic: works on any {payload, signature} blob
@@ -84,6 +134,7 @@ class RelayHandler(BaseHTTPRequestHandler):
         eid = attestation_id(event)
         with _lock:
             if not any(attestation_id(e) == eid for e in _events):
+                _evict_oldest_for_signer(event['payload'].get('signer_pubkey'))
                 _events.append(event)
                 _append_event(event)
         self.send_response(200)

{weed_cli-1.2.8 → weed_cli-1.3.1}/node.py

@@ -347,18 +347,43 @@ def run_host_tunnel(relay_host, relay_port, token, entry, leaves, file_path, pri
     DATA connection, dialed back to the relay on demand (NEWSTREAM), so
     concurrent tunneled downloads don't block each other.
 
-    The control connection sends nothing at all between REGISTER and the
-    first real NEWSTREAM — which can be minutes or hours if no one
-    downloads in the meantime. Real-world proxies in the middle (observed:
-    Fly's own edge) reset TCP connections that go idle for a few minutes,
-    which silently unregisters the host with no error on this end until
-    the next download attempt fails. A small periodic heartbeat keeps the
+    REGISTER gets one immediate OK/ERR reply (see below), then the
+    control connection sends nothing at all until the first real
+    NEWSTREAM — which can be minutes or hours if no one downloads in the
+    meantime. Real-world proxies in the middle (observed: Fly's own
+    edge) reset TCP connections that go idle for a few minutes, which
+    silently unregisters the host with no error on this end until the
+    next download attempt fails. A small periodic heartbeat keeps the
     connection looking active; tunnel_relay.py's REGISTER loop already
     discards anything it receives that isn't relevant to it (it only ever
-    checks for EOF), so this needs zero changes on the relay side."""
+    checks for EOF), so this needs zero changes on the relay side.
+
+    The OK/ERR reply exists so a REGISTER for a token someone else
+    already holds an active registration for can be refused instead of
+    silently overwriting it — content_hash tokens are public (announced
+    via discover), so without this anyone could squat/hijack another
+    host's rendezvous slot for content they didn't actually publish."""
     entries_by_hash = {entry['sha256']: (entry, leaves, file_path)}
     ctrl = _connect_tunnel_socket(relay_host, relay_port, use_tls)
     ctrl.sendall(f'REGISTER {token}\n'.encode())
+    # one LineReader for the whole connection, created before the first
+    # read and reused for the NEWSTREAM loop below -- creating a second
+    # one later would lose whatever extra bytes this first recv() also
+    # happened to pick up (LineReader buffers internally; a fresh
+    # instance starts with an empty buffer, discarding anything already
+    # read into the old one)
+    reader = LineReader(ctrl)
+    ack = reader.readline()
+    if ack != 'OK':
+        ctrl.close()
+        # tunnel_relay.py now refuses a REGISTER for a token someone
+        # else already holds an active registration for, instead of
+        # silently letting the new one steal it -- content_hash tokens
+        # are public (announced via discover), so this stops anyone from
+        # squatting/hijacking another host's rendezvous slot for content
+        # they didn't actually publish
+        sys.exit(f"tunnel relay at {relay_host}:{relay_port} rejected REGISTER for "
+                  f"{token[:16]}...: {ack or '(connection closed)'}")
     if not quiet:
         tls_note = ' (tls)' if use_tls else ''
         print(f"[tunnel] registered {token[:16]}... with relay {relay_host}:{relay_port}{tls_note}")
@@ -375,7 +400,6 @@ def run_host_tunnel(relay_host, relay_port, token, entry, leaves, file_path, pri
     threading.Thread(target=send_heartbeats, daemon=True).start()
 
     try:
-        reader = LineReader(ctrl)
         while True:
             line = reader.readline()
             if not line:

{weed_cli-1.2.8 → weed_cli-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "1.2.8"
+version = "1.3.1"
 description = "Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel"
 readme = "README.md"
 license = { text = "MIT" }

{weed_cli-1.2.8 → weed_cli-1.3.1}/tunnel_relay.py

@@ -18,6 +18,9 @@ raw pipe (CONNECT/DATA, once paired):
   REGISTER <token>          host -> relay, persistent control connection.
                              token is whatever the host wants to be found
                              under (node.py uses the archive's content_hash).
+                             Replies OK, or ERR if another still-active
+                             connection already holds this token (first
+                             registration wins; no stealing an active one).
   CONNECT <token>           downloader -> relay, wants to reach that host.
                              Everything sent after this line IS the tunneled
                              protocol, not a relay command.
@@ -41,7 +44,7 @@ _pending_streams = {}  # stream_id -> _Pairing (defined below)
 _lock = threading.Lock()
 
 
-def recv_line(sock):
+def recv_line(sock, timeout=10, max_len=256):
     """Byte-at-a-time on purpose: CONNECT/DATA connections become a raw
     byte pipe immediately after this first line, and the real client
     (HostConnection.connect_via_tunnel) sends its next protocol command
@@ -49,14 +52,33 @@ def recv_line(sock):
     those bytes along with the handshake line, leaving nothing for pipe()
     to forward. One byte at a time guarantees this stops exactly at the
     newline and never reads into what comes after. Only runs once per
-    connection (a ~20-40 byte line), not on the hot path."""
-    buf = bytearray()
-    while True:
-        b = sock.recv(1)
-        if not b or b == b'\n':
-            break
-        buf += b
-    return buf.decode().strip()
+    connection (a ~20-40 byte line), not on the hot path.
+
+    The read timeout and length cap are specific to this one line, not
+    the socket in general: a client that never sends a newline (or
+    trickles bytes in one at a time forever) would otherwise tie up this
+    thread's connection slot indefinitely, and daemon_threads has no cap
+    on how many of those can pile up. Neither limit costs a real client
+    anything — every genuine REGISTER/CONNECT/DATA line arrives
+    immediately and is ~20-40 bytes. The timeout is cleared again before
+    returning since callers keep using this same socket afterward:
+    REGISTER's control connection sits idle between real downloads for
+    as long as minutes or hours (see node.py's heartbeat), and pipe()
+    needs plain unbounded blocking reads once a connection becomes a raw
+    byte pipe."""
+    sock.settimeout(timeout)
+    try:
+        buf = bytearray()
+        while True:
+            b = sock.recv(1)
+            if not b or b == b'\n':
+                break
+            buf += b
+            if len(buf) > max_len:
+                raise ValueError(f'line exceeds {max_len} bytes')
+        return buf.decode().strip()
+    finally:
+        sock.settimeout(None)
 
 
 def pipe(src, dst):
@@ -76,8 +98,31 @@ def pipe(src, dst):
 
 
 def handle_register(conn, token, quiet):
+    """token is a content_hash, which is public the moment a host
+    announces it (see discover()) -- refusing a second REGISTER while
+    the first is still active stops anyone else from squatting/
+    hijacking that host's rendezvous slot for content they didn't
+    publish. The entry only exists in _registrations while that
+    connection's own recv loop below is still blocked waiting on it, so
+    "still in the dict" and "still alive" are the same thing here; a
+    genuinely dead registration is already gone by the time this runs
+    again (see the `finally` cleanup)."""
     with _lock:
+        if token in _registrations:
+            try:
+                conn.sendall(b'ERR token already registered\n')
+            except OSError:
+                pass
+            conn.close()
+            return
         _registrations[token] = conn
+    try:
+        conn.sendall(b'OK\n')
+    except OSError:
+        with _lock:
+            if _registrations.get(token) is conn:
+                del _registrations[token]
+        return
     if not quiet:
         print(f"[tunnel] {token[:16]}... registered", flush=True)
     try:
@@ -165,7 +210,16 @@ def handle_data(conn, stream_id):
 
 class TunnelHandler(socketserver.BaseRequestHandler):
     def handle(self):
-        line = recv_line(self.request)
+        try:
+            line = recv_line(self.request)
+        except (socket.timeout, ValueError, OSError):
+            # a client that never sent a line, sent one too slowly, or
+            # sent one too long -- recv_line's own timeout/length cap
+            # already protects the server from this; it's routine, not
+            # a bug, so close quietly instead of socketserver logging a
+            # full traceback for it
+            self.request.close()
+            return
         parts = line.split()
         if len(parts) < 2:
             self.request.close()

{weed_cli-1.2.8 → weed_cli-1.3.1}/web_ui.py

@@ -35,8 +35,19 @@ except ImportError:
     _HAS_QR = False
 
 WEB_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'web')
-DEFAULT_RELAY = 'http://127.0.0.1:9101'
+# same $WEED_RELAY/$WEED_TUNNEL convention weed.py's CLI subcommands and
+# shell.py's WeedShell already read (see weed.py's _default_relay) --
+# without this, running web_ui.py directly ignored them entirely and
+# silently fell back to the loopback default, even with a real relay
+# configured for every other way of running this tool
+DEFAULT_RELAY = os.environ.get('WEED_RELAY', 'http://127.0.0.1:9101')
+DEFAULT_TUNNEL = os.environ.get('WEED_TUNNEL')
 LIBRARY_PATH = os.path.expanduser('~/.weed_library.json')
+# every real POST body here is a handful of JSON fields (hashes, URLs,
+# titles) -- no endpoint ever legitimately needs anywhere near this much,
+# it's purely a cap against a client claiming a huge Content-Length and
+# making the server read an unbounded amount into memory
+MAX_BODY_SIZE = 1024 * 1024
 
 # script-relative, not CWD-relative -- same reasoning as WEB_DIR above, so
 # downloads land in the same place regardless of the directory this was
@@ -268,6 +279,8 @@ class Handler(BaseHTTPRequestHandler):
 
     def _read_json_body(self):
         length = int(self.headers.get('Content-Length', 0))
+        if length > MAX_BODY_SIZE:
+            raise ValueError(f'body too large ({length} bytes, max {MAX_BODY_SIZE})')
         return json.loads(self.rfile.read(length)) if length else {}
 
     def do_GET(self):
@@ -276,8 +289,9 @@ class Handler(BaseHTTPRequestHandler):
 
         if path == '/api/whoami':
             return self._json({'pubkey': _identity().pubkey_hex()})
-        if path == '/api/lan-url':
-            return self._json({'url': _lan_url})
+        if path == '/api/config':
+            return self._json({'lan_url': _lan_url, 'default_relay': DEFAULT_RELAY,
+                                'default_tunnel': DEFAULT_TUNNEL})
         if path == '/api/discover':
             return self._json({'results': node.discover(qs.get('relay') or [DEFAULT_RELAY])})
         if path == '/api/hosts':
@@ -309,8 +323,30 @@ class Handler(BaseHTTPRequestHandler):
             return self._handle_qr(data)
         self._serve_static(path)
 
+    def _check_origin(self):
+        """This server has no auth at all (see module docstring) -- the
+        only thing stopping any webpage you happen to have open in the
+        same browser from POSTing here (start hosting an arbitrary local
+        directory, download attacker-chosen content to an
+        attacker-chosen path, like/subscribe as you) is confirming the
+        request actually came from this UI, not some other origin your
+        browser also has open. Browsers always set Origin on cross-origin
+        fetch/XHR and can't be told by page JS to fake it, so a mismatch
+        here means a real cross-site request; a request with no Origin at
+        all (curl, direct API use, older browsers on a same-origin form
+        post) is let through since it isn't the CSRF-from-another-tab
+        shape this defends against."""
+        origin = self.headers.get('Origin')
+        if not origin:
+            return True
+        host = self.headers.get('Host', '')
+        return origin in (f'http://{host}', f'https://{host}')
+
     def do_POST(self):
         path = urlparse(self.path).path
+        if not self._check_origin():
+            return self._json({'error': 'rejected: request Origin does not match this server — '
+                                         'looks like a cross-site request, not this UI'}, status=403)
         try:
             body = self._read_json_body()
         except Exception as e:
@@ -506,7 +542,12 @@ class Handler(BaseHTTPRequestHandler):
             path = '/index.html'
         safe_path = os.path.normpath(path).lstrip('/')
         full_path = os.path.join(WEB_DIR, safe_path)
-        if not os.path.abspath(full_path).startswith(os.path.abspath(WEB_DIR)) \
+        # the trailing os.sep matters: without it, a sibling directory
+        # that happens to share WEB_DIR's name as a string prefix (e.g.
+        # "web-private") would also pass this check -- str.startswith
+        # doesn't know about path boundaries, only os.path.join does
+        web_dir_abs = os.path.abspath(WEB_DIR)
+        if not os.path.abspath(full_path).startswith(web_dir_abs + os.sep) \
                 or not os.path.isfile(full_path):
             return self._json({'error': 'not found'}, status=404)
         ctype, _ = mimetypes.guess_type(full_path)

{weed_cli-1.2.8 → weed_cli-1.3.1}/weed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.2.8
+Version: 1.3.1
 Summary: Censorship-resistant video PoC — discovery/hosting/download over signed relay events, a real Kademlia DHT, or a TLS-capable NAT-traversal tunnel
 License: MIT
 Keywords: p2p,video,censorship-resistant,discovery,dht,kademlia,nat-traversal