aboutsummaryrefslogtreecommitdiff
path: root/webmentions_ssg/url_security.py
blob: c4324e067602291eb1eb2aedeeef3f9c38a7691c (plain) (blame)
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("//")
    )