@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/telephone/acces.js

@@ -0,0 +1,457 @@
+/**
+ * Accès depuis le téléphone : la console, joignable par le réseau local en HTTPS, pour les seuls appareils appairés.
+ *
+ * Fermé par défaut, ouvert depuis les Réglages du PC. Une fois ouvert, il le reste aux démarrages suivants, jusqu'à ce qu'on
+ * le ferme. Le serveur de la boucle locale (127.0.0.1:4317) ne change pas. Ce module tient l'écoute, le certificat, les
+ * codes d'appairage et les appareils. La garde et les routes restent dans server/http/guard.ts et server/app.ts.
+ *
+ * Écoute : un seul port (4318) par adresse du PC sur un réseau privé. Le premier octet de chaque connexion dit s'il s'agit
+ * de TLS : sinon, une redirection vers https, pour qu'une adresse tapée sans « https:// » mène quand même à la console.
+ */
+import { createHash, randomBytes, randomInt, timingSafeEqual } from 'node:crypto';
+import fs from 'node:fs';
+import http from 'node:http';
+import https from 'node:https';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { AppError, notFound } from '../errors.js';
+import { loadCertificate, makeCertificate } from './certificat.js';
+import { qrRows } from './qr.js';
+export const PHONE_PORT = 4318;
+export const COOKIE = '__Host-promethee-appareil';
+/** Un appareil qui ne s'est pas montré depuis 30 jours doit être appairé de nouveau. */
+export const DEVICE_DAYS = 30;
+export const CODE_MINUTES = 10;
+export const CODE_TRIES = 5;
+/** Essais d'appairage par minute, tous codes confondus. */
+const TRIES_PER_MINUTE = 20;
+const DAY = 86_400_000;
+/** Sans ambiguïté à la lecture : ni O, ni 0, ni I, ni 1, ni L. */
+const ALPHABET = 'ABCDEFGHJKMNPQRSTUVWXYZ23456789';
+const isPrivate = (ip) => /^10\./.test(ip) || /^192\.168\./.test(ip) || /^172\.(1[6-9]|2\d|3[01])\./.test(ip);
+/** 100.64.0.0/10 : les adresses que Tailscale donne aux appareils de ton réseau privé. */
+const isTailscale = (ip) => /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(ip);
+/** Cartes virtuelles : WSL, Hyper-V, machines virtuelles, Docker, Bluetooth. Un téléphone n'y est jamais. */
+const VIRTUAL = /vEthernet|WSL|Hyper-V|VirtualBox|vboxnet|VMware|Docker|Loopback|Bluetooth/i;
+/**
+ * Adresses IPv4 du PC où un téléphone peut le joindre : le réseau local (adresses privées, cartes virtuelles écartées), et
+ * l'adresse Tailscale si Tailscale est installé, pour joindre la console de l'extérieur sans rien ouvrir sur internet.
+ */
+export function lanAddresses(interfaces = os.networkInterfaces()) {
+    const lan = [];
+    const tailnet = [];
+    for (const [name, list] of Object.entries(interfaces)) {
+        const tailscale = /tailscale/i.test(name);
+        if (!tailscale && VIRTUAL.test(name))
+            continue;
+        for (const a of list ?? []) {
+            if (a.family !== 'IPv4' || a.internal)
+                continue;
+            if (tailscale && isTailscale(a.address) && !tailnet.includes(a.address))
+                tailnet.push(a.address);
+            if (!tailscale && isPrivate(a.address) && !lan.includes(a.address))
+                lan.push(a.address);
+        }
+    }
+    // Tailscale d'abord : le QR code mène à la première adresse, et celle-là marche chez toi comme dehors. Pour le navigateur
+    // du téléphone, chaque adresse est un site à part, appairé à part.
+    return [...tailnet, ...lan];
+}
+/** Toutes les 30 s, l'accès ouvert relit les adresses du PC : un autre Wi-Fi, ou Tailscale qui démarre, sont pris en compte. */
+export const WATCH_MS = 30_000;
+/** « Chrome sur Android », « Safari sur iPhone »… Rien d'autre n'est tiré de l'en-tête. */
+export function deviceName(ua) {
+    const browser = /EdgA?\/|EdgiOS\//.test(ua)
+        ? 'Edge'
+        : /SamsungBrowser\//.test(ua)
+            ? 'Samsung Internet'
+            : /Firefox\/|FxiOS\//.test(ua)
+                ? 'Firefox'
+                : /CriOS\/|Chrome\//.test(ua)
+                    ? 'Chrome'
+                    : /Safari\//.test(ua)
+                        ? 'Safari'
+                        : 'Navigateur';
+    const system = /iPhone/.test(ua) ? 'iPhone' : /iPad/.test(ua) ? 'iPad' : /Android/.test(ua) ? 'Android' : /Windows/.test(ua) ? 'Windows' : /Mac OS X|Macintosh/.test(ua) ? 'Mac' : /Linux/.test(ua) ? 'Linux' : 'appareil inconnu';
+    return `${browser} sur ${system}`;
+}
+export const normalizeCode = (code) => code.toUpperCase().replace(/[^A-Z0-9]/g, '');
+const sha256 = (s) => createHash('sha256').update(s).digest('hex');
+const sameHex = (a, b) => a.length === b.length && timingSafeEqual(Buffer.from(a, 'hex'), Buffer.from(b, 'hex'));
+/** La valeur du cookie d'appareil dans un en-tête Cookie, ou null. */
+export function cookieValue(header) {
+    for (const part of (header ?? '').split(';')) {
+        const at = part.indexOf('=');
+        if (at > 0 && part.slice(0, at).trim() === COOKIE)
+            return part.slice(at + 1).trim();
+    }
+    return null;
+}
+export const setCookie = (value) => `${COOKIE}=${value}; Path=/; Max-Age=${DEVICE_DAYS * 86_400}; HttpOnly; Secure; SameSite=Strict`;
+export class PhoneAccess {
+    file;
+    port;
+    now;
+    stored;
+    listening = null;
+    cert = null;
+    error = null;
+    pairing = null;
+    tries = [];
+    /** Connexions ouvertes par chaque appareil : retirer un appareil les coupe. */
+    connections = new Map();
+    options;
+    watcher = null;
+    rechecking = false;
+    constructor(options) {
+        this.options = options;
+        this.file = options.dir ? path.join(options.dir, 'appareils.json') : null;
+        this.port = options.port ?? PHONE_PORT;
+        this.now = options.now ?? Date.now;
+        this.stored = this.load();
+        if (options.dir) {
+            const key = this.read('cle.pem');
+            const cert = this.read('certificat.pem');
+            if (key && cert)
+                this.cert = loadCertificate(key, cert, new Date(this.now()));
+        }
+    }
+    // ------------------------------------------------------------ Disque
+    read(name) {
+        if (!this.options.dir)
+            return null;
+        try {
+            return fs.readFileSync(path.join(this.options.dir, name), 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    write(name, text) {
+        if (!this.options.dir)
+            return;
+        fs.mkdirSync(this.options.dir, { recursive: true });
+        const file = path.join(this.options.dir, name);
+        fs.writeFileSync(`${file}.tmp`, text, 'utf8');
+        fs.renameSync(`${file}.tmp`, file);
+    }
+    load() {
+        const text = this.read('appareils.json');
+        if (!text)
+            return { active: false, devices: [] };
+        try {
+            const s = JSON.parse(text);
+            const devices = (Array.isArray(s.devices) ? s.devices : []).filter((d) => typeof d?.id === 'string' && typeof d.name === 'string' && typeof d.hash === 'string' && /^[a-f0-9]{64}$/.test(d.hash) && typeof d.pairedAt === 'string');
+            return { active: s.active === true, devices };
+        }
+        catch {
+            return { active: false, devices: [] };
+        }
+    }
+    save() {
+        if (this.file)
+            this.write('appareils.json', `${JSON.stringify(this.stored, null, 2)}\n`);
+    }
+    // ------------------------------------------------------------ État
+    urls() {
+        return (this.listening?.ips ?? []).map((ip) => `https://${ip}:${this.listening?.port ?? this.port}`);
+    }
+    /** Hôtes acceptés par la garde : « IP:port » de chaque adresse écoutée. */
+    hosts() {
+        return (this.listening?.ips ?? []).map((ip) => `${ip}:${this.listening?.port ?? this.port}`);
+    }
+    expired(d) {
+        return this.now() - Date.parse(d.lastSeenAt ?? d.pairedAt) > DEVICE_DAYS * DAY;
+    }
+    devices() {
+        const live = this.stored.devices.filter((d) => !this.expired(d));
+        if (live.length !== this.stored.devices.length) {
+            this.stored.devices = live;
+            this.save();
+        }
+        return live;
+    }
+    state() {
+        const pairing = this.pairing && this.pairing.expiresAt > this.now() ? this.pairing : null;
+        const url = this.urls()[0];
+        return {
+            active: this.stored.active,
+            urls: this.urls(),
+            port: this.listening?.port ?? this.port,
+            fingerprint: this.cert?.fingerprint ?? null,
+            error: this.error,
+            pairing: pairing && url
+                ? { code: pairing.code, expiresAt: new Date(pairing.expiresAt).toISOString(), url: `${url}/#appairer=${pairing.code}`, qr: qrRows(`${url}/#appairer=${pairing.code}`) }
+                : null,
+            devices: this.devices().map(({ id, name, pairedAt, lastSeenAt }) => ({ id, name, pairedAt, lastSeenAt })),
+        };
+    }
+    summary() {
+        return { active: this.stored.active, urls: this.urls(), devices: this.devices().length };
+    }
+    // ------------------------------------------------------------ Ouverture et fermeture
+    /** Au démarrage du serveur : rouvre l'accès s'il était ouvert. */
+    async resume() {
+        if (!this.stored.active)
+            return;
+        await this.listen();
+        this.watch();
+        this.options.journal.add({
+            kind: 'security',
+            outcome: this.listening ? 'info' : 'error',
+            title: this.listening ? 'Accès téléphone rouvert au démarrage' : 'Accès téléphone : écoute impossible au démarrage',
+            detail: this.listening ? `${this.urls().join(', ')}, appareils appairés seulement` : (this.error ?? ''),
+        });
+    }
+    async open() {
+        const was = this.stored.active;
+        this.stored.active = true;
+        this.save();
+        await this.listen();
+        this.watch();
+        if (this.listening)
+            this.newCode();
+        if (!was)
+            this.options.journal.add({
+                kind: 'security',
+                outcome: this.listening ? 'info' : 'error',
+                title: this.listening ? 'Accès téléphone ouvert' : 'Accès téléphone : écoute impossible',
+                detail: this.listening ? `${this.urls().join(', ')}, appareils appairés seulement` : (this.error ?? ''),
+            });
+        return this.state();
+    }
+    async close() {
+        const was = this.stored.active;
+        this.stored.active = false;
+        this.pairing = null;
+        this.save();
+        this.unwatch();
+        await this.stop();
+        this.error = null;
+        if (was)
+            this.options.journal.add({ kind: 'security', outcome: 'info', title: 'Accès téléphone fermé', detail: 'La console ne répond plus que sur cette machine.' });
+        return this.state();
+    }
+    certificate(ips) {
+        if (this.cert && ips.every((ip) => this.cert?.ips.includes(ip)))
+            return this.cert;
+        // Nouvelle adresse (autre Wi-Fi) : nouveau certificat, nouvelle empreinte. Les appareils restent appairés.
+        this.cert = makeCertificate(ips, new Date(this.now()));
+        this.write('cle.pem', this.cert.key);
+        this.write('certificat.pem', this.cert.cert);
+        return this.cert;
+    }
+    addresses() {
+        return this.options.addresses ? this.options.addresses() : lanAddresses();
+    }
+    watch() {
+        if (this.watcher)
+            return;
+        this.watcher = setInterval(() => void this.recheck(), this.options.watchMs ?? WATCH_MS);
+        this.watcher.unref();
+    }
+    unwatch() {
+        if (this.watcher)
+            clearInterval(this.watcher);
+        this.watcher = null;
+    }
+    /** Les adresses ont changé (autre Wi-Fi, Tailscale démarré ou arrêté), ou l'écoute avait échoué : on rouvre. */
+    async recheck() {
+        if (!this.stored.active || this.rechecking)
+            return;
+        const ips = this.addresses();
+        const before = this.listening?.ips ?? [];
+        const same = ips.length === before.length && ips.every((ip) => before.includes(ip));
+        if (same && (this.listening || ips.length === 0))
+            return;
+        this.rechecking = true;
+        try {
+            const was = this.listening !== null;
+            await this.listen();
+            if (!same || (!was && this.listening))
+                this.options.journal.add({
+                    kind: 'security',
+                    outcome: this.listening ? 'info' : 'error',
+                    title: 'Accès téléphone : adresses du PC changées',
+                    detail: this.listening ? `${this.urls().join(', ')}, appareils appairés seulement` : (this.error ?? ''),
+                });
+        }
+        finally {
+            this.rechecking = false;
+        }
+    }
+    async listen() {
+        await this.stop();
+        this.error = null;
+        const ips = this.addresses();
+        if (ips.length === 0) {
+            this.error = 'Le PC n’a pas d’adresse sur un réseau local. Connecte-le au Wi-Fi, puis ferme et rouvre l’accès.';
+            return;
+        }
+        let cert;
+        try {
+            cert = this.certificate(ips);
+        }
+        catch (err) {
+            this.error = `Certificat impossible à créer : ${err instanceof Error ? err.message : String(err)}`;
+            return;
+        }
+        const sockets = new Set();
+        const tls = https.createServer({ key: cert.key, cert: cert.cert, minVersion: 'TLSv1.2' }, this.options.serve);
+        const plain = http.createServer((req, res) => {
+            const host = (req.headers.host ?? '').toLowerCase();
+            if (!this.hosts().includes(host)) {
+                res.writeHead(421, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('Hôte non autorisé.');
+                return;
+            }
+            res.writeHead(307, { Location: `https://${host}${(req.url ?? '/').startsWith('/') ? req.url : '/'}`, 'Cache-Control': 'no-store' });
+            res.end();
+        });
+        const fronts = [];
+        // Port 0 (tests) : le système en choisit un à la première adresse, les suivantes prennent le même.
+        let port = this.port;
+        try {
+            for (const ip of ips) {
+                const front = net.createServer((socket) => {
+                    sockets.add(socket);
+                    socket.on('close', () => sockets.delete(socket));
+                    socket.on('error', () => socket.destroy());
+                    // Une connexion muette ne garde pas une place : 15 s pour envoyer son premier octet.
+                    socket.setTimeout(15_000, () => socket.destroy());
+                    socket.once('data', (chunk) => {
+                        socket.setTimeout(0);
+                        socket.pause();
+                        socket.unshift(chunk);
+                        (chunk[0] === 0x16 ? tls : plain).emit('connection', socket);
+                        process.nextTick(() => socket.resume());
+                    });
+                });
+                await new Promise((resolve, reject) => {
+                    front.once('error', reject);
+                    front.listen(port, ip, () => {
+                        front.off('error', reject);
+                        resolve();
+                    });
+                });
+                fronts.push(front);
+                if (port === 0)
+                    port = front.address().port;
+            }
+        }
+        catch (err) {
+            for (const f of fronts)
+                f.close();
+            const code = err.code;
+            this.error = code === 'EADDRINUSE' ? `Le port ${this.port} est déjà pris. Ferme l’autre programme, ou change de port avec la variable PROMETHEE_PORT_TELEPHONE.` : `Écoute impossible : ${err instanceof Error ? err.message : String(err)}`;
+            return;
+        }
+        this.listening = { ips, port, fronts, tls, plain, sockets };
+    }
+    async stop() {
+        const l = this.listening;
+        if (!l)
+            return;
+        this.listening = null;
+        // Dans cet ordre, sans attendre entre les deux : plus de nouvelle connexion, puis les connexions ouvertes coupées tout de
+        // suite. Attendre la fermeture avant de couper laisserait un téléphone, sur une connexion gardée ouverte, envoyer encore
+        // des requêtes à un accès déjà fermé.
+        const closed = l.fronts.map((f) => new Promise((resolve) => f.close(() => resolve())));
+        for (const s of l.sockets)
+            s.destroy();
+        l.tls.closeAllConnections();
+        l.plain.closeAllConnections();
+        this.connections.clear();
+        await Promise.all(closed);
+    }
+    // ------------------------------------------------------------ Appairage
+    newCode() {
+        if (!this.stored.active || !this.listening)
+            throw new AppError('phone_closed', 409, 'L’accès téléphone est fermé : ouvre-le d’abord.');
+        let code = '';
+        for (let i = 0; i < 8; i++)
+            code += ALPHABET[randomInt(ALPHABET.length)];
+        this.pairing = { code, expiresAt: this.now() + CODE_MINUTES * 60_000, tries: 0 };
+        return this.state();
+    }
+    /** Échange un code contre un appareil. Rend la valeur du cookie à poser. */
+    pair(given, userAgent) {
+        const now = this.now();
+        this.tries = this.tries.filter((t) => now - t < 60_000);
+        if (this.tries.length >= TRIES_PER_MINUTE)
+            throw new AppError('pairing_throttled', 429, 'Trop d’essais d’appairage. Attends une minute.');
+        this.tries.push(now);
+        const pairing = this.pairing;
+        if (!pairing || pairing.expiresAt <= now)
+            throw new AppError('pairing_expired', 400, 'Aucun code d’appairage en cours, ou il a expiré. Sur le PC, ouvre Réglages, Téléphone, et demande un nouveau code.');
+        const code = normalizeCode(given);
+        const right = code.length === pairing.code.length && timingSafeEqual(Buffer.from(code), Buffer.from(pairing.code));
+        if (!right) {
+            pairing.tries++;
+            const left = CODE_TRIES - pairing.tries;
+            if (left <= 0) {
+                this.pairing = null;
+                this.options.journal.add({ kind: 'security', outcome: 'refused', title: 'Code d’appairage grillé', detail: `${CODE_TRIES} essais faux depuis le réseau local.` });
+                throw new AppError('pairing_refused', 403, 'Code incorrect. Ce code est maintenant grillé : demande un nouveau code sur le PC.');
+            }
+            throw new AppError('pairing_refused', 403, `Code incorrect. ${left > 1 ? `Encore ${left} essais` : 'Encore un essai'} avec ce code.`);
+        }
+        this.pairing = null;
+        const base = deviceName(userAgent);
+        const taken = new Set(this.devices().map((d) => d.name));
+        let name = base;
+        for (let i = 2; taken.has(name); i++)
+            name = `${base} (${i})`;
+        const id = randomBytes(8).toString('hex');
+        const secret = randomBytes(32).toString('base64url');
+        const at = new Date(now).toISOString();
+        this.stored.devices.push({ id, name, hash: sha256(secret), pairedAt: at, lastSeenAt: at });
+        this.save();
+        this.options.journal.add({ kind: 'security', outcome: 'info', title: `Téléphone appairé : ${name}`, detail: 'Il peut utiliser la console depuis le réseau local. Retire-le dans Réglages, Téléphone.' });
+        return { device: { id, name, pairedAt: at, lastSeenAt: at }, cookie: `${id}.${secret}` };
+    }
+    /** L'appareil d'une requête, d'après son cookie. null s'il est inconnu, retiré ou expiré. */
+    device(cookieHeader, socket) {
+        const value = cookieValue(cookieHeader);
+        const m = value ? /^([a-f0-9]{16})\.([A-Za-z0-9_-]{43})$/.exec(value) : null;
+        if (!m)
+            return null;
+        const found = this.devices().find((d) => d.id === m[1]);
+        if (!found || !sameHex(found.hash, sha256(m[2] ?? '')))
+            return null;
+        const now = this.now();
+        // L'heure de dernière visite part sur le disque au plus toutes les 10 minutes.
+        if (!found.lastSeenAt || now - Date.parse(found.lastSeenAt) > 600_000) {
+            found.lastSeenAt = new Date(now).toISOString();
+            this.save();
+        }
+        if (socket) {
+            let set = this.connections.get(found.id);
+            if (!set)
+                this.connections.set(found.id, (set = new Set()));
+            if (!set.has(socket)) {
+                set.add(socket);
+                socket.once('close', () => set.delete(socket));
+            }
+        }
+        const { id, name, pairedAt, lastSeenAt } = found;
+        return { id, name, pairedAt, lastSeenAt };
+    }
+    removeDevice(id) {
+        const found = this.stored.devices.find((d) => d.id === id);
+        if (!found)
+            throw notFound('Cet appareil n’est pas, ou plus, appairé.');
+        this.stored.devices = this.stored.devices.filter((d) => d.id !== id);
+        this.save();
+        for (const s of this.connections.get(id) ?? [])
+            s.destroy();
+        this.connections.delete(id);
+        this.options.journal.add({ kind: 'security', outcome: 'info', title: `Téléphone retiré : ${found.name}`, detail: 'Son cookie ne vaut plus rien, ses connexions sont coupées.' });
+        return this.state();
+    }
+    async dispose() {
+        this.unwatch();
+        await this.stop();
+    }
+}

package/lib/server/telephone/certificat.js

@@ -0,0 +1,79 @@
+/**
+ * Certificat du téléphone : ECDSA P-256, signé par lui-même, valable un an, pour les adresses du PC sur le réseau local.
+ * Écrit en DER à la main (quelques dizaines de lignes) plutôt qu'avec une dépendance ou OpenSSL : Node sait signer et relire
+ * un certificat, pas en fabriquer un.
+ *
+ * Aucune autorité ne le signe : le navigateur du téléphone avertit à la première visite. Le chiffrement protège de l'écoute
+ * sur le Wi-Fi. Contre un attaquant actif sur le même réseau au moment de l'appairage, c'est l'empreinte, comparée à l'œil,
+ * qui protège (docs/SECURITE.md).
+ */
+import { X509Certificate, createPrivateKey, generateKeyPairSync, randomBytes, sign } from 'node:crypto';
+import { isIPv4 } from 'node:net';
+const NAME = 'Prométhée, accès téléphone';
+const DAY = 86_400_000;
+export const CERT_DAYS = 365;
+const length = (n) => (n < 0x80 ? [n] : n < 0x100 ? [0x81, n] : [0x82, n >> 8, n & 0xff]);
+const tlv = (tag, ...parts) => {
+    const body = Buffer.concat(parts);
+    return Buffer.concat([Buffer.from([tag, ...length(body.length)]), body]);
+};
+const seq = (...parts) => tlv(0x30, ...parts);
+const set = (...parts) => tlv(0x31, ...parts);
+const octets = (b) => tlv(0x04, b);
+const bits = (b, unused = 0) => tlv(0x03, Buffer.from([unused]), b);
+const explicit = (n, inner) => tlv(0xa0 + n, inner);
+const bool = (v) => tlv(0x01, Buffer.from([v ? 0xff : 0]));
+const utf8 = (s) => tlv(0x0c, Buffer.from(s, 'utf8'));
+/** Entier positif : un zéro devant si le bit de poids fort est à 1. */
+const integer = (b) => tlv(0x02, (b[0] ?? 0) & 0x80 ? Buffer.concat([Buffer.from([0]), b]) : b);
+export function oid(dotted) {
+    const [a = 0, b = 0, ...rest] = dotted.split('.').map(Number);
+    const out = [40 * a + b];
+    for (const n of rest) {
+        const chunk = [n & 0x7f];
+        for (let v = Math.floor(n / 128); v > 0; v = Math.floor(v / 128))
+            chunk.unshift((v & 0x7f) | 0x80);
+        out.push(...chunk);
+    }
+    return tlv(0x06, Buffer.from(out));
+}
+/** UTCTime (AAMMJJhhmmssZ), valable jusqu'en 2049. */
+const time = (d) => tlv(0x17, Buffer.from(d.toISOString().replace(/[-:T]/g, '').slice(2, 14) + 'Z', 'ascii'));
+const extension = (id, critical, value) => seq(oid(id), ...(critical ? [bool(true)] : []), octets(value));
+const ECDSA_SHA256 = seq(oid('1.2.840.10045.4.3.2'));
+export function makeCertificate(ips, now = new Date()) {
+    const addresses = ips.filter((ip) => isIPv4(ip));
+    if (addresses.length === 0)
+        throw new Error('Aucune adresse IPv4 pour le certificat.');
+    const { privateKey, publicKey } = generateKeyPairSync('ec', { namedCurve: 'prime256v1' });
+    const name = seq(set(seq(oid('2.5.4.3'), utf8(NAME))));
+    const serial = randomBytes(16);
+    serial[0] = (serial[0] ?? 0) & 0x7f || 0x01;
+    const notBefore = new Date(now.getTime() - DAY);
+    const notAfter = new Date(now.getTime() + CERT_DAYS * DAY);
+    const san = seq(...addresses.map((ip) => tlv(0x87, Buffer.from(ip.split('.').map(Number)))));
+    const tbs = seq(explicit(0, integer(Buffer.from([2]))), integer(serial), ECDSA_SHA256, name, seq(time(notBefore), time(notAfter)), name, publicKey.export({ type: 'spki', format: 'der' }), explicit(3, seq(extension('2.5.29.19', true, seq()), extension('2.5.29.15', true, bits(Buffer.from([0x80]), 7)), extension('2.5.29.37', false, seq(oid('1.3.6.1.5.5.7.3.1'))), extension('2.5.29.17', false, san))));
+    const der = seq(tbs, ECDSA_SHA256, bits(sign('sha256', tbs, privateKey)));
+    const cert = `-----BEGIN CERTIFICATE-----\n${der.toString('base64').replace(/(.{64})/g, '$1\n').replace(/\n$/, '')}\n-----END CERTIFICATE-----\n`;
+    const x509 = new X509Certificate(cert);
+    return { key: privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(), cert, fingerprint: x509.fingerprint256, ips: addresses, notAfter: notAfter.toISOString() };
+}
+/** Relit un certificat enregistré. null s'il est abîmé, si la clé ne va pas avec, ou s'il expire dans moins de 30 jours. */
+export function loadCertificate(key, cert, now = new Date()) {
+    try {
+        const x509 = new X509Certificate(cert);
+        if (!x509.checkPrivateKey(createPrivateKey(key)))
+            return null;
+        if (Date.parse(x509.validTo) - now.getTime() < 30 * DAY)
+            return null;
+        const ips = (x509.subjectAltName ?? '')
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => s.startsWith('IP Address:'))
+            .map((s) => s.slice('IP Address:'.length));
+        return { key, cert, fingerprint: x509.fingerprint256, ips, notAfter: new Date(x509.validTo).toISOString() };
+    }
+    catch {
+        return null;
+    }
+}