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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wormhole-proxy
-Version: 3.3.0
+Version: 3.3.2
 Summary: Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11
 License: MIT
 Keywords: wormhole,asynchronous,web,proxy

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

@@ -1,7 +1,7 @@
 # Main project metadata (PEP 621 standard)
 [project]
 name = "wormhole-proxy"
-version = "3.3.0"
+version = "3.3.2"
 description = "Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11"
 readme = "README.md"
 authors = [

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

@@ -100,18 +100,27 @@ async def update_database(
 ) -> None:
     """
     Fetches all public blocklists, filters them against an allowlist,
-    and compiles them into a SQLite database.
+    optimizes them, and compiles them into a SQLite database.
     """
     db_path = Path(db_path_str)
     db_path.parent.mkdir(parents=True, exist_ok=True)
 
-    # Start with the hardcoded default allowlist
-    allowlist_domains: set[str] = DEFAULT_ALLOWLIST.copy()
+    # Fetch and parse all blocklists
+    all_blocked_domains: set[str] = set()
+    async with aiohttp.ClientSession() as session:
+        tasks = [_fetch_list(session, url) for url in BLOCKLIST_URLS]
+        results = await asyncio.gather(*tasks)
+
+    logger.info("\nParsing all fetched lists...")
+    for content in results:
+        all_blocked_domains.update(_parse_domains_from_content(content))
+
     logger.info(
-        f"Loaded {len(allowlist_domains)} domains from the default allowlist."
+        f"Found {len(all_blocked_domains)} unique domains before filtering."
     )
 
-    # Add domains from the user-provided file, if any
+    # Load allowlist to filter domains before optimization and writing to the DB.
+    allowlist_domains: set[str] = DEFAULT_ALLOWLIST.copy()
     if allowlist_path_str:
         logger.info(f"Loading custom allowlist from: {allowlist_path_str}")
         try:
@@ -120,34 +129,22 @@ async def update_database(
                     if line.strip() and not line.startswith("#"):
                         allowlist_domains.add(line.strip().lower())
             logger.info(
-                f"Total allowlist size is now {len(allowlist_domains)} domains."
+                f"Total allowlist size is {len(allowlist_domains)} domains."
             )
         except FileNotFoundError:
             logger.warning(
-                "Custom allowlist file not found. Proceeding without it."
+                "Custom allowlist file not found. Proceeding with defaults."
             )
 
-    # Fetch and parse all blocklists
-    all_blocked_domains: set[str] = set()
-    async with aiohttp.ClientSession() as session:
-        tasks = [_fetch_list(session, url) for url in BLOCKLIST_URLS]
-        results = await asyncio.gather(*tasks)
-
-    logger.info("\nParsing all fetched lists...")
-    for content in results:
-        all_blocked_domains.update(_parse_domains_from_content(content))
-
-    logger.info(
-        f"Found {len(all_blocked_domains)} unique domains before filtering."
-    )
-
-    # Remove allowed domains from the blocklist
+    # Remove any domains from the blocklist that are exactly in the allowlist.
+    # This allows a user to allow a parent domain (e.g., 'x.com') while still
+    # letting specific ad-serving subdomains (e.g., 'ad-api.x.com') be blocked.
     if allowlist_domains:
         original_count = len(all_blocked_domains)
         all_blocked_domains -= allowlist_domains
         num_removed = original_count - len(all_blocked_domains)
         logger.info(
-            f"Removed {num_removed} domains that were in the allowlist."
+            f"Removed {num_removed} domains that were present in the allowlist."
         )
 
     # Optimize the final blocklist

{wormhole_proxy-3.3.0 → wormhole_proxy-3.3.2}/wormhole/resolver.py

@@ -134,11 +134,11 @@ class Resolver:
             return [ip]
 
         # 2. Query DNS using aiodns for IPv4 and IPv6 addresses concurrently
-        tasks = [
+        results = await asyncio.gather(
             self.resolver.query(hostname, "A"),
             self.resolver.query(hostname, "AAAA"),
-        ]
-        results = await asyncio.gather(*tasks, return_exceptions=True)
+            return_exceptions=True,
+        )
 
         resolved_ips: set[str] = set()
         for res in results:

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

@@ -136,33 +136,44 @@ def load_allowlist(path: str, host: str) -> int:
 
 def is_ad_domain(hostname: str) -> bool:
     """
-    Checks if a hostname is blocked. It first checks against a runtime allowlist,
-    then checks the main blocklist.
+    Checks if a hostname is blocked using a more specific block/allow logic.
+    The blocklist is checked before the allowlist to allow for more granular control.
+
+    The order of checks is:
+    1. Exact match in blocklist -> Block
+    2. Exact match in allowlist -> Allow
+    3. Parent domain in blocklist -> Block
+    4. Parent domain in allowlist -> Allow
     """
     hostname_lower = hostname.lower()
 
-    # 1. Check the allowlist first.
-    if ALLOW_LIST_SET:
-        if hostname_lower in ALLOW_LIST_SET:
-            return False  # It's explicitly allowed
-        # Check for parent domains in allowlist
-        parts = hostname_lower.split(".")
-        for i in range(1, len(parts)):
-            parent_domain = ".".join(parts[i:])
-            if parent_domain in ALLOW_LIST_SET:
-                return False  # A parent domain is allowed
-
-    # 2. If not allowed, check the blocklist.
-    if not AD_BLOCK_SET:
-        return False
-
+    # --- Highest Priority: Check for an exact match in the blocklist ---
+    # This ensures that if 'ad-api.x.com' is specifically in the blocklist,
+    # it is blocked immediately, even if 'x.com' is on the allowlist.
     if hostname_lower in AD_BLOCK_SET:
         return True
 
+    # --- Second Priority: Check for an exact match in the allowlist ---
+    if hostname_lower in ALLOW_LIST_SET:
+        return False
+
+    # --- Third Priority: Check for parent domains in the blocklist ---
+    # This blocks subdomains of a blocked parent (e.g., if 'ad-server.com'
+    # is blocked, 'analytics.ad-server.com' will also be blocked).
     parts = hostname_lower.split(".")
     for i in range(1, len(parts)):
         parent_domain = ".".join(parts[i:])
         if parent_domain in AD_BLOCK_SET:
             return True
 
+    # --- Fourth Priority: Check for parent domains in the allowlist ---
+    # This allows subdomains of an allowed parent (e.g., if 'x.com' is
+    # allowed, 'www.x.com' will also be allowed), unless the subdomain
+    # itself was caught by the blocklist checks above.
+    for i in range(1, len(parts)):
+        parent_domain = ".".join(parts[i:])
+        if parent_domain in ALLOW_LIST_SET:
+            return False
+
+    # Default to not blocking if no specific rules match
     return False

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

@@ -106,7 +106,8 @@ async def handle_connection(
                 uri,
                 ident,
                 allow_private,
-                verbose,
+                max_attempts=MAX_RETRY,
+                verbose=verbose,
             )
         else:
             # The check above ensures `headers` is `list[str]` and `payload` is `bytes`.
@@ -119,7 +120,8 @@ async def handle_connection(
                 payload,
                 ident,
                 allow_private,
-                verbose,
+                max_attempts=MAX_RETRY,
+                verbose=verbose,
             )
 
     except Exception as e: