feat: add uuid seed option for deterministic UUID/password generation in relay mode

Author: nichind

singbox2proxy/base.py

@@ -1471,6 +1471,7 @@ def __init__(
         relay_protocol: str = None,
         relay_host: str = None,
         relay_port: int = None,
+        uuid_seed: str = None,
     ):
         """Initialize a SingBoxProxy instance.
 
@@ -1508,6 +1509,7 @@ def __init__(
                             (e.g., "vmess", "ss", "trojan").
             relay_host: Hostname or IP address of the relay server.
             relay_port: Port of the relay server. If None, an unused port is automatically selected
+            uuid_seed: Optional seed string for generating consistent UUIDs in relay mode.
 
         Raises:
             TypeError: If config is not a string or path-like object.
@@ -1571,6 +1573,7 @@ def __init__(
         self.relay_host = relay_host
         self.relay_port = relay_port or (self._pick_unused_port([self.http_port, self.socks_port]) if relay_protocol else None)
         self.relay_url = None
+        self.uuid_seed = uuid_seed
         self._relay_credentials = {}  # Store credentials for URL generation
 
         # Runtime state
@@ -1704,6 +1707,40 @@ def stderr(self) -> str:
         """
         return "".join(self._stderr_lines)
 
+    def _generate_deterministic_uuid(self, seed: str, suffix: str = "") -> str:
+        """Generate a deterministic UUID from a seed string.
+        
+        Args:
+            seed: The seed string to generate UUID from
+            suffix: Optional suffix to append to seed for different UUIDs
+            
+        Returns:
+            str: A valid UUID v5 string
+        """
+        import uuid
+        
+        # Use UUID5 with a namespace for deterministic generation
+        namespace = uuid.NAMESPACE_DNS
+        combined_seed = f"{seed}{suffix}"
+        return str(uuid.uuid5(namespace, combined_seed))
+    
+    def _generate_deterministic_password(self, seed: str, length: int = 16) -> str:
+        """Generate a deterministic password from a seed string.
+        
+        Args:
+            seed: The seed string to generate password from
+            length: Length of the password (for shadowsocks compatibility)
+            
+        Returns:
+            str: A deterministic password
+        """
+        import hashlib
+        
+        # Generate deterministic password from seed
+        hash_obj = hashlib.sha256(seed.encode())
+        # Take hex digest and truncate to desired length
+        return hash_obj.hexdigest()[:length]
+    
     def _get_public_ip(self) -> str:
         """Get the public IP address of this machine.
 
@@ -1813,7 +1850,10 @@ def _generate_relay_inbound(self) -> dict:
         port = self.relay_port
 
         if protocol == "vmess":
-            user_id = str(uuid.uuid4())
+            if self.uuid_seed:
+                user_id = self._generate_deterministic_uuid(self.uuid_seed, "vmess")
+            else:
+                user_id = str(uuid.uuid4())
             self._relay_credentials["uuid"] = user_id
             return {
                 "type": "vmess",
@@ -1824,12 +1864,18 @@ def _generate_relay_inbound(self) -> dict:
             }
 
         elif protocol == "trojan":
-            password = str(uuid.uuid4())
+            if self.uuid_seed:
+                password = self._generate_deterministic_password(self.uuid_seed + "trojan", 36)
+            else:
+                password = str(uuid.uuid4())
             self._relay_credentials["password"] = password
             return {"type": "trojan", "tag": "relay-in", "listen": "0.0.0.0", "listen_port": port, "users": [{"password": password}]}
 
         elif protocol in ("ss", "shadowsocks"):
-            password = str(uuid.uuid4())[:16]
+            if self.uuid_seed:
+                password = self._generate_deterministic_password(self.uuid_seed + "shadowsocks", 16)
+            else:
+                password = str(uuid.uuid4())[:16]
             self._relay_credentials["password"] = password
             return {
                 "type": "shadowsocks",

singbox2proxy/cli.py

@@ -82,13 +82,15 @@ def main():
     parser.add_argument(
         "--relay",
         choices=["vmess", "trojan", "ss", "shadowsocks", "socks", "http"],
-        help="Create a shareable proxy URL that relays traffic (e.g., --relay vless). Can be used without a proxy URL for direct connection.",
+        help="Create a shareable proxy URL that relays traffic (e.g., --relay vmess). Can be used without a proxy URL for direct connection.",
     )
 
     parser.add_argument("--relay-host", help="Host/IP to use in the relay URL (default: auto-detect)")
 
     parser.add_argument("--relay-port", type=int, help="Port to use for the relay server (default: auto-assign)")
 
+    parser.add_argument("--uuid-seed", help="Seed for deterministic UUID/password generation (makes relay URLs persistent across restarts)")
+
     args = parser.parse_args()
 
     # Configure logging
@@ -190,6 +192,7 @@ def main():
                 relay_protocol=args.relay,
                 relay_host=args.relay_host,
                 relay_port=args.relay_port,
+                uuid_seed=args.uuid_seed,
             )
             proxies.append(main_proxy)
 
@@ -232,15 +235,42 @@ def _save_config(config, path):
         # Test the proxy if requested
         if args.test:
             print("\nTesting proxy connection...")
+            
+            # Ping test
+            print("\n1. Ping Test:")
+            try:
+                import time as time_module
+                ping_times = []
+                for i in range(3):
+                    start = time_module.time()
+                    response = main_proxy.request("GET", "https://www.google.com/generate_204", timeout=5)
+                    elapsed = (time_module.time() - start) * 1000  # Convert to ms
+                    if response.status_code in (200, 204):
+                        ping_times.append(elapsed)
+                        print(f"  Attempt {i+1}: {elapsed:.2f} ms")
+                    else:
+                        print(f"  Attempt {i+1}: Failed (status {response.status_code})")
+                
+                if ping_times:
+                    avg_ping = sum(ping_times) / len(ping_times)
+                    min_ping = min(ping_times)
+                    max_ping = max(ping_times)
+                    print(f"  Average: {avg_ping:.2f} ms (min: {min_ping:.2f} ms, max: {max_ping:.2f} ms)")
+            except Exception as e:
+                print(f"  Ping test failed: {str(e)}")
+            
+            # IP test
+            print("\n2. IP Detection Test:")
             try:
                 response = main_proxy.request("GET", "https://api.ipify.org?format=json")
                 if response.status_code == 200:
                     ip_data = response.json()
-                    print(f"Proxy test successful! External IP: {ip_data['ip']}")
+                    print(f"  External IP: {ip_data['ip']}")
+                    print("\n✓ All tests passed!")
                 else:
-                    print(f"Proxy test failed with status code: {response.status_code}")
+                    print(f"  Failed with status code: {response.status_code}")
             except Exception as e:
-                print(f"Proxy test failed: {str(e)}")
+                print(f"  IP test failed: {str(e)}")
             sys.exit(0)
 
         print("\nProxy is running. Press Ctrl+C to stop.")