PHP

Votre site vérifie au plus une fois par minute si Manicou lui demande de se protéger.

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

Ce garde s’exécute dans PHP, donc une faille de PHP lui-même, comme PHP2SHELL, peut passer avant lui. Si vous le pouvez, posez plutôt la recette nginx, Apache ou Cloudflare, devant PHP.

  1. Copiez les fichiers

    • manicou.php et garde.php dans le dossier manicou/ du site
    • maintenance.html au même endroit, la page que verront vos visiteurs, à mettre à votre nom
    • chargeur.php à côté de ce dossier, jamais dedans. Sans le dossier ou ses réglages, il ne fait rien, et le site marche toujours
  2. Créez manicou/reglages.php

    manicou/reglages.php
    <?php
    return [
      'sonde' => 'snd_…',
      'domaine' => '…',
      'adresse' => 'https://app.manicou.dev/api/v1',
      'cles' => ['k1' => '…'],
      'page' => __DIR__ . '/maintenance.html',
    ];
  3. Chargez le garde avant le site

    php.ini
    auto_prepend_file = /chemin/du/site/chargeur.php
    ou en tête d’index.php
    require __DIR__ . '/chargeur.php';

Les fichiers

manicou.php Voir le 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 Voir le 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 Voir le 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 Voir le 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.html Voir le code
maintenance.html
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="robots" content="noindex">
<title>[Nom du site]</title>
<style>
*{box-sizing:border-box}
body{margin:0;background:#fff;color:#171717;font:16px/1.6 system-ui,-apple-system,"Segoe UI",sans-serif;text-align:center}
header{padding:40px 24px 0}
.logo{width:72px;height:72px;margin:0 auto;border-radius:16px;background:#171717}
.nom{margin:12px 0 0;font-size:1.125rem;font-weight:600}
main{max-width:40rem;margin:0 auto;padding:48px 24px}
h1{margin:0 0 16px;font-size:2.5rem;line-height:1.15;font-weight:600;letter-spacing:-.02em}
p{margin:0}
.phrase,.joindre,.manicou{color:#4d4d4d}
.joindre{margin-top:40px;font-size:.9375rem}
.contact{display:flex;flex-direction:column;align-items:center;gap:8px;margin-top:8px}
a{color:inherit;font-size:1.125rem;text-underline-offset:.25em}
footer{padding:0 24px 40px;font-size:.875rem}
@media (max-width:640px){header{padding-top:28px}.logo{width:56px;height:56px}main{padding:32px 20px}h1{font-size:1.75rem}}
</style>
</head>
<body>
<header>
<!-- Votre logo à la place de ce carré, en image intégrée (data:) -->
<div class="logo"></div>
<p class="nom">[Nom du site]</p>
</header>
<main>
<h1>[Nom du site] vous protège.</h1>
<p class="phrase" id="manicou-phrase">Une faille de sécurité qui touche de nombreux sites est en cours.<br>Nous attendons son correctif pour reprendre le service.</p>
<p class="joindre">Pour nous joindre</p>
<p class="contact"><a href="tel:[numéro sans espace]">[téléphone]</a><a href="mailto:[e-mail]">[e-mail]</a></p>
</main>
<footer>
<p class="manicou">Site protégé par Manicou</p>
</footer>
</body>
</html>

L’essai

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

Poser la recette