@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/audits/modules/web.js

@@ -0,0 +1,302 @@
+import { httpRequest, pool } from '../net.js';
+import { parseUrl, plural, resteACorrigerEnTete } from '../types.js';
+const urlField = { key: 'url', label: 'Adresse du site', help: 'Le site doit être dans ton périmètre autorisé.', placeholder: 'https://exemple.fr', required: true };
+/** Suit au plus trois redirections, sans jamais sortir du périmètre autorisé. */
+async function fetchPage(start, ctx) {
+    const hops = [];
+    let current = start.href;
+    let result = await httpRequest(current);
+    for (let i = 0; i < 3 && result.status >= 300 && result.status < 400 && result.location; i++) {
+        const next = new URL(result.location);
+        if (!ctx.inScope(next.hostname))
+            return { result, hops, leftScope: next.hostname };
+        hops.push(next.href);
+        current = next.href;
+        result = await httpRequest(current);
+    }
+    return { result, hops, leftScope: null };
+}
+// ------------------------------------------------------------------ En-têtes HTTP
+const SESSION_COOKIE = /sess|sid|auth|token|login|jwt/i;
+export function analyzeHeaders(headers, setCookies, isHttps) {
+    const findings = [];
+    const checks = [];
+    const has = (name) => headers[name];
+    const check = (label, status, value) => void checks.push({ label, status, value });
+    const hsts = has('strict-transport-security');
+    if (!isHttps)
+        check('Strict-Transport-Security', 'skip', 'page servie en HTTP');
+    else if (!hsts) {
+        check('Strict-Transport-Security', 'fail', 'absent');
+        findings.push({ severity: 'medium', title: 'HSTS absent', detail: 'Sans Strict-Transport-Security, le navigateur accepte de revenir en HTTP : un attaquant sur le réseau peut intercepter la première requête.', recommendation: 'Ajouter « Strict-Transport-Security: max-age=31536000; includeSubDomains ».' });
+    }
+    else {
+        const age = Number(/max-age=(\d+)/i.exec(hsts)?.[1] ?? 0);
+        check('Strict-Transport-Security', age >= 15552000 ? 'pass' : 'warn', hsts);
+        if (age < 15552000)
+            findings.push({ severity: 'low', title: 'HSTS trop court', detail: `max-age vaut ${age} s, soit moins de six mois.`, evidence: hsts, recommendation: 'Passer max-age à 31536000 (un an).' });
+    }
+    const csp = has('content-security-policy');
+    if (!csp) {
+        check('Content-Security-Policy', 'fail', 'absent');
+        findings.push({ severity: 'medium', title: 'Content-Security-Policy absente', detail: 'Aucune politique ne limite les scripts que la page peut charger : une injection de script (XSS) s’exécute sans obstacle.', recommendation: 'Définir une CSP, en commençant par « default-src \'self\' ».' });
+    }
+    else {
+        // Seule la directive qui gouverne les scripts compte ici : script-src, sinon default-src.
+        const directives = new Map(csp.split(';').map((d) => d.trim().split(/\s+/)).filter((parts) => parts[0]).map((parts) => [(parts[0] ?? '').toLowerCase(), parts.slice(1).join(' ')]));
+        const scripts = directives.get('script-src') ?? directives.get('default-src') ?? '';
+        const loose = /'unsafe-inline'|'unsafe-eval'/.test(scripts);
+        check('Content-Security-Policy', loose ? 'warn' : 'pass', csp.length > 120 ? `${csp.slice(0, 120)}…` : csp);
+        if (loose)
+            findings.push({ severity: 'low', title: 'CSP permissive', detail: 'La politique autorise unsafe-inline ou unsafe-eval pour les scripts, ce qui annule une bonne partie de la protection contre les XSS.', evidence: csp.slice(0, 300), recommendation: 'Remplacer unsafe-inline par des nonces ou des empreintes.' });
+    }
+    const xfo = has('x-frame-options');
+    const frameAncestors = csp ? /frame-ancestors/i.test(csp) : false;
+    if (xfo || frameAncestors)
+        check('Protection contre l’encadrement', 'pass', xfo ?? 'frame-ancestors (CSP)');
+    else {
+        check('Protection contre l’encadrement', 'fail', 'ni X-Frame-Options ni frame-ancestors');
+        findings.push({ severity: 'medium', title: 'Page encadrable par un autre site', detail: 'Sans X-Frame-Options ni frame-ancestors, la page peut être affichée dans une iframe invisible (détournement de clic).', recommendation: 'Ajouter « X-Frame-Options: DENY » ou « frame-ancestors \'none\' » dans la CSP.' });
+    }
+    const nosniff = has('x-content-type-options');
+    if (nosniff?.toLowerCase().includes('nosniff'))
+        check('X-Content-Type-Options', 'pass', nosniff);
+    else {
+        check('X-Content-Type-Options', 'fail', nosniff ?? 'absent');
+        findings.push({ severity: 'low', title: 'X-Content-Type-Options absent', detail: 'Le navigateur peut deviner le type d’un fichier et exécuter comme script un contenu qui n’en est pas un.', recommendation: 'Ajouter « X-Content-Type-Options: nosniff ».' });
+    }
+    const referrer = has('referrer-policy');
+    check('Referrer-Policy', referrer ? 'pass' : 'warn', referrer ?? 'absent');
+    if (!referrer)
+        findings.push({ severity: 'low', title: 'Referrer-Policy absente', detail: 'L’adresse complète des pages peut être transmise aux sites tiers.', recommendation: 'Ajouter « Referrer-Policy: strict-origin-when-cross-origin ».' });
+    const permissions = has('permissions-policy');
+    check('Permissions-Policy', permissions ? 'pass' : 'info', permissions ? (permissions.length > 100 ? `${permissions.slice(0, 100)}…` : permissions) : 'absent');
+    for (const name of ['server', 'x-powered-by', 'x-aspnet-version']) {
+        const value = has(name);
+        if (!value)
+            continue;
+        const versioned = /\d+\.\d+/.test(value);
+        check(`En-tête ${name}`, versioned ? 'warn' : 'info', value);
+        if (versioned)
+            findings.push({ severity: 'low', title: `Version divulguée par l’en-tête ${name}`, detail: 'Connaître la version exacte aide à choisir une faille connue.', evidence: `${name}: ${value}`, recommendation: 'Masquer la version (server_tokens off sous nginx, ServerTokens Prod sous Apache).' });
+    }
+    for (const cookie of setCookies) {
+        const cookieName = cookie.split('=')[0]?.trim() ?? 'cookie';
+        const flags = cookie.toLowerCase();
+        const missing = [isHttps && !/;\s*secure/.test(flags) ? 'Secure' : null, !/;\s*httponly/.test(flags) ? 'HttpOnly' : null, !/;\s*samesite=/.test(flags) ? 'SameSite' : null].filter((f) => f !== null);
+        check(`Cookie ${cookieName}`, missing.length === 0 ? 'pass' : 'fail', missing.length === 0 ? 'Secure, HttpOnly, SameSite' : `manque ${missing.join(', ')}`);
+        if (missing.length > 0) {
+            const sensitive = SESSION_COOKIE.test(cookieName);
+            findings.push({
+                severity: sensitive && (missing.includes('Secure') || missing.includes('HttpOnly')) ? 'medium' : 'low',
+                title: `Cookie « ${cookieName} » mal protégé`,
+                detail: `Attributs manquants : ${missing.join(', ')}.${sensitive ? ' Son nom laisse penser qu’il porte la session.' : ''}`,
+                recommendation: 'Poser Secure, HttpOnly et SameSite=Lax (ou Strict) sur les cookies de session.',
+            });
+        }
+    }
+    const acao = has('access-control-allow-origin');
+    if (acao === '*' && has('access-control-allow-credentials')?.toLowerCase() === 'true') {
+        check('CORS', 'fail', 'origine * avec identifiants');
+        findings.push({ severity: 'high', title: 'CORS ouvert avec identifiants', detail: 'Access-Control-Allow-Origin: * combiné à Allow-Credentials: true expose les réponses authentifiées à tous les sites.', recommendation: 'Lister les origines autorisées une par une.' });
+    }
+    else if (acao)
+        check('CORS', acao === '*' ? 'info' : 'pass', `Access-Control-Allow-Origin: ${acao}`);
+    const summary = `${resteACorrigerEnTete(findings.filter((f) => f.severity !== 'info').length)} sur ${checks.length} vérifications.`;
+    return { summary, findings, checks };
+}
+export const headersModule = {
+    info: {
+        id: 'headers',
+        letter: 'γ',
+        title: 'En-têtes HTTP',
+        objective: 'Vérifier que le site envoie les en-têtes qui protègent ses visiteurs : HSTS, CSP, anti-encadrement, cookies.',
+        perimeter: 'Une requête GET sur l’adresse donnée, plus trois redirections au maximum, sans sortir du périmètre autorisé.',
+        results: 'Chaque en-tête attendu avec sa valeur, et pour chaque manque le risque et la ligne à ajouter.',
+        input: 'url',
+        fields: [urlField],
+    },
+    resolve: (input) => {
+        const url = parseUrl(input.url);
+        return { label: url.origin + (url.pathname === '/' ? '' : url.pathname), host: url.hostname };
+    },
+    async run(input, ctx) {
+        const url = parseUrl(input.url);
+        ctx.progress('Requête sur le site', 0, 1);
+        const { result, leftScope } = await fetchPage(url, ctx);
+        ctx.progress('Analyse des en-têtes', 1, 1);
+        const out = analyzeHeaders(result.headers, result.setCookies, new URL(result.url).protocol === 'https:');
+        out.checks.unshift({ label: 'Réponse', status: result.status < 400 ? 'info' : 'warn', value: `${result.status} sur ${result.url}` });
+        if (leftScope)
+            out.checks.push({ label: 'Redirection', status: 'info', value: `vers ${leftScope}, hors périmètre : non suivie` });
+        return out;
+    },
+};
+// ------------------------------------------------------------------ Audit de sécurité web
+export function analyzeHtml(body, isHttps) {
+    const findings = [];
+    if (isHttps) {
+        const mixed = [...body.matchAll(/<(?:script|img|iframe|link|audio|video|source)\b[^>]*?(?:src|href)\s*=\s*["'](http:\/\/[^"']+)["']/gi)].map((m) => m[1] ?? '');
+        if (mixed.length > 0)
+            findings.push({ severity: 'medium', title: 'Contenu mixte', detail: `${plural(mixed.length, 'ressource chargée', 'ressources chargées')} en HTTP depuis une page HTTPS : elles peuvent être modifiées en chemin.`, evidence: mixed.slice(0, 3).join('\n'), recommendation: 'Charger toutes les ressources en HTTPS.' });
+    }
+    const insecureForm = /<form\b[^>]*action\s*=\s*["']http:\/\//i.test(body);
+    const password = /<input\b[^>]*type\s*=\s*["']password["']/i.test(body);
+    if (insecureForm)
+        findings.push({ severity: 'high', title: 'Formulaire envoyé en HTTP', detail: 'Un formulaire de la page envoie ses données en clair.', recommendation: 'Faire pointer l’attribut action vers une adresse HTTPS.' });
+    if (password && !isHttps)
+        findings.push({ severity: 'high', title: 'Mot de passe saisi sur une page HTTP', detail: 'Le champ mot de passe est servi sans chiffrement.', recommendation: 'Servir la page de connexion en HTTPS uniquement.' });
+    if (/<title>\s*Index of \//i.test(body))
+        findings.push({ severity: 'medium', title: 'Listage de répertoire activé', detail: 'Le serveur affiche le contenu du dossier au lieu d’une page.', recommendation: 'Désactiver l’index automatique (autoindex off, Options -Indexes).' });
+    return findings;
+}
+export const webModule = {
+    info: {
+        id: 'web',
+        letter: 'ε',
+        title: 'Audit de sécurité web',
+        objective: 'Contrôler le comportement de l’application : passage forcé en HTTPS, contenu mixte, formulaires, méthodes HTTP, fichiers de contact sécurité.',
+        perimeter: 'Huit requêtes au plus : la racine du site en HTTP, l’adresse donnée et trois redirections au plus dans ton périmètre, une requête OPTIONS, robots.txt et /.well-known/security.txt.',
+        results: 'Les constats sur la page d’accueil et la configuration du serveur, avec leur gravité.',
+        input: 'url',
+        fields: [urlField],
+    },
+    resolve: (input) => {
+        const url = parseUrl(input.url);
+        return { label: url.origin, host: url.hostname };
+    },
+    async run(input, ctx) {
+        const url = parseUrl(input.url);
+        const findings = [];
+        const checks = [];
+        const total = 5;
+        const httpsOrigin = `https://${url.host}`;
+        ctx.progress('Redirection HTTP vers HTTPS', 0, total);
+        try {
+            const plain = await httpRequest(`http://${url.hostname}/`, { method: 'GET', timeoutMs: 6000 });
+            const forced = plain.status >= 300 && plain.status < 400 && (plain.location ?? '').startsWith('https://');
+            checks.push({ label: 'HTTP redirigé vers HTTPS', status: forced ? 'pass' : 'fail', value: forced ? `${plain.status} vers ${plain.location}` : `réponse ${plain.status} sans redirection HTTPS` });
+            if (!forced)
+                findings.push({ severity: 'medium', title: 'Le site répond en HTTP sans rediriger', detail: 'Un visiteur qui tape l’adresse sans « https:// » reste en clair.', recommendation: 'Rediriger tout le trafic du port 80 vers HTTPS (301).' });
+        }
+        catch {
+            checks.push({ label: 'HTTP redirigé vers HTTPS', status: 'info', value: 'port 80 fermé ou injoignable' });
+        }
+        ctx.progress('Page d’accueil', 1, total);
+        const { result: page, leftScope } = await fetchPage(url, ctx);
+        const isHttps = new URL(page.url).protocol === 'https:';
+        checks.push({ label: 'Page d’accueil', status: page.status < 400 ? 'info' : 'warn', value: `${page.status} sur ${page.url}` });
+        if (leftScope)
+            checks.push({ label: 'Redirection', status: 'info', value: `vers ${leftScope}, hors périmètre : non suivie` });
+        const html = analyzeHtml(page.body, isHttps);
+        findings.push(...html);
+        checks.push({ label: 'Contenu de la page', status: html.length === 0 ? 'pass' : 'fail', value: html.length === 0 ? 'ni contenu mixte ni formulaire en clair' : html.map((f) => f.title).join(', ') });
+        ctx.progress('Méthodes HTTP', 2, total);
+        try {
+            const options = await httpRequest(url.href, { method: 'OPTIONS', timeoutMs: 6000 });
+            const allow = options.headers.allow ?? options.headers['access-control-allow-methods'] ?? '';
+            const risky = allow.split(',').map((m) => m.trim().toUpperCase()).filter((m) => ['TRACE', 'PUT', 'DELETE', 'CONNECT'].includes(m));
+            checks.push({ label: 'Méthodes annoncées', status: risky.length > 0 ? 'warn' : 'pass', value: allow || 'non annoncées' });
+            if (risky.length > 0)
+                findings.push({ severity: 'low', title: `Méthodes ${risky.join(', ')} annoncées`, detail: 'Le serveur annonce des méthodes rarement nécessaires sur un site public.', evidence: `Allow: ${allow}`, recommendation: 'Limiter les méthodes à GET, HEAD et POST si l’application n’en utilise pas d’autres.' });
+        }
+        catch {
+            checks.push({ label: 'Méthodes annoncées', status: 'skip', value: 'pas de réponse à OPTIONS' });
+        }
+        ctx.progress('robots.txt', 3, total);
+        try {
+            const robots = await httpRequest(`${isHttps ? httpsOrigin : url.origin}/robots.txt`, { timeoutMs: 6000, maxBytes: 32 * 1024 });
+            const disallow = robots.status === 200 ? [...robots.body.matchAll(/^\s*Disallow:\s*(\S+)/gim)].map((m) => m[1] ?? '') : [];
+            checks.push({ label: 'robots.txt', status: 'info', value: robots.status === 200 ? `${plural(disallow.length, 'chemin déclaré', 'chemins déclarés')}` : `absent (${robots.status})` });
+            const sensitive = disallow.filter((p) => /admin|backup|private|secret|config|\.git|intern/i.test(p));
+            if (sensitive.length > 0)
+                findings.push({ severity: 'info', title: 'robots.txt signale des chemins sensibles', detail: 'Ces chemins sont cachés aux moteurs de recherche, mais lisibles par tous dans robots.txt.', evidence: sensitive.slice(0, 6).join('\n'), recommendation: 'Vérifier que chacun exige une authentification.' });
+        }
+        catch {
+            checks.push({ label: 'robots.txt', status: 'skip', value: 'injoignable' });
+        }
+        ctx.progress('security.txt', 4, total);
+        try {
+            const sec = await httpRequest(`${isHttps ? httpsOrigin : url.origin}/.well-known/security.txt`, { timeoutMs: 6000, maxBytes: 16 * 1024 });
+            const present = sec.status === 200 && /^contact:/im.test(sec.body);
+            // Une réponse 200 sans ligne Contact peut être un vrai fichier incomplet, ou la page d'accueil servie pour tout chemin.
+            checks.push({ label: 'security.txt', status: present ? 'pass' : 'info', value: present ? 'présent, avec un contact' : sec.status === 200 ? 'réponse 200 sans ligne Contact' : `absent (${sec.status})` });
+            if (!present)
+                findings.push({ severity: 'info', title: sec.status === 200 ? 'Pas de ligne Contact dans security.txt' : 'Pas de fichier security.txt', detail: 'Un chercheur qui trouve une faille ne sait pas à qui la signaler.', recommendation: 'Publier /.well-known/security.txt avec une ligne Contact.' });
+        }
+        catch {
+            checks.push({ label: 'security.txt', status: 'skip', value: 'injoignable' });
+        }
+        ctx.progress('Terminé', total, total);
+        const real = findings.filter((f) => f.severity !== 'info').length;
+        return { summary: `${resteACorrigerEnTete(real)} sur la page d’accueil et le serveur.`, findings, checks };
+    },
+};
+export const PROBES = [
+    { path: '/.git/HEAD', label: 'Dépôt Git', signature: /^ref: refs\//m, severity: 'critical', detail: 'Le dossier .git est servi : tout le code source et son historique sont téléchargeables.', recommendation: 'Interdire l’accès à /.git/ et retirer le dossier du serveur.' },
+    { path: '/.env', label: 'Fichier .env', signature: /^[A-Z][A-Z0-9_]{2,}\s*=\s*\S/m, severity: 'critical', detail: 'Le fichier .env est lisible : il contient en général des mots de passe et des clés d’API.', recommendation: 'Bloquer l’accès aux fichiers cachés et changer tous les secrets exposés.' },
+    { path: '/.svn/entries', label: 'Dépôt Subversion', signature: /^\d+\s*$|svn:/m, severity: 'high', detail: 'Les métadonnées Subversion sont servies.', recommendation: 'Interdire l’accès à /.svn/.' },
+    { path: '/.htaccess', label: 'Fichier .htaccess', signature: /RewriteEngine|AuthType|Require |<Files/i, severity: 'medium', detail: 'La configuration Apache du dossier est lisible.', recommendation: 'Bloquer l’accès aux fichiers commençant par un point.' },
+    { path: '/web.config', label: 'web.config', signature: /<configuration[\s>]/i, severity: 'high', detail: 'La configuration IIS est lisible, parfois avec des chaînes de connexion.', recommendation: 'Vérifier le filtrage des requêtes IIS.' },
+    { path: '/phpinfo.php', label: 'phpinfo()', signature: /phpinfo\(\)|PHP Version \d/i, severity: 'high', detail: 'La page phpinfo détaille la configuration du serveur, ses chemins et ses variables d’environnement.', recommendation: 'Supprimer ce fichier.' },
+    { path: '/server-status', label: 'Statut Apache', signature: /Apache Server Status/i, severity: 'medium', detail: 'La page de statut montre les requêtes en cours et les adresses des visiteurs.', recommendation: 'Restreindre mod_status à la machine locale.' },
+    { path: '/actuator/env', label: 'Spring Actuator', signature: /"propertySources"|"activeProfiles"/, severity: 'high', detail: 'L’environnement de l’application Spring est exposé.', recommendation: 'Fermer ou authentifier les points d’accès Actuator.' },
+    { path: '/config.php.bak', label: 'Sauvegarde de configuration', signature: /<\?php/, severity: 'high', detail: 'Une sauvegarde de fichier PHP est servie en texte : son code et ses secrets sont lisibles.', recommendation: 'Supprimer les sauvegardes du dossier public.' },
+    { path: '/wp-config.php.bak', label: 'Sauvegarde WordPress', signature: /DB_PASSWORD|<\?php/, severity: 'critical', detail: 'La sauvegarde de wp-config.php expose les identifiants de la base de données.', recommendation: 'Supprimer le fichier et changer le mot de passe de la base.' },
+    { path: '/.DS_Store', label: 'Fichier .DS_Store', signature: /Bud1/, severity: 'low', detail: 'Ce fichier macOS révèle les noms des fichiers du dossier.', recommendation: 'Le supprimer et l’exclure du déploiement.' },
+    { path: '/composer.json', label: 'composer.json', signature: /"require"\s*:/, severity: 'low', detail: 'La liste des dépendances PHP et leurs versions sont publiques.', recommendation: 'Ne pas servir ce fichier.' },
+    { path: '/package.json', label: 'package.json', signature: /"dependencies"\s*:|"name"\s*:/, severity: 'low', detail: 'La liste des dépendances JavaScript et leurs versions sont publiques.', recommendation: 'Ne pas servir ce fichier.' },
+];
+export const exposureModule = {
+    info: {
+        id: 'exposure',
+        letter: 'ζ',
+        title: 'Mauvaises configurations',
+        objective: 'Repérer les fichiers qui ne devraient jamais être servis : dépôt Git, .env, sauvegardes, pages de diagnostic.',
+        perimeter: `${PROBES.length} requêtes GET sur des chemins connus (${PROBES.slice(0, 4).map((p) => p.path).join(', ')}…). Chaque réponse est comparée à la signature du vrai fichier.`,
+        results: 'La liste des chemins testés et, pour chaque fichier exposé, ce qu’il révèle et comment le fermer.',
+        input: 'url',
+        fields: [urlField],
+    },
+    resolve: (input) => {
+        const url = parseUrl(input.url);
+        return { label: url.origin, host: url.hostname };
+    },
+    async run(input, ctx) {
+        const url = parseUrl(input.url);
+        const findings = [];
+        let done = 0;
+        ctx.progress('Chemins sensibles', 0, PROBES.length);
+        const results = await pool(PROBES, 4, async (probe) => {
+            let status = 0;
+            let exposed = false;
+            try {
+                const res = await httpRequest(url.origin + probe.path, { timeoutMs: 6000, maxBytes: 64 * 1024 });
+                status = res.status;
+                exposed = res.status === 200 && probe.signature.test(res.body);
+            }
+            catch {
+                status = -1;
+            }
+            ctx.progress(probe.path, ++done, PROBES.length);
+            return { probe, status, exposed };
+        });
+        const checks = results.map(({ probe, status, exposed }) => ({
+            label: probe.path,
+            status: exposed ? 'fail' : status === -1 ? 'skip' : 'pass',
+            value: exposed ? `exposé (${probe.label})` : status === -1 ? 'pas de réponse' : status === 200 ? 'réponse 200 sans le contenu attendu' : `réponse ${status}`,
+        }));
+        for (const { probe, exposed } of results) {
+            if (exposed)
+                findings.push({ severity: probe.severity, title: `${probe.label} accessible`, detail: probe.detail, evidence: url.origin + probe.path, recommendation: probe.recommendation });
+        }
+        // Un chemin sans réponse ne prouve rien : il ne compte pas parmi les chemins « non exposés ».
+        const muets = results.filter((r) => r.status === -1).length;
+        const rien = muets === 0
+            ? `Aucun des ${PROBES.length} fichiers sensibles testés n’est exposé.`
+            : muets === PROBES.length
+                ? `Aucun des ${PROBES.length} chemins testés n’a répondu.`
+                : `Aucun fichier exposé parmi ${plural(PROBES.length - muets, 'chemin qui a répondu', 'chemins qui ont répondu')}, ${muets} sans réponse.`;
+        return { summary: findings.length === 0 ? rien : `${plural(findings.length, 'fichier sensible exposé', 'fichiers sensibles exposés')} sur ${PROBES.length} testés.`, findings, checks };
+    },
+};

package/lib/server/audits/net.js

@@ -0,0 +1,141 @@
+/** Sondes réseau des modules d'audit : requête HTTP(S), connexion TCP, poignée de main TLS. */
+import http from 'node:http';
+import https from 'node:https';
+import net from 'node:net';
+import tls from 'node:tls';
+const USER_AGENT = 'Promethee-Audit/2.0 (audit local autorisé)';
+/** Requête unique, sans suivi de redirection. Les certificats invalides sont acceptés : c'est le module TLS qui les juge. */
+export function httpRequest(target, options = {}) {
+    const url = new URL(target);
+    const lib = url.protocol === 'https:' ? https : http;
+    const maxBytes = options.maxBytes ?? 256 * 1024;
+    return new Promise((resolve, reject) => {
+        const req = lib.request(url, { method: options.method ?? 'GET', headers: { 'User-Agent': USER_AGENT, Accept: '*/*' }, timeout: options.timeoutMs ?? 8000, agent: false, rejectUnauthorized: false }, (res) => {
+            const chunks = [];
+            let size = 0;
+            res.on('data', (chunk) => {
+                size += chunk.length;
+                if (size <= maxBytes)
+                    chunks.push(chunk);
+                else
+                    res.destroy();
+            });
+            const finish = () => {
+                const headers = {};
+                for (const [name, value] of Object.entries(res.headers))
+                    if (value !== undefined)
+                        headers[name.toLowerCase()] = Array.isArray(value) ? value.join(', ') : value;
+                resolve({
+                    url: url.href,
+                    status: res.statusCode ?? 0,
+                    headers,
+                    setCookies: res.headers['set-cookie'] ?? [],
+                    body: Buffer.concat(chunks).toString('utf8'),
+                    location: res.headers.location ? new URL(res.headers.location, url).href : null,
+                });
+            };
+            res.on('end', finish);
+            res.on('close', finish);
+        });
+        req.on('timeout', () => req.destroy(new Error('délai dépassé')));
+        req.on('error', (err) => reject(err));
+        req.end();
+    });
+}
+/** Connexion TCP complète puis fermeture immédiate : aucun paquet forgé. */
+export function tcpProbe(host, port, timeoutMs = 1500) {
+    return new Promise((resolve) => {
+        const socket = net.connect({ host, port });
+        let settled = false;
+        const done = (state) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(state);
+        };
+        socket.setTimeout(timeoutMs, () => done('filtered'));
+        socket.on('connect', () => done('open'));
+        socket.on('error', (err) => done(err.code === 'ECONNREFUSED' ? 'closed' : 'filtered'));
+    });
+}
+const name = (o) => {
+    if (!o || typeof o !== 'object')
+        return '';
+    const record = o;
+    return String(record.CN ?? record.O ?? '');
+};
+/** Poignée de main TLS. « only » force une seule version du protocole pour savoir si le serveur l'accepte. */
+export function tlsProbe(host, port, only, timeoutMs = 6000) {
+    return new Promise((resolve) => {
+        let socket;
+        try {
+            socket = tls.connect({
+                host,
+                port,
+                servername: net.isIP(host) ? undefined : host,
+                rejectUnauthorized: false,
+                ...(only ? { minVersion: only, maxVersion: only, ...(only === 'TLSv1' || only === 'TLSv1.1' ? { ciphers: 'DEFAULT@SECLEVEL=0' } : {}) } : {}),
+            });
+        }
+        catch (err) {
+            resolve({ ok: false, reason: 'unsupported', message: err instanceof Error ? err.message : String(err) });
+            return;
+        }
+        let settled = false;
+        const done = (attempt) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(attempt);
+        };
+        socket.setTimeout(timeoutMs, () => done({ ok: false, reason: 'unreachable', message: 'délai dépassé' }));
+        socket.on('secureConnect', () => {
+            const cert = socket.getPeerCertificate();
+            const alt = typeof cert.subjectaltname === 'string' ? cert.subjectaltname.split(',').map((s) => s.trim().replace(/^DNS:|^IP Address:/, '')) : [];
+            done({
+                ok: true,
+                info: {
+                    protocol: socket.getProtocol(),
+                    cipher: socket.getCipher()?.name ?? null,
+                    authorized: socket.authorized,
+                    authorizationError: socket.authorizationError ? String(socket.authorizationError) : null,
+                    subject: name(cert.subject),
+                    issuer: name(cert.issuer),
+                    validFrom: cert.valid_from ?? '',
+                    validTo: cert.valid_to ?? '',
+                    altNames: alt,
+                    keyBits: typeof cert.bits === 'number' ? cert.bits : null,
+                    selfSigned: Boolean(cert.subject && cert.issuer && JSON.stringify(cert.subject) === JSON.stringify(cert.issuer)),
+                },
+            });
+        });
+        socket.on('error', (err) => {
+            const text = `${err.code ?? ''} ${err.message}`;
+            // Le client lui-même ne sait pas parler cette version : on ne peut rien conclure sur le serveur.
+            if (/NO_PROTOCOLS_AVAILABLE|UNSUPPORTED_PROTOCOL|no protocols available|unsupported protocol/i.test(text) && !/alert/i.test(text))
+                done({ ok: false, reason: 'unsupported', message: err.message });
+            else if (/ECONNREFUSED|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|ETIMEDOUT|EAI_AGAIN/.test(text))
+                done({ ok: false, reason: 'unreachable', message: err.message });
+            else
+                done({ ok: false, reason: 'refused', message: err.message });
+        });
+    });
+}
+/** Exécute des tâches avec un nombre limité en parallèle. */
+export async function pool(items, limit, worker) {
+    const results = new Array(items.length);
+    let next = 0;
+    const run = async () => {
+        for (;;) {
+            const index = next++;
+            const item = items[index];
+            if (index >= items.length || item === undefined)
+                return;
+            results[index] = await worker(item, index);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, run));
+    return results;
+}

package/lib/server/audits/registry.js

@@ -0,0 +1,202 @@
+/** Registre des modules d'audit : contrôle du périmètre, exécution, historique, rapport. */
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { SEVERITIES } from '../../shared/types.js';
+import { describeError, forbidden, notFound } from '../errors.js';
+import { hostInScope, isLoopback } from '../engine/paths.js';
+import { readJson, writeJson } from '../stores.js';
+import { configModule, filesModule } from './modules/local.js';
+import { portsModule, surfaceModule, tlsModule } from './modules/network.js';
+import { exposureModule, headersModule, webModule } from './modules/web.js';
+import { parseHost } from './types.js';
+export const MODULES = [surfaceModule, portsModule, headersModule, tlsModule, webModule, exposureModule, configModule, filesModule];
+const SEVERITY_LABELS = { critical: 'Critique', high: 'Élevée', medium: 'Moyenne', low: 'Faible', info: 'Information' };
+export function countBySeverity(findings) {
+    const counts = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+    for (const f of findings)
+        counts[f.severity]++;
+    return counts;
+}
+const summarize = (run) => ({ id: run.id, module: run.module, target: run.target, startedAt: run.startedAt, durationMs: run.durationMs, status: run.status, counts: countBySeverity(run.findings) });
+export class Audits {
+    runs = new Map();
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+        if (!deps.dir)
+            return;
+        fs.mkdirSync(deps.dir, { recursive: true });
+        for (const name of fs.readdirSync(deps.dir)) {
+            if (!/^[a-f0-9]{16}\.json$/.test(name))
+                continue;
+            const run = readJson(path.join(deps.dir, name), null);
+            if (run && typeof run.id === 'string' && Array.isArray(run.findings))
+                this.runs.set(run.id, run);
+        }
+    }
+    modules() {
+        return MODULES.map((m) => m.info);
+    }
+    /** Lance un module. Le périmètre est vérifié avant le premier paquet. */
+    async *run(moduleId, input) {
+        const mod = MODULES.find((m) => m.info.id === moduleId);
+        if (!mod)
+            throw notFound('Module d’audit inconnu.');
+        const { label, host } = mod.resolve(input);
+        const targets = this.deps.targets();
+        if (host !== null && !hostInScope(host, targets)) {
+            this.deps.journal.add({ kind: 'refusal', outcome: 'refused', title: `Audit « ${mod.info.title} » refusé : ${host} hors périmètre`, data: { module: moduleId, host } });
+            throw forbidden(`« ${host} » n’est pas dans ton périmètre autorisé. Déclare cette cible dans Audits › Périmètre si elle t’appartient ou si tu as une autorisation écrite.`, 'target_out_of_scope');
+        }
+        const queue = [];
+        let wake = null;
+        let finished = false;
+        const push = (event) => {
+            queue.push(event);
+            wake?.();
+            wake = null;
+        };
+        const started = Date.now();
+        const base = { id: randomBytes(8).toString('hex'), module: moduleId, target: label, startedAt: new Date(started).toISOString() };
+        const work = (async () => {
+            let run;
+            try {
+                const out = await mod.run(input, {
+                    progress: (text, done, total) => push({ type: 'progress', label: text, done, total }),
+                    engine: this.deps.engine,
+                    roots: this.deps.settings().engine.roots,
+                    home: this.deps.home,
+                    now: new Date(),
+                    inScope: (h) => hostInScope(h, targets),
+                });
+                run = { ...base, durationMs: Date.now() - started, status: 'done', summary: out.summary, checks: out.checks, findings: out.findings.map((f) => ({ ...f, id: randomBytes(6).toString('hex') })) };
+            }
+            catch (err) {
+                const { message } = describeError(err);
+                run = { ...base, durationMs: Date.now() - started, status: 'error', error: message, summary: 'Le module n’a pas pu aller au bout.', checks: [], findings: [] };
+            }
+            this.runs.set(run.id, run);
+            if (this.deps.dir)
+                writeJson(path.join(this.deps.dir, `${run.id}.json`), run);
+            const counts = countBySeverity(run.findings);
+            this.deps.journal.add({
+                kind: 'audit',
+                outcome: run.status === 'done' ? 'ok' : 'error',
+                title: `${mod.info.title} · ${label}`,
+                detail: run.status === 'done' ? run.summary : run.error,
+                data: { audit: run.id, module: moduleId, target: label, durationMs: run.durationMs, counts },
+            });
+            push({ type: 'result', run });
+        })().finally(() => {
+            finished = true;
+            wake?.();
+        });
+        for (;;) {
+            const event = queue.shift();
+            if (event) {
+                yield event;
+                continue;
+            }
+            if (finished)
+                break;
+            await new Promise((resolve) => {
+                wake = resolve;
+            });
+        }
+        await work;
+    }
+    get(id) {
+        const run = this.runs.get(id);
+        if (!run)
+            throw notFound('Audit introuvable.');
+        return run;
+    }
+    remove(id) {
+        this.get(id);
+        this.runs.delete(id);
+        if (this.deps.dir)
+            fs.rmSync(path.join(this.deps.dir, `${id}.json`), { force: true });
+    }
+    history(filter = {}) {
+        return [...this.runs.values()]
+            .filter((r) => !filter.module || r.module === filter.module)
+            .sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+            .map(summarize);
+    }
+    /** Dernier audit réussi de chaque couple module + cible : c'est l'état actuel connu. */
+    latest() {
+        const byKey = new Map();
+        for (const run of this.runs.values()) {
+            if (run.status !== 'done')
+                continue;
+            const key = `${run.module}|${run.target}`;
+            const known = byKey.get(key);
+            if (!known || known.startedAt < run.startedAt)
+                byKey.set(key, run);
+        }
+        return [...byKey.values()].sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    }
+    report(id) {
+        const run = this.get(id);
+        const mod = MODULES.find((m) => m.info.id === run.module);
+        const date = new Date(run.startedAt).toLocaleString('fr-FR');
+        const lines = [
+            `# ${mod?.info.title ?? run.module} · ${run.target}`,
+            '',
+            `- Date : ${date}`,
+            `- Durée : ${(run.durationMs / 1000).toFixed(1)} s`,
+            `- Module : ${mod?.info.title ?? run.module}`,
+            `- Périmètre du test : ${mod?.info.perimeter ?? ''}`,
+            '',
+            `## Résumé`,
+            '',
+            run.status === 'done' ? run.summary : `Échec : ${run.error ?? 'erreur inconnue'}`,
+            '',
+        ];
+        const counts = countBySeverity(run.findings);
+        if (run.findings.length > 0) {
+            lines.push('## Constats', '', '| Gravité | Nombre |', '|---|---|');
+            for (const s of SEVERITIES)
+                if (counts[s] > 0)
+                    lines.push(`| ${SEVERITY_LABELS[s]} | ${counts[s]} |`);
+            lines.push('');
+            for (const s of SEVERITIES) {
+                for (const f of run.findings.filter((x) => x.severity === s)) {
+                    lines.push(`### [${SEVERITY_LABELS[s]}] ${f.title}`, '', f.detail, '');
+                    if (f.evidence)
+                        lines.push('```', f.evidence, '```', '');
+                    if (f.recommendation)
+                        lines.push(`**Correction :** ${f.recommendation}`, '');
+                }
+            }
+        }
+        if (run.checks.length > 0) {
+            const status = { pass: 'conforme', fail: 'à corriger', warn: 'à surveiller', info: 'information', skip: 'non vérifié' };
+            lines.push('## Vérifications', '', '| Vérification | État | Valeur |', '|---|---|---|');
+            for (const c of run.checks)
+                lines.push(`| ${c.label.replace(/\|/g, '\\|')} | ${status[c.status]} | ${c.value.replace(/\|/g, '\\|').replace(/\n/g, ' ')} |`);
+            lines.push('');
+        }
+        lines.push('---', `Rapport produit par Prométhée, ${ouLeTestAPorte(run.target, mod)}.`);
+        return lines.join('\n');
+    }
+}
+/**
+ * Où le test a porté, pour la dernière ligne du rapport exporté. « Une cible déclarée » est faux pour la machine elle-même
+ * (127.0.0.1 n'est jamais déclarée) et pour les modules sans cible réseau (relecture D, groupe des « Haute »).
+ */
+export function ouLeTestAPorte(target, mod) {
+    if (mod?.info.input === 'path')
+        return 'sur des fichiers des dossiers autorisés de cette machine';
+    if (mod?.info.input === 'none')
+        return 'sur cette machine';
+    let hote = null;
+    try {
+        hote = parseHost(target).host;
+    }
+    catch {
+        hote = null;
+    }
+    return hote !== null && isLoopback(hote) ? 'sur cette machine' : 'sur une cible déclarée dans le périmètre autorisé';
+}