aboutsummaryrefslogtreecommitdiff
path: root/webmentions_ssg/forms/validators.py
blob: a22c942013b11e990224633575a0947444010ff5 (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
134
135
136
137
138
139
140
141
142
# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
#
# SPDX-License-Identifier: BSD-3-Clause

"""Custom Webmention URL and date field validators."""

import ipaddress

import httpx
from flask import current_app
from wtforms import DateField, Field, ValidationError
from wtforms.form import BaseForm
from wtforms.validators import StopValidation

from ..hostname import normalize_hostname
from ..net import is_public_address
from ..validation import is_control_character


class MaxURLBytes:
    """Check the UTF-8 byte length of a submitted URL using the current config."""

    def __init__(
        self, config_key: str = "MAX_WEBMENTION_URL_BYTES", message: str | None = None
    ) -> None:
        self.config_key = config_key
        self.message = message

    def __call__(self, form: BaseForm, field: Field) -> None:
        if field.data is None:
            return

        max_bytes = current_app.config[self.config_key]

        try:
            length = len(field.data.encode("utf-8"))
        except UnicodeEncodeError as exc:
            raise ValidationError(field.gettext("URL must be valid UTF-8.")) from exc

        if length > max_bytes:
            raise ValidationError(
                self.message or field.gettext(f"URL must not exceed {max_bytes} bytes.")
            )


class StrictHTTPURL:
    """Require an HTTP(S) URL that httpx can parse without rewriting whitespace.

    httpx automatically percent-encodes some whitespace. Reject it instead of
    silently changing the submitted URL (which may be used in exact URL matches).
    """

    def __call__(self, form: BaseForm, field: Field) -> None:
        value = field.data
        if not isinstance(value, str):
            raise StopValidation(field.gettext("Invalid URL."))

        if any(
            character.isspace() or is_control_character(character)
            for character in value
        ):
            raise StopValidation(field.gettext("Invalid URL."))

        try:
            parsed = httpx.URL(value)
        except (httpx.InvalidURL, ValueError, UnicodeError) as exc:
            raise StopValidation(field.gettext("Invalid URL.")) from exc

        if not parsed.host:
            raise StopValidation(field.gettext("Invalid URL."))

        if parsed.scheme not in ("http", "https"):
            raise StopValidation(
                field.gettext(f"{field.name} must begin with http or https")
            )


class AllowedTargetHostname:
    """Validate that a URL uses an allowed hostname.

    :param message: Optional validation error message.
    """

    def __init__(self, message: str | None = None) -> None:
        """Initialize the validator.

        :param message: Optional validation error message.
        """
        self.message = message

    def __call__(self, form: BaseForm, field: Field) -> None:
        """Validate that a URL uses an allowed hostname.

        :param form: Form containing the field.
        :param field: Field containing the URL to validate.
        :raises ValidationError: If the URL hostname is not configured as allowed.
        """
        try:
            hostname = normalize_hostname(field.data, from_url=True)
        except ValueError:
            hostname = None

        if hostname in current_app.config["ALLOWED_TARGET_HOSTNAMES"]:
            return
        raise ValidationError(
            self.message
            or field.gettext(
                "Target hostname is not in ALLOWED_TARGET_HOSTNAMES."
                if hostname is not None
                else "Invalid input."
            )
        )


class RejectNonPublicIPLiteral:
    """Reject non-public IP literals without performing DNS in the web worker."""

    def __call__(self, form: BaseForm, field: Field) -> None:
        try:
            hostname = normalize_hostname(field.data, from_url=True)
        except ValueError as exc:
            raise ValidationError(field.gettext("Invalid input.")) from exc

        try:
            address = ipaddress.ip_address(hostname)
        except ValueError:
            return  # Named hosts are resolved only during the background fetch.

        if not is_public_address(address):
            raise ValidationError(field.gettext("URL must use a public address."))


class CanonicalDate:
    """Require HTML date inputs to use the canonical YYYY-MM-DD format."""

    def __call__(self, form: BaseForm, field: DateField) -> None:
        if (
            field.data is not None
            and field.raw_data
            and field.raw_data[0] != field.data.isoformat()
        ):
            raise ValidationError(field.gettext("Invalid date."))