Apache

Your server checks every minute whether Manicou is asking it to protect itself.

In the client area, this code is already filled in for your site.

  1. Copy the files

    • manicou.py and drapeau.py in /opt/manicou/
    • maintenance.en.html in the same folder, the page your visitors will see, to fill in with your name
  2. Create /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.en.html",
      "pages": "/path/to/site/.manicou"
    }
  3. Run the guard every minute

    crontab
    * * * * * www-data python3 /opt/manicou/drapeau.py /etc/manicou.json
  4. Connect Apache

    • apache.conf at the top of the site’s .htaccess
    • From .htaccess, the page is served under the site root, hence pages in /etc/manicou.json

The files

manicou.py View the 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 View the 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)
apache.conf View the code
apache.conf
# La recette Apache (pièce C23 de docs/CONSTRUCTION.md) : les drapeaux que pose drapeau.py, lus à chaque requête. Apache 2.4.13 ou
# plus, mod_rewrite, et mod_headers pour Retry-After et X-Manicou.
# À mettre de préférence dans le VirtualHost du site : là, aucune règle d'un dossier ne la contourne. À défaut, en tête du
# .htaccess de la racine : RewriteOptions InheritDownBefore l'applique aussi aux dossiers qui ont leur propre RewriteEngine On.
# Le dossier des drapeaux, MANICOU_DOSSIER plus bas, est celui de /etc/manicou.json, lisible par Apache. Un dossier par site, et
# deux sites d'un même serveur ont chacun le leur.
# 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 Apache 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 (page-maintenance.html, page-restreint.html), et portent
# l'en-tête X-Manicou, à quoi Manicou reconnaît l'effet de son ordre ; ceux du site ne le portent pas. Apache ne lit pas le
# numéro de l'ordre dans un drapeau, et l'en-tête ne porte que le niveau.
# Pour retirer la recette, retirez d'abord ces règles et rechargez Apache, puis la ligne du cron et le dossier.

RewriteEngine On
RewriteOptions InheritDownBefore

# La page de Manicou, servie après le refus par une redirection interne : rien ne s'y rejuge.
RewriteCond %{ENV:REDIRECT_STATUS} =503
RewriteRule ^ - [L]

RewriteRule ^ - [E=MANICOU_DOSSIER:/var/lib/manicou]

# Le niveau de l'heure en cours, AAAAMMJJHH. « observe- » vient de l'interrupteur de Manicou : rien n'est refusé, et ce qui l'aurait
# été se note, dans le VirtualHost, par
#   CustomLog "logs/manicou-observation.log" combined env=MANICOU_OBSERVATION
RewriteCond %{ENV:MANICOU_DOSSIER}/restreint.%{TIME_YEAR}%{TIME_MON}%{TIME_DAY}%{TIME_HOUR} -f
RewriteRule ^ - [E=MANICOU_ETAT:restreint]
RewriteCond %{ENV:MANICOU_DOSSIER}/maintenance.%{TIME_YEAR}%{TIME_MON}%{TIME_DAY}%{TIME_HOUR} -f
RewriteRule ^ - [E=MANICOU_ETAT:maintenance]
RewriteCond %{ENV:MANICOU_DOSSIER}/observe-restreint.%{TIME_YEAR}%{TIME_MON}%{TIME_DAY}%{TIME_HOUR} -f
RewriteRule ^ - [E=MANICOU_ETAT:restreint,E=MANICOU_OBSERVE:1]
RewriteCond %{ENV:MANICOU_DOSSIER}/observe-maintenance.%{TIME_YEAR}%{TIME_MON}%{TIME_DAY}%{TIME_HOUR} -f
RewriteRule ^ - [E=MANICOU_ETAT:maintenance,E=MANICOU_OBSERVE:1]

# Ce qui passe toujours : robots.txt, et la route de santé du site, à ajouter à la liste si elle existe, par exemple
# (robots\.txt|api/sante). Demandés tels quels, en lecture, sans chaîne de requête ni mise à niveau (D16).
RewriteCond %{THE_REQUEST} "^(GET|HEAD) /(robots\.txt) HTTP/"
RewriteCond %{HTTP:Upgrade} ^$
RewriteRule ^ - [E=MANICOU_OUVERT:1]

