PHP

Your site checks at most once a minute whether Manicou is asking it to protect itself.

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

This guard runs inside PHP: a flaw in PHP itself, such as PHP2SHELL, can get past it. If you can, install the nginx, Apache or Cloudflare recipe instead, in front of PHP.

  1. Copy the files

    • manicou.php and garde.php in the site’s manicou/ folder
    • maintenance.en.html in the same folder, the page your visitors will see, to fill in with your name
    • chargeur.php next to that folder, never inside it. Without the folder or its settings it does nothing, and the site keeps working
  2. Create manicou/reglages.php

    manicou/reglages.php
    <?php
    return [
      'sonde' => 'snd_…',
      'domaine' => '…',
      'adresse' => 'https://app.manicou.dev/api/v1',
      'cles' => ['k1' => '…'],
      'page' => __DIR__ . '/maintenance.en.html',
    ];
  3. Load the guard before the site

    php.ini
    auto_prepend_file = /path/to/site/chargeur.php
    or at the top of index.php
    require __DIR__ . '/chargeur.php';

The files

manicou.php View the code
manicou.php
<?php
// 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 : l'extension sodium, livrée avec PHP depuis la 7.2, suffit. PHP 8 ou plus.
//
// 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.

declare(strict_types=1);

const MANICOU_TOLERANCE = 300; // secondes d'écart permises entre l'horloge du site et l'heure de signature
const MANICOU_NIVEAUX = ['normal', 'restreint', 'maintenance'];

function manicou_octets(string $base64): ?string
{
    if (!preg_match('#^[A-Za-z0-9+/]*={0,2}$#', $base64) || strlen($base64) % 4 !== 0) return null;
    $octets = base64_decode($base64, true);
    return $octets === false ? null : $octets;
}

function manicou_signe(string $message, string $signatures, array $cles): bool
{
    foreach (explode(' ', $signatures) as $s) {
        if (!str_starts_with($s, 'v1a,')) continue;
        $signature = manicou_octets(substr($s, 4));
        if ($signature === null || strlen($signature) !== SODIUM_CRYPTO_SIGN_BYTES) continue;
        foreach ($cles as $cle) {
            $brute = manicou_octets((string) $cle);
            if ($brute === null || strlen($brute) !== SODIUM_CRYPTO_SIGN_PUBLICKEYBYTES) continue;
            if (sodium_crypto_sign_verify_detached($signature, $message, $brute)) return true;
        }
    }
    return false;
}

/**
 * $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 null
 * 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.
 */
function manicou_verifier_etat(array $entetes, string $corps, array $cles, string $domaine, string $sonde, int $dernierNumero = 0, ?int $maintenant = null): array
{
    $maintenant ??= time();
    $entetes = array_change_key_case($entetes, CASE_LOWER);
    $id = (string) ($entetes['webhook-id'] ?? '');
    $horodatage = (string) ($entetes['webhook-timestamp'] ?? '');
    $signatures = (string) ($entetes['webhook-signature'] ?? '');
    if ($id === '' || $signatures === '' || !preg_match('/^[0-9]{1,12}$/', $horodatage)) return ['ok' => false, 'raison' => 'entetes'];
    if (abs($maintenant - (int) $horodatage) > MANICOU_TOLERANCE) return ['ok' => false, 'raison' => 'horodatage'];
    if (!manicou_signe("$id.$horodatage.$corps", $signatures, $cles)) return ['ok' => false, 'raison' => 'signature'];

    $e = json_decode($corps, true);
    $expire = is_array($e) && is_string($e['expireLe'] ?? null) ? strtotime($e['expireLe']) : false;
    if (!is_array($e) || !is_string($e['sonde'] ?? null) || !is_string($e['domaine'] ?? null) || !in_array($e['niveau'] ?? null, MANICOU_NIVEAUX, true)
        || !is_int($e['numero'] ?? null) || !is_bool($e['essai'] ?? null) || $expire === false) {
        return ['ok' => false, 'raison' => 'corps'];
    }
    $echeance = $e['echeance'] ?? null;
    if ($echeance !== null && (!is_string($echeance) || strtotime($echeance) === false)) return ['ok' => false, 'raison' => 'corps'];
    if (array_key_exists('parti', $e) && !is_bool($e['parti'])) return ['ok' => false, 'raison' => 'corps'];
    if (array_key_exists('observation', $e) && ($e['niveau'] !== 'normal' || !in_array($e['observation'], ['restreint', 'maintenance'], true))) return ['ok' => false, 'raison' => 'corps'];
    if (strtolower($e['domaine']) !== strtolower($domaine)) return ['ok' => false, 'raison' => 'domaine'];
    if ($e['sonde'] !== $sonde) return ['ok' => false, 'raison' => 'sonde'];
    if ($expire <= $maintenant) return ['ok' => false, 'raison' => 'expire'];
    if ($e['numero'] < $dernierNumero) return ['ok' => false, 'raison' => 'numero'];
    return ['ok' => true, 'etat' => ['niveau' => $e['niveau'], 'numero' => $e['numero'], 'essai' => $e['essai'], 'expireLe' => $e['expireLe'], 'echeance' => $echeance, 'parti' => ($e['parti'] ?? false) === true, 'observation' => $e['observation'] ?? null]];
}
garde.php View the code
garde.php
<?php
// Le garde des sites PHP (pièce C23 de docs/CONSTRUCTION.md). À charger avant tout le reste, par chargeur.php, posé à côté du
// dossier manicou/ et nommé par auto_prepend_file (dans php.ini, ou « php_value auto_prepend_file /chemin/chargeur.php » dans
// le .htaccess), ou en tête d'index.php. Le chargeur ne fait rien si ce dossier ou ses réglages manquent, et le site marche
// toujours. PHP 8 ou plus, sans paquet. Ses réglages sont dans reglages.php, posé à côté (voir reglages.exemple.php).
//
// - normal : tout passe ;
// - restreint : le site reste lisible ; ce qui n'est pas GET ou HEAD, une mise à niveau, une méthode ou une adresse demandée par
//   un paramètre ou un en-tête, un chemin qu'un serveur lirait autrement, et les chemins sensibles (administration, connexion),
//   répondent 503 ;
// - maintenance : tout répond 503.
//
// L'état se relit au plus une fois par minute, par la première requête qui le trouve trop vieux, ou par cron
// (« php garde.php rafraichir »), et se garde dans un fichier, dans un dossier à soi seul : etat/, à côté de ce fichier,
// sinon un dossier privé du dossier temporaire. Le fichier garde le dernier état vérifié avec sa sonde et son échéance. Un état
// refusé, une panne de Manicou ou un réseau coupé ne changent rien jusqu'à cette échéance (D-111), six heures pour le restreint
// et quarante-huit pour la maintenance, que chaque lecture renouvelle. Passée l'échéance sans nouvelle de Manicou, le site
// rouvre. Sans aucun état valable, le garde part fermé, en restreint par défaut (« demarrage »), le temps d'une lecture si
// Manicou répond, six heures au plus sinon, et réessaie toutes les dix secondes. robots.txt et la route de santé donnée dans
// « sante », demandés tels quels en lecture, passent toujours. En maintenance, le garde répond lui-même à robots.txt, car PHP qui
// le sert veut dire que le site le produit, et le site ne doit pas tourner.
//
// Un état normal qui porte « observation » vient de l'interrupteur de Manicou (D-145) : le site reste ouvert, et le garde note au
// journal de PHP ce que le niveau observé aurait refusé. Une erreur du garde laisse passer la requête et se dit au journal (D21).

