nginx

Votre serveur vérifie chaque minute si Manicou lui demande de se protéger.

Dans l’espace client, ce code est déjà rempli pour votre site.

  1. Copiez les fichiers

    • manicou.py et drapeau.py dans /opt/manicou/
    • maintenance.html au même endroit, la page que verront vos visiteurs, à mettre à votre nom
    • nginx.conf en /etc/nginx/manicou.conf
  2. Créez /etc/manicou.json

    /etc/manicou.json
    {
      "sonde": "snd_…",
      "domaine": "…",
      "adresse": "https://app.manicou.dev/api/v1",
      "cles": {"k1": "…"},
      "dossier": "/var/lib/manicou",
      "page": "/opt/manicou/maintenance.html"
    }
  3. Lancez le garde chaque minute

    crontab
    * * * * * www-data python3 /opt/manicou/drapeau.py /etc/manicou.json
  4. Branchez nginx

    dans le bloc server
    include /etc/nginx/manicou.conf;
    nginx -s reload

Les fichiers

manicou.py Voir le code
manicou.py
"""Vérifier l'état que Manicou signe pour une sonde (pièce C23 de docs/CONSTRUCTION.md).

À recopier dans la recette du site, sans aucun paquet. Si `cryptography` est installé, il vérifie la signature ; sinon,
la vérification Ed25519 de la RFC 8032, écrite plus bas, s'en charge : lente, mais un état par minute ne lui coûte rien.

Le message suit Standard Webhooks, signature « v1a » (Ed25519) sur « id.horodatage.corps ». Un état ne s'applique que s'il
est signé par une des clés de Manicou recopiées dans la recette, récent, pour ce domaine et cette sonde, pas expiré, et
d'un numéro au moins égal au dernier appliqué. Un état refusé ne change rien : le site garde l'état qu'il applique
jusqu'au prochain état valable.
"""

import base64
import binascii
import hashlib
import json
import re
import time
from datetime import datetime

TOLERANCE = 300  # secondes d'écart permises entre l'horloge du site et l'heure de signature
NIVEAUX = ("normal", "restreint", "maintenance")