# 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), 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, et les chemins sensibles (administration,
# connexion), quelle que soit leur casse. %{REQUEST_URI} est le chemin entier et décodé, dans le VirtualHost comme dans un .htaccess.
RewriteCond %{REQUEST_METHOD} !^(GET|HEAD)$ [OR]
RewriteCond %{HTTP:Upgrade} . [OR]
RewriteCond %{HTTP:X-HTTP-Method-Override} . [OR]
RewriteCond %{HTTP:X-HTTP-Method} . [OR]
RewriteCond %{HTTP:X-Method-Override} . [OR]
RewriteCond %{HTTP:X-Middleware-Subrequest} . [OR]
RewriteCond %{HTTP:X-Original-URL} . [OR]
RewriteCond %{HTTP:X-Rewrite-URL} . [OR]
RewriteCond %{QUERY_STRING} "(^|&)(\+|%20)*(_|\.|%5f|%2e)(m|%6d|%4d)(e|%65|%45)(t|%74|%54)(h|%68|%48)(o|%6f|%4f)(d|%64|%44)(=|&|\[|%5b|$)" [NC,OR]
RewriteCond %{THE_REQUEST} "^\S+\s+[^?\s]*%(2f|5c|2e)" [NC,OR]
RewriteCond %{REQUEST_URI} "%[0-9a-f]{2}|[\x00-\x1f\x7f;]|::|:\x24|~[0-9]" [NC,OR]
RewriteCond %{REQUEST_URI} "(^|/)[. ]*( |\.\.\.)[. ]*(/|$)" [OR]
RewriteCond %{REQUEST_URI} "^/+(admin|administrator|connexion|login|user/login|wp-admin|wp-login\.php)[. ]*(/|$)" [NC]
RewriteRule ^ - [E=MANICOU_R:1]

# Le refus, s'il y en a un.
RewriteCond %{ENV:MANICOU_ETAT} =maintenance
RewriteCond %{ENV:MANICOU_OUVERT} !=1
RewriteRule ^ - [E=MANICOU_REFUS:maintenance]
RewriteCond %{ENV:MANICOU_ETAT} =restreint
RewriteCond %{ENV:MANICOU_R} =1
RewriteCond %{ENV:MANICOU_OUVERT} !=1
RewriteRule ^ - [E=MANICOU_REFUS:restreint]
RewriteCond %{ENV:MANICOU_OBSERVE} !=1
RewriteCond %{ENV:MANICOU_REFUS} ^(maintenance|restreint)$
RewriteRule ^ - [R=503,L,E=MANICOU:%1]
RewriteCond %{ENV:MANICOU_OBSERVE} =1
RewriteCond %{ENV:MANICOU_REFUS} ^(maintenance|restreint)$
RewriteRule ^ - [E=MANICOU_OBSERVATION:%1]

# La page, servie quelle que soit la méthode refusée. Dans un .htaccess, elle doit être sous la racine du site : donnez à drapeau.py
# le réglage "pages", par exemple "/var/www/monsite/.manicou". Dans le VirtualHost, elle se lit dans le dossier des drapeaux, avec
#   AliasMatch "^/\.manicou/page-(maintenance|restreint)\.html$" "/var/lib/manicou/page-$1.html"
#   <Directory "/var/lib/manicou">
#       Require all granted
#   </Directory>
ErrorDocument 503 /.manicou/page-%{reqenv:MANICOU}.html
<IfModule mod_headers.c>
    Header always set Retry-After "300" "expr=%{REQUEST_STATUS} == 503"
    Header always set X-Manicou "%{MANICOU}e" env=MANICOU
    # La page passe par une redirection interne, qui préfixe la variable.
    Header always set X-Manicou "%{REDIRECT_MANICOU}e" env=REDIRECT_MANICOU
    Header always set Cache-Control "no-store" env=REDIRECT_MANICOU
    Header always set 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'" env=REDIRECT_MANICOU
    Header always set X-Content-Type-Options "nosniff" env=REDIRECT_MANICOU
</IfModule>
maintenance.en.html View the code
maintenance.en.html
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="robots" content="noindex">
<title>[Site name]</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>
<!-- Your logo in place of this square, as an embedded image (data:) -->
<div class="logo"></div>
<p class="nom">[Site name]</p>
</header>
<main>
<h1>[Site name] is protecting you.</h1>
<p class="phrase" id="manicou-phrase">A security vulnerability affecting many websites is under way.<br>We are waiting for its fix to resume service.</p>
<p class="joindre">To reach us</p>
<p class="contact"><a href="tel:[number without spaces]">[phone]</a><a href="mailto:[email]">[email]</a></p>
</main>
<footer>
<p class="manicou">Site protected by Manicou</p>
</footer>
</body>
</html>

The test

Run it from the client area: it checks the recipe live.

Install the recipe