declare(strict_types=1);

if (!is_file(__DIR__ . '/manicou.php')) {
    error_log('[manicou] manicou.php manque à côté de garde.php, le garde laisse passer le site. Recopiez le dossier manicou/ en entier.');
    return;
}
require_once __DIR__ . '/manicou.php';

const MANICOU_LECTURES = ['GET', 'HEAD'];
const MANICOU_REESSAI = 10;
const MANICOU_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.
const MANICOU_ECHEANCES = ['restreint' => 6 * MANICOU_HEURE, 'maintenance' => 48 * MANICOU_HEURE];
// Une ligne d'observation par cause, toutes les dix minutes au plus.
const MANICOU_AVIS_OBSERVATION = 600;
// Ce que le garde répond à robots.txt en maintenance. Rien n'est interdit, et chaque page répond 503.
const MANICOU_ROBOTS = "User-agent: *\nDisallow:\n";
const MANICOU_CHEMINS_SENSIBLES = ['/admin', '/administrator', '/connexion', '/login', '/user/login', '/wp-admin', '/wp-login.php'];
const MANICOU_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.',
];
// Les en-têtes qui demandent une autre méthode à un cadriciel (D8). L'API REST de WordPress et Slim 4 les lisent même sur un GET,
// et l'OWASP CRS les refuse. En restreint, une requête qui en porte un répond 503.
const MANICOU_ENTETES_DE_METHODE = ['x-http-method-override', 'x-http-method', 'x-method-override', 'x-middleware-subrequest'];
// Les en-têtes qui donnent une autre adresse que la requête (d'anciens Symfony et Zend, IIS). Leur adresse se juge comme la sienne.
const MANICOU_ENTETES_DE_REECRITURE = ['x-original-url', 'x-rewrite-url'];
const MANICOU_CAUSES = [
    'maintenance' => 'maintenance',
    'ecriture' => 'écriture',
    'mise-a-niveau' => 'mise à niveau',
    'methode' => 'méthode demandée par un paramètre ou un en-tête',
    'reecriture' => 'adresse donnée par un en-tête',
    'ambigu' => 'chemin qu\'un serveur lirait autrement',
    'sensible' => 'chemin sensible',
];
// La page de maintenance de Manicou (maintenance.html, ou maintenance.en.html, une fois le nom et le contact du site remplis). Le
// site qui donne son chemin dans « page » la sert à la place du message. Telle quelle en maintenance. En restreint, la phrase
// de son élément id="manicou-phrase" devient celle du mode restreint, dans la langue de la page, ou « phrase_restreint ».
const MANICOU_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.',
];
// La page ne charge ni script ni fichier d'ailleurs. Son style est dans la page, ses images et ses polices en data.
const MANICOU_CSP_PAGE = "default-src 'none'; style-src 'unsafe-inline'; img-src data:; font-src data:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";

