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.
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 name
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" }Run the guard every minute
crontab* * * * * www-data python3 /opt/manicou/drapeau.py /etc/manicou.jsonConnect Apache
apache.confat the top of the site’s.htaccess- From
.htaccess, the page is served under the site root, hencepagesin/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.