weed-cli 1.2.7__tar.gz → 1.3.0__tar.gz

{weed_cli-1.2.7 → weed_cli-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.2.7
+Version: 1.3.0
 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.7 → weed_cli-1.3.0}/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.7 → weed_cli-1.3.0}/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.7 → weed_cli-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weed-cli"
-version = "1.2.7"
+version = "1.3.0"
 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.7 → weed_cli-1.3.0}/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.7 → weed_cli-1.3.0}/web_ui.py

@@ -37,6 +37,11 @@ except ImportError:
 WEB_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'web')
 DEFAULT_RELAY = 'http://127.0.0.1:9101'
 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
@@ -137,7 +142,7 @@ def _rehydrate_jobs_from_library():
             'status': 'done', 'idx': 0, 'n_chunks': None,
             'content_hash': content_hash, 'path': rec['path'],
             'title': rec.get('title'), 'size': rec.get('size'), 'bps': rec.get('bps'),
-            'error': None,
+            'signer_pubkey': rec.get('signer_pubkey'), 'error': None,
         }
 _lan_url = None   # set once in run_web_ui() -- the base URL a phone on the
                    # same LAN can actually reach this server at, or None if
@@ -211,7 +216,8 @@ def _run_host_job(host_id, archive_dir, file_name, port, price, relay_urls, adve
             _hosts[host_id].update(status='error', error=f'{type(e).__name__}: {e}')
 
 
-def _run_download_job(job_id, content_hash, relay_urls, out_path, k, use_lightning, title=None):
+def _run_download_job(job_id, content_hash, relay_urls, out_path, k, use_lightning, title=None,
+                       signer_pubkey=None):
     def on_progress(idx, n_chunks):
         with _lock:
             _jobs[job_id].update(idx=idx, n_chunks=n_chunks)
@@ -229,6 +235,7 @@ def _run_download_job(job_id, content_hash, relay_urls, out_path, k, use_lightni
             _library['downloads'][content_hash] = {
                 'content_hash': content_hash, 'job_id': job_id, 'path': path,
                 'title': title, 'downloaded_at': time.time(), 'size': size, 'bps': bps,
+                'signer_pubkey': signer_pubkey,
             }
             _save_library()
     except SystemExit as e:
@@ -266,6 +273,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):
@@ -307,8 +316,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:
@@ -356,13 +387,16 @@ class Handler(BaseHTTPRequestHandler):
         k = int(body.get('k') or 3)
         use_lightning = bool(body.get('lightning'))
         title = body.get('title')
+        signer_pubkey = body.get('signer_pubkey')
 
         job_id = uuid.uuid4().hex[:12]
         with _lock:
             _jobs[job_id] = {'status': 'running', 'idx': 0, 'n_chunks': None,
-                              'content_hash': content_hash, 'path': None, 'title': title, 'error': None}
+                              'content_hash': content_hash, 'path': None, 'title': title,
+                              'signer_pubkey': signer_pubkey, 'error': None}
         threading.Thread(target=_run_download_job,
-                          args=(job_id, content_hash, relay_urls, out_path, k, use_lightning, title),
+                          args=(job_id, content_hash, relay_urls, out_path, k, use_lightning, title,
+                                signer_pubkey),
                           daemon=True).start()
         self._json({'job_id': job_id})
 
@@ -501,7 +535,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.7 → weed_cli-1.3.0}/weed_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weed-cli
-Version: 1.2.7
+Version: 1.3.0
 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