/**
 * Une cible de requête (« /chemin?requête », ou « http://hôte/chemin?requête ») en ['chemin', 'requete'], sans fragment, et sans
 * la lire par parse_url, qui prend « //wp-admin/x » pour un hôte suivi de « /x ».
 */
function manicou_decouper(string $cible): array
{
    if (preg_match('#^[a-z][a-z0-9+.\-]*://[^/?\#]*#i', $cible, $m)) $cible = substr($cible, strlen($m[0]));
    $cible = explode('#', $cible, 2)[0];
    $morceaux = explode('?', $cible, 2);
    return ['chemin' => $morceaux[0] === '' ? '/' : $morceaux[0], 'requete' => $morceaux[1] ?? ''];
}

/**
 * Le chemin canonisé une fois, et ce qu'il a d'ambigu (D12), comme garde.mjs : décodé une fois, « \ » lu comme « / », les « / »
 * répétés réunis, « . » et « .. » résolus, les points et espaces qui finissent un segment ôtés, en minuscules. Ambigu, ce qu'un
 * serveur ou un système de fichiers lirait autrement : un « / », un « \ » ou un « . » encodés, un encodage cassé ou qui reste après
 * le décodage, des octets qui ne sont pas de l'UTF-8, un caractère de contrôle, « ; », « :: » ou « :$ », « ~ » suivi d'un chiffre,
 * un segment fait de points et d'espaces autre que « . » et « .. ». En restreint, un chemin ambigu répond 503.
 */
function manicou_canoniser(string $brut): array
{
    $ambigu = preg_match('/%(2f|5c|2e)/i', $brut) === 1 || preg_match('/%(?![0-9a-f]{2})/i', $brut) === 1;
    $d = rawurldecode($brut);
    if (preg_match('//u', $d) !== 1) $ambigu = true;
    if (preg_match('/%[0-9a-f]{2}/i', $d) === 1 || preg_match('/[\x00-\x1f\x7f]/', $d) === 1 || str_contains($d, ';') || preg_match('/::|:\$/', $d) === 1 || preg_match('/~[0-9]/', $d) === 1) $ambigu = true;
    $pile = [];
    foreach (explode('/', str_replace('\\', '/', $d)) as $segment) {
        if ($segment === '' || $segment === '.') continue;
        if ($segment === '..') {
            array_pop($pile);
            continue;
        }
        if (preg_match('/^[. ]+$/', $segment) === 1) {
            $ambigu = true;
            continue;
        }
        $pile[] = strtolower(rtrim($segment, '. '));
    }
    return ['chemin' => '/' . implode('/', $pile), 'ambigu' => $ambigu];
}

/** Le chemin d'une cible, canonisé, sans dire s'il est ambigu. Jamais parse_url (audit du 10 novembre 2026, S6). */
function manicou_normaliser(string $uri): string
{
    return manicou_canoniser(manicou_decouper($uri)['chemin'])['chemin'];
}

/** L'utilisateur de ce processus, si l'extension posix le dit. */
function manicou_uid(): ?int
{
    return function_exists('posix_geteuid') ? posix_geteuid() : null;
}

/**
 * Un dossier à soi : pas un lien, à ce processus, où il peut écrire ; s'il est privé, fermé aux autres (0700). Un voisin
 * d'hébergement ne peut donc ni lire ni remplacer l'état (audit du 10 novembre 2026, S8).
 */
function manicou_dossier_sur(string $dossier, bool $prive): bool
{
    if (!is_dir($dossier) && !@mkdir($dossier, 0700, true) && !is_dir($dossier)) return false;
    clearstatcache(true, $dossier);
    if (is_link($dossier) || !is_writable($dossier)) return false;
    $uid = manicou_uid();
    if ($uid !== null && fileowner($dossier) !== $uid) return false;
    return !$prive || (fileperms($dossier) & 0077) === 0;
}

/** Le fichier de l'état : celui des réglages, sinon etat/ à côté de ce fichier, sinon un dossier privé du dossier temporaire. */
function manicou_fichier(array $r): ?string
{
    if (isset($r['fichier'])) return manicou_dossier_sur(dirname((string) $r['fichier']), false) ? (string) $r['fichier'] : null;
    foreach ([__DIR__ . '/etat', sys_get_temp_dir() . '/manicou-' . substr(hash('sha256', __DIR__), 0, 16)] as $dossier) {
        if (manicou_dossier_sur($dossier, true)) return $dossier . '/etat.json';
    }
    return null;
}

/**
 * Le dernier état gardé pour cette sonde. Vérifié, ['connu' => true, 'niveau', 'numero', 'echeance' (null en normal), …] ; sans
 * état vérifié, ['connu' => false, 'depuis' => l'heure du départ, 0 avant le premier]. Un état gardé pour une autre sonde, ou par
 * une recette 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. Un état normal peut garder le niveau qu'il observe (« observation »).
 */