# Ed25519 selon la RFC 8032 (§5.1 et §6), pour vérifier seulement : tout y est public, le temps de calcul ne trahit rien.
_P = 2**255 - 19
_L = 2**252 + 27742317777372353535851937790883648493
_D = -121665 * pow(121666, _P - 2, _P) % _P
_RACINE_DE_MOINS_UN = pow(2, (_P - 1) // 4, _P)


def _abscisse(y, signe):
    if y >= _P:
        return None
    x2 = (y * y - 1) * pow(_D * y * y + 1, _P - 2, _P) % _P
    if x2 == 0:
        return None if signe else 0
    x = pow(x2, (_P + 3) // 8, _P)
    if (x * x - x2) % _P:
        x = x * _RACINE_DE_MOINS_UN % _P
    if (x * x - x2) % _P:
        return None
    if (x & 1) != signe:
        x = _P - x
    return x


def _point(octets):
    if len(octets) != 32:
        return None
    y = int.from_bytes(octets, "little")
    signe, y = y >> 255, y & ((1 << 255) - 1)
    x = _abscisse(y, signe)
    return None if x is None else (x, y, 1, x * y % _P)


def _somme(a, b):
    A = (a[1] - a[0]) * (b[1] - b[0]) % _P
    B = (a[1] + a[0]) * (b[1] + b[0]) % _P
    C = 2 * a[3] * b[3] * _D % _P
    D = 2 * a[2] * b[2] % _P
    E, F, G, H = B - A, D - C, D + C, B + A
    return (E * F % _P, G * H % _P, F * G % _P, E * H % _P)


def _fois(n, a):
    r = (0, 1, 1, 0)
    while n:
        if n & 1:
            r = _somme(r, a)
        a = _somme(a, a)
        n >>= 1
    return r


def _egaux(a, b):
    return (a[0] * b[2] - b[0] * a[2]) % _P == 0 and (a[1] * b[2] - b[1] * a[2]) % _P == 0


_Y_BASE = 4 * pow(5, _P - 2, _P) % _P
_X_BASE = _abscisse(_Y_BASE, 0)
_BASE = (_X_BASE, _Y_BASE, 1, _X_BASE * _Y_BASE % _P)


def ed25519_rfc8032(cle, signature, message):
    """Vrai si `signature` (64 octets) signe `message` pour la clé publique `cle` (32 octets)."""
    if len(cle) != 32 or len(signature) != 64:
        return False
    a, r = _point(cle), _point(signature[:32])
    s = int.from_bytes(signature[32:], "little")
    if a is None or r is None or s >= _L:
        return False
    h = int.from_bytes(hashlib.sha512(signature[:32] + cle + message).digest(), "little") % _L
    return _egaux(_fois(s, _BASE), _somme(r, _fois(h, a)))


try:
    from cryptography.exceptions import InvalidSignature
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

    def _ed25519(cle, signature, message):
        try:
            Ed25519PublicKey.from_public_bytes(cle).verify(signature, message)
            return True
        except (InvalidSignature, ValueError):
            return False

except ImportError:
    _ed25519 = ed25519_rfc8032


def _octets(texte):
    try:
        return base64.b64decode(texte, validate=True)
    except (binascii.Error, ValueError):
        return None


def _signe(message, signatures, cles):
    for s in signatures.split(" "):
        if not s.startswith("v1a,"):
            continue
        signature = _octets(s[4:])
        if signature is None or len(signature) != 64:
            continue
        for cle in cles.values():
            brute = _octets(cle)
            if brute is not None and len(brute) == 32 and _ed25519(brute, signature, message):
                return True
    return False


def _instant(texte):
    try:
        return datetime.fromisoformat(texte.replace("Z", "+00:00")).timestamp()
    except (AttributeError, TypeError, ValueError):
        return None


def verifier_etat(entetes, corps, cles, domaine, sonde, dernier_numero=0, maintenant=None):
    """entetes : les en-têtes reçus ; corps : le texte reçu, tel quel ; cles : {identifiant: clé en base64}.

    Rend {"ok": True, "etat": {...}}, ou {"ok": False, "raison": ...}.

    Depuis la 0.12.141, l'état dit aussi jusqu'à quand le garde peut le tenir sans nouvelle de Manicou (echeance, une date, ou
    None en normal), et parti vaut True quand le site a quitté Manicou. Depuis la 0.12.180, un état normal peut porter
    observation, le niveau que le garde observe sans l'appliquer, quand l'interrupteur de Manicou est posé (D-145). Tous sont
    facultatifs, et une recette plus ancienne les ignore, et reste ouverte.
    """
    maintenant = int(time.time()) if maintenant is None else maintenant
    e = {str(k).lower(): str(v) for k, v in entetes.items()}
    id_, horodatage, signatures = e.get("webhook-id", ""), e.get("webhook-timestamp", ""), e.get("webhook-signature", "")
    if not id_ or not signatures or not re.fullmatch(r"[0-9]{1,12}", horodatage):
        return {"ok": False, "raison": "entetes"}
    if abs(maintenant - int(horodatage)) > TOLERANCE:
        return {"ok": False, "raison": "horodatage"}
    brut = corps.encode("utf-8") if isinstance(corps, str) else corps
    if not _signe(f"{id_}.{horodatage}.".encode("utf-8") + brut, signatures, cles):
        return {"ok": False, "raison": "signature"}

    try:
        etat = json.loads(brut)
    except ValueError:
        return {"ok": False, "raison": "corps"}
    expire = _instant(etat.get("expireLe")) if isinstance(etat, dict) and isinstance(etat.get("expireLe"), str) else None
    if (
        not isinstance(etat, dict)
        or not isinstance(etat.get("sonde"), str)
        or not isinstance(etat.get("domaine"), str)
        or etat.get("niveau") not in NIVEAUX
        or type(etat.get("numero")) is not int
        or type(etat.get("essai")) is not bool
        or expire is None
    ):
        return {"ok": False, "raison": "corps"}
    echeance = etat.get("echeance")
    if echeance is not None and (not isinstance(echeance, str) or _instant(echeance) is None):
        return {"ok": False, "raison": "corps"}
    if "parti" in etat and type(etat["parti"]) is not bool:
        return {"ok": False, "raison": "corps"}
    if "observation" in etat and (etat["niveau"] != "normal" or etat["observation"] not in ("restreint", "maintenance")):
        return {"ok": False, "raison": "corps"}
    if etat["domaine"].lower() != domaine.lower():
        return {"ok": False, "raison": "domaine"}
    if etat["sonde"] != sonde:
        return {"ok": False, "raison": "sonde"}
    if expire <= maintenant:
        return {"ok": False, "raison": "expire"}
    if etat["numero"] < dernier_numero:
        return {"ok": False, "raison": "numero"}
    return {
        "ok": True,
        "etat": {"niveau": etat["niveau"], "numero": etat["numero"], "essai": etat["essai"], "expireLe": etat["expireLe"], "echeance": echeance, "parti": etat.get("parti") is True, "observation": etat.get("observation")},
    }
drapeau.py Voir le code
drapeau.py
"""Le garde des sites servis par nginx ou Apache (pièce C23 de docs/CONSTRUCTION.md).

Lancé chaque minute (cron ou minuterie systemd), il lit l'état que Manicou signe pour la sonde, le vérifie (manicou.py,
posé à côté), et pose ou retire les drapeaux, des fichiers vides, que la configuration du serveur teste (nginx.conf,
apache.conf). Python 3.8 ou plus, sans paquet.

Depuis la 0.12.180, chaque drapeau porte son heure, à l'heure locale du serveur (« maintenance.2026111814 ») : le script pose ceux
des heures qui viennent jusqu'à l'échéance de l'état, et le serveur ne lit que celui de l'heure en cours. S'il cesse de tourner, ou
s'il échoue avant d'effacer, le site rouvre seul à l'échéance (D21). Les drapeaux sans heure (« maintenance », « restreint ») restent
posés pour les configurations d'avant la 0.12.180, à mettre à jour avec lui.

Un état refusé, une panne de Manicou ou un réseau coupé ne changent rien jusqu'à l'échéance de l'état appliqué (D-111), six
heures pour le restreint et quarante-huit pour la maintenance, que chaque lecture renouvelle. Passée cette échéance, les
drapeaux s'effacent et le site rouvre. Sans aucun état valable, le drapeau de départ se pose, restreint par défaut (ou
`demarrage`), six heures au plus si Manicou ne répond pas. Un état normal qui porte `observation` vient de l'interrupteur de
Manicou (D-145) : le site reste ouvert, et le drapeau « observe-<niveau> » laisse le serveur noter ce que ce niveau aurait refusé.
Le script le dit sur la sortie d'erreur, avec l'écart de l'horloge quand c'est elle qui fait refuser l'état.

La page de maintenance du site (`page`, maintenance.html mise à son nom) s'écrit, telle quelle et avec la phrase du mode
restreint, en page-maintenance.html et page-restreint.html, dans `pages`, le dossier des drapeaux par défaut, que le serveur sert
pour ses 503. Sans elle, une page qui porte la phrase de Manicou.

    * * * * * www-data python3 /opt/manicou/drapeau.py /etc/manicou.json

/etc/manicou.json, {"sonde": "…", "domaine": "…", "adresse": "https://…/api/v1", "cles": {…}, "dossier": "/var/lib/manicou",
"page": "/var/www/monsite/maintenance.html"}
Un dossier par site, lisible par le serveur web et modifiable par l'utilisateur qui lance le script. etat.json y garde le
dernier état vérifié avec sa sonde et son échéance. Pour retirer la recette, retirez d'abord la règle du serveur, rechargez-le,
puis retirez la ligne du cron et le dossier.
"""

import email.utils
import json
import os
import re
import sys
import time
import urllib.parse
import urllib.request

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

import manicou  # noqa: E402

DELAI = 10  # secondes
DRAPEAUX = ("maintenance", "restreint")
NIVEAUX = ("normal", "restreint", "maintenance")
HEURE = 3600
# Ce qu'un état tient sans nouvelle de Manicou, au plus (D-111). Une échéance signée plus courte s'applique, une plus longue non.
ECHEANCES = {"restreint": 6 * HEURE, "maintenance": 48 * HEURE}
# Les drapeaux de l'heure, que ce script pose et efface seul.
DRAPEAU_HORAIRE = re.compile(r"^(maintenance|restreint|observe-maintenance|observe-restreint)\.[0-9]{10}$")
# La page du site, lue au plus jusqu'à cette taille.
PAGE_MAX = 1024 * 1024
MESSAGES = {
    "maintenance": "Le site est en maintenance pour quelques minutes. Merci de revenir un peu plus tard.",
    "restreint": "Cette action est suspendue pour quelques minutes. Merci de réessayer un peu plus tard.",
}
PHRASES_RESTREINT = {
    "fr": "Une faille de sécurité qui touche de nombreux sites est en cours.<br>Certains services sont suspendus en attendant son correctif.",
    "en": "A security vulnerability affecting many websites is under way.<br>Some services are suspended until its fix.",
}


def _adresse_sure(adresse):
    u = urllib.parse.urlsplit(adresse)
    return u.scheme == "https" or (u.scheme == "http" and u.hostname in ("127.0.0.1", "localhost"))


def _ecrire(chemin, contenu):
    provisoire = chemin + ".tmp"
    with open(provisoire, "w", encoding="utf-8", newline="") as f:
        f.write(contenu)
    os.replace(provisoire, chemin)


def _poser(dossier, niveau):
    """Les drapeaux sans heure, pour les configurations d'avant la 0.12.180."""
    for drapeau in DRAPEAUX:
        chemin = os.path.join(dossier, drapeau)
        if drapeau == niveau and not os.path.exists(chemin):
            _ecrire(chemin, "")
        elif drapeau != niveau and os.path.exists(chemin):
            os.remove(chemin)


def heure(t):
    """L'heure locale qui nomme un drapeau, AAAAMMJJHH, comme $time_iso8601 de nginx et %{TIME_HOUR} d'Apache la lisent."""
    return time.strftime("%Y%m%d%H", time.localtime(t))


def heures(debut, fin):
    """Les heures d'un niveau tenu de debut à fin : celle en cours, puis chaque heure qui finit avant fin. Une heure que l'échéance
    entame n'en est pas, pour que le serveur seul ne tienne jamais le niveau au-delà de l'échéance."""
    if fin <= debut:
        return []
    noms = []
    t = debut
    while t < fin:
        nom = heure(t)
        if nom not in noms:
            noms.append(nom)
        t += 60
    derniere = heure(fin - 1)
    if derniere != noms[0] and derniere == heure(fin) and derniere in noms:
        noms.remove(derniere)
    return noms


def _poser_horaires(dossier, voulus):
    """Pose les drapeaux de l'heure voulus, et efface les autres, passés ou au-delà de l'échéance."""
    for nom in voulus:
        chemin = os.path.join(dossier, nom)
        if not os.path.exists(chemin):
            _ecrire(chemin, "")
    for nom in os.listdir(dossier):
        if DRAPEAU_HORAIRE.match(nom) and nom not in voulus:
            os.remove(os.path.join(dossier, nom))


def page_restreinte(page, phrase=None):
    """La page en mode restreint : la phrase de son élément id="manicou-phrase", celle du restreint, dans la langue de la page."""
    repere = page.find('id="manicou-phrase"')
    ouvre = -1 if repere < 0 else page.find(">", repere)
    ferme = -1 if ouvre < 0 else page.find("</p>", ouvre)
    if ferme < 0:
        return page
    langue = "en" if 'lang="en' in page[:400].lower() else "fr"
    return page[: ouvre + 1] + (phrase if phrase is not None else PHRASES_RESTREINT[langue]) + page[ferme:]


def _page_simple(niveau):
    return f'<!doctype html>\n<html lang="fr">\n<meta charset="utf-8">\n<title>Maintenance</title>\n<p>{MESSAGES[niveau]}</p>\n</html>\n'


def _ecrire_pages(reglages, dossier):
    """Les deux pages que le serveur sert pour ses 503, écrites seulement quand elles changent. Rend une erreur à dire, ou None."""
    pages = reglages.get("pages", dossier)
    erreur = None
    source = reglages.get("page")
    contenu = None
    if source:
        try:
            with open(source, "rb") as f:
                brut = f.read(PAGE_MAX + 1)
            if len(brut) > PAGE_MAX:
                erreur = "manicou, la page de maintenance dépasse 1 Mo, la phrase de Manicou la remplace"
            else:
                contenu = brut.decode("utf-8")
        except (OSError, UnicodeDecodeError) as e:
            erreur = f"manicou, la page de maintenance ne se lit pas ({e.__class__.__name__}), la phrase de Manicou la remplace"
    voulues = {
        "page-maintenance.html": contenu if contenu is not None else _page_simple("maintenance"),
        "page-restreint.html": page_restreinte(contenu, reglages.get("phrase_restreint")) if contenu is not None else _page_simple("restreint"),
    }
    try:
        os.makedirs(pages, exist_ok=True)
        for nom, texte in voulues.items():
            chemin = os.path.join(pages, nom)
            try:
                with open(chemin, encoding="utf-8", newline="") as f:
                    if f.read() == texte:
                        continue
            except (OSError, UnicodeDecodeError):
                pass
            _ecrire(chemin, texte)
    except OSError as e:
        erreur = f"manicou, les pages de maintenance ne s'écrivent pas dans {pages} ({e.__class__.__name__}), le serveur sert sa propre page"
    return erreur


def _accuser(reglages, etat):
    """L'accusé est indicatif, Manicou constate l'effet de l'extérieur. Une erreur ici ne change rien."""
    corps = json.dumps({"sonde": reglages["sonde"], "numero": etat["numero"], "niveau": etat["niveau"], "applique": True}).encode("utf-8")
    requete = urllib.request.Request(reglages["adresse"] + "/sites/accuses", data=corps, method="POST", headers={"content-type": "application/json"})
    try:
        urllib.request.urlopen(requete, timeout=DELAI).close()
    except Exception:  # noqa: BLE001
        pass


def _nombre(v):
    return isinstance(v, (int, float)) and not isinstance(v, bool)


def _lire_etat(fichier, sonde, maintenant):
    """Le dernier état gardé pour cette sonde, ou None. Un état d'une autre sonde, ou d'avant la 0.12.141 qui ne gardait pas la
    sonde, ne vaut rien ici (D5), et un site recréé suit les ordres de sa nouvelle sonde dès le premier."""
    try:
        with open(fichier, encoding="utf-8") as f:
            e = json.load(f)
    except (OSError, ValueError):
        return None
    if not isinstance(e, dict) or e.get("sonde") != sonde:
        return None
    if e.get("connu") is True and e.get("niveau") in NIVEAUX and type(e.get("numero")) is int:
        normal = e["niveau"] == "normal"
        observation = e.get("observation")
        if observation is not None and (not normal or observation not in ("restreint", "maintenance")):
            return None
        if (normal and e.get("echeance") is None) or (not normal and _nombre(e.get("echeance"))):
            lu = {"sonde": sonde, "connu": True, "niveau": e["niveau"], "numero": e["numero"], "echeance": e.get("echeance")}
            return {**lu, "observation": observation} if observation else lu
        return None
    if e.get("connu") is False and _nombre(e.get("depuis")) and e["depuis"] <= maintenant:
        return {"sonde": sonde, "connu": False, "depuis": e["depuis"]}
    return None


def _niveau(etat, demarrage, maintenant):
    """Le niveau à appliquer maintenant, échéance comprise."""
    if etat["connu"]:
        return etat["niveau"] if etat["niveau"] == "normal" or maintenant < etat["echeance"] else "normal"
    return demarrage if demarrage == "normal" or maintenant < etat["depuis"] + ECHEANCES[demarrage] else "normal"


def _fin(etat, demarrage):
    """L'échéance du niveau appliqué, en secondes."""
    return etat["echeance"] if etat["connu"] else etat["depuis"] + ECHEANCES[demarrage]


def _horloge(entetes, maintenant):
    """L'écart de l'horloge de ce serveur avec celle de Manicou, lu dans l'en-tête Date de sa réponse (D14)."""
    date = {str(k).lower(): v for k, v in entetes.items()}.get("date")
    try:
        sienne = email.utils.parsedate_to_datetime(date).timestamp()
    except Exception:  # noqa: BLE001
        return "son heure s'écarte de plus de cinq minutes de celle de ce serveur, remettez l'horloge à l'heure"
    ecart = round(maintenant - sienne)
    if abs(ecart) <= manicou.TOLERANCE:
        return None
    sens = "avance" if ecart > 0 else "retarde"
    return f"l'horloge de ce serveur {sens} de {abs(ecart)} s sur celle de Manicou (en-tête Date), aucun état ne s'applique tant qu'elle n'est pas remise à l'heure"


def rafraichir(fichier_reglages, maintenant=None):
    with open(fichier_reglages, encoding="utf-8") as f:
        reglages = json.load(f)
    if not _adresse_sure(reglages["adresse"]):
        print("manicou, l'adresse doit être en https", file=sys.stderr)
        return 2
    demarrage = reglages.get("demarrage", "restreint")
    if demarrage not in NIVEAUX:
        print("manicou, demarrage vaut normal, restreint ou maintenance", file=sys.stderr)
        return 2
    dossier = reglages["dossier"]
    os.makedirs(dossier, exist_ok=True)
    fichier_etat = os.path.join(dossier, "etat.json")
    maintenant = time.time() if maintenant is None else maintenant
    avant = _lire_etat(fichier_etat, reglages["sonde"], maintenant)
    garde = avant or {"sonde": reglages["sonde"], "connu": False, "depuis": maintenant}

    erreur = None
    v = None
    url = reglages["adresse"] + "/sites/etat?sonde=" + urllib.parse.quote(reglages["sonde"], safe="")
    try:
        with urllib.request.urlopen(urllib.request.Request(url, headers={"accept": "application/json"}), timeout=DELAI) as reponse:
            entetes = dict(reponse.headers.items())
            corps = reponse.read(65536)
    except Exception as e:  # noqa: BLE001
        erreur = f"manicou, état illisible ({e.__class__.__name__})"
    else:
        v = manicou.verifier_etat(entetes, corps, reglages["cles"], reglages["domaine"], reglages["sonde"], garde["numero"] if garde["connu"] else 0, int(maintenant))
        if not v["ok"]:
            erreur = f"manicou, état refusé ({v['raison']})"
            ecart = _horloge(entetes, maintenant) if v["raison"] == "horodatage" else None
            if ecart:
                erreur += f", {ecart}"

    change = False
    if v and v["ok"]:
        niveau, numero, observation = v["etat"]["niveau"], v["etat"]["numero"], v["etat"].get("observation")
        echeance = None
        if niveau != "normal":
            signee = manicou._instant(v["etat"]["echeance"]) if v["etat"]["echeance"] else None
            echeance = min(maintenant + ECHEANCES[niveau], signee if signee is not None else float("inf"))
        precedent = garde if garde["connu"] else {"niveau": "normal", "numero": 0, "observation": None}
        change = (niveau, numero, observation) != (precedent["niveau"], precedent["numero"], precedent.get("observation"))
        garde = {"sonde": reglages["sonde"], "connu": True, "niveau": niveau, "numero": numero, "echeance": echeance}
        if observation:
            garde["observation"] = observation

    effectif = _niveau(garde, demarrage, maintenant)
    _poser(dossier, effectif)
    voulus = [f"{effectif}.{h}" for h in heures(maintenant, _fin(garde, demarrage))] if effectif != "normal" else []
    observation = garde.get("observation") if garde["connu"] and effectif == "normal" else None
    if observation:
        voulus += [f"observe-{observation}.{h}" for h in dict.fromkeys([heure(maintenant), heure(maintenant + HEURE)])]
    _poser_horaires(dossier, voulus)
    if garde != avant:
        _ecrire(fichier_etat, json.dumps(garde))
    if change:
        _accuser(reglages, garde)
        if observation:
            print(f"manicou, Manicou a mis le garde en observation du {observation}, le site reste ouvert", file=sys.stderr)
    erreur_page = _ecrire_pages(reglages, dossier)
    if erreur_page:
        print(erreur_page, file=sys.stderr)
    if erreur:
        tenu = garde["niveau"] if garde["connu"] else demarrage
        suite = "les drapeaux restent" if effectif == tenu else "l'échéance est passée, le site rouvre"
        print(f"{erreur}, {suite}", file=sys.stderr)
        return 1
    if v["etat"]["parti"]:
        print("manicou, Manicou ne suit plus ce site et lui sert l'état normal, retirez la recette (la règle du serveur d'abord)", file=sys.stderr)
    return 0


if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit("usage : python3 drapeau.py /etc/manicou.json")
    try:
        sys.exit(rafraichir(sys.argv[1]))
    except Exception as e:  # noqa: BLE001
        # Les drapeaux de l'heure s'éteignent seuls à leur échéance, même si ce script ne les efface plus (D21).
        print(f"manicou, drapeau.py a échoué ({e.__class__.__name__}), les drapeaux posés s'éteignent seuls à leur échéance", file=sys.stderr)
        sys.exit(1)
nginx.conf Voir le code
nginx.conf
# La recette nginx (pièce C23 de docs/CONSTRUCTION.md) : les drapeaux que pose drapeau.py, lus à chaque requête. nginx 1.18 ou plus.
# À inclure dans le bloc server { } du site, avant ses blocs location : include /etc/nginx/manicou.conf;
# Le dossier des drapeaux, $manicou_dossier plus bas, est celui de /etc/manicou.json, lisible par nginx. Un dossier par site,
# et deux sites d'un même serveur ont chacun le leur, chacun son fichier de réglages et son fichier inclus.
# Chaque drapeau porte son heure, à l'heure locale du serveur, celle où tourne drapeau.py (D21). drapeau.py pose ceux des heures
# qui viennent, jusqu'à l'échéance de l'état, six heures pour le restreint et quarante-huit pour la maintenance sans nouvelle de
# Manicou, et nginx ne lit que celui de l'heure en cours. Si drapeau.py cesse de tourner, le site rouvre seul à l'échéance.
# Les 503 de ces règles servent la page de maintenance que drapeau.py écrit dans le dossier, et portent l'en-tête X-Manicou, à
# quoi Manicou reconnaît l'effet de son ordre ; ceux du site ne le portent pas. nginx ne lit pas le numéro de l'ordre dans un
# drapeau, et l'en-tête ne porte que le niveau. Ces règles prennent le error_page 503 du bloc server : retirez le vôtre.
# Pour retirer la recette, retirez d'abord la ligne include et rechargez nginx, puis la ligne du cron et le dossier.

set $manicou_dossier "/var/lib/manicou";

# L'heure en cours, AAAAMMJJHH, et le niveau que ses drapeaux disent. « observe- » vient de l'interrupteur de Manicou : rien n'est
# refusé, et ce qui l'aurait été se note, si vous ajoutez à côté de votre propre access_log, dans le bloc server :
#   access_log /var/log/nginx/manicou-observation.log combined if=$manicou_observation;
set $manicou_heure "";
if ($time_iso8601 ~ "^(\d{4})-(\d{2})-(\d{2})T(\d{2})") {
    set $manicou_heure "$1$2$3$4";
}
set $manicou_etat "";
set $manicou_observe "";
if (-f "$manicou_dossier/restreint.$manicou_heure") {
    set $manicou_etat "restreint";
}
if (-f "$manicou_dossier/maintenance.$manicou_heure") {
    set $manicou_etat "maintenance";
}
if (-f "$manicou_dossier/observe-restreint.$manicou_heure") {
    set $manicou_etat "restreint";
    set $manicou_observe "o";
}
if (-f "$manicou_dossier/observe-maintenance.$manicou_heure") {
    set $manicou_etat "maintenance";
    set $manicou_observe "o";
}
# Le niveau du refus, gardé pour la page qui le sert après la redirection interne.
if ($uri != "/.manicou/page.html") {
    set $manicou_niveau "";
}
if ($request_uri ~ "^/\.manicou/page\.html") {
    set $manicou_niveau "";
}

# Ce qui passe toujours : robots.txt, et la route de santé du site, à ajouter sous robots.txt si elle existe, par exemple
#   if ($request_uri = "/api/sante") { set $manicou_ouvert "o"; }
# Demandés tels quels, en lecture, sans chaîne de requête ni mise à niveau ($request_uri est la requête brute, D16).
set $manicou_ouvert "";
if ($request_uri = "/robots.txt") {
    set $manicou_ouvert "o";
}
if ($request_method !~ ^(GET|HEAD)$) {
    set $manicou_ouvert "";
}
if ($http_upgrade) {
    set $manicou_ouvert "";
}

# restreint : ce qui n'est pas GET ou HEAD, une mise à niveau (D3), une méthode ou une adresse demandée par un en-tête ou par
# _method, dans chacune des écritures que PHP lit comme $_GET['_method'] (D8), …
set $manicou_r "";
if ($request_method !~ ^(GET|HEAD)$) {
    set $manicou_r "r";
}
if ($http_upgrade) {
    set $manicou_r "r";
}
if ($http_x_http_method_override) {
    set $manicou_r "r";
}
if ($http_x_http_method) {
    set $manicou_r "r";
}
if ($http_x_method_override) {
    set $manicou_r "r";
}
if ($http_x_middleware_subrequest) {
    set $manicou_r "r";
}
if ($http_x_original_url) {
    set $manicou_r "r";
}
if ($http_x_rewrite_url) {
    set $manicou_r "r";
}
if ($args ~* "(^|&)(\+|%20)*(_|\.|%5f|%2e)(m|%6d|%4d)(e|%65|%45)(t|%74|%54)(h|%68|%48)(o|%6f|%4f)(d|%64|%44)(=|&|\[|%5b|$)") {
    set $manicou_r "r";
}
# … un chemin qu'un serveur lirait autrement (D12) : un « / », un « \ » ou un « . » encodés dans la requête brute, et une fois
# décodé, ce qui reste encodé, un caractère de contrôle, « ; », « :: » ou « :$ », « ~ » suivi d'un chiffre, un segment de points et
# d'espaces, …
if ($request_uri ~* "^[^?]*%(2f|5c|2e)") {
    set $manicou_r "r";
}
if ($uri ~* "%[0-9a-f]{2}|[\x00-\x1f\x7f;]|::|:\x24|~[0-9]") {
    set $manicou_r "r";
}
if ($uri ~ "(^|/)[. ]*( |\.\.\.)[. ]*(/|$)") {
    set $manicou_r "r";
}
# … et les chemins sensibles (administration, connexion), quelle que soit leur casse. $uri est déjà décodé, ses « .. » résolus et
# ses « / » répétés réunis.
if ($uri ~* "^/+(admin|administrator|connexion|login|user/login|wp-admin|wp-login\.php)[. ]*(/|$)") {
    set $manicou_r "r";
}

# Le refus, s'il y en a un, puis sa page.
set $manicou_refus "";
set $manicou_m "$manicou_etat:$manicou_ouvert";
if ($manicou_m = "maintenance:") {
    set $manicou_refus "maintenance";
}
set $manicou_rr "$manicou_etat:$manicou_r:$manicou_ouvert";
if ($manicou_rr = "restreint:r:") {
    set $manicou_refus "restreint";
}
if ($uri = "/.manicou/page.html") {
    set $manicou_refus "";
}
set $manicou_fin "$manicou_refus:$manicou_observe";
if ($manicou_fin = "maintenance:") {
    set $manicou_niveau "maintenance";
    return 503;
}
if ($manicou_fin = "restreint:") {
    set $manicou_niveau "restreint";
    return 503;
}
set $manicou_observation "";
if ($manicou_fin ~ "^(maintenance|restreint):o$") {
    set $manicou_observation "$1";
}

# La page, servie en GET quelle que soit la méthode refusée (error_page vers une adresse la change), jamais rejugée.
error_page 503 /.manicou/page.html;
location = /.manicou/page.html {
    internal;
    root $manicou_dossier;
    charset utf-8;
    try_files /page-$manicou_niveau.html =503;
    add_header X-Manicou $manicou_niveau always;
    add_header Retry-After "300" always;
    add_header Cache-Control "no-store" always;
    add_header Content-Security-Policy "default-src 'none'; style-src 'unsafe-inline'; img-src data:; font-src data:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'" always;
    add_header X-Content-Type-Options "nosniff" always;
}
maintenance.html Voir le code
maintenance.html
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="robots" content="noindex">
<title>[Nom du site]</title>
<style>
*{box-sizing:border-box}
body{margin:0;background:#fff;color:#171717;font:16px/1.6 system-ui,-apple-system,"Segoe UI",sans-serif;text-align:center}
header{padding:40px 24px 0}
.logo{width:72px;height:72px;margin:0 auto;border-radius:16px;background:#171717}
.nom{margin:12px 0 0;font-size:1.125rem;font-weight:600}
main{max-width:40rem;margin:0 auto;padding:48px 24px}
h1{margin:0 0 16px;font-size:2.5rem;line-height:1.15;font-weight:600;letter-spacing:-.02em}
p{margin:0}
.phrase,.joindre,.manicou{color:#4d4d4d}
.joindre{margin-top:40px;font-size:.9375rem}
.contact{display:flex;flex-direction:column;align-items:center;gap:8px;margin-top:8px}
a{color:inherit;font-size:1.125rem;text-underline-offset:.25em}
footer{padding:0 24px 40px;font-size:.875rem}
@media (max-width:640px){header{padding-top:28px}.logo{width:56px;height:56px}main{padding:32px 20px}h1{font-size:1.75rem}}
</style>
</head>
<body>
<header>
<!-- Votre logo à la place de ce carré, en image intégrée (data:) -->
<div class="logo"></div>
<p class="nom">[Nom du site]</p>
</header>
<main>
<h1>[Nom du site] vous protège.</h1>
<p class="phrase" id="manicou-phrase">Une faille de sécurité qui touche de nombreux sites est en cours.<br>Nous attendons son correctif pour reprendre le service.</p>
<p class="joindre">Pour nous joindre</p>
<p class="contact"><a href="tel:[numéro sans espace]">[téléphone]</a><a href="mailto:[e-mail]">[e-mail]</a></p>
</main>
<footer>
<p class="manicou">Site protégé par Manicou</p>
</footer>
</body>
</html>

L’essai

Lancez-le depuis l’espace client, il vérifie la recette en direct.

Poser la recette