1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
#
# SPDX-License-Identifier: BSD-3-Clause
"""Validate URL schemes and publicly routable network destinations."""
import ipaddress
from urllib.parse import urlsplit
import dns.exception
import dns.resolver
class AddressResolutionError(Exception):
"""A hostname could not be resolved (potentially transient)."""
class UnsafeAddressError(ValueError):
"""A hostname or IP literal identifies a non-public network address."""
_NAT64_PREFIX = ipaddress.IPv6Network("64:ff9b::/96")
_IPV4_COMPATIBLE_PREFIX = ipaddress.IPv6Network("::/96")
def is_public_address(address: ipaddress.IPv4Address | ipaddress.IPv6Address) -> bool:
"""Reject non-public addresses, including IPv4 hidden in IPv6 forms.
``is_global`` alone does not reliably exclude IPv6 transition addresses
across Python versions or networks with NAT64/6to4 routing.
"""
if isinstance(address, ipaddress.IPv6Address):
# The well-known NAT64 prefix can translate an otherwise global IPv6
# address into a private IPv4 destination. IPv4-compatible addresses
# similarly embed IPv4 in ::/96, even without ipv4_mapped metadata.
if address in _NAT64_PREFIX or address in _IPV4_COMPATIBLE_PREFIX:
return False
# 6to4 and IPv4-mapped IPv6 addresses expose their embedded IPv4
# destination through ipaddress; validate that destination as well.
for embedded in (address.sixtofour, address.ipv4_mapped):
if embedded is not None and not embedded.is_global:
return False
return address.is_global
def public_addresses(
hostname: str, *, lifetime: float | None = None
) -> tuple[str, ...]:
"""Resolve *once* and return only checked, globally routable IP addresses.
A DNS name with a mixture of public and private answers is rejected in its
entirety. IP literals are handled without DNS, including IPv6 literals.
The returned strings must be used for the actual TCP connection; checking
them and then connecting to ``hostname`` reintroduces DNS rebinding.
"""
try:
literal = ipaddress.ip_address(hostname)
except ValueError:
literal = None
if literal is not None:
addresses = (literal,)
else:
try:
answers = dns.resolver.resolve_name(hostname, lifetime=lifetime)
addresses = tuple(ipaddress.ip_address(a) for a in answers.addresses())
except (dns.exception.DNSException, ValueError) as exc:
raise AddressResolutionError(
f"Could not resolve hostname {hostname!r}"
) from exc
if not addresses:
raise AddressResolutionError(f"Could not resolve hostname {hostname!r}")
if any(not is_public_address(address) for address in addresses):
raise UnsafeAddressError(f"Non-public network address for {hostname!r}")
return tuple(str(address) for address in addresses)
def is_public_url(url: str) -> bool:
"""Return whether the URL resolves entirely to public IP addresses.
This is useful for diagnostics, but **not** sufficient to authorize a
request: network connections must use the exact validated IP address.
"""
hostname = urlsplit(url).hostname
if hostname is None:
raise ValueError("No hostname was specified")
try:
public_addresses(hostname)
except UnsafeAddressError:
return False
return True
def is_http_url(url: str) -> bool:
"""
Check whether a URL is an absolute HTTP or HTTPS URL.
:param url: URL to validate.
:return: Whether the URL uses HTTP or HTTPS and contains a hostname.
"""
try:
parsed = urlsplit(url)
except ValueError:
return False
return parsed.scheme.lower() in {"http", "https"} and parsed.hostname is not None
def is_safe_next_url(next_url: str) -> bool:
"""Allow redirects only to paths on this site."""
# Check the original string too: urlsplit("///evil.example").path is
# "/evil.example", even though browsers can treat the original as external.
if "\\" in next_url or not next_url.startswith("/") or next_url.startswith("//"):
return False
try:
target = urlsplit(next_url)
except ValueError:
return False
return (
not target.scheme
and not target.netloc
and target.path.startswith("/")
and not target.path.startswith("//")
)
|