function manicou_etat_garde(string $fichier, string $sonde): array
{
    $vide = ['sonde' => $sonde, 'connu' => false, 'depuis' => 0, 'luLe' => 0, 'horlogeLe' => 0];
    clearstatcache(true, $fichier);
    $uid = manicou_uid();
    if (!is_file($fichier) || is_link($fichier) || ($uid !== null && fileowner($fichier) !== $uid)) return $vide;
    $e = json_decode((string) @file_get_contents($fichier), true);
    if (!is_array($e) || ($e['sonde'] ?? null) !== $sonde) return $vide;
    $lu = ['luLe' => is_int($e['luLe'] ?? null) ? $e['luLe'] : 0, 'horlogeLe' => is_int($e['horlogeLe'] ?? null) ? $e['horlogeLe'] : 0];
    if (($e['connu'] ?? null) === true && in_array($e['niveau'] ?? null, MANICOU_NIVEAUX, true) && is_int($e['numero'] ?? null)) {
        $echeance = $e['echeance'] ?? null;
        $normal = $e['niveau'] === 'normal';
        $observation = $e['observation'] ?? null;
        if ($observation !== null && (!$normal || !in_array($observation, ['restreint', 'maintenance'], true))) return $vide;
        if (($normal && $echeance === null) || (!$normal && is_int($echeance))) {
            return ['sonde' => $sonde, 'connu' => true, 'niveau' => $e['niveau'], 'numero' => $e['numero'], 'echeance' => $echeance, 'observation' => $observation] + $lu;
        }
        return $vide;
    }
    if (($e['connu'] ?? null) === false && is_int($e['depuis'] ?? null) && $e['depuis'] <= time()) return ['sonde' => $sonde, 'connu' => false, 'depuis' => $e['depuis']] + $lu;
    return $vide;
}

/** Le niveau à appliquer à l'instant $t, échéance comprise. */
function manicou_niveau(array $etat, string $demarrage, int $t): string
{
    if ($etat['connu']) return ($etat['niveau'] === 'normal' || $t < $etat['echeance']) ? $etat['niveau'] : 'normal';
    $depuis = $etat['depuis'] ?: $t;
    return ($demarrage === 'normal' || $t < $depuis + MANICOU_ECHEANCES[$demarrage]) ? $demarrage : 'normal';
}

/** L'écart de l'horloge de ce serveur avec celle de Manicou, lu dans l'en-tête Date de sa réponse (D14). */
function manicou_horloge(?string $date, int $t): string
{
    $sienne = is_string($date) ? strtotime($date) : false;
    if ($sienne === false) return '[manicou] L\'état de Manicou est refusé, son heure s\'écarte de plus de cinq minutes de celle de ce serveur. Remettez l\'horloge du serveur à l\'heure.';
    $ecart = $t - $sienne;
    return sprintf('[manicou] L\'horloge de ce serveur %s de %d s sur celle de Manicou (en-tête Date). Aucun état ne s\'applique tant qu\'elle n\'est pas remise à l\'heure.', $ecart > 0 ? 'avance' : 'retarde', abs($ecart));
}

/** L'en-tête X-Manicou du 503, avec le niveau, le numéro de l'ordre appliqué et l'empreinte de la sonde (D11). */
function manicou_entete(string $niveau, array $etat, array $r): string
{
    return $niveau . '; numero=' . ($etat['connu'] ? $etat['numero'] : 0) . '; sonde=' . substr(hash('sha256', (string) $r['sonde']), 0, 8);
}

function manicou_garder_etat(string $fichier, array $etat): void
{
    $provisoire = $fichier . '.' . getmypid() . '.tmp';
    if (@file_put_contents($provisoire, json_encode($etat)) !== false) {
        @chmod($provisoire, 0600);
        @rename($provisoire, $fichier);
    }
}

function manicou_entetes(array $lignes): array
{
    $entetes = [];
    foreach ($lignes as $ligne) {
        if (!str_contains($ligne, ':')) continue;
        [$nom, $valeur] = explode(':', $ligne, 2);
        $entetes[strtolower(trim($nom))] = trim($valeur);
    }
    return $entetes;
}

/** Rend [en-têtes, corps], ou null si Manicou ne répond pas 200. Par cURL s'il est là, sinon par les flux de PHP. */
function manicou_lire(string $url, int $delai): ?array
{
    if (function_exists('curl_init')) {
        $lignes = [];
        $c = curl_init($url);
        curl_setopt_array($c, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => $delai,
            CURLOPT_HTTPHEADER => ['Accept: application/json'],
            CURLOPT_HEADERFUNCTION => function ($c, string $ligne) use (&$lignes): int {
                $lignes[] = $ligne;
                return strlen($ligne);
            },
        ]);
        $corps = curl_exec($c);
        $statut = curl_getinfo($c, CURLINFO_RESPONSE_CODE);
        return is_string($corps) && $statut === 200 ? [manicou_entetes($lignes), $corps] : null;
    }
    $contexte = stream_context_create(['http' => ['timeout' => $delai, 'ignore_errors' => true, 'header' => "Accept: application/json\r\n"]]);
    $corps = @file_get_contents($url, false, $contexte);
    $lignes = function_exists('http_get_last_response_headers') ? (http_get_last_response_headers() ?? []) : ($http_response_header ?? []);
    if ($corps === false || !preg_match('#^HTTP/\S+\s+200\b#', $lignes[0] ?? '')) return null;
    return [manicou_entetes(array_slice($lignes, 1)), $corps];
}

