Files
archived-camoufox/pythonlib/camoufox/ip.py
T
Jake WriterandClaude Opus 5.5 6a22248c0b fix(python): NewContext looks up a proxy's exit IP through the right URL, or fails
NewContext derives the context's WebRTC IP and timezone from the proxy's exit
IP. That lookup had two defects, and both left the context showing the
host's values while its traffic went through the proxy:

- It built its own proxy URL with urlparse, which reads a scheme-less server
  such as "1.2.3.4:8080" (a form Playwright accepts) as scheme "1.2.3.4" with
  no host. urllib could not use a SOCKS proxy at all.
- Any failure was swallowed, and the context opened without the values.

The URL is now built with Proxy.as_string(), which the geoip launch path
already uses (scheme-less means http). The lookup goes through requests,
which handles SOCKS, and a failed lookup raises InvalidIP, naming the two
options that skip it. The tests cover scheme-less, http and socks5 servers
with credentials, both failure modes, and the case where no lookup is needed,
for NewContext and AsyncNewContext.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 15:22:28 -06:00

138 lines
3.9 KiB
Python

import re
from dataclasses import dataclass
from functools import lru_cache
from typing import Dict, Optional, Tuple
import requests
from .exceptions import InvalidIP, InvalidProxy
"""
Helpers to find the user's public IP address for geolocation.
"""
@dataclass
class Proxy:
"""
Stores proxy information.
"""
server: str
username: Optional[str] = None
password: Optional[str] = None
bypass: Optional[str] = None
@staticmethod
def parse_server(server: str) -> Tuple[str, str, Optional[str]]:
"""
Parses the proxy server string.
"""
proxy_match = re.match(r'^(?:(?P<schema>\w+)://)?(?P<url>.*?)(?:\:(?P<port>\d+))?$', server)
if not proxy_match:
raise InvalidProxy(f"Invalid proxy server: {server}")
return proxy_match['schema'], proxy_match['url'], proxy_match['port']
def as_string(self) -> str:
schema, url, port = self.parse_server(self.server)
if not schema:
schema = 'http'
result = f"{schema}://"
if self.username:
result += f"{self.username}"
if self.password:
result += f":{self.password}"
result += "@"
result += url
if port:
result += f":{port}"
return result
@staticmethod
def as_requests_proxy(proxy_string: str) -> Dict[str, str]:
"""
Converts the proxy to a requests proxy dictionary.
"""
return {
'http': proxy_string,
'https': proxy_string,
}
@lru_cache(128, typed=True)
def valid_ipv4(ip: str) -> bool:
return bool(re.match(r'^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$', ip))
@lru_cache(128, typed=True)
def valid_ipv6(ip: str) -> bool:
return bool(re.match(r'^(([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4})$', ip))
def validate_ip(ip: str) -> None:
if not valid_ipv4(ip) and not valid_ipv6(ip):
raise InvalidIP(f"Invalid IP address: {ip}")
def proxy_exit_geo(proxy: str) -> Tuple[str, str]:
"""
The exit IP of `proxy` and that IP's timezone, looked up through the proxy.
Raises InvalidIP when the lookup fails: a context that silently kept the
host's WebRTC IP and timezone behind a proxy would be a leak.
"""
try:
resp = requests.get(
"http://ip-api.com/json?fields=status,message,query,timezone",
proxies=Proxy.as_requests_proxy(proxy),
timeout=10,
)
resp.raise_for_status()
data = resp.json()
except requests.RequestException as exception:
raise InvalidIP(f"{PROXY_LOOKUP_FAILED}: {exception}") from exception
if data.get("status") != "success" or not data.get("timezone"):
raise InvalidIP(f"{PROXY_LOOKUP_FAILED}: {data.get('message') or data}")
validate_ip(data["query"])
return data["query"], data["timezone"]
PROXY_LOOKUP_FAILED = (
"Could not look up the proxy's exit IP and timezone. Pass webrtc_ip and "
"timezone_id explicitly to skip the lookup"
)
@lru_cache(maxsize=None)
def public_ip(proxy: Optional[str] = None) -> str:
"""
Sends a request to a public IP api
"""
URLS = [
# Prefers IPv4
"https://api.ipify.org",
"https://checkip.amazonaws.com",
"https://ipinfo.io/ip",
# IPv4 & IPv6
"https://icanhazip.com",
"https://ifconfig.co/ip",
"https://ipecho.net/plain",
]
end_exception = None
for url in URLS:
try:
resp = requests.get(
url,
proxies=Proxy.as_requests_proxy(proxy) if proxy else None,
timeout=5,
verify=True,
)
resp.raise_for_status()
ip = resp.text.strip()
validate_ip(ip)
return ip
except (requests.exceptions.ProxyError, requests.RequestException, InvalidIP) as exception:
end_exception = exception
raise InvalidIP(f"Failed to get IP address: {end_exception}")