aboutsummaryrefslogtreecommitdiff
path: root/webmentions_ssg/url_security.py
blob: 4e7940baa3283c938e6e14e509962836cfd1f828 (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
# 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."""


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 address.is_global 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("//")
    )