/** L'accusé est indicatif : Manicou constate l'effet de l'extérieur. Une erreur ici ne change rien. */
function manicou_accuser(array $r, array $etat): void
{
    $corps = (string) json_encode(['sonde' => $r['sonde'], 'numero' => $etat['numero'], 'niveau' => $etat['niveau'], 'applique' => true]);
    $url = $r['adresse'] . '/sites/accuses';
    $delai = (int) ($r['delai'] ?? 2);
    if (function_exists('curl_init')) {
        $c = curl_init($url);
        curl_setopt_array($c, [CURLOPT_RETURNTRANSFER => true, CURLOPT_TIMEOUT => $delai, CURLOPT_POST => true, CURLOPT_POSTFIELDS => $corps, CURLOPT_HTTPHEADER => ['Content-Type: application/json']]);
        curl_exec($c);
        return;
    }
    @file_get_contents($url, false, stream_context_create(['http' => ['method' => 'POST', 'timeout' => $delai, 'ignore_errors' => true, 'header' => "Content-Type: application/json\r\n", 'content' => $corps]]));
}

/** Relit l'état sur Manicou, une requête à la fois (un verrou). Rend le dernier état gardé, renouvelé si Manicou a répondu. */
function manicou_rafraichir(array $r): array
{
    $verrou = @fopen($r['fichier'] . '.verrou', 'c');
    if ($verrou === false || !flock($verrou, LOCK_EX | LOCK_NB)) return manicou_etat_garde($r['fichier'], (string) $r['sonde']); // un autre relit déjà
    try {
        $t = time();
        $etat = manicou_etat_garde($r['fichier'], (string) $r['sonde']);
        if (!$etat['connu'] && $etat['depuis'] === 0) $etat['depuis'] = $t;
        $etat['luLe'] = $t;
        $reponse = manicou_lire($r['adresse'] . '/sites/etat?sonde=' . rawurlencode($r['sonde']), (int) ($r['delai'] ?? 2));
        $v = $reponse === null ? ['ok' => false, 'raison' => 'illisible'] : manicou_verifier_etat($reponse[0], $reponse[1], $r['cles'], $r['domaine'], $r['sonde'], $etat['connu'] ? $etat['numero'] : 0, $t);
        $change = false;
        if ($v['ok']) {
            $niveau = $v['etat']['niveau'];
            $numero = $v['etat']['numero'];
            $observation = $v['etat']['observation'] ?? null;
            // Renouvelée à chaque lecture, jamais au-delà de six ou quarante-huit heures, même si Manicou signe plus loin.
            $echeance = null;
            if ($niveau !== 'normal') {
                $echeance = $t + MANICOU_ECHEANCES[$niveau];
                $signee = is_string($v['etat']['echeance']) ? strtotime($v['etat']['echeance']) : false;
                if ($signee !== false && $signee < $echeance) $echeance = $signee;
            }
            $avant = $etat['connu'] ? [$etat['niveau'], $etat['numero'], $etat['observation'] ?? null] : ['normal', 0, null];
            $change = [$niveau, $numero, $observation] !== $avant;
            $etat = ['sonde' => $r['sonde'], 'connu' => true, 'niveau' => $niveau, 'numero' => $numero, 'echeance' => $echeance, 'observation' => $observation, 'luLe' => $t, 'horlogeLe' => $etat['horlogeLe']];
            if ($change && $v['etat']['parti']) error_log('[manicou] Manicou ne suit plus ce site, et lui sert l\'état normal. Retirez la recette de Manicou, la directive qui charge le garde d\'abord, puis ses fichiers.');
            if ($change && $observation !== null) error_log("[manicou] Manicou a mis le garde en observation du $observation. Le site reste ouvert, et ce que le $observation aurait refusé se note ici.");
        } elseif ($v['raison'] === 'horodatage' && $t - $etat['horlogeLe'] >= MANICOU_HEURE) {
            $etat['horlogeLe'] = $t;
            error_log(manicou_horloge($reponse[0]['date'] ?? null, $t));
        }
        // Gardé même sans changement : l'heure de lecture fait attendre avant le prochain essai.
        manicou_garder_etat($r['fichier'], $etat);
        if ($change) manicou_accuser($r, $etat);
        return $etat;
    } finally {
        flock($verrou, LOCK_UN);
        fclose($verrou);
    }
}

function manicou_sensible(string $chemin, array $prefixes): bool
{
    foreach ($prefixes as $p) {
        $p = manicou_normaliser($p);
        if ($chemin === $p || str_starts_with($chemin, $p . '/')) return true;
    }
    return false;
}

/** Les paramètres de la chaîne de requête, nommés comme PHP les lit dans $_GET, le nom en minuscules, les valeurs en textes. */
function manicou_parametres(string $requete): array
{
    if ($requete === '') return [];
    $lus = [];
    @parse_str($requete, $lus);
    $liste = [];
    foreach ($lus as $nom => $valeur) {
        $valeurs = is_array($valeur) ? array_filter($valeur, 'is_string') : [is_string($valeur) ? $valeur : ''];
        foreach ($valeurs as $v) $liste[] = [strtolower((string) $nom), $v];
        if ($valeurs === []) $liste[] = [strtolower((string) $nom), ''];
    }
    return $liste;
}

