Satelit Shield, de la script la server.

# Caddyfile: /_sh/* goes to Shield, with your secret and the visitor's address
example.md {
	handle_path /_sh/* {
		rewrite * /shield/v1{uri}
		reverse_proxy https://api.satelit.md {
			header_up Host {upstream_hostport}
			header_up X-Shield-Secret {env.SHIELD_SECRET}
			header_up X-Shield-Client-IP {client_ip}
			header_up -Cookie
			header_up -Authorization
		}
	}
	# ... the rest of your site
}

# in every page:
# <script src="/_sh/sensor.js" data-site="shp_XXXXXXXXXXXXXXXXXXXXXXXX" data-base="/_sh" async></script>

# nginx: /_sh/ goes to Shield, with your secret and the visitor's address
location /_sh/ {
    proxy_pass https://api.satelit.md/shield/v1/;
    proxy_ssl_server_name on;
    proxy_set_header Host api.satelit.md;
    proxy_set_header X-Shield-Secret "shs_...";        # keep this file out of your repository
    proxy_set_header X-Shield-Client-IP $remote_addr;  # behind Cloudflare: $http_cf_connecting_ip
    proxy_set_header Cookie "";
    proxy_set_header Authorization "";
}

# in every page:
# <script src="/_sh/sensor.js" data-site="shp_XXXXXXXXXXXXXXXXXXXXXXXX" data-base="/_sh" async></script>

// Satelit Shield: check a pass (the __shp cookie) on your own server, with no call to Shield. Node 18+.
// A pass is p1.{exp}.{token}.{sig}; sig is the first 22 characters of
// base64url(HMAC-SHA256(pass key, "p1|{exp}|{token}|{client key}|{User-Agent}")).
import { createHash, createHmac, timingSafeEqual } from "node:crypto";

// The pass key: HMAC-SHA256 with the key sha256_hex(secret) over "satelit-shield-pass-v1", in hex.
export function passKey(secret) {
  const key = createHash("sha256").update(secret).digest("hex");
  return createHmac("sha256", key).update("satelit-shield-pass-v1").digest("hex");
}

// The client key: an IPv4 address as it is, an IPv6 address as its /64 (the first four groups and "::").
export function clientKey(ip) {
  const v4 = /^(?:::ffff:)?(\d{1,3}(?:\.\d{1,3}){3})$/i.exec(ip);
  if (v4) return v4[1];
  const [head, tail = ""] = ip.toLowerCase().split("%")[0].split("::");
  const a = head ? head.split(":") : [];
  const b = tail ? tail.split(":") : [];
  const groups = [...a, ...Array(Math.max(0, 8 - a.length - b.length)).fill("0"), ...b];
  return groups.slice(0, 4).map((g) => parseInt(g, 16).toString(16)).join(":") + "::";
}

// True when the pass has not expired and was signed for this address and this browser.
export function passValid(pass, secret, ip, userAgent, now = Date.now() / 1000) {
  const m = /^p1\.(\d+)\.([0-9a-f]{16})\.([A-Za-z0-9_-]{22})$/.exec(pass ?? "");
  if (!m || Number(m[1]) <= now) return false;
  const message = `p1|${m[1]}|${m[2]}|${clientKey(ip)}|${userAgent}`;
  const sig = createHmac("sha256", passKey(secret)).update(message).digest("base64url").slice(0, 22);
  return timingSafeEqual(Buffer.from(sig), Buffer.from(m[3]));
}

"""Satelit Shield: check a pass (the __shp cookie) on your own server, with no call to Shield. Python 3.8+.

A pass is p1.{exp}.{token}.{sig}; sig is the first 22 characters of
base64url(HMAC-SHA256(pass key, "p1|{exp}|{token}|{client key}|{User-Agent}")).
"""
import base64
import hashlib
import hmac
import ipaddress
import re
import time

PASS = re.compile(r"p1\.(\d+)\.([0-9a-f]{16})\.([A-Za-z0-9_-]{22})")


def pass_key(secret):
    """HMAC-SHA256 with the key sha256_hex(secret) over "satelit-shield-pass-v1", in hex."""
    key = hashlib.sha256(secret.encode()).hexdigest().encode()
    return hmac.new(key, b"satelit-shield-pass-v1", hashlib.sha256).hexdigest()


def client_key(ip):
    """An IPv4 address as it is, an IPv6 address as its /64 (the first four groups and "::")."""
    a = ipaddress.ip_address(ip.split("%")[0])
    if a.version == 6 and a.ipv4_mapped:
        a = a.ipv4_mapped
    if a.version == 4:
        return str(a)
    return ":".join(format(int(g, 16), "x") for g in a.exploded.split(":")[:4]) + "::"


def pass_valid(value, secret, ip, user_agent, now=None):
    """True when the pass has not expired and was signed for this address and this browser."""
    m = PASS.fullmatch(value or "")
    if not m or int(m[1]) <= (time.time() if now is None else now):
        return False
    message = f"p1|{m[1]}|{m[2]}|{client_key(ip)}|{user_agent}".encode()
    mac = hmac.new(pass_key(secret).encode(), message, hashlib.sha256).digest()
    sig = base64.urlsafe_b64encode(mac).decode().rstrip("=")[:22]
    return hmac.compare_digest(sig, m[3])

curl https://api.satelit.md/shield/v1/verify \
  -H "Authorization: Bearer $SHIELD_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "token": "<the token from the form>",
    "ip": "203.0.113.9"
  }'

// Node 18+: the token came with the form, ip is the visitor's address
async function fromPerson(token, ip) {
  const res = await fetch("https://api.satelit.md/shield/v1/verify", {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.SHIELD_SECRET}`, "Content-Type": "application/json" },
    body: JSON.stringify({ token, ip }),
  });
  const v = await res.json();
  return v.success === true && v.action !== "block";
}

import json, os, urllib.request

def from_person(token, ip):
    req = urllib.request.Request(
        "https://api.satelit.md/shield/v1/verify",
        data=json.dumps({"token": token, "ip": ip}).encode(),
        headers={"Authorization": f"Bearer {os.environ['SHIELD_SECRET']}", "Content-Type": "application/json"},
    )
    with urllib.request.urlopen(req, timeout=5) as res:
        v = json.load(res)
    return v.get("success") is True and v.get("action") != "block"

<?php
function from_person(string $token, string $ip): bool {
    $ch = curl_init("https://api.satelit.md/shield/v1/verify");
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_TIMEOUT => 5,
        CURLOPT_HTTPHEADER => ["Authorization: Bearer " . getenv("SHIELD_SECRET"), "Content-Type: application/json"],
        CURLOPT_POSTFIELDS => json_encode(["token" => $token, "ip" => $ip]),
    ]);
    $v = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return ($v["success"] ?? false) === true && ($v["action"] ?? "") !== "block";
}