nginx
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.
Copy the files
manicou.pyanddrapeau.pyin/opt/manicou/maintenance.en.htmlin the same folder, the page your visitors will see, to fill in with your namenginx.confas/etc/nginx/manicou.conf
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" }Run the guard every minute
crontab* * * * * www-data python3 /opt/manicou/drapeau.py /etc/manicou.jsonConnect nginx
in the server blockinclude /etc/nginx/manicou.conf;nginx -s reload
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)
nginx.conf View the 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.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.