/**
 * En restreint, ce qu'une adresse a d'interdit : une méthode demandée par « _method » (dans chacune des écritures que $_GET lit
 * comme lui), un chemin ambigu ou sensible. ?rest_route= sert l'API REST de WordPress comme /wp-json/ : sa route se juge comme un
 * chemin sous /wp-json.
 */
function manicou_juger_cible(string $chemin, string $requete, array $prefixes): ?string
{
    $params = manicou_parametres($requete);
    foreach ($params as [$nom]) if ($nom === '_method') return 'methode';
    $c = manicou_canoniser($chemin);
    if ($c['ambigu']) return 'ambigu';
    if (manicou_sensible($c['chemin'], $prefixes)) return 'sensible';
    foreach ($params as [$nom, $valeur]) {
        if ($nom !== 'rest_route') continue;
        $route = manicou_canoniser('/wp-json/' . $valeur);
        if ($route['ambigu']) return 'ambigu';
        if (manicou_sensible($route['chemin'], $prefixes)) return 'sensible';
    }
    return null;
}

/**
 * Ce que le niveau refuse d'une requête, ['raison' => …, 'robots' => bool], ou null. $cible est REQUEST_URI, telle qu'elle
 * arrive, et $entetes les en-têtes, noms en minuscules. Les exceptions se comparent au chemin brut, octet pour octet, sans chaîne de
 * requête (D16) : une normalisation large les élargit.
 */
function manicou_juger(string $niveau, string $methode, string $cible, array $r, array $entetes = []): ?array
{
    if ($niveau === 'normal') return null;
    ['chemin' => $brut, 'requete' => $requete] = manicou_decouper($cible);
    $lecture = in_array(strtoupper($methode), MANICOU_LECTURES, true);
    $miseANiveau = ($entetes['upgrade'] ?? '') !== '';
    $telQuel = $lecture && !$miseANiveau && $requete === '';
    if ($telQuel && in_array($brut, $r['sante'] ?? [], true)) return null;
    if ($niveau === 'maintenance') {
        if ($lecture && !$miseANiveau && manicou_canoniser($brut)['chemin'] === '/robots.txt') return ['raison' => 'robots', 'robots' => true];
        return ['raison' => 'maintenance', 'robots' => false];
    }
    if ($telQuel && $brut === '/robots.txt') return null;
    if (!$lecture) return ['raison' => 'ecriture', 'robots' => false];
    if ($miseANiveau) return ['raison' => 'mise-a-niveau', 'robots' => false];
    foreach (MANICOU_ENTETES_DE_METHODE as $nom) if (array_key_exists($nom, $entetes)) return ['raison' => 'methode', 'robots' => false];
    $prefixes = $r['chemins_sensibles'] ?? MANICOU_CHEMINS_SENSIBLES;
    $raison = manicou_juger_cible($brut, $requete, $prefixes);
    if ($raison !== null) return ['raison' => $raison, 'robots' => false];
    foreach (MANICOU_ENTETES_DE_REECRITURE as $nom) {
        if (!array_key_exists($nom, $entetes)) continue;
        $autre = manicou_decouper((string) $entetes[$nom]);
        if (manicou_juger_cible($autre['chemin'], $autre['requete'], $prefixes) !== null) return ['raison' => 'reecriture', 'robots' => false];
    }
    return null;
}

/**
 * Rend null pour laisser passer, ou [statut, texte] pour répondre à la place du site. La route de santé du site, demandée telle
 * quelle en lecture, passe toujours, et robots.txt aussi, que le garde sert lui-même en maintenance ([200, MANICOU_ROBOTS]).
 */
function manicou_decider(string $niveau, string $methode, string $cible, array $r, array $entetes = []): ?array
{
    $d = manicou_juger($niveau, $methode, $cible, $r, $entetes);
    if ($d === null) return null;
    if ($d['robots']) return [200, MANICOU_ROBOTS];
    $messages = ($r['messages'] ?? []) + MANICOU_MESSAGES;
    return [503, $messages[$niveau === 'maintenance' ? 'maintenance' : 'restreint']];
}

/** Les en-têtes que le garde regarde, lus dans $_SERVER, noms en minuscules. */
function manicou_entetes_de_la_requete(array $serveur): array
{
    $entetes = [];
    foreach (array_merge(['upgrade'], MANICOU_ENTETES_DE_METHODE, MANICOU_ENTETES_DE_REECRITURE) as $nom) {
        $cle = 'HTTP_' . strtoupper(str_replace('-', '_', $nom));
        if (isset($serveur[$cle]) && is_string($serveur[$cle])) $entetes[$nom] = $serveur[$cle];
    }
    return $entetes;
}

/**
 * En observation, ce que le niveau observé aurait refusé, noté au journal de PHP au plus toutes les dix minutes par cause. Chaque
 * requête de PHP est seule : une marque à côté du fichier de l'état retient l'heure du dernier avis.
 */
