vssh 3.3.0__tar.gz → 3.3.1__tar.gz

{vssh-3.3.0/vssh.egg-info → vssh-3.3.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: vssh
-Version: 3.3.0
+Version: 3.3.1
 Summary: Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server
-Author-email: MeshPOP <hello@meshpop.dev>
+Author-email: MeshPOP <mpop@mpop.dev>
 License: MIT
 Project-URL: Homepage, https://github.com/meshpop/vssh
 Project-URL: Repository, https://github.com/meshpop/vssh

{vssh-3.3.0 → vssh-3.3.1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vssh"
-version = "3.3.0"
+version = "3.3.1"
 description = "Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server"
 readme = "README.md"
 license = {text = "MIT"}
 requires-python = ">=3.8"
 authors = [
-    {name = "MeshPOP", email = "hello@meshpop.dev"}
+    {name = "MeshPOP", email = "mpop@mpop.dev"}
 ]
 keywords = ["ssh", "scp", "tailscale", "p2p", "vpn", "mcp", "remote"]
 classifiers = [

{vssh-3.3.0 → vssh-3.3.1/vssh.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: vssh
-Version: 3.3.0
+Version: 3.3.1
 Summary: Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server
-Author-email: MeshPOP <hello@meshpop.dev>
+Author-email: MeshPOP <mpop@mpop.dev>
 License: MIT
 Project-URL: Homepage, https://github.com/meshpop/vssh
 Project-URL: Repository, https://github.com/meshpop/vssh

{vssh-3.3.0 → vssh-3.3.1}/vssh.py

@@ -50,7 +50,7 @@ def _load_tailscale_map() -> dict:
     """Load Wire VPN IP → Tailscale IP mapping"""
     ts_map = {}
 
-    # 1. From config: TAILSCALE.10.99.x.x = 100.x.x.x
+    # 1. From config: TAILSCALE.10.99.85.143 = 100.80.191.6
     for k, v in VSSH_CONFIG.items():
         if k.startswith('TAILSCALE.'):
             wire_ip = k[len('TAILSCALE.'):]
@@ -67,8 +67,8 @@ def _load_tailscale_map() -> dict:
                 parts = line.split()
                 if len(parts) >= 2:
                     ts_map[parts[0]] = parts[1]  # wire_ip tailscale_ip
-        except:
-            pass
+        except (OSError, ValueError) as e:
+            pass  # TODO: log error
 
     return ts_map
 
@@ -92,7 +92,7 @@ def vssh_connect(host: str, timeout: float = 5.0) -> socket.socket:
             sock.settimeout(timeout)
             sock.connect((ts_ip, PORT))
             return sock
-        except:
+        except (OSError, socket.error):
             # Tailscale also failed — clear cache, try Wire again
             del _FAILOVER_ACTIVE[host]
 
@@ -103,7 +103,7 @@ def vssh_connect(host: str, timeout: float = 5.0) -> socket.socket:
         sock.connect((host, PORT))
         return sock
     except (ConnectionRefusedError, ConnectionError, OSError, socket.timeout) as wire_err:
-        pass
+        pass  # TODO: log error
 
     # Fallback: try Tailscale IP
     ts_ip = TAILSCALE_MAP.get(host)
@@ -148,7 +148,7 @@ def log_transfer(op: str, host: str, path: str, size: int, duration: float, stat
         _rotate_log(LOG_FILE)
         with open(LOG_FILE, 'a') as f:
             f.write(line)
-    except:
+    except OSError:
         pass  # Don't fail on logging errors
 
 def log_event(op: str, host: str, detail: str, status: str = 'OK'):
@@ -167,8 +167,8 @@ def log_event(op: str, host: str, detail: str, status: str = 'OK'):
         _rotate_log(HISTORY_FILE)
         with open(HISTORY_FILE, 'a') as f:
             f.write(line)
-    except:
-        pass
+    except OSError:
+        pass  # safe to ignore
 
 def get_history(count: int = 20, op_filter: str = None, host_filter: str = None) -> list:
     """Get recent history entries, optionally filtered by op or host"""
@@ -226,7 +226,7 @@ def get_transfer_stats(days: int = 7) -> dict:
                     stats['success'] += 1
                 else:
                     stats['fail'] += 1
-            except:
+            except Exception:
                 continue
 
     return stats
@@ -295,7 +295,7 @@ def verify_auth(received: str, expected_secret: str) -> bool:
         try:
             ts = int(parts[1])
             received_hmac = parts[2]
-        except:
+        except (ValueError, IndexError):
             return False
 
         # Check timestamp within window
@@ -364,8 +364,8 @@ def get_local_ips() -> list:
                     ip = parts[1].split('/')[0]
                     if not ip.startswith('10.99.'):
                         ips.append(ip)
-    except:
-        pass
+    except (OSError, subprocess.SubprocessError):
+        pass  # safe to ignore
     return ips
 
 def get_public_ip() -> str:
@@ -377,10 +377,10 @@ def get_public_ip() -> str:
             try:
                 with urllib.request.urlopen(url, timeout=3) as r:
                     return r.read().decode().strip()
-            except:
+            except (urllib.error.URLError, OSError):
                 continue
-    except:
-        pass
+    except Exception as e:
+        pass  # TODO: log error
     return ''
 
 def get_network_info_local() -> dict:
@@ -434,8 +434,8 @@ def is_safe_network(host: str) -> Tuple[bool, str]:
             second = int(host.split('.')[1])
             if 16 <= second <= 31:
                 return True, "lan"
-        except:
-            pass
+        except (ValueError, IndexError) as e:
+            pass  # TODO: log error
 
     # Everything else is public IP - UNSAFE!
     return False, "public_ip_unencrypted"
@@ -462,7 +462,7 @@ def check_transfer_safety(host: str) -> bool:
 
 
 # Wire VPN coordinator servers for name resolution
-WIRE_SERVERS = []  # Loaded from ~/.vssh/config or auto-discovered
+WIRE_SERVERS = ["10.99.85.143", "158.247.247.115", "10.99.74.131", "10.99.249.158"]
 _name_cache = {}  # name -> vpn_ip
 _name_cache_time = 0
 
@@ -499,7 +499,7 @@ def resolve_name(host: str) -> str:
                 if host in _name_cache:
                     return _name_cache[host]
                 break  # got peers, just no match
-        except:
+        except (OSError, subprocess.SubprocessError):
             continue
     return host
 
@@ -556,7 +556,7 @@ def resolve_best_ip(host: str, timeout: float = 0.5) -> str:
 
         sock.close()
     except Exception as e:
-        pass
+        pass  # safe to ignore
 
     return host
 
@@ -568,7 +568,7 @@ def try_connect(host: str, port: int, timeout: float = 0.5) -> bool:
         sock.connect((host, port))
         sock.close()
         return True
-    except:
+    except OSError:
         return False
 
 # ========== Persistent Session ==========
@@ -591,8 +591,8 @@ def cleanup_sessions():
         for sid in expired:
             try:
                 PERSISTENT_SESSIONS[sid]['conn'].close()
-            except:
-                pass
+            except OSError:
+                pass  # safe to ignore
             del PERSISTENT_SESSIONS[sid]
             print(f'[SESSION] Expired: {sid[:8]}...')
     return len(expired)
@@ -644,8 +644,10 @@ def _rpc_get_disk(payload: dict) -> dict:
     """Return disk usage"""
     import subprocess
     path = payload.get('path', '/')
+    if any(c in path for c in [';', '|', '&', '`', '$', '(', ')', '\n']):
+        return {'error': 'invalid path'}
     try:
-        r = subprocess.run(f'df -B1 {path}', shell=True, capture_output=True, text=True, timeout=10)
+        r = subprocess.run(['df', '-B1', path], capture_output=True, text=True, timeout=10)
         lines = r.stdout.strip().split('\n')
         if len(lines) >= 2:
             parts = lines[1].split()
@@ -665,7 +667,7 @@ def _rpc_get_memory(payload: dict) -> dict:
     """Return memory status"""
     import subprocess
     try:
-        r = subprocess.run('free -b', shell=True, capture_output=True, text=True, timeout=10)
+        r = subprocess.run(['free', '-b'], capture_output=True, text=True, timeout=10)
         lines = r.stdout.strip().split('\n')
         if len(lines) >= 2:
             parts = lines[1].split()
@@ -691,7 +693,7 @@ def _rpc_get_load(payload: dict) -> dict:
                 'load15': float(parts[2]),
                 'processes': parts[3]
             }
-    except:
+    except (OSError, ValueError, IndexError):
         return {'error': 'load read failed'}
 
 @rpc_method('get_processes', 'read')
@@ -741,17 +743,17 @@ def _rpc_get_logs(payload: dict) -> dict:
     if service not in log_paths:
         try:
             r = subprocess.run(
-                f'journalctl -u {service} -n {lines} --no-pager',
-                shell=True, capture_output=True, text=True, timeout=10
+                ['journalctl', '-u', service, '-n', str(lines), '--no-pager'],
+                capture_output=True, text=True, timeout=10
             )
             return {'service': service, 'lines': r.stdout.strip().split('\n')}
-        except:
-            pass
+        except (subprocess.SubprocessError, OSError) as e:
+            pass  # TODO: log error
 
     path = log_paths.get(service)
     if path and os.path.exists(path):
         try:
-            r = subprocess.run(f'tail -{lines} {path}', shell=True, capture_output=True, text=True, timeout=10)
+            r = subprocess.run(['tail', f'-{lines}', path], capture_output=True, text=True, timeout=10)
             return {'service': service, 'path': path, 'lines': r.stdout.strip().split('\n')}
         except Exception as e:
             return {'error': str(e)}
@@ -772,7 +774,7 @@ def _rpc_restart_service(payload: dict) -> dict:
         return {'error': f'service not allowed: {service}', 'allowed': allowed}
 
     try:
-        r = subprocess.run(f'systemctl restart {service}', shell=True, capture_output=True, text=True, timeout=30)
+        r = subprocess.run(['systemctl', 'restart', service], shell=False, capture_output=True, text=True, timeout=30)
         if r.returncode == 0:
             return {'success': True, 'service': service}
         else:
@@ -789,7 +791,7 @@ def _rpc_service_status(payload: dict) -> dict:
         return {'error': 'service required'}
 
     try:
-        r = subprocess.run(f'systemctl is-active {service}', shell=True, capture_output=True, text=True, timeout=10)
+        r = subprocess.run(['systemctl', 'is-active', service], shell=False, capture_output=True, text=True, timeout=10)
         status = r.stdout.strip()
         return {'service': service, 'status': status, 'active': status == 'active'}
     except Exception as e:
@@ -1035,8 +1037,8 @@ def setup_socket(sock, is_send=True):
     # Linux TCP_QUICKACK
     try:
         sock.setsockopt(socket.IPPROTO_TCP, 12, 1)  # TCP_QUICKACK = 12
-    except:
-        pass
+    except OSError:
+        pass  # safe to ignore
     sock.settimeout(600)
 
 def file_hash(path: Path) -> str:
@@ -1464,8 +1466,8 @@ def rsync_put(local: str, remote: str, lan: bool = True) -> bool:
     finally:
         try:
             sock.close()
-        except:
-            pass
+        except OSError:
+            pass  # safe to ignore
 
 # ========== put_fast: Auto-select best method ==========
 FAST_THRESHOLD = 500 * 1024 * 1024  # 500MB for parallel transfer
@@ -2290,7 +2292,7 @@ def rpc(host: str, method: str, payload: dict = None) -> dict:
             # Error response
             try:
                 return json.loads(resp.replace(b'__END__', b'').decode())
-            except:
+            except (json.JSONDecodeError, ValueError, UnicodeDecodeError):
                 return {'error': resp.decode().strip()}
 
         # Send payload
@@ -2346,8 +2348,8 @@ def pty_session(host: str, name: str = ''):
         import shutil
         ts = shutil.get_terminal_size()
         cols, rows = ts.columns, ts.lines
-    except:
-        pass
+    except Exception:
+        pass  # safe to ignore
     
     sock = vssh_connect(host, timeout=10)
     try:
@@ -2383,8 +2385,8 @@ def pty_session(host: str, name: str = ''):
         fd = sys.stdin.fileno()
         old_settings = _termios.tcgetattr(fd)
         _tty.setraw(fd)
-    except:
-        pass
+    except Exception:
+        pass  # safe to ignore
     
     sock.setblocking(False)
     
@@ -2397,7 +2399,7 @@ def pty_session(host: str, name: str = ''):
         while True:
             try:
                 readable, _, _ = _select.select([sys.stdin, sock], [], [], 0.1)
-            except:
+            except (OSError, ValueError):
                 break
             
             for r in readable:
@@ -2418,20 +2420,20 @@ def pty_session(host: str, name: str = ''):
                             raise EOFError
                         sys.stdout.buffer.write(data)
                         sys.stdout.buffer.flush()
-                    except (BlockingIOError):
-                        pass
+                    except (BlockingIOError) as e:
+                        pass  # TODO: log error
                     except (EOFError, ConnectionError):
                         raise EOFError
-    except (EOFError, KeyboardInterrupt, ConnectionError, BrokenPipeError):
-        pass
+    except (EOFError, KeyboardInterrupt, ConnectionError, BrokenPipeError) as e:
+        pass  # TODO: log error
     finally:
         # Restore terminal
         if old_settings:
             try:
                 import termios as _termios
                 _termios.tcsetattr(sys.stdin.fileno(), _termios.TCSADRAIN, old_settings)
-            except:
-                pass
+            except Exception:
+                pass  # safe to ignore
         sock.close()
         print()  # newline after raw mode
     
@@ -2585,8 +2587,8 @@ class VsshSession:
             try:
                 self.sock.sendall(f"CLOSE:{self.session_id}\n".encode())
                 self.sock.recv(32)  # CLOSE_OK
-            except:
-                pass
+            except OSError as e:
+                pass  # TODO: log error
             finally:
                 self.sock.close()
                 self.sock = None
@@ -2949,10 +2951,15 @@ def server():
 
             elif cmd == 'SSH':
                 cmdline = ':'.join(parts[2:])
-                conn.sendall(b'OK\n')
-                print(f'[SSH] {addr[0]}: {cmdline}')
-                result = subprocess.run(cmdline, shell=True, capture_output=True, timeout=60)
-                conn.sendall(result.stdout + result.stderr + b'__END__')
+                _dangerous = ['rm -rf /', 'mkfs ', 'dd if=/dev/zero']
+                if any(d in cmdline for d in _dangerous):
+                    conn.sendall(b'FAIL\n')
+                    print(f'[SSH] BLOCKED dangerous: {cmdline}')
+                else:
+                    conn.sendall(b'OK\n')
+                    print(f'[SSH] {addr[0]}: {cmdline}')
+                    result = subprocess.run(cmdline, shell=True, capture_output=True, timeout=60)
+                    conn.sendall(result.stdout + result.stderr + b'__END__')
 
             elif cmd == 'INFO':
                 conn.sendall(b'OK\n')
@@ -2961,7 +2968,7 @@ def server():
                     try:
                         r = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=10)
                         return r.stdout.strip() or r.stderr.strip() or '-'
-                    except:
+                    except (subprocess.SubprocessError, OSError):
                         return '-'
 
                 info = {
@@ -3011,11 +3018,15 @@ def server():
                 # Pipe command output to stdout: PIPE_DOWN:auth:cmd
                 cmdline = ':'.join(parts[2:])
                 print(f'[PIPE_DOWN] {addr[0]}: {cmdline}')
-
-                result = subprocess.run(cmdline, shell=True, capture_output=True, timeout=600)
-                output = result.stdout
-                conn.sendall(f'OK:{len(output)}\n'.encode())
-                conn.sendall(output)
+                _dangerous = ['rm -rf /', 'mkfs ', 'dd if=/dev/zero']
+                if any(d in cmdline for d in _dangerous):
+                    conn.sendall(b'FAIL\n')
+                    print(f'[PIPE_DOWN] BLOCKED dangerous: {cmdline}')
+                else:
+                    result = subprocess.run(cmdline, shell=True, capture_output=True, timeout=600)
+                    output = result.stdout
+                    conn.sendall(f'OK:{len(output)}\n'.encode())
+                    conn.sendall(output)
 
             elif cmd == 'MPUT':
                 # Multiplexed put: MPUT:auth:file_count
@@ -3113,7 +3124,7 @@ def server():
                         payload_data += chunk
                     try:
                         payload = json.loads(payload_data.decode())
-                    except:
+                    except (json.JSONDecodeError, ValueError, UnicodeDecodeError):
                         payload = {}
 
                 print(f'[RPC] {addr[0]}: {method}({payload})')
@@ -3201,8 +3212,8 @@ def server():
                                     payload_data += chunk
                                 try:
                                     payload = json.loads(payload_data.decode())
-                                except:
-                                    pass
+                                except (json.JSONDecodeError, ValueError, UnicodeDecodeError) as e:
+                                    pass  # TODO: log error
 
                             result = handle_rpc(method, payload, sender_ip=addr[0])
                             conn.sendall(f'RPC_RESULT:{len(result)}\n'.encode())
@@ -3457,8 +3468,8 @@ Env: VSSH_SECRET
         if len(args) > 1:
             try:
                 days = int(args[1])
-            except:
-                pass
+            except (ValueError, TypeError) as e:
+                pass  # TODO: log error
         stats = get_transfer_stats(days)
         print(f'Transfer Statistics (last {days} days)')
         print(f'  Total transfers: {stats["total"]}')
@@ -3622,11 +3633,11 @@ Env: VSSH_SECRET
                             buf += chunk
                         try:
                             result['info'] = json.loads(buf.decode())
-                        except:
-                            pass
+                        except (json.JSONDecodeError, ValueError, UnicodeDecodeError) as e:
+                            pass  # TODO: log error
                 s.close()
-            except:
-                pass
+            except OSError:
+                pass  # safe to ignore
             return result
 
         if full_mode:

{vssh-3.3.0 → vssh-3.3.1}/vssh_mcp_server.py

@@ -43,7 +43,7 @@ def load_config():
     try:
         with open(CONFIG_PATH) as f:
             return json.load(f)
-    except:
+    except (json.JSONDecodeError, ValueError) as e:
         return {}
 
 def get_servers():
@@ -108,8 +108,8 @@ def _get_tailscale_map():
                     parts = line.split()
                     if len(parts) >= 2:
                         _ts_map_cache[parts[0]] = parts[1]
-        except:
-            pass
+        except OSError as e:
+            pass  # TODO: log error
     return _ts_map_cache
 
 def vssh_connect(ip: str, timeout: int = 5) -> socket.socket:
@@ -126,7 +126,7 @@ def vssh_connect(ip: str, timeout: int = 5) -> socket.socket:
             sock.settimeout(timeout)
             sock.connect((ts_ip, VSSH_PORT))
             return sock
-        except:
+        except OSError as e:
             del _failover_cache[ip]
 
     # Primary: Wire VPN
@@ -135,8 +135,8 @@ def vssh_connect(ip: str, timeout: int = 5) -> socket.socket:
         sock.settimeout(timeout)
         sock.connect((ip, VSSH_PORT))
         return sock
-    except:
-        pass
+    except OSError as e:
+        pass  # TODO: log error
 
     # Fallback: Tailscale
     ts_map = _get_tailscale_map()
@@ -291,7 +291,7 @@ def tool_vssh_status():
                 "ip": ip,
                 "latency_ms": round(latency, 1)
             }
-        except:
+        except OSError as e:
             results[name] = {
                 "status": "offline",
                 "ip": ip
@@ -426,7 +426,7 @@ def tool_vssh_p2p_status():
             "external_port": external[1] if external else 0,
             "nat_type": "cone" if external else "unknown"
         }
-    except:
+    except Exception as e:
         return {
             "p2p_available": False,
             "note": "P2P module not loaded"
@@ -504,8 +504,8 @@ def tool_vssh_keys():
                 sock = vssh_connect(ip, timeout=2)
                 sock.close()
                 keys["servers_with_vssh"].append(name)
-            except:
-                pass
+            except OSError as e:
+                pass  # safe to ignore
 
     return keys
 

{vssh-3.3.0 → vssh-3.3.1}/vssh_p2p.py

@@ -292,7 +292,7 @@ def hole_punch_udp(peer_ip: str, peer_port: int, local_port: int, duration: int
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     try:
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-    except:
+    except OSError as e:
         pass  # Not available on all platforms
     sock.bind(('', local_port))
     sock.setblocking(False)
@@ -307,7 +307,7 @@ def hole_punch_udp(peer_ip: str, peer_port: int, local_port: int, duration: int
         try:
             sock.sendto(msg, peer)
             sent += 1
-        except: pass
+        except Exception:  pass  # TODO: log error
 
         try:
             data, addr = sock.recvfrom(1024)
@@ -318,7 +318,7 @@ def hole_punch_udp(peer_ip: str, peer_port: int, local_port: int, duration: int
                     sock.close()
                     return True
         except BlockingIOError: pass
-        except: pass
+        except Exception:  pass  # TODO: log error
 
         time.sleep(0.05)
 
@@ -338,8 +338,8 @@ def tcp_simultaneous_open(peer_ip: str, peer_port: int, local_port: int, timeout
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     try:
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-    except:
-        pass
+    except OSError as e:
+        pass  # TODO: log error
     sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
     sock.bind(('', local_port))
     sock.settimeout(1)
@@ -414,8 +414,8 @@ def wrap_p2p_tls(sock: socket.socket, is_server: bool) -> ssl.SSLSocket:
         # Prefer ChaCha20 for speed on non-AES-NI hardware
         try:
             ctx.set_ciphers('ECDHE+CHACHA20:ECDHE+AESGCM:@STRENGTH')
-        except:
-            pass
+        except Exception as e:
+            pass  # TODO: log error
         ctx.minimum_version = ssl.TLSVersion.TLSv1_2
         tls_sock = ctx.wrap_socket(sock, server_side=True)
     else:
@@ -424,8 +424,8 @@ def wrap_p2p_tls(sock: socket.socket, is_server: bool) -> ssl.SSLSocket:
         ctx.verify_mode = ssl.CERT_NONE  # Self-signed, verified by HMAC below
         try:
             ctx.set_ciphers('ECDHE+CHACHA20:ECDHE+AESGCM:@STRENGTH')
-        except:
-            pass
+        except OSError as e:
+            pass  # TODO: log error
         ctx.minimum_version = ssl.TLSVersion.TLSv1_2
         tls_sock = ctx.wrap_socket(sock, server_hostname='vssh-p2p')
 
@@ -917,7 +917,7 @@ def main():
             sock.connect((relay_ip, VSSH_PORT))
             sock.close()
             print(f"   OK: {relay_ip}:{VSSH_PORT}")
-        except:
+        except OSError as e:
             print(f"   FAILED: Cannot connect to relay")
             return
 

{vssh-3.3.0 → vssh-3.3.1}/vssh_p2p_fast.py

@@ -44,8 +44,8 @@ def setup_fast_socket(sock):
     # Try to set TCP quickack (Linux only)
     try:
         sock.setsockopt(socket.IPPROTO_TCP, 12, 1)  # TCP_QUICKACK
-    except:
-        pass
+    except OSError as e:
+        pass  # TODO: log error
 
 
 def p2p_send_stream(stream_id: int, sock: socket.socket, path: Path,
@@ -387,8 +387,8 @@ def p2p_receive_fast(ctrl_sock: socket.socket) -> bool:
         # Clean up temp dir
         try:
             temp_dir.rmdir()
-        except:
-            pass
+        except OSError as e:
+            pass  # TODO: log error
 
         print(f"  Saved {final_path} ({size/elapsed/1024/1024:.1f}MB/s)")
         ctrl_sock.sendall(b'OK\n')
@@ -398,8 +398,8 @@ def p2p_receive_fast(ctrl_sock: socket.socket) -> bool:
         print(f"  Receive error: {e}")
         try:
             ctrl_sock.sendall(f'ERROR:{e}\n'.encode())
-        except:
-            pass
+        except (ValueError, TypeError) as e:
+            pass  # TODO: log error
         return False
 
 

{vssh-3.3.0 → vssh-3.3.1}/vssh_quic.py

@@ -47,7 +47,7 @@ def verify_token(token: str, secret: str) -> bool:
             return False
         expected = compute_hmac(secret, ts)
         return parts[2] == expected
-    except:
+    except Exception:
         return False
 
 def file_hash(path: Path) -> str: