@nosserb/prmt 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,331 @@
+/** Modules réseau : surface d'attaque (DNS), ports ouverts, TLS. */
+import { Resolver } from 'node:dns/promises';
+import net from 'node:net';
+import { badRequest } from '../../errors.js';
+import { httpRequest, pool, tcpProbe, tlsProbe } from '../net.js';
+import { isLoopback } from '../../engine/paths.js';
+import { parseHost, plural, resteACorriger } from '../types.js';
+const targetField = { key: 'target', label: 'Cible', help: 'Nom d’hôte ou IP de ton périmètre autorisé.', placeholder: 'exemple.fr', required: true };
+// ------------------------------------------------------------------ Surface d'attaque
+async function lookup(query) {
+    try {
+        return await query();
+    }
+    catch {
+        return [];
+    }
+}
+export const surfaceModule = {
+    info: {
+        id: 'surface',
+        letter: 'α',
+        title: 'Surface d’attaque',
+        objective: 'Dresser ce qu’un attaquant voit en premier : adresses, serveurs de noms, messagerie, services web.',
+        perimeter: 'Requêtes DNS (A, AAAA, CNAME, NS, MX, TXT, DMARC, et PTR de la première adresse), puis une requête HEAD sur le port 80 et une sur le port 443. Aucun balayage de ports.',
+        results: 'Les enregistrements trouvés, la protection de la messagerie (SPF, DMARC) et ce que les serveurs web annoncent.',
+        input: 'target',
+        fields: [targetField],
+    },
+    resolve: (input) => {
+        const { host } = parseHost(input.target);
+        return { label: host, host };
+    },
+    async run(input, ctx) {
+        const { host } = parseHost(input.target);
+        const findings = [];
+        const checks = [];
+        const isIp = net.isIP(host) !== 0;
+        const resolver = new Resolver({ timeout: 4000, tries: 2 });
+        const total = 4;
+        ctx.progress('Résolution DNS', 0, total);
+        const [a, aaaa, cname, ns, mx, txt] = isIp
+            ? [[host], [], [], [], [], []]
+            : await Promise.all([
+                lookup(() => resolver.resolve4(host)),
+                lookup(() => resolver.resolve6(host)),
+                lookup(() => resolver.resolveCname(host)),
+                lookup(() => resolver.resolveNs(host)),
+                lookup(() => resolver.resolveMx(host)),
+                lookup(() => resolver.resolveTxt(host)),
+            ]);
+        const list = (items) => (items.length > 0 ? items.join(', ') : 'aucun');
+        checks.push({ label: 'Adresses IPv4 (A)', status: a.length > 0 ? 'info' : 'warn', value: list(a) });
+        if (!isIp) {
+            checks.push({ label: 'Adresses IPv6 (AAAA)', status: 'info', value: list(aaaa) });
+            if (cname.length > 0)
+                checks.push({ label: 'Alias (CNAME)', status: 'info', value: list(cname) });
+            checks.push({ label: 'Serveurs de noms (NS)', status: 'info', value: list(ns) });
+            checks.push({ label: 'Messagerie (MX)', status: 'info', value: list(mx.sort((x, y) => x.priority - y.priority).map((m) => `${m.exchange} (${m.priority})`)) });
+        }
+        if (a.length === 0 && aaaa.length === 0 && cname.length === 0) {
+            findings.push({ severity: 'info', title: 'Le nom ne se résout pas', detail: `Aucune adresse trouvée pour ${host}. Vérifie l’orthographe ou la zone DNS.` });
+        }
+        ctx.progress('Protection de la messagerie', 1, total);
+        if (!isIp) {
+            const flat = txt.map((parts) => parts.join(''));
+            const spf = flat.find((t) => /^v=spf1/i.test(t));
+            const dmarc = (await lookup(() => resolver.resolveTxt(`_dmarc.${host}`))).map((p) => p.join('')).find((t) => /^v=DMARC1/i.test(t));
+            const sendsMail = mx.length > 0;
+            checks.push({ label: 'SPF', status: spf ? 'pass' : sendsMail ? 'fail' : 'info', value: spf ?? 'absent' });
+            checks.push({ label: 'DMARC', status: dmarc ? (/p=none/i.test(dmarc) ? 'warn' : 'pass') : sendsMail ? 'fail' : 'info', value: dmarc ?? 'absent' });
+            if (!spf)
+                findings.push({ severity: sendsMail ? 'medium' : 'low', title: 'Pas d’enregistrement SPF', detail: 'N’importe quel serveur peut envoyer des courriels au nom de ce domaine sans être signalé.', recommendation: sendsMail ? 'Publier un enregistrement TXT « v=spf1 … -all » listant tes serveurs d’envoi.' : 'Si le domaine n’envoie pas de courriel, publier « v=spf1 -all ».' });
+            else if (/\+all/i.test(spf))
+                findings.push({ severity: 'high', title: 'SPF qui autorise tout le monde', detail: 'Le mécanisme +all valide n’importe quel expéditeur.', evidence: spf, recommendation: 'Remplacer +all par -all.' });
+            if (!dmarc)
+                findings.push({ severity: sendsMail ? 'medium' : 'low', title: 'Pas d’enregistrement DMARC', detail: 'Sans DMARC, les destinataires ne savent pas quoi faire des courriels qui usurpent le domaine.', recommendation: 'Publier « _dmarc » avec « v=DMARC1; p=quarantine; rua=mailto:… ».' });
+            else if (/p=none/i.test(dmarc))
+                findings.push({ severity: 'low', title: 'DMARC en simple observation', detail: 'La politique p=none ne bloque rien.', evidence: dmarc, recommendation: 'Passer à p=quarantine puis p=reject une fois les rapports vérifiés.' });
+        }
+        ctx.progress('Services web', 2, total);
+        for (const [scheme, port] of [['http', 80], ['https', 443]]) {
+            try {
+                const res = await httpRequest(`${scheme}://${host}/`, { method: 'HEAD', timeoutMs: 5000 });
+                const server = res.headers.server ?? 'non annoncé';
+                const redirect = res.location ? ` → ${res.location}` : '';
+                checks.push({ label: `Port ${port} (${scheme.toUpperCase()})`, status: 'info', value: `${res.status}${redirect} · serveur : ${server}` });
+                if (/\d+\.\d+/.test(server))
+                    findings.push({ severity: 'low', title: `Version du serveur visible sur le port ${port}`, detail: 'Le serveur annonce son logiciel et sa version exacte.', evidence: `Server: ${server}`, recommendation: 'Masquer la version dans la configuration du serveur.' });
+            }
+            catch {
+                checks.push({ label: `Port ${port} (${scheme.toUpperCase()})`, status: 'info', value: 'pas de réponse' });
+            }
+        }
+        ctx.progress('Nom inverse', 3, total);
+        const first = a[0];
+        if (first) {
+            const reverse = await lookup(() => resolver.reverse(first));
+            checks.push({ label: `Nom inverse de ${first}`, status: 'info', value: list(reverse) });
+        }
+        ctx.progress('Terminé', total, total);
+        const real = findings.filter((f) => f.severity !== 'info').length;
+        return { summary: `${plural(a.length + aaaa.length, 'adresse', 'adresses')}, ${plural(mx.length, 'serveur de messagerie', 'serveurs de messagerie')}, ${resteACorriger(real)}.`, findings, checks };
+    },
+};
+// ------------------------------------------------------------------ Ports
+export const DEFAULT_PORTS = [21, 22, 23, 25, 53, 80, 110, 135, 139, 143, 443, 445, 465, 587, 993, 995, 1433, 3306, 3389, 5432, 5900, 5985, 6379, 8080, 8443, 9200, 11434, 27017];
+const SERVICES = {
+    21: { name: 'FTP', risky: 'transfert de fichiers en clair' },
+    22: { name: 'SSH' },
+    23: { name: 'Telnet', risky: 'administration en clair' },
+    25: { name: 'SMTP' },
+    53: { name: 'DNS' },
+    80: { name: 'HTTP' },
+    110: { name: 'POP3' },
+    135: { name: 'RPC Windows', risky: 'service Windows interne' },
+    139: { name: 'NetBIOS', risky: 'partage Windows' },
+    143: { name: 'IMAP' },
+    443: { name: 'HTTPS' },
+    445: { name: 'SMB', risky: 'partage de fichiers Windows' },
+    465: { name: 'SMTPS' },
+    587: { name: 'SMTP (soumission)' },
+    993: { name: 'IMAPS' },
+    995: { name: 'POP3S' },
+    1433: { name: 'SQL Server', risky: 'base de données' },
+    3306: { name: 'MySQL', risky: 'base de données' },
+    3389: { name: 'Bureau à distance (RDP)', risky: 'prise de contrôle à distance' },
+    5432: { name: 'PostgreSQL', risky: 'base de données' },
+    5900: { name: 'VNC', risky: 'prise de contrôle à distance' },
+    5985: { name: 'WinRM', risky: 'administration Windows à distance' },
+    6379: { name: 'Redis', risky: 'base de données souvent sans mot de passe' },
+    8080: { name: 'HTTP (alternatif)' },
+    8443: { name: 'HTTPS (alternatif)' },
+    9200: { name: 'Elasticsearch', risky: 'base de données souvent sans mot de passe' },
+    11434: { name: 'Ollama', risky: 'API de modèles sans authentification' },
+    27017: { name: 'MongoDB', risky: 'base de données' },
+};
+export function parsePorts(value, field) {
+    const raw = (value ?? '').trim();
+    if (!raw)
+        return [];
+    const ports = new Set();
+    for (const part of raw.split(/[\s,;]+/).filter(Boolean)) {
+        const range = /^(\d{1,5})-(\d{1,5})$/.exec(part);
+        const from = Number(range ? range[1] : part);
+        const to = Number(range ? range[2] : part);
+        if (!Number.isInteger(from) || !Number.isInteger(to) || from < 1 || to > 65535 || from > to)
+            throw badRequest(`${field} : « ${part} » n’est pas un port valide.`);
+        for (let p = from; p <= to; p++)
+            ports.add(p);
+        if (ports.size > 64)
+            throw badRequest(`${field} : 64 ports au maximum par vérification.`);
+    }
+    return [...ports].sort((x, y) => x - y);
+}
+/**
+ * `local` : la cible est cette machine (127.0.0.1, localhost, ::1). Un port qui y répond peut n'écouter que sur la boucle locale,
+ * comme Ollama : le balayage ne dit pas s'il est joignable depuis le réseau, le constat ne le dit pas non plus (relecture D).
+ */
+export function classifyPorts(results, expected, local = false) {
+    const findings = [];
+    const declared = expected.length > 0;
+    const checks = results.map(({ port, state }) => {
+        const service = SERVICES[port];
+        const label = `Port ${port}${service ? ` · ${service.name}` : ''}`;
+        if (state !== 'open')
+            return { label, status: expected.includes(port) ? 'warn' : 'pass', value: state === 'closed' ? 'fermé' : 'filtré (pas de réponse)' };
+        const unexpected = declared && !expected.includes(port);
+        if (unexpected) {
+            findings.push({ severity: service?.risky ? 'high' : 'medium', title: `Port ${port} ouvert sans être attendu`, detail: `${service?.name ?? 'Service inconnu'} répond alors qu’il ne figure pas dans ta liste de ports attendus.${service?.risky ? ` Risque : ${service.risky}.` : ''}`, recommendation: 'Fermer le port au pare-feu, ou l’ajouter à la liste s’il est voulu.' });
+        }
+        else if (!declared && service?.risky && local) {
+            findings.push({ severity: 'medium', title: `${service.name} ouvert (port ${port})`, detail: `Risque s’il est joignable depuis le réseau : ${service.risky}. Un test depuis cette machine ne dit pas s’il l’est.`, recommendation: `Lire son adresse d’écoute avec Get-NetTCPConnection -LocalPort ${port} -State Listen : 127.0.0.1 le garde sur cette machine, 0.0.0.0 l’ouvre au réseau.` });
+        }
+        else if (!declared && service?.risky) {
+            findings.push({ severity: 'medium', title: `${service.name} exposé (port ${port})`, detail: `Risque : ${service.risky}. Ce service ne devrait en général pas être joignable depuis l’extérieur.`, recommendation: 'Le restreindre à un réseau de confiance ou à un VPN.' });
+        }
+        return { label, status: unexpected ? 'fail' : !declared && service?.risky ? 'warn' : 'info', value: 'ouvert' };
+    });
+    for (const port of expected) {
+        const found = results.find((r) => r.port === port);
+        if (found && found.state !== 'open')
+            findings.push({ severity: 'info', title: `Port ${port} attendu mais injoignable`, detail: 'Le service prévu sur ce port ne répond pas.' });
+    }
+    const open = results.filter((r) => r.state === 'open').length;
+    return { summary: `${plural(open, 'port ouvert', 'ports ouverts')} sur ${results.length} testés${declared ? `, ${plural(findings.filter((f) => f.severity !== 'info').length, 'inattendu', 'inattendus')}` : ''}.`, findings, checks };
+}
+export const portsModule = {
+    info: {
+        id: 'ports',
+        letter: 'β',
+        title: 'Ports autorisés',
+        objective: 'Comparer les ports réellement ouverts à ceux que tu attends.',
+        perimeter: `Une connexion TCP complète par port, refermée aussitôt (pas de paquets forgés). Par défaut ${DEFAULT_PORTS.length} ports courants. 64 ports au plus par liste, 96 en tout, 12 en parallèle.`,
+        results: 'L’état de chaque port. Un constat par port ouvert hors de ta liste, ou, sans liste, par service à risque ouvert.',
+        input: 'target',
+        fields: [
+            targetField,
+            { key: 'ports', label: 'Ports à tester', help: `Vide : les ${DEFAULT_PORTS.length} ports courants.`, placeholder: '22, 443, 8000-8010', required: false },
+            { key: 'expected', label: 'Ports attendus ouverts', help: 'Rempli : tout autre port ouvert est signalé.', placeholder: '80, 443', required: false },
+        ],
+    },
+    resolve: (input) => {
+        const { host } = parseHost(input.target);
+        return { label: host, host };
+    },
+    async run(input, ctx) {
+        const { host } = parseHost(input.target);
+        const expected = parsePorts(input.expected, 'Ports attendus');
+        const asked = parsePorts(input.ports, 'Ports à tester');
+        const ports = [...new Set([...(asked.length > 0 ? asked : DEFAULT_PORTS), ...expected])].sort((x, y) => x - y);
+        if (ports.length > 96)
+            throw badRequest('Trop de ports : réduis la liste.');
+        let done = 0;
+        ctx.progress('Connexions TCP', 0, ports.length);
+        const results = await pool(ports, 12, async (port) => {
+            const state = await tcpProbe(host, port);
+            ctx.progress(`Port ${port}`, ++done, ports.length);
+            return { port, state };
+        });
+        return classifyPorts(results, expected, isLoopback(host));
+    },
+};
+// ------------------------------------------------------------------ TLS
+const DAY = 86_400_000;
+export function analyzeCertificate(info, host, now) {
+    const findings = [];
+    const checks = [];
+    const expires = new Date(info.validTo);
+    const days = Math.floor((expires.getTime() - now.getTime()) / DAY);
+    const dateText = Number.isNaN(expires.getTime()) ? info.validTo : expires.toLocaleDateString('fr-FR');
+    if (Number.isNaN(days))
+        checks.push({ label: 'Expiration du certificat', status: 'skip', value: 'date illisible' });
+    else if (days < 0) {
+        checks.push({ label: 'Expiration du certificat', status: 'fail', value: `expiré depuis ${-days} j (${dateText})` });
+        findings.push({ severity: 'critical', title: 'Certificat expiré', detail: `Le certificat a expiré le ${dateText}. Les navigateurs affichent une alerte bloquante.`, recommendation: 'Renouveler le certificat et automatiser le renouvellement.' });
+    }
+    else {
+        checks.push({ label: 'Expiration du certificat', status: days < 30 ? 'warn' : 'pass', value: `dans ${days} j (${dateText})` });
+        if (days < 15)
+            findings.push({ severity: 'high', title: 'Certificat sur le point d’expirer', detail: `Il reste ${days} jours.`, recommendation: 'Renouveler le certificat maintenant.' });
+        else if (days < 30)
+            findings.push({ severity: 'medium', title: 'Certificat à renouveler ce mois-ci', detail: `Il reste ${days} jours.`, recommendation: 'Planifier le renouvellement.' });
+    }
+    const matches = net.isIP(host) !== 0 || info.altNames.some((n) => n.toLowerCase() === host || (n.startsWith('*.') && host.endsWith(n.slice(1).toLowerCase()) && host.split('.').length === n.split('.').length));
+    checks.push({ label: 'Nom couvert par le certificat', status: matches ? 'pass' : 'fail', value: info.altNames.slice(0, 6).join(', ') || info.subject || 'aucun nom' });
+    if (!matches)
+        findings.push({ severity: 'high', title: 'Le certificat ne couvre pas ce nom', detail: `${host} n’apparaît pas dans les noms du certificat.`, evidence: info.altNames.join(', '), recommendation: 'Émettre un certificat qui inclut ce nom.' });
+    if (info.selfSigned) {
+        checks.push({ label: 'Chaîne de confiance', status: 'fail', value: 'certificat auto-signé' });
+        findings.push({ severity: 'high', title: 'Certificat auto-signé', detail: 'Aucune autorité reconnue ne garantit ce certificat : un visiteur ne peut pas distinguer ton serveur d’un imposteur.', recommendation: 'Utiliser un certificat d’une autorité reconnue (Let’s Encrypt est gratuit).' });
+    }
+    else if (!info.authorized && info.authorizationError && !/HOSTNAME_MISMATCH|ERR_TLS_CERT_ALTNAME|CERT_HAS_EXPIRED/i.test(info.authorizationError)) {
+        checks.push({ label: 'Chaîne de confiance', status: 'fail', value: info.authorizationError });
+        findings.push({ severity: 'high', title: 'Chaîne de certificats non reconnue', detail: `La vérification échoue : ${info.authorizationError}.`, recommendation: 'Servir la chaîne complète, intermédiaires compris.' });
+    }
+    else
+        checks.push({ label: 'Chaîne de confiance', status: 'pass', value: `émis par ${info.issuer || 'inconnu'}` });
+    if (info.keyBits !== null) {
+        const weak = info.keyBits < 2048 && info.keyBits >= 1024;
+        const tiny = info.keyBits < 1024 && info.keyBits > 521;
+        checks.push({ label: 'Taille de clé', status: weak || tiny ? 'fail' : 'pass', value: `${info.keyBits} bits` });
+        if (weak || tiny)
+            findings.push({ severity: 'high', title: 'Clé du certificat trop courte', detail: `${info.keyBits} bits : en dessous de 2048 bits pour RSA, la clé est considérée comme cassable.`, recommendation: 'Générer une clé RSA de 2048 bits au moins, ou une clé ECDSA P-256.' });
+    }
+    if (info.cipher) {
+        const weakCipher = /RC4|3DES|DES-CBC|NULL|EXPORT|MD5/i.test(info.cipher);
+        checks.push({ label: 'Suite négociée', status: weakCipher ? 'fail' : 'pass', value: `${info.protocol ?? '?'} · ${info.cipher}` });
+        if (weakCipher)
+            findings.push({ severity: 'medium', title: 'Suite de chiffrement faible', detail: `Le serveur a choisi ${info.cipher}.`, recommendation: 'Désactiver RC4, 3DES et les suites sans authentification.' });
+    }
+    return { summary: '', findings, checks };
+}
+const VERSIONS = [
+    { version: 'TLSv1', label: 'TLS 1.0', deprecated: true },
+    { version: 'TLSv1.1', label: 'TLS 1.1', deprecated: true },
+    { version: 'TLSv1.2', label: 'TLS 1.2', deprecated: false },
+    { version: 'TLSv1.3', label: 'TLS 1.3', deprecated: false },
+];
+export const tlsModule = {
+    info: {
+        id: 'tls',
+        letter: 'δ',
+        title: 'TLS / SSL',
+        objective: 'Vérifier le certificat et les versions de TLS que le serveur accepte.',
+        perimeter: 'Cinq poignées de main TLS sur le port choisi (443 par défaut) : une normale, puis une par version de TLS 1.0 à 1.3. Aucune donnée applicative n’est envoyée.',
+        results: 'Validité, nom, chaîne et clé du certificat, puis la liste des versions acceptées.',
+        input: 'target',
+        fields: [{ ...targetField, help: 'Nom d’hôte ou IP de ton périmètre, avec le port s’il n’est pas 443 (exemple.fr:8443).' }],
+    },
+    resolve: (input) => {
+        const { host, port } = parseHost(input.target);
+        return { label: port && port !== 443 ? `${host}:${port}` : host, host };
+    },
+    async run(input, ctx) {
+        const { host, port: givenPort } = parseHost(input.target);
+        const port = givenPort ?? 443;
+        const total = 1 + VERSIONS.length;
+        ctx.progress('Certificat', 0, total);
+        const main = await tlsProbe(host, port);
+        if (!main.ok) {
+            return {
+                summary: `Pas de TLS sur ${host}:${port}.`,
+                findings: [{ severity: 'info', title: 'Poignée de main TLS impossible', detail: main.reason === 'unreachable' ? `Le port ${port} ne répond pas (${main.message}).` : `Le serveur a refusé la connexion TLS (${main.message}).` }],
+                checks: [{ label: `TLS sur le port ${port}`, status: 'fail', value: main.message }],
+            };
+        }
+        const out = analyzeCertificate(main.info, host, ctx.now);
+        let done = 1;
+        const accepted = [];
+        for (const { version, label, deprecated } of VERSIONS) {
+            ctx.progress(label, done++, total);
+            const attempt = await tlsProbe(host, port, version);
+            if (attempt.ok) {
+                accepted.push(label);
+                out.checks.push({ label, status: deprecated ? 'fail' : 'pass', value: 'acceptée' });
+                if (deprecated)
+                    out.findings.push({ severity: 'medium', title: `${label} encore acceptée`, detail: `${label} est obsolète depuis 2021 (RFC 8996) et vulnérable à des attaques connues.`, recommendation: 'Désactiver TLS 1.0 et 1.1, garder 1.2 et 1.3.' });
+            }
+            else if (attempt.reason === 'unsupported')
+                out.checks.push({ label, status: 'skip', value: 'non testable depuis cette machine' });
+            else
+                out.checks.push({ label, status: deprecated ? 'pass' : 'warn', value: 'refusée' });
+        }
+        if (!accepted.includes('TLS 1.3') && out.checks.some((c) => c.label === 'TLS 1.3' && c.value === 'refusée'))
+            out.findings.push({ severity: 'low', title: 'TLS 1.3 non proposé', detail: 'TLS 1.3 est plus rapide et retire les suites fragiles.', recommendation: 'Activer TLS 1.3 sur le serveur.' });
+        ctx.progress('Terminé', total, total);
+        const real = out.findings.filter((f) => f.severity !== 'info').length;
+        out.summary = `${accepted.join(', ') || 'Aucune version'} acceptée${accepted.length > 1 ? 's' : ''}, ${resteACorriger(real)}.`;
+        return out;
+    },
+};