function manicou_observer(string $niveau, string $raison, string $methode, string $cible, array $r): void
{
    if ($r['fichier'] === null) return;
    $marque = $r['fichier'] . '.observation-' . preg_replace('/[^a-z-]/', '', $raison);
    clearstatcache(true, $marque);
    $vue = @filemtime($marque);
    if (is_int($vue) && time() - $vue < MANICOU_AVIS_OBSERVATION) return;
    @touch($marque);
    $cause = MANICOU_CAUSES[$raison] ?? $raison;
    error_log(sprintf('[manicou] En observation du %s, une requête aurait reçu 503, pour %s, %s %s. Un avis par cause et par dix minutes au plus.', $niveau, $cause, substr(strtoupper($methode), 0, 20), json_encode(substr($cible, 0, 200), JSON_UNESCAPED_SLASHES | JSON_INVALID_UTF8_SUBSTITUTE)));
}

/** La page du site pour ce niveau, ou null s'il n'en donne pas ou qu'elle ne se lit pas. Le message en texte part alors. */
function manicou_page(string $niveau, array $r): ?string
{
    $chemin = $r['page'] ?? null;
    if (!is_string($chemin) || $chemin === '' || !is_file($chemin)) return null;
    $page = file_get_contents($chemin);
    if ($page === false || $page === '') return null;
    if ($niveau !== 'restreint') return $page;
    $repere = strpos($page, 'id="manicou-phrase"');
    $ouvre = $repere === false ? false : strpos($page, '>', $repere);
    $ferme = $ouvre === false ? false : strpos($page, '</p>', $ouvre);
    if ($ferme === false) return $page;
    $langue = str_contains(strtolower(substr($page, 0, 400)), 'lang="en') ? 'en' : 'fr';
    $phrase = is_string($r['phrase_restreint'] ?? null) ? $r['phrase_restreint'] : MANICOU_PHRASES_RESTREINT[$langue];
    return substr($page, 0, $ouvre + 1) . $phrase . substr($page, $ferme);
}

function manicou_reglages(array $r): array
{
    foreach (['sonde', 'domaine', 'adresse', 'cles'] as $champ) {
        if (empty($r[$champ])) throw new RuntimeException("manicou : « $champ » manque dans reglages.php");
    }
    if (!str_starts_with($r['adresse'], 'https://') && !preg_match('#^http://(127\.0\.0\.1|localhost)(:\d+)?/#', $r['adresse'])) {
        throw new RuntimeException("manicou : l'adresse doit être en https");
    }
    if (isset($r['demarrage']) && !in_array($r['demarrage'], MANICOU_NIVEAUX, true)) {
        throw new RuntimeException('manicou : « demarrage » vaut normal, restreint ou maintenance');
    }
    if (isset($r['sante']) && (!is_array($r['sante']) || array_filter($r['sante'], fn ($c): bool => !is_string($c) || !str_starts_with($c, '/')) !== [])) {
        throw new RuntimeException('manicou, « sante » est une liste de chemins qui commencent par /');
    }
    $r['demarrage'] ??= 'restreint';
    $r['fichier'] = manicou_fichier($r);
    return $r;
}

function manicou_garder(array $r): void
{
    if ($r['fichier'] === null) {
        // Aucun dossier sûr pour l'état. Le garde ne lit rien, reste à son niveau de départ six heures au plus après la pose de ses
        // réglages, et le dit au journal de PHP.
        error_log('manicou : aucun dossier sûr pour garder l\'état ; donnez « fichier » dans reglages.php, dans un dossier à vous');
        $pose = @filemtime(__DIR__ . '/reglages.php');
        $etat = ['connu' => false, 'depuis' => is_int($pose) ? $pose : time()];
    } else {
        $etat = manicou_etat_garde($r['fichier'], (string) $r['sonde']);
        if (time() - $etat['luLe'] >= ($etat['connu'] ? (int) ($r['rafraichir'] ?? 60) : MANICOU_REESSAI)) $etat = manicou_rafraichir($r);
    }
    $niveau = manicou_niveau($etat, $r['demarrage'], time());
    $observe = $niveau === 'normal' && $etat['connu'] ? ($etat['observation'] ?? null) : null;
    if ($niveau === 'normal' && $observe === null) return;
    $methode = (string) ($_SERVER['REQUEST_METHOD'] ?? 'GET');
    $cible = (string) ($_SERVER['REQUEST_URI'] ?? '/');
    $entetes = manicou_entetes_de_la_requete($_SERVER);
    if ($observe !== null) {
        $j = manicou_juger($observe, $methode, $cible, $r, $entetes);
        if ($j !== null && !$j['robots']) manicou_observer($observe, $j['raison'], $methode, $cible, $r);
        return;
    }
    $d = manicou_decider($niveau, $methode, $cible, $r, $entetes);
    if ($d === null) return;
    if ($d[0] === 200) {
        // robots.txt en maintenance, servi par le garde.
        http_response_code(200);
        header('Content-Type: text/plain; charset=utf-8');
        header('Cache-Control: no-store');
        if ($methode !== 'HEAD') echo $d[1];
        exit;
    }
    $page = manicou_page($niveau, $r);
    http_response_code($d[0]);
    if ($page === null) {
        header('Content-Type: text/plain; charset=utf-8');
    } else {
        header('Content-Type: text/html; charset=utf-8');
        header('Content-Security-Policy: ' . MANICOU_CSP_PAGE);
        header('X-Content-Type-Options: nosniff');
    }
    header('Retry-After: 300');
    header('Cache-Control: no-store');
    // Manicou y reconnaît l'effet de son ordre en cours, et non un 503 du site lui-même ou d'un autre garde du même hôte.
    header('X-Manicou: ' . manicou_entete($niveau, $etat, $r));
    if ($methode !== 'HEAD') echo $page ?? $d[1];
    exit;
}

