@nosserb/prmt 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,429 @@
+/** Modules locaux : configuration de sécurité de Windows, analyse de fichiers. */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { badRequest, forbidden } from '../../errors.js';
+import { classifyPath } from '../../engine/paths.js';
+import { plural, resteACorrigerEnTete } from '../types.js';
+/** Lit le JSON produit par ConvertTo-Json (un objet ou un tableau) au milieu d'une sortie de commande. */
+export function parseRows(output) {
+    const start = output.search(/[[{]/);
+    if (start < 0)
+        return [];
+    try {
+        const data = JSON.parse(output.slice(start).trim());
+        const rows = Array.isArray(data) ? data : [data];
+        return rows.filter((r) => r !== null && typeof r === 'object');
+    }
+    catch {
+        return [];
+    }
+}
+const truthy = (v) => v === true || v === 1 || v === 'True' || v === '1';
+/** Une valeur présente dans la sortie. Absente ou nulle, elle n'a pas été lue : on n'en déduit rien. */
+const lu = (v) => v !== null && v !== undefined && v !== '';
+/**
+ * Une vérification dont la sortie ne dit rien de lisible (vide, `[]`, sans JSON, champ absent) : « Non vérifié », sans constat.
+ * Jamais « conforme » sur une protection qu'on n'a pas lue, jamais d'alerte non plus (relecture D, groupe A).
+ */
+const nonLu = (value) => ({ check: { status: 'skip', value }, findings: [] });
+const RISKY_LISTENERS = { 135: 'RPC', 139: 'NetBIOS', 445: 'SMB', 3389: 'RDP', 5985: 'WinRM', 5900: 'VNC', 23: 'Telnet', 21: 'FTP' };
+export const CONFIG_CHECKS = [
+    {
+        label: 'Pare-feu Windows',
+        command: 'Get-NetFirewallProfile | Select-Object Name, Enabled | ConvertTo-Json -Compress',
+        judge(rows) {
+            // Aucun profil dans la sortie : rien ne dit que le pare-feu est actif. Non vérifié, jamais « conforme ».
+            const profils = rows.filter((r) => lu(r.Enabled));
+            if (profils.length === 0)
+                return nonLu('aucun profil lu dans la sortie');
+            const off = profils.filter((r) => !truthy(r.Enabled)).map((r) => String(r.Name));
+            return {
+                check: { status: off.length === 0 ? 'pass' : 'fail', value: off.length === 0 ? plural(profils.length, 'profil actif', 'profils actifs') : `désactivé : ${off.join(', ')}` },
+                findings: off.length === 0 ? [] : [{ severity: 'high', title: 'Pare-feu désactivé', detail: `Profil${off.length > 1 ? 's' : ''} sans pare-feu : ${off.join(', ')}. Tous les services en écoute sont joignables sur ces réseaux.`, recommendation: 'Réactiver le pare-feu : Paramètres › Confidentialité et sécurité › Sécurité Windows › Pare-feu.' }],
+            };
+        },
+    },
+    {
+        label: 'Antivirus Defender',
+        command: 'Get-MpComputerStatus | Select-Object AntivirusEnabled, RealTimeProtectionEnabled, AntivirusSignatureAge, IsTamperProtected | ConvertTo-Json -Compress',
+        judge(rows) {
+            const r = rows[0];
+            if (!r || !lu(r.RealTimeProtectionEnabled))
+                return nonLu('état de la protection en temps réel non lu dans la sortie');
+            const findings = [];
+            const realtime = truthy(r.RealTimeProtectionEnabled);
+            const age = lu(r.AntivirusSignatureAge) && Number.isFinite(Number(r.AntivirusSignatureAge)) ? Number(r.AntivirusSignatureAge) : null;
+            if (!realtime)
+                findings.push({ severity: 'high', title: 'Protection en temps réel désactivée', detail: 'Defender n’analyse pas les fichiers à leur ouverture.', recommendation: 'Réactiver la protection en temps réel dans Sécurité Windows (sauf si un autre antivirus la remplace).' });
+            if (age !== null && age > 7)
+                findings.push({ severity: 'medium', title: 'Signatures antivirus anciennes', detail: `Les signatures ont ${age} jours.`, recommendation: 'Lancer une mise à jour de Windows Update.' });
+            if (realtime && lu(r.IsTamperProtected) && !truthy(r.IsTamperProtected))
+                findings.push({ severity: 'low', title: 'Protection contre les falsifications désactivée', detail: 'Un programme peut désactiver Defender sans ton accord.', recommendation: 'Activer la protection contre les falsifications dans Sécurité Windows.' });
+            return { check: { status: findings.length === 0 ? 'pass' : realtime ? 'warn' : 'fail', value: `temps réel ${realtime ? 'actif' : 'inactif'} · ${age === null ? 'âge des signatures non lu' : `signatures de ${age} j`}` }, findings };
+        },
+    },
+    {
+        label: 'Contrôle de compte (UAC)',
+        command: "Get-ItemProperty -Path 'HKLM:\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System' | Select-Object EnableLUA, ConsentPromptBehaviorAdmin | ConvertTo-Json -Compress",
+        judge(rows) {
+            const r = rows[0];
+            if (!r || !lu(r.EnableLUA))
+                return nonLu('EnableLUA non lu dans la sortie');
+            const on = Number(r.EnableLUA) === 1;
+            const silent = Number(r.ConsentPromptBehaviorAdmin ?? 5) === 0;
+            const findings = [];
+            if (!on)
+                findings.push({ severity: 'high', title: 'UAC désactivé', detail: 'Tous les programmes lancés par un administrateur obtiennent les droits complets sans demande.', recommendation: 'Remettre EnableLUA à 1 et redémarrer.' });
+            else if (silent)
+                findings.push({ severity: 'medium', title: 'UAC sans demande de confirmation', detail: 'L’élévation est accordée silencieusement aux administrateurs.', recommendation: 'Remonter le curseur UAC au niveau par défaut.' });
+            return { check: { status: !on ? 'fail' : silent ? 'warn' : 'pass', value: !on ? 'désactivé' : silent ? 'actif, sans confirmation' : 'actif' }, findings };
+        },
+    },
+    {
+        label: 'Bureau à distance (RDP)',
+        command: "Get-ItemProperty -Path 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server' | Select-Object fDenyTSConnections | ConvertTo-Json -Compress",
+        judge(rows) {
+            const r = rows[0];
+            if (!r || !lu(r.fDenyTSConnections))
+                return nonLu('fDenyTSConnections non lu dans la sortie');
+            const enabled = Number(r.fDenyTSConnections) === 0;
+            return {
+                check: { status: enabled ? 'warn' : 'pass', value: enabled ? 'activé' : 'désactivé' },
+                findings: enabled ? [{ severity: 'medium', title: 'Bureau à distance activé', detail: 'La machine accepte les connexions RDP. C’est une cible fréquente des attaques par force brute.', recommendation: 'Le désactiver s’il ne sert pas, sinon le limiter au réseau local ou à un VPN.' }] : [],
+            };
+        },
+    },
+    {
+        label: 'Partage SMB',
+        command: 'Get-SmbServerConfiguration | Select-Object EnableSMB1Protocol, RequireSecuritySignature | ConvertTo-Json -Compress',
+        judge(rows) {
+            const r = rows[0];
+            if (!r || !lu(r.EnableSMB1Protocol))
+                return nonLu('état de SMBv1 non lu dans la sortie');
+            const smb1 = truthy(r.EnableSMB1Protocol);
+            const signature = !lu(r.RequireSecuritySignature) ? 'non lue' : truthy(r.RequireSecuritySignature) ? 'exigée' : 'facultative';
+            return {
+                check: { status: smb1 ? 'fail' : 'pass', value: `SMBv1 ${smb1 ? 'activé' : 'désactivé'} · signature ${signature}` },
+                findings: smb1 ? [{ severity: 'high', title: 'SMBv1 activé', detail: 'SMBv1 est le protocole exploité par WannaCry (EternalBlue). Il n’a plus de raison d’être activé.', recommendation: 'Désactiver SMBv1 dans les fonctionnalités de Windows.' }] : [],
+            };
+        },
+    },
+    {
+        label: 'Comptes locaux',
+        command: 'Get-LocalUser | Select-Object Name, Enabled, PasswordRequired | ConvertTo-Json -Compress',
+        judge(rows) {
+            const comptes = rows.filter((r) => lu(r.Name) && lu(r.Enabled));
+            if (comptes.length === 0)
+                return nonLu('aucun compte lu dans la sortie');
+            const active = comptes.filter((r) => truthy(r.Enabled));
+            const noPassword = active.filter((r) => !truthy(r.PasswordRequired)).map((r) => String(r.Name));
+            const guest = active.some((r) => /^(invité|guest)$/i.test(String(r.Name)));
+            const findings = [];
+            if (guest)
+                findings.push({ severity: 'high', title: 'Compte Invité activé', detail: 'Le compte Invité permet d’ouvrir une session sans mot de passe.', recommendation: 'Désactiver le compte Invité.' });
+            if (noPassword.length > 0)
+                findings.push({ severity: 'medium', title: 'Compte actif sans mot de passe obligatoire', detail: `Compte${noPassword.length > 1 ? 's' : ''} concerné${noPassword.length > 1 ? 's' : ''} : ${noPassword.join(', ')}.`, recommendation: 'Exiger un mot de passe pour chaque compte actif.' });
+            return { check: { status: findings.length === 0 ? 'pass' : 'warn', value: `${plural(active.length, 'compte actif', 'comptes actifs')} sur ${comptes.length}` }, findings };
+        },
+    },
+    {
+        label: 'Services en écoute',
+        command: 'Get-NetTCPConnection -State Listen | Select-Object LocalAddress, LocalPort | ConvertTo-Json -Compress',
+        judge(rows) {
+            if (!rows.some((r) => lu(r.LocalAddress) && lu(r.LocalPort)))
+                return nonLu('aucun port en écoute lu dans la sortie');
+            const exposed = [...new Set(rows.filter((r) => ['0.0.0.0', '::'].includes(String(r.LocalAddress))).map((r) => Number(r.LocalPort)))].sort((a, b) => a - b);
+            const risky = exposed.filter((p) => RISKY_LISTENERS[p] !== undefined);
+            return {
+                check: { status: risky.length > 0 ? 'warn' : 'info', value: `${plural(exposed.length, 'port en écoute', 'ports en écoute')} sur toutes les interfaces${risky.length > 0 ? `, dont ${risky.map((p) => `${p} (${RISKY_LISTENERS[p]})`).join(', ')}` : ''}` },
+                findings: risky.length > 0 ? [{ severity: 'low', title: 'Services Windows à l’écoute sur toutes les interfaces', detail: `Ports ${risky.map((p) => `${p} (${RISKY_LISTENERS[p]})`).join(', ')}. Ils sont joignables depuis le réseau si le pare-feu les laisse passer.`, recommendation: 'Vérifier que le pare-feu bloque ces ports sur les réseaux publics.' }] : [],
+            };
+        },
+    },
+    {
+        label: 'Dernière mise à jour',
+        command: 'Get-HotFix | Sort-Object InstalledOn -Descending | Select-Object -First 1 HotFixID, InstalledOn | ConvertTo-Json -Compress',
+        judge(rows, raw, now) {
+            const ms = Number(/Date\((\d+)\)/.exec(raw)?.[1] ?? NaN);
+            if (Number.isNaN(ms))
+                return { check: { status: 'skip', value: 'date du dernier correctif illisible' }, findings: [] };
+            const days = Math.floor((now.getTime() - ms) / 86_400_000);
+            const id = String(rows[0]?.HotFixID ?? 'correctif');
+            return {
+                check: { status: days > 60 ? 'warn' : 'pass', value: `${id} il y a ${days} j` },
+                findings: days > 60 ? [{ severity: 'medium', title: 'Aucun correctif installé depuis plus de deux mois', detail: `Le dernier correctif (${id}) date de ${days} jours.`, recommendation: 'Lancer Windows Update.' }] : [],
+            };
+        },
+    },
+    {
+        label: 'Politique d’exécution PowerShell',
+        command: 'Get-ExecutionPolicy',
+        judge(_rows, raw) {
+            const policy = raw.trim().split(/\r?\n/).pop()?.trim() ?? '';
+            if (!/^(Restricted|AllSigned|RemoteSigned|Unrestricted|Bypass|Undefined|Default)$/i.test(policy))
+                return nonLu('politique non lue dans la sortie');
+            const loose = /^(Unrestricted|Bypass)$/i.test(policy);
+            return {
+                check: { status: loose ? 'warn' : 'pass', value: policy },
+                findings: loose ? [{ severity: 'low', title: 'Scripts PowerShell sans restriction', detail: `La politique d’exécution est « ${policy} » : tout script téléchargé s’exécute sans avertissement.`, recommendation: 'Revenir à RemoteSigned.' }] : [],
+            };
+        },
+    },
+];
+function failure(result) {
+    const text = result.output.trim().split(/\r?\n/)[0] ?? '';
+    if (/acc[èe]s refus|access is denied|privil|[ée]l[ée]vation|administrat/i.test(result.output))
+        return 'droits administrateur requis';
+    return text ? text.slice(0, 120) : `code de sortie ${result.exitCode ?? '?'}`;
+}
+export const configModule = {
+    info: {
+        id: 'config',
+        letter: 'η',
+        title: 'Configuration de la machine',
+        objective: 'Contrôler les réglages de sécurité de ce PC : pare-feu, antivirus, UAC, RDP, SMB, comptes, mises à jour.',
+        perimeter: `${CONFIG_CHECKS.length} commandes PowerShell de lecture, listées ci-dessous, exécutées par le moteur avec la même liste blanche que le terminal. Rien n’est modifié.`,
+        results: 'L’état de chaque réglage, et pour chaque constat le risque et le réglage à changer.',
+        input: 'none',
+        fields: [],
+        commands: CONFIG_CHECKS.map((c) => c.command),
+    },
+    resolve: () => ({ label: 'Cette machine', host: null }),
+    async run(_input, ctx) {
+        const findings = [];
+        const checks = [];
+        let done = 0;
+        for (const item of CONFIG_CHECKS) {
+            ctx.progress(item.label, done, CONFIG_CHECKS.length);
+            try {
+                const result = await ctx.engine.runRead(item.command);
+                if (result.exitCode !== 0 && parseRows(result.output).length === 0 && !/^[A-Za-z]+\s*$/.test(result.output.trim()))
+                    checks.push({ label: item.label, status: 'skip', value: failure(result) });
+                else {
+                    const judged = item.judge(parseRows(result.output), result.output, ctx.now);
+                    checks.push({ label: item.label, ...judged.check });
+                    findings.push(...judged.findings);
+                }
+            }
+            catch (err) {
+                checks.push({ label: item.label, status: 'skip', value: err instanceof Error ? err.message.slice(0, 140) : 'erreur' });
+            }
+            done++;
+        }
+        ctx.progress('Terminé', done, CONFIG_CHECKS.length);
+        const skipped = checks.filter((c) => c.status === 'skip').length;
+        return { summary: `${resteACorrigerEnTete(findings.filter((f) => f.severity !== 'info').length)} sur ${checks.length - skipped} réglages vérifiés${skipped > 0 ? `, ${skipped} non vérifié${skipped > 1 ? 's' : ''}` : ''}.`, findings, checks };
+    },
+};
+// ------------------------------------------------------------------ Analyse de fichiers
+const MAGIC = [
+    { kind: 'pe', label: 'exécutable Windows', test: (b) => b[0] === 0x4d && b[1] === 0x5a },
+    { kind: 'elf', label: 'exécutable Linux', test: (b) => b.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])) },
+    { kind: 'zip', label: 'archive ZIP ou document Office', test: (b) => b.subarray(0, 4).equals(Buffer.from([0x50, 0x4b, 0x03, 0x04])) },
+    { kind: 'pdf', label: 'PDF', test: (b) => b.subarray(0, 4).toString('latin1') === '%PDF' },
+    { kind: 'png', label: 'image PNG', test: (b) => b.subarray(0, 4).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47])) },
+    { kind: 'jpg', label: 'image JPEG', test: (b) => b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff },
+    { kind: 'gif', label: 'image GIF', test: (b) => b.subarray(0, 4).toString('latin1') === 'GIF8' },
+    { kind: 'ole', label: 'document Office ancien ou installeur MSI', test: (b) => b.subarray(0, 4).equals(Buffer.from([0xd0, 0xcf, 0x11, 0xe0])) },
+    { kind: 'gzip', label: 'archive gzip', test: (b) => b[0] === 0x1f && b[1] === 0x8b },
+    { kind: '7z', label: 'archive 7-Zip', test: (b) => b.subarray(0, 4).equals(Buffer.from([0x37, 0x7a, 0xbc, 0xaf])) },
+    { kind: 'rar', label: 'archive RAR', test: (b) => b.subarray(0, 4).toString('latin1') === 'Rar!' },
+];
+const EXPECTED = {
+    '.exe': 'pe', '.dll': 'pe', '.sys': 'pe', '.scr': 'pe', '.com': 'pe', '.pdf': 'pdf', '.png': 'png', '.jpg': 'jpg', '.jpeg': 'jpg', '.gif': 'gif',
+    '.zip': 'zip', '.docx': 'zip', '.xlsx': 'zip', '.pptx': 'zip', '.jar': 'zip', '.doc': 'ole', '.xls': 'ole', '.ppt': 'ole', '.msi': 'ole',
+};
+const DOUBLE_EXTENSION = /\.(?:pdf|docx?|xlsx?|pptx?|jpe?g|png|gif|txt|zip)\.(?:exe|scr|bat|cmd|com|pif|js|vbs|ps1|lnk|hta)$/i;
+const TEXT_EXTENSIONS = new Set(['.env', '.ini', '.conf', '.config', '.cfg', '.json', '.yml', '.yaml', '.xml', '.toml', '.properties', '.ps1', '.psm1', '.bat', '.cmd', '.sh', '.py', '.js', '.ts', '.php', '.rb', '.go', '.rs', '.java', '.cs', '.sql', '.txt', '.md', '.log', '.tf', '.pem', '.key', '']);
+const SKIP_DIRS = new Set(['node_modules', '.git', '.venv', 'venv', '__pycache__', 'dist', 'build', 'target', 'appdata', '$recycle.bin', '.cache']);
+const SECRET_RULES = [
+    { label: 'Clé privée', pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/, severity: 'critical' },
+    { label: 'Clé d’accès AWS', pattern: /\bAKIA[0-9A-Z]{16}\b/, severity: 'high' },
+    { label: 'Jeton GitHub', pattern: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/, severity: 'high' },
+    { label: 'Jeton Slack', pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}/, severity: 'high' },
+    { label: 'Mot de passe ou clé en clair', pattern: /(?:password|passwd|pwd|mot_?de_?passe|(?:client[_-]?)?secret(?:[_-]?key)?|api[_-]?key|private[_-]?key|(?:access|auth)[_-]?token)\s*[:=]\s*["']?([^\s"'#;,<>{}$]{6,})/i, severity: 'medium' },
+];
+const PLACEHOLDER = /^(?:changeme|change_me|example|exemple|password|secret|xxx+|\*+|null|none|true|false|undefined|your[_-].*|<.*>)$/i;
+export function scanSecrets(text) {
+    const hits = [];
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length && hits.length < 20; i++) {
+        const line = lines[i] ?? '';
+        if (line.length > 2000)
+            continue;
+        for (const rule of SECRET_RULES) {
+            const m = rule.pattern.exec(line);
+            if (!m)
+                continue;
+            const value = m[1] ?? m[0];
+            if (m[1] !== undefined && PLACEHOLDER.test(value))
+                continue;
+            hits.push({ label: rule.label, severity: rule.severity, line: i + 1, excerpt: `${value.slice(0, 4)}…` });
+            break;
+        }
+    }
+    return hits;
+}
+export function entropy(bytes) {
+    if (bytes.length === 0)
+        return 0;
+    const counts = new Array(256).fill(0);
+    for (const b of bytes)
+        counts[b] = (counts[b] ?? 0) + 1;
+    let h = 0;
+    for (const c of counts) {
+        if (c === 0)
+            continue;
+        const p = c / bytes.length;
+        h -= p * Math.log2(p);
+    }
+    return Math.round(h * 100) / 100;
+}
+/** Analyse un fichier à partir de son nom et de son contenu (ou de son début). */
+export function inspectFile(name, head, text) {
+    const findings = [];
+    const ext = path.extname(name).toLowerCase();
+    const magic = MAGIC.find((m) => m.test(head)) ?? null;
+    if (DOUBLE_EXTENSION.test(name))
+        findings.push({ severity: 'high', title: `Double extension : ${name}`, detail: 'Le nom se termine comme un document mais le fichier est un programme. C’est une ruse classique de pièce jointe piégée.', recommendation: 'Ne pas l’ouvrir. Le supprimer s’il ne vient pas d’une source sûre.' });
+    const expected = EXPECTED[ext];
+    if (magic?.kind === 'pe' && expected !== 'pe')
+        findings.push({ severity: 'high', title: `Exécutable déguisé : ${name}`, detail: `Le contenu est un exécutable Windows alors que l’extension est « ${ext || 'absente'} ».`, recommendation: 'Vérifier sa provenance et son empreinte avant tout usage.' });
+    else if (expected && magic && magic.kind !== expected)
+        findings.push({ severity: 'low', title: `Extension trompeuse : ${name}`, detail: `L’extension annonce autre chose que le contenu (${magic.label}).` });
+    let secrets = 0;
+    if (text !== null) {
+        for (const hit of scanSecrets(text)) {
+            secrets++;
+            findings.push({ severity: hit.severity, title: `${hit.label} dans ${name}`, detail: `Ligne ${hit.line}. Un secret en clair dans un fichier finit souvent dans une sauvegarde ou un dépôt.`, evidence: `ligne ${hit.line} : ${hit.excerpt}`, recommendation: 'Déplacer le secret dans un coffre ou une variable d’environnement, puis le renouveler.' });
+        }
+    }
+    return { kind: magic?.kind ?? null, kindLabel: magic?.label ?? (text !== null ? 'texte' : 'format non reconnu'), findings, secrets };
+}
+const MAX_FILES = 400;
+const MAX_DEPTH = 5;
+const MAX_TEXT = 1024 * 1024;
+function readHead(file, size) {
+    const fd = fs.openSync(file, 'r');
+    try {
+        const buf = Buffer.alloc(Math.min(size, 262_144));
+        const read = fs.readSync(fd, buf, 0, buf.length, 0);
+        return buf.subarray(0, read);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function looksText(name, head) {
+    return TEXT_EXTENSIONS.has(path.extname(name).toLowerCase()) && !head.subarray(0, 4096).includes(0);
+}
+export const filesModule = {
+    info: {
+        id: 'files',
+        letter: 'θ',
+        title: 'Analyse de fichiers',
+        objective: 'Inspecter un fichier ou un dossier : secrets en clair, exécutables déguisés, doubles extensions.',
+        perimeter: `Lecture seule, dans tes dossiers autorisés uniquement. Un dossier est parcouru sur ${MAX_DEPTH} niveaux et ${MAX_FILES} fichiers au plus, sans entrer dans node_modules, .git, AppData, dist, build ni ${SKIP_DIRS.size - 5} autres dossiers de ce genre. Les secrets trouvés ne sont pas recopiés : seuls leurs quatre premiers caractères le sont.`,
+        results: 'Pour un fichier : empreinte SHA-256, type réel, entropie. Pour un dossier : chaque fichier suspect avec sa raison.',
+        input: 'path',
+        fields: [{ key: 'path', label: 'Fichier ou dossier', help: 'Chemin absolu, dans l’un de tes dossiers autorisés.', placeholder: 'C:\\Users\\toi\\Documents\\projet', required: true }],
+    },
+    resolve: (input) => {
+        const raw = (input.path ?? '').trim();
+        if (!raw)
+            throw badRequest('Indique le chemin d’un fichier ou d’un dossier.');
+        return { label: raw, host: null };
+    },
+    async run(input, ctx) {
+        const raw = (input.path ?? '').trim();
+        const resolved = classifyPath(raw, { cwd: ctx.roots[0] ?? ctx.home, roots: [...ctx.roots], home: ctx.home });
+        if (resolved.kind !== 'file' || !resolved.inScope)
+            throw forbidden(`« ${raw} » est en dehors de tes dossiers autorisés (${ctx.roots.join(', ')}).`, 'path_out_of_scope');
+        const stat = fs.statSync(resolved.absolute, { throwIfNoEntry: false });
+        if (!stat)
+            throw badRequest(`« ${resolved.absolute} » n’existe pas.`);
+        const findings = [];
+        const checks = [];
+        if (stat.isFile()) {
+            ctx.progress('Lecture du fichier', 0, 1);
+            const head = readHead(resolved.absolute, stat.size);
+            const name = path.basename(resolved.absolute);
+            const text = looksText(name, head) && stat.size <= MAX_TEXT ? fs.readFileSync(resolved.absolute, 'utf8') : null;
+            const report = inspectFile(name, head, text);
+            const hash = createHash('sha256');
+            await new Promise((resolve, reject) => fs.createReadStream(resolved.absolute).on('data', (c) => hash.update(c)).on('end', resolve).on('error', reject));
+            const h = entropy(head);
+            checks.push({ label: 'Taille', status: 'info', value: `${stat.size.toLocaleString('fr-FR')} octets` });
+            checks.push({ label: 'Type réel', status: 'info', value: report.kindLabel });
+            checks.push({ label: 'SHA-256', status: 'info', value: hash.digest('hex') });
+            checks.push({ label: 'Entropie', status: h > 7.5 && !['zip', 'gzip', '7z', 'rar', 'png', 'jpg', 'pdf'].includes(report.kind ?? '') ? 'warn' : 'info', value: `${h} bits par octet${h > 7.5 ? ' (contenu compressé ou chiffré)' : ''}` });
+            checks.push({ label: 'Secrets en clair', status: report.secrets > 0 ? 'fail' : text === null ? 'skip' : 'pass', value: text === null ? 'fichier binaire ou trop gros, non analysé' : String(report.secrets) });
+            findings.push(...report.findings);
+            ctx.progress('Terminé', 1, 1);
+            return { summary: findings.length === 0 ? 'Rien de suspect dans ce fichier.' : `${plural(findings.length, 'point à vérifier', 'points à vérifier')} dans ce fichier.`, findings, checks };
+        }
+        const files = [];
+        let truncated = false;
+        const walk = (dir, depth) => {
+            if (depth > MAX_DEPTH || truncated)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                if (entry.isSymbolicLink())
+                    continue;
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!SKIP_DIRS.has(entry.name.toLowerCase()))
+                        walk(full, depth + 1);
+                }
+                else if (entry.isFile()) {
+                    if (files.length >= MAX_FILES) {
+                        truncated = true;
+                        return;
+                    }
+                    files.push(full);
+                }
+            }
+        };
+        walk(resolved.absolute, 0);
+        let executables = 0;
+        let textFiles = 0;
+        let secrets = 0;
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i] ?? '';
+            if (i % 20 === 0)
+                ctx.progress(path.basename(file), i, files.length);
+            try {
+                const size = fs.statSync(file).size;
+                const head = readHead(file, size);
+                const name = path.basename(file);
+                const text = looksText(name, head) && size <= MAX_TEXT ? fs.readFileSync(file, 'utf8') : null;
+                if (text !== null)
+                    textFiles++;
+                const report = inspectFile(name, head, text);
+                if (report.kind === 'pe')
+                    executables++;
+                secrets += report.secrets;
+                const relative = path.relative(resolved.absolute, file);
+                for (const f of report.findings.slice(0, 5))
+                    findings.push({ ...f, evidence: `${relative}${f.evidence ? ` · ${f.evidence}` : ''}` });
+            }
+            catch {
+                /* fichier verrouillé ou illisible : ignoré */
+            }
+        }
+        ctx.progress('Terminé', files.length, files.length);
+        checks.push({ label: 'Fichiers parcourus', status: truncated ? 'warn' : 'info', value: `${files.length}${truncated ? ` (limite de ${MAX_FILES} atteinte)` : ''}` });
+        checks.push({ label: 'Fichiers texte analysés', status: 'info', value: String(textFiles) });
+        checks.push({ label: 'Exécutables Windows', status: 'info', value: String(executables) });
+        checks.push({ label: 'Secrets en clair', status: secrets > 0 ? 'fail' : 'pass', value: String(secrets) });
+        return { summary: findings.length === 0 ? `Rien de suspect dans les ${files.length} fichiers parcourus.` : `${plural(findings.length, 'constat à vérifier', 'constats à vérifier')} dans ${files.length} fichiers.`, findings: findings.slice(0, 80), checks };
+    },
+};