wormhole-proxy 3.2.2__tar.gz → 3.3.0__tar.gz

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wormhole-proxy
-Version: 3.2.2
+Version: 3.3.0
 Summary: Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11
 License: MIT
 Keywords: wormhole,asynchronous,web,proxy
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: Proxy Servers
 Provides-Extra: performance
+Requires-Dist: aiodns (>=3.5.0,<4.0.0)
 Requires-Dist: aiohttp (>=3.12.13,<4.0.0)
 Requires-Dist: aiosqlite (>=0.17.0,<0.18.0)
 Requires-Dist: loguru (>=0.7.2,<0.8.0)
@@ -59,6 +60,7 @@ Description-Content-Type: text/markdown
 ## Dependency
 
   - Python \>= 3.11
+  - aiodns
   - aiohttp
   - aiosqlite
   - loguru

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/README.md

@@ -29,6 +29,7 @@
 ## Dependency
 
   - Python \>= 3.11
+  - aiodns
   - aiohttp
   - aiosqlite
   - loguru

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 # Main project metadata (PEP 621 standard)
 [project]
 name = "wormhole-proxy"
-version = "3.2.2"
+version = "3.3.0"
 description = "Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11"
 readme = "README.md"
 authors = [
@@ -43,6 +43,7 @@ performance = ["winloop", "uvloop"]
 packages = [{include = "wormhole"}]
 
 [tool.poetry.dependencies]
+aiodns = "^3.5.0"
 aiohttp = "^3.12.13"
 aiosqlite = "^0.17.0"
 loguru = "^0.7.2"

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/ad_blocker.py

@@ -7,7 +7,7 @@ import asyncio
 import re
 
 # A curated list of popular and well-maintained ad-block lists
-BLOCKLIST_URLS = [
+BLOCKLIST_URLS: list[str] = [
     "https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts",
     "https://pgl.yoyo.org/adservers/serverlist.php?hostformat=hosts&showintro=0&mimetype=plaintext",
     "https://easylist.to/easylist/easylist.txt",
@@ -25,7 +25,7 @@ DOMAIN_REGEX = re.compile(
 
 async def _fetch_list(session: aiohttp.ClientSession, url: str) -> str:
     """Fetches the content of a single blocklist URL with a retry mechanism."""
-    max_retries = 3
+    max_retries: int = 3
     timeout = aiohttp.ClientTimeout(total=15)  # seconds
     for attempt in range(max_retries):
         try:
@@ -79,8 +79,8 @@ def _filter_redundant_domains(domains: set[str]) -> set[str]:
     e.g., if 'example.com' is present, 'ad.example.com' is removed.
     """
     # Sort by length descending to ensure we process subdomains before parents
-    sorted_domains = sorted(list(domains), key=len, reverse=True)
-    optimized_set = set(sorted_domains)
+    sorted_domains: list[str] = sorted(list(domains), key=len, reverse=True)
+    optimized_set: set[str] = set(sorted_domains)
 
     for domain in sorted_domains:
         parts = domain.split(".")
@@ -106,7 +106,7 @@ async def update_database(
     db_path.parent.mkdir(parents=True, exist_ok=True)
 
     # Start with the hardcoded default allowlist
-    allowlist_domains = DEFAULT_ALLOWLIST.copy()
+    allowlist_domains: set[str] = DEFAULT_ALLOWLIST.copy()
     logger.info(
         f"Loaded {len(allowlist_domains)} domains from the default allowlist."
     )
@@ -152,8 +152,10 @@ async def update_database(
 
     # Optimize the final blocklist
     logger.info("Optimizing list by removing redundant subdomains...")
-    optimized_domains = _filter_redundant_domains(all_blocked_domains)
-    num_redundant_removed = len(all_blocked_domains) - len(optimized_domains)
+    optimized_domains: set[str] = _filter_redundant_domains(all_blocked_domains)
+    num_redundant_removed: int = len(all_blocked_domains) - len(
+        optimized_domains
+    )
     logger.info(
         f"Optimization complete. Removed {num_redundant_removed} redundant domains."
     )

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/auth_manager.py

@@ -1,19 +1,20 @@
 from pathlib import Path
+from typing import Any
 import getpass
 import hashlib
 import os
 import stat
 import sys
 
-REALM = "Wormhole Proxy"
-HASH_ALGORITHM = hashlib.sha256  # Use SHA-256
+REALM: str = "Wormhole Proxy"
+HASH_ALGORITHM = hashlib.sha256
 
 
 def _get_password_confirm() -> str | None:
     """Gets and confirms a new password from the user."""
     try:
-        p1 = getpass.getpass()
-        p2 = getpass.getpass("Retype password: ")
+        p1: str = getpass.getpass()
+        p2: str = getpass.getpass("Retype password: ")
         if p1 != p2:
             print("Passwords do not match.", file=sys.stderr)
             return None
@@ -61,9 +62,9 @@ def _secure_create_file(path: Path) -> bool:
             return False
 
 
-def _read_auth_file(path: Path) -> dict:
+def _read_auth_file(path: Path) -> dict[str, Any]:
     """Reads the auth file into a dictionary."""
-    users = {}
+    users: dict[str, Any] = {}
     if path.is_file():
         with open(path, "r", encoding="utf-8") as f:
             for line in f:

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/authentication.py

@@ -5,7 +5,7 @@ import re
 import secrets
 
 # This must match the REALM in auth_manager.py
-REALM = "Wormhole Proxy"
+REALM: str = "Wormhole Proxy"
 HASH_ALGORITHM = hashlib.sha256
 
 # Caches for performance
@@ -46,10 +46,13 @@ def _load_auth_file(path: Path) -> dict | None:
     return _auth_file_cache
 
 
+# This regex handles quoted and unquoted values
+QUOTE_UNQUOTE_RE = re.compile(r'(\w+)=(?:"([^"]*)"|([^\s,]*))')
+
+
 def _parse_digest_header(header_value: str) -> dict[str, str]:
     """Parses the Digest authentication header into a dictionary."""
-    # This regex handles quoted and unquoted values
-    parts = re.findall(r'(\w+)=(?:"([^"]*)"|([^\s,]*))', header_value)
+    parts = QUOTE_UNQUOTE_RE.findall(header_value)
     # The regex produces tuples like ('key', 'quoted_val', ''), so we merge
     return {key: val1 or val2 for key, val1, val2 in parts}
 
@@ -80,7 +83,6 @@ async def verify_credentials(
     reader: asyncio.StreamReader,
     writer: asyncio.StreamWriter,
     method: str,  # HTTP Method (e.g., 'CONNECT') is needed for HA2 calculation
-    uri: str,  # The original URI from the request line
     headers: list[str],
     auth_file_path: str,
 ) -> dict[str, str] | None:

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/handler.py

@@ -1,6 +1,7 @@
 from .logger import logger, format_log_message as flm
 from .safeguards import has_public_ipv6, is_ad_domain, is_private_ip
 from .tools import get_content_length, get_host_and_port
+from .resolver import resolver
 import asyncio
 import ipaddress
 import random
@@ -66,6 +67,7 @@ async def _resolve_and_validate_host(
 ) -> list[str]:
     """
     Resolves a hostname to a list of IPs, validates them, and caches the list.
+    Uses aiodns via a custom resolver that respects the local hosts file.
     Supports DNS load balancing and prioritizes IPv6 if available.
     Raises:
         PermissionError: If the host is an ad domain or resolves to only private IPs.
@@ -88,11 +90,9 @@ async def _resolve_and_validate_host(
             )
             return ip_list
 
-    # Resolve hostname
-    loop = asyncio.get_running_loop()
+    # Resolve hostname using aiodns resolver
     try:
-        addr_info_list = await loop.getaddrinfo(host, None, family=0)
-        resolved_ips = {info[4][0] for info in addr_info_list}
+        resolved_ips = await resolver.resolve(host)
     except OSError as e:
         raise OSError(f"Failed to resolve host: {host}") from e
 
@@ -153,58 +153,93 @@ async def _resolve_and_validate_host(
     return final_ip_list
 
 
-async def _create_connection_with_retries(
+async def _create_fastest_connection(
     ip_list: list[str],
     port: int,
     ident: dict[str, str],
-    max_attempts: int = 3,
     timeout: int = 5,
+    max_attempts: int = 3,
     verbose: int = 0,
 ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
     """
-    Tries to connect to a list of IPs with a fast timeout and retry mechanism.
+    Implements a robust "Happy Eyeballs" connection algorithm with retries.
+    It wraps the concurrent connection logic in a retry loop.
     """
     last_error = None
 
-    # Create a list of connection targets to try, ensuring we don't exceed max_attempts
-    targets_to_try = (ip_list * (max_attempts // len(ip_list) + 1))[
-        :max_attempts
-    ]
-
-    for i, ip in enumerate(targets_to_try):
-        attempt = i + 1
+    for attempt in range(max_attempts):
         logger.debug(
             flm(
-                f"Connection attempt {attempt}/{max_attempts} to {ip}:{port}",
+                f"Connection attempt {attempt + 1}/{max_attempts} to {ip_list}",
                 ident,
                 verbose,
             )
         )
-        try:
-            # Use a short timeout for each connection attempt
-            reader, writer = await asyncio.wait_for(
-                asyncio.open_connection(ip, port), timeout=timeout
+
+        tasks = {
+            asyncio.create_task(
+                asyncio.wait_for(
+                    asyncio.open_connection(ip, port), timeout=timeout
+                ),
+                name=ip,
             )
-            logger.debug(
-                flm(
-                    f"Successfully connected to {ip}:{port} on attempt {attempt}",
-                    ident,
-                    verbose,
-                )
+            for ip in ip_list
+        }
+
+        # Inner loop for the "Happy Eyeballs" race
+        while tasks:
+            done, pending = await asyncio.wait(
+                tasks, return_when=asyncio.FIRST_COMPLETED
             )
-            return reader, writer
-        except (OSError, asyncio.TimeoutError) as e:
-            last_error = e
+
+            for task in done:
+                try:
+                    reader, writer = task.result()
+                    # On success, cancel pending tasks and return the connection
+                    for p_task in pending:
+                        p_task.cancel()
+                    if pending:
+                        await asyncio.gather(*pending, return_exceptions=True)
+                    peer = writer.get_extra_info("peername")
+                    logger.debug(
+                        flm(
+                            f"Successfully established fastest connection to {peer[0]}:{peer[1]}",
+                            ident,
+                            verbose,
+                        )
+                    )
+                    return reader, writer
+                except (
+                    OSError,
+                    asyncio.TimeoutError,
+                    asyncio.CancelledError,
+                ) as e:
+                    ip = task.get_name()
+                    logger.debug(
+                        flm(
+                            f"Connection to {ip}:{port} failed within race: {e}",
+                            ident,
+                            verbose,
+                        )
+                    )
+                    last_error = e
+
+            tasks = pending
+
+        # If the inner loop finishes, all IPs failed in this attempt.
+        # Wait before the next retry, if any.
+        if attempt < max_attempts - 1:
             logger.warning(
                 flm(
-                    f"Connection to {ip}:{port} failed on attempt {attempt}: {e}",
+                    f"All connections failed on attempt {attempt + 1}. Retrying in 1 second...",
                     ident,
                     verbose,
                 )
             )
+            await asyncio.sleep(1)
 
     raise OSError(
-        f"Failed to connect after {max_attempts} attempts. Last error: {last_error}"
+        f"All connection attempts failed after {max_attempts} retries. Last error: {last_error}"
     )
 
 
@@ -218,6 +253,7 @@ async def process_https_tunnel(
     uri: str,
     ident: dict[str, str],
     allow_private: bool,
+    max_attempts: int = 3,
     verbose: int = 0,
 ) -> None:
     """Establishes an HTTPS tunnel and relays data between client and server."""
@@ -230,10 +266,8 @@ async def process_https_tunnel(
         ip_list = await _resolve_and_validate_host(
             host, ident, allow_private, verbose
         )
-
-        # Attempt to connect to one of the IPs with retry logic.
-        server_reader, server_writer = await _create_connection_with_retries(
-            ip_list, port, ident, verbose=verbose
+        server_reader, server_writer = await _create_fastest_connection(
+            ip_list, port, ident, max_attempts=max_attempts, verbose=verbose
         )
 
         # Signal the client that the tunnel is established.
@@ -259,6 +293,7 @@ async def process_https_tunnel(
         logger.warning(flm(f"{method} 403 {uri} ({e})", ident, verbose))
         client_writer.write(b"HTTP/1.1 403 Forbidden\r\n\r\n")
         await client_writer.drain()
+
     except Exception as e:
         msg = flm(f"{method} 502 {uri} ({e})", ident, verbose)
         if verbose > 2:  # Show full traceback only for -vv
@@ -288,10 +323,8 @@ async def _send_http_request(
     """Helper function to connect and send an HTTP request."""
     request_line = f"{method} {path or '/'} {version}".encode()
     headers_bytes = "\r\n".join(headers).encode()
-
-    # Attempt to connect to one of the IPs with retry logic.
-    server_reader, server_writer = await _create_connection_with_retries(
-        ip_list, port, ident, max_attempts, verbose=verbose
+    server_reader, server_writer = await _create_fastest_connection(
+        ip_list, port, ident, max_attempts=max_attempts, verbose=verbose
     )
 
     server_writer.write(request_line + b"\r\n" + headers_bytes + b"\r\n\r\n")
@@ -429,13 +462,16 @@ async def process_http_request(
             final_headers = [
                 h for h in headers if not h.lower().startswith("proxy-")
             ]
+
             if not any(h.lower().startswith("host:") for h in final_headers):
                 final_headers.insert(0, f"Host: {host_header}")
+
             final_headers = [
                 h
                 for h in final_headers
                 if not h.lower().startswith("connection:")
             ]
+
             final_headers.append("Connection: close")
 
             server_reader, server_writer = await _send_http_request(
@@ -472,6 +508,7 @@ async def process_http_request(
         logger.warning(flm(f"{method} 403 {uri} ({e})", ident, verbose))
         client_writer.write(b"HTTP/1.1 403 Forbidden\r\n\r\n")
         await client_writer.drain()
+
     except Exception as e:
         msg = flm(f"{method} 502 {uri} ({e})", ident, verbose)
         if verbose > 2:  # Show full traceback only for -vv
@@ -484,6 +521,7 @@ async def process_http_request(
                 await client_writer.drain()
             except ConnectionError:
                 pass  # Ignore if client is already closed
+
     finally:
         if server_writer and not server_writer.is_closing():
             server_writer.close()

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/logger.py

@@ -22,7 +22,8 @@ class LogThrottler:
         if self.repeat_count > 2:
             self.logger.opt(depth=2).log(
                 self.level,
-                f"{self.last_message} (and {self.repeat_count -1} more in the last {self.delay} seconds.)",
+                f"{self.last_message} "
+                f"(and {self.repeat_count -1} more in the last {self.delay} seconds.)",
                 **kwargs,
             )
         elif self.repeat_count == 2:
@@ -62,7 +63,10 @@ class LogThrottler:
 # In loguru, the logger is imported and ready to be configured.
 # We just need to ensure other modules import this configured instance.
 def setup_logger(
-    syslog_host: str | None = None, syslog_port: int = 514, verbose: int = 0
+    syslog_host: str | None = None,
+    syslog_port: int = 514,
+    verbose: int = 0,
+    async_mode: bool = True,
 ) -> None:
     """
     Configures the global loguru logger instance. This should only be called once.
@@ -110,10 +114,12 @@ def setup_logger(
     logging.getLogger("asyncio").setLevel(
         logging.DEBUG if verbose >= 2 else logging.CRITICAL
     )
-    if verbose < 2:
-        logger.info = LogThrottler(logger, "info").process
-        logger.warning = LogThrottler(logger, "warning").process
-        logger.error = LogThrottler(logger, "error").process
+
+    # Only enable the async LogThrottler if we are in async mode.
+    if async_mode and verbose < 2:
+        logger.info = LogThrottler(logger, "info").process  # type: ignore
+        logger.warning = LogThrottler(logger, "warning").process  # type: ignore
+        logger.error = LogThrottler(logger, "error").process  # type: ignore
 
 
 def format_log_message(

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/proxy.py

@@ -10,6 +10,7 @@ if sys.version_info < (3, 11):
 from .ad_blocker import update_database
 from .auth_manager import add_user, modify_user, delete_user
 from .logger import logger, setup_logger, format_log_message as flm
+from .resolver import resolver
 from .safeguards import load_ad_block_db, load_allowlist
 from .server import start_wormhole_server
 from .version import VERSION
@@ -210,7 +211,8 @@ def main() -> int:
     )
     args = parser.parse_args()
 
-    # Print license information and exit.
+    # --- Utility Command Handling ---
+    # These commands run synchronously and exit.
     if args.license:
         print(parser.description)
         try:
@@ -222,7 +224,6 @@ def main() -> int:
             return 1
         return 0
 
-    # Handle authentication management commands.
     if args.auth_add:
         return add_user(args.auth_add[0], args.auth_add[1])
     if args.auth_mod:
@@ -230,12 +231,22 @@ def main() -> int:
     if args.auth_del:
         return delete_user(args.auth_del[0], args.auth_del[1])
 
-    # Setup the uvloop before any other operations thay migh use the event loop.
+    # --- Server and DB Update Handling ---
+    # Determine if we are running the full async server or a utility.
+    is_server_mode = not args.update_ad_block_db
+
+    # Setup the uvloop before any other operations that might use the event loop.
     if uvloop:
         uvloop.install()
 
-    # Setup logging before any other operations.
-    setup_logger(args.syslog_host, args.syslog_port, args.verbose)
+    # Setup logging. Disable async features for synchronous utility commands.
+    setup_logger(
+        args.syslog_host,
+        args.syslog_port,
+        args.verbose,
+        async_mode=is_server_mode,
+    )
+    resolver.configure(verbose=args.verbose)
 
     if args.update_ad_block_db:
         # For this standalone utility, configure a simple logger to show progress.
@@ -249,6 +260,7 @@ def main() -> int:
             return 1
         return 0
 
+    # --- Main Server Execution ---
     if not 1024 <= args.port <= 65535:
         parser.error("Port must be between 1024 and 65535.")
 

wormhole_proxy-3.3.0/wormhole/resolver.py

@@ -0,0 +1,173 @@
+from .logger import logger, format_log_message as flm
+from pathlib import Path
+from typing import ClassVar
+import aiodns
+import asyncio
+import os
+import re
+import sys
+
+# Regex to parse a line in the hosts file.
+# It captures the IP address and all hostnames on the line.
+# It ignores comments starting with '#'.
+HOSTS_LINE_REGEX = re.compile(r"^\s*([^\s#]+)\s+([^#]+)")
+
+
+class Resolver:
+    """
+    A DNS resolver that uses aiodns and a persistent hosts file cache.
+    This class is implemented as a singleton to ensure only one instance
+    is used throughout the application.
+    """
+
+    # Class variable to hold the singleton instance
+    _instance: ClassVar["Resolver | None"] = None
+
+    def __init__(self) -> None:
+        """
+        Initializes the resolver, loads the hosts file, and sets the
+        singleton instance. The aiodns.DNSResolver is created lazily.
+        """
+        if not Resolver._instance:
+            self.resolver: aiodns.DNSResolver | None = None
+            self.hosts_cache: dict[str, str] = {}
+            self.verbose: int = 0  # Verbosity level, configured separately
+            self._load_hosts_file()
+            Resolver._instance = self
+
+    def configure(self, verbose: int) -> None:
+        """Sets the verbosity level for logging."""
+        self.verbose = verbose
+
+    @staticmethod
+    def get_instance() -> "Resolver":
+        """Static access method to get the singleton instance."""
+        if Resolver._instance is None:
+            Resolver()
+        return Resolver._instance  # type: ignore
+
+    def _get_hosts_path(self) -> Path:
+        """Determines the correct path to the hosts file based on the OS."""
+        if sys.platform == "win32":
+            # Use the SYSTEMROOT environment variable on Windows
+            return (
+                Path(os.environ["SYSTEMROOT"])
+                / "System32"
+                / "drivers"
+                / "etc"
+                / "hosts"
+            )
+        else:
+            # For Linux, macOS, and other UNIX-like systems
+            return Path("/etc/hosts")
+
+    def _load_hosts_file(self) -> None:
+        """Parses the system's hosts file and populates the cache."""
+        hosts_path = self._get_hosts_path()
+        ident = {"id": "resolver", "client": "internal"}
+
+        if not hosts_path.exists():
+            logger.warning(
+                flm(
+                    f"Hosts file not found at {hosts_path}, skipping.",
+                    ident,
+                    self.verbose,
+                )
+            )
+            return
+
+        try:
+            with open(hosts_path, "r", encoding="utf-8") as f:
+                for line in f:
+                    match = HOSTS_LINE_REGEX.match(line)
+                    if not match:
+                        continue
+
+                    ip_address = match.group(1)
+                    hostnames_str = match.group(2)
+                    hostnames = hostnames_str.strip().split()
+
+                    for hostname in hostnames:
+                        self.hosts_cache[hostname.lower()] = ip_address
+
+            logger.info(
+                flm(
+                    f"Loaded {len(self.hosts_cache)} entries from {hosts_path}",
+                    ident,
+                    self.verbose,
+                )
+            )
+        except Exception as e:
+            logger.error(
+                flm(
+                    f"Failed to load or parse hosts file at {hosts_path}: {e}",
+                    ident,
+                    self.verbose,
+                )
+            )
+
+    async def resolve(self, hostname: str) -> list[str]:
+        """
+        Resolves a hostname to a list of IP addresses.
+
+        1. Checks the local hosts file cache first.
+        2. If not found, queries DNS for A and AAAA records using aiodns.
+        """
+        # Create a specific ident for this resolution request
+        ident = {"id": "resolver", "client": hostname}
+
+        # Lazily initialize the resolver on first use to attach to the correct event loop.
+        if self.resolver is None:
+            loop = asyncio.get_running_loop()
+            self.resolver = aiodns.DNSResolver(loop=loop)
+
+        hostname_lower = hostname.lower()
+        # 1. Check hosts file cache
+        if ip := self.hosts_cache.get(hostname_lower):
+            logger.debug(
+                flm(
+                    f"Resolved to {ip} from hosts file cache.",
+                    ident,
+                    self.verbose,
+                )
+            )
+            return [ip]
+
+        # 2. Query DNS using aiodns for IPv4 and IPv6 addresses concurrently
+        tasks = [
+            self.resolver.query(hostname, "A"),
+            self.resolver.query(hostname, "AAAA"),
+        ]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        resolved_ips: set[str] = set()
+        for res in results:
+            if isinstance(res, list):
+                for record in res:
+                    resolved_ips.add(record.host)
+            elif isinstance(res, aiodns.error.DNSError):
+                # Ignore common "not found" errors. Log other DNS errors for debugging.
+                if res.args[0] not in (
+                    aiodns.error.ARES_ENODATA,
+                    aiodns.error.ARES_ENOTFOUND,
+                ):
+                    logger.debug(
+                        flm(f"aiodns query failed: {res}", ident, self.verbose)
+                    )
+            elif isinstance(res, Exception):
+                logger.warning(
+                    flm(
+                        f"Unexpected error during DNS resolution: {res}",
+                        ident,
+                        self.verbose,
+                    )
+                )
+
+        if not resolved_ips:
+            raise OSError(f"Failed to resolve host: {hostname}")
+
+        return list(resolved_ips)
+
+
+# Initialize the singleton instance so it's ready for other modules to import
+resolver = Resolver.get_instance()

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/safeguards.py

@@ -20,6 +20,7 @@ DEFAULT_ALLOWLIST: set[str] = {
     "data.jsdelivr.com",  # jsDelivr API
     "esm.run",  # jsDelivr for JavaScript modules
     "unpkg.com",  # Unpkg CDN
+    "bing.com",  # Bing for search functionality
     "twitter.com",  # Twitter for social media integration
     "x.com",  # X (formerly Twitter) for social media integration"
 }

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/server.py

@@ -79,12 +79,11 @@ async def handle_connection(
 
         # --- Authentication Check ---
         if auth_file_path:
-            # Pass method and uri for Digest authentication calculation
+            # Pass method for Digest authentication calculation
             user_ident = await verify_credentials(
                 client_reader,
                 client_writer,
                 method,
-                uri,
                 headers,
                 auth_file_path,
             )

{wormhole_proxy-3.2.2 → wormhole_proxy-3.3.0}/wormhole/tools.py

@@ -1,21 +1,26 @@
 import re
 
+# Regex patterns for extracting host and port from a string
 REGEX_HOST = re.compile(r"(.+?):([0-9]{1,5})")
 
-REGEX_CONTENT_LENGTH = re.compile(
-    r"\r\nContent-Length: ([0-9]+)\r\n", re.IGNORECASE
-)
-
 
 def get_host_and_port(
     hostname: str, default_port: str | None = None
 ) -> tuple[str, int]:
+    """Extracts the host and port from a hostname string."""
     if match := REGEX_HOST.search(hostname):
         return match.group(1), int(match.group(2))
     return hostname, int(default_port or "80")
 
 
+# Regex pattern for extracting Content-Length from HTTP headers
+REGEX_CONTENT_LENGTH = re.compile(
+    r"\r\nContent-Length: ([0-9]+)\r\n", re.IGNORECASE
+)
+
+
 def get_content_length(header: str) -> int:
+    """Extracts the Content-Length from an HTTP header string."""
     if match := REGEX_CONTENT_LENGTH.search(header):
         return int(match.group(1))
     return 0

wormhole_proxy-3.3.0/wormhole/version.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+VERSION: str = version("wormhole-proxy")

wormhole_proxy-3.2.2/wormhole/version.py

@@ -1,3 +0,0 @@
-from importlib.metadata import version
-
-VERSION = version("wormhole-proxy")