mirror of
https://github.com/daijro/camoufox.git
synced 2026-11-19 00:07:28 +00:00
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>
138 lines
3.9 KiB
Python
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}")
|