// Le garde ne bloque jamais un site, même mal posé (D21) : sans reglages.php, ou sur toute erreur, il laisse passer et le dit au
// journal de PHP.
if (!defined('MANICOU_SANS_DEMARRAGE')) {
    if (!is_file(__DIR__ . '/reglages.php')) {
        error_log('[manicou] reglages.php manque à côté de garde.php, le garde laisse passer le site. Posez-le d\'après reglages.exemple.php.');
    } else {
        try {
            $manicou_reglages = manicou_reglages(require __DIR__ . '/reglages.php');
            if (PHP_SAPI !== 'cli') {
                manicou_garder($manicou_reglages);
            } elseif (realpath($_SERVER['SCRIPT_FILENAME'] ?? '') === __FILE__ && ($argv[1] ?? '') === 'rafraichir' && $manicou_reglages['fichier'] !== null) {
                manicou_rafraichir($manicou_reglages);
            }
        } catch (\Throwable $e) {
            error_log('[manicou] Le garde a échoué et laisse passer la requête, ' . get_class($e) . ', ' . substr($e->getMessage(), 0, 300));
        }
        unset($manicou_reglages);
    }
}
chargeur.php View the code
chargeur.php
<?php
// Le chargeur du garde PHP de Manicou. Il se pose à côté du dossier manicou/, et c'est lui que nomme auto_prepend_file (dans
// php.ini, ou « php_value auto_prepend_file /chemin/chargeur.php » dans le .htaccess). Sans le dossier manicou/, ou sans ses
// réglages, il ne fait rien, et le site marche toujours, alors qu'un auto_prepend_file qui nomme un fichier absent fait répondre
// 500 à tout le site. Une erreur du garde laisse passer la requête et se dit au journal de PHP (D21). Laissé par mégarde dans le
// dossier manicou/, il charge encore le garde posé à côté de lui.
//
// Pour retirer la recette, retirez d'abord la directive auto_prepend_file, puis ce fichier et le dossier manicou/.

(static function (): void {
    $dossier = is_file(__DIR__ . '/manicou/garde.php') ? __DIR__ . '/manicou' : (is_file(__DIR__ . '/garde.php') ? __DIR__ : null);
    if ($dossier === null) return;
    foreach (['manicou.php', 'reglages.php'] as $fichier) {
        if (!is_file($dossier . '/' . $fichier)) {
            error_log("[manicou] $fichier manque dans le dossier de la recette, le garde laisse passer le site.");
            return;
        }
    }
    try {
        require_once $dossier . '/garde.php';
    } catch (\Throwable $e) {
        error_log('[manicou] Le garde a échoué et laisse passer la requête, ' . get_class($e) . ', ' . substr($e->getMessage(), 0, 300));
    }
})();
reglages.exemple.php View the code
reglages.exemple.php
<?php
// Les réglages du garde PHP (garde.php) : copier ce fichier en reglages.php, à côté, et le remplir avec ce que l'espace
// client de Manicou donne avec la recette. Le garde se charge par chargeur.php, posé à côté du dossier manicou/.

return [
    'sonde' => 'snd_…',
    'domaine' => 'exemple.fr',
    'adresse' => 'https://…/api/v1',
    'cles' => ['identifiant de la clé' => 'clé publique en base64'],
    // La page que voit un visiteur arrêté : maintenance.html (maintenance.en.html en anglais), copiée à côté et mise à votre
    // nom. Sans ce fichier, le garde répond par une phrase en texte.
    'page' => __DIR__ . '/maintenance.html',

    // Facultatifs :
    // 'fichier' => '/var/lib/monsite/manicou.json',  // l'état gardé, dans un dossier à vous ; par défaut, etat/ à côté de
    //                                                 // garde.php, créé en 0700. Le cron, s'il y en a un, tourne sous le
    //                                                 // même utilisateur que PHP.
    // 'demarrage' => 'restreint',                     // tant qu'aucun état valable n'a été lu : restreint (par défaut),
    //                                                 // maintenance, ou normal pour laisser tout passer ; six heures au
    //                                                 // plus pour le restreint, quarante-huit pour la maintenance
    // 'sante' => ['/api/sante'],                      // la route de santé du site, qui passe toujours en lecture,
    //                                                 // comme robots.txt
    // 'chemins_sensibles' => ['/admin', '/wp-admin', '/wp-login.php'],
    // 'messages' => ['maintenance' => '…', 'restreint' => '…'],
    // 'phrase_restreint' => '…',                      // la phrase de la page en mode restreint, en HTML, si celle de
    //                                                 // Manicou ne vous va pas
];
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