@mostajs/crypto-box 0.1.0 → 0.2.0

package/dist/aead.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @mostajs/crypto-box — Chiffrement authentifié (AEAD), en un coup et EN FLUX.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+import type { Bytes } from './types.js';
+/**
+ * AES-256-GCM par défaut. ChaCha20-Poly1305 en option : AES n'est rapide QUE si le processeur
+ * possède AES-NI. Sur les petits ARM sans accélération — exactement le matériel des bornes et
+ * serveurs TicketFlow — ChaCha20 est nettement plus rapide, et à temps constant par construction.
+ */
+export type AeadAlgo = 'aes-256-gcm' | 'chacha20-poly1305';
+/** Taille de bloc du flux. 64 Kio : compromis mémoire / surcoût de tag (16 o par bloc). */
+export declare const CHUNK_SIZE: number;
+/**
+ * Chiffre en un coup. Format autoportant : `MJSC2 | algo(1) | iv(12) | tag(16) | chiffré`.
+ *
+ * ⚠ Tout est mis EN MÉMOIRE. Pour une archive de sauvegarde, utilisez `aeadEncryptStream` :
+ * une base de plusieurs gigaoctets ferait tomber le processus ici.
+ *
+ * Le nonce est tiré au hasard À CHAQUE APPEL et n'est jamais fourni par l'appelant : le
+ * réutiliser en GCM révèle le XOR des clairs et permet de forger des messages. L'option
+ * n'existe donc pas.
+ */
+export declare function aeadEncrypt(key: Bytes, plaintext: Bytes | string, algo?: AeadAlgo): Buffer;
+/**
+ * Déchiffre un blob `aeadEncrypt`. Lève si la clé est fausse OU si **un seul bit** a changé :
+ * un déchiffrement qui « réussirait » sur des octets corrompus rendrait une sauvegarde
+ * silencieusement fausse.
+ *
+ * Lit aussi le format `MJSC1` de la 0.1.0 (AES-GCM implicite) : on ne casse pas ce qu'on a
+ * déjà pu écrire.
+ */
+export declare function aeadDecrypt(key: Bytes, blob: Bytes): Buffer;
+/**
+ * Chiffre un FLUX. Sortie : `MJSS1 | algo(1) | base(8)` puis, par bloc,
+ * `len(4) | tag(16) | chiffré`.
+ *
+ * Chaque bloc porte son propre tag, son compteur et son drapeau final. Le flux résiste donc à
+ * l'altération, au réordonnancement, à la suppression ET à la troncature — les quatre attaques
+ * qu'un simple « chiffrer par morceaux » laisse passer.
+ */
+export declare function aeadEncryptStream(key: Bytes, source: AsyncIterable<Bytes> | Iterable<Bytes>, algo?: AeadAlgo): AsyncGenerator<Buffer>;
+/**
+ * Déchiffre un flux produit par `aeadEncryptStream`.
+ *
+ * LÈVE si le flux est tronqué (bloc final jamais vu), réordonné, ou altéré d'un bit. Une
+ * archive à moitié restaurée est pire qu'une restauration qui échoue franchement.
+ */
+export declare function aeadDecryptStream(key: Bytes, source: AsyncIterable<Bytes> | Iterable<Bytes>): AsyncGenerator<Buffer>;

package/dist/aead.js

@@ -0,0 +1,214 @@
+/**
+ * @mostajs/crypto-box — Chiffrement authentifié (AEAD), en un coup et EN FLUX.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+import { randomBytes, createCipheriv, createDecipheriv } from 'node:crypto';
+const ALGO_ID = { 'aes-256-gcm': 1, 'chacha20-poly1305': 2 };
+const ID_ALGO = { 1: 'aes-256-gcm', 2: 'chacha20-poly1305' };
+const MAGIC_ONE = Buffer.from('MJSC2'); // un coup (0.2.0 : porte l'algorithme)
+const MAGIC_ONE_V1 = Buffer.from('MJSC1'); // un coup (0.1.0 : AES-GCM implicite) — relu, plus écrit
+const MAGIC_STREAM = Buffer.from('MJSS1'); // flux
+const IV_LEN = 12; // 96 bits : la taille recommandée pour GCM comme pour ChaCha20-Poly1305
+const TAG_LEN = 16;
+/** Taille de bloc du flux. 64 Kio : compromis mémoire / surcoût de tag (16 o par bloc). */
+export const CHUNK_SIZE = 64 * 1024;
+function requireKey(key) {
+    if (key.length !== 32)
+        throw new Error('crypto-box : la clé doit faire 32 octets (voir deriveKey/randomKey)');
+    return Buffer.from(key);
+}
+// ─── Un coup (petites charges : clés enveloppées, manifestes, jetons) ────────
+/**
+ * Chiffre en un coup. Format autoportant : `MJSC2 | algo(1) | iv(12) | tag(16) | chiffré`.
+ *
+ * ⚠ Tout est mis EN MÉMOIRE. Pour une archive de sauvegarde, utilisez `aeadEncryptStream` :
+ * une base de plusieurs gigaoctets ferait tomber le processus ici.
+ *
+ * Le nonce est tiré au hasard À CHAQUE APPEL et n'est jamais fourni par l'appelant : le
+ * réutiliser en GCM révèle le XOR des clairs et permet de forger des messages. L'option
+ * n'existe donc pas.
+ */
+export function aeadEncrypt(key, plaintext, algo = 'aes-256-gcm') {
+    const k = requireKey(key);
+    const iv = randomBytes(IV_LEN);
+    // `as never` ferait choisir à TS la surcharge CCM, dont `setAAD` prend 2 arguments.
+    const cipher = createCipheriv(algo, k, iv, { authTagLength: TAG_LEN });
+    const body = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    return Buffer.concat([MAGIC_ONE, Buffer.from([ALGO_ID[algo]]), iv, cipher.getAuthTag(), body]);
+}
+/**
+ * Déchiffre un blob `aeadEncrypt`. Lève si la clé est fausse OU si **un seul bit** a changé :
+ * un déchiffrement qui « réussirait » sur des octets corrompus rendrait une sauvegarde
+ * silencieusement fausse.
+ *
+ * Lit aussi le format `MJSC1` de la 0.1.0 (AES-GCM implicite) : on ne casse pas ce qu'on a
+ * déjà pu écrire.
+ */
+export function aeadDecrypt(key, blob) {
+    const k = requireKey(key);
+    const buf = Buffer.from(blob);
+    let algo;
+    let off;
+    if (buf.subarray(0, 5).equals(MAGIC_ONE)) {
+        algo = ID_ALGO[buf[5]];
+        if (!algo)
+            throw new Error('crypto-box : algorithme inconnu');
+        off = 6;
+    }
+    else if (buf.subarray(0, 5).equals(MAGIC_ONE_V1)) {
+        algo = 'aes-256-gcm';
+        off = 5;
+    }
+    else {
+        throw new Error('crypto-box : format inconnu (ni MJSC1 ni MJSC2)');
+    }
+    if (buf.length < off + IV_LEN + TAG_LEN)
+        throw new Error('crypto-box : blob tronqué');
+    const iv = buf.subarray(off, off + IV_LEN);
+    const tag = buf.subarray(off + IV_LEN, off + IV_LEN + TAG_LEN);
+    const body = buf.subarray(off + IV_LEN + TAG_LEN);
+    const decipher = createDecipheriv(algo, k, iv, { authTagLength: TAG_LEN });
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(body), decipher.final()]); // `final()` vérifie le tag
+}
+// ─── Flux (archives : la lacune bloquante de la 0.1.0) ───────────────────────
+/**
+ * Nonce d'un bloc : `base(8) ‖ compteur(4, big-endian)`.
+ *
+ * Le compteur est ce qui interdit le RÉORDONNANCEMENT : un bloc déplacé se déchiffre avec un
+ * nonce différent de celui qui l'a chiffré, donc son tag échoue.
+ */
+function chunkNonce(base, counter) {
+    const n = Buffer.alloc(IV_LEN);
+    base.copy(n, 0, 0, 8);
+    n.writeUInt32BE(counter, 8);
+    return n;
+}
+/**
+ * Données associées d'un bloc : `compteur(4) ‖ final(1)`.
+ *
+ * Le drapeau `final` est ce qui interdit la TRONCATURE. Sans lui, un attaquant coupe l'archive
+ * en deux et le déchiffrement « réussit » sur la première moitié — chaque bloc restant
+ * authentique. Le déchiffreur exige d'avoir vu le bloc marqué final, sinon il LÈVE.
+ */
+function chunkAad(counter, final) {
+    const aad = Buffer.alloc(5);
+    aad.writeUInt32BE(counter, 0);
+    aad[4] = final ? 1 : 0;
+    return aad;
+}
+/** Re-découpe une source hétérogène en blocs de taille fixe. */
+async function* rechunk(source, size) {
+    let buf = Buffer.alloc(0);
+    for await (const part of source) {
+        buf = Buffer.concat([buf, Buffer.from(part)]);
+        while (buf.length >= size) {
+            yield buf.subarray(0, size);
+            buf = buf.subarray(size);
+        }
+    }
+    yield buf; // dernier bloc (éventuellement vide : une archive vide reste une archive)
+}
+/**
+ * Chiffre un FLUX. Sortie : `MJSS1 | algo(1) | base(8)` puis, par bloc,
+ * `len(4) | tag(16) | chiffré`.
+ *
+ * Chaque bloc porte son propre tag, son compteur et son drapeau final. Le flux résiste donc à
+ * l'altération, au réordonnancement, à la suppression ET à la troncature — les quatre attaques
+ * qu'un simple « chiffrer par morceaux » laisse passer.
+ */
+export async function* aeadEncryptStream(key, source, algo = 'aes-256-gcm') {
+    const k = requireKey(key);
+    const base = randomBytes(8);
+    yield Buffer.concat([MAGIC_STREAM, Buffer.from([ALGO_ID[algo]]), base]);
+    let counter = 0;
+    let pending = null;
+    for await (const chunk of rechunk(source, CHUNK_SIZE)) {
+        if (pending !== null) {
+            yield sealChunk(k, algo, base, counter++, pending, false);
+        }
+        pending = chunk;
+    }
+    // Le dernier bloc — et lui seul — porte le drapeau final.
+    yield sealChunk(k, algo, base, counter, pending ?? Buffer.alloc(0), true);
+}
+function sealChunk(key, algo, base, counter, data, final) {
+    const cipher = createCipheriv(algo, key, chunkNonce(base, counter), { authTagLength: TAG_LEN });
+    cipher.setAAD(chunkAad(counter, final));
+    const body = Buffer.concat([cipher.update(data), cipher.final()]);
+    const header = Buffer.alloc(4);
+    header.writeUInt32BE(body.length, 0);
+    return Buffer.concat([header, cipher.getAuthTag(), body]);
+}
+/**
+ * Déchiffre un flux produit par `aeadEncryptStream`.
+ *
+ * LÈVE si le flux est tronqué (bloc final jamais vu), réordonné, ou altéré d'un bit. Une
+ * archive à moitié restaurée est pire qu'une restauration qui échoue franchement.
+ */
+export async function* aeadDecryptStream(key, source) {
+    const k = requireKey(key);
+    let buf = Buffer.alloc(0);
+    let algo = null;
+    let base = null;
+    let counter = 0;
+    let done = false;
+    for await (const part of source) {
+        buf = Buffer.concat([buf, Buffer.from(part)]);
+        if (algo === null) {
+            if (buf.length < 14)
+                continue;
+            if (!buf.subarray(0, 5).equals(MAGIC_STREAM))
+                throw new Error('crypto-box : format inconnu (pas un flux MJSS1)');
+            algo = ID_ALGO[buf[5]];
+            if (!algo)
+                throw new Error('crypto-box : algorithme inconnu');
+            base = buf.subarray(6, 14);
+            buf = buf.subarray(14);
+        }
+        // Un bloc = len(4) | tag(16) | corps(len)
+        for (;;) {
+            // L'ordre compte : on sort D'ABORD s'il ne reste rien à lire. Tester `done` avant
+            // reviendrait à traiter la FIN NORMALE d'un flux valide comme une falsification —
+            // c'est exactement le faux positif qu'a levé le test ChaCha.
+            if (buf.length < 4 + TAG_LEN)
+                break;
+            if (done)
+                throw new Error('crypto-box : données après le bloc final (flux falsifié)');
+            const len = buf.readUInt32BE(0);
+            if (buf.length < 4 + TAG_LEN + len)
+                break;
+            const tag = buf.subarray(4, 4 + TAG_LEN);
+            const body = buf.subarray(4 + TAG_LEN, 4 + TAG_LEN + len);
+            buf = buf.subarray(4 + TAG_LEN + len);
+            // On ignore quel bloc est final : on ESSAIE « non final », puis « final ». Le tag
+            // tranche — impossible de mentir sur le drapeau sans casser l'authentification.
+            const out = openChunk(k, algo, base, counter, tag, body);
+            if (out.final)
+                done = true;
+            counter += 1;
+            yield out.data;
+        }
+    }
+    if (!done) {
+        // Le cas capital : l'archive a été coupée. Chaque bloc reçu était authentique, mais il
+        // en manque. Sans ce contrôle, on restaurerait une base à moitié — silencieusement.
+        throw new Error('crypto-box : flux TRONQUÉ (bloc final absent)');
+    }
+    if (buf.length > 0)
+        throw new Error('crypto-box : octets résiduels après le bloc final');
+}
+function openChunk(key, algo, base, counter, tag, body) {
+    for (const final of [false, true]) {
+        try {
+            const d = createDecipheriv(algo, key, chunkNonce(base, counter), { authTagLength: TAG_LEN });
+            d.setAAD(chunkAad(counter, final));
+            d.setAuthTag(tag);
+            const data = Buffer.concat([d.update(body), d.final()]);
+            return { data, final };
+        }
+        catch { /* essaie l'autre drapeau */ }
+    }
+    throw new Error(`crypto-box : bloc ${counter} invalide (altéré, réordonné ou clé fausse)`);
+}

package/dist/envelope.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @mostajs/crypto-box — Signature Ed25519, échange X25519, et CHIFFREMENT PAR ENVELOPPE.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ *
+ * ─── LE MODÈLE D'ENVELOPPE, ET POURQUOI IL EST TRANCHÉ AINSI ─────────────────
+ *
+ * Chiffrer une archive DIRECTEMENT avec la phrase du client a deux conséquences fâcheuses :
+ *   1. changer de phrase impose de RE-CHIFFRER toutes les archives (40 Go pour un mot) ;
+ *   2. on ne peut pas chiffrer « pour » un client sans connaître sa phrase.
+ *
+ * Le modèle d'enveloppe (celui d'`age`) les supprime tous les deux :
+ *   - chaque archive est chiffrée par une clé de données ALÉATOIRE (DEK) ;
+ *   - la DEK est ENVELOPPÉE pour une ou plusieurs clés publiques de destinataires (KEK).
+ *
+ * Ce que cela permet, concrètement :
+ *   - le client change de phrase → on ré-enveloppe 32 OCTETS, pas les archives ;
+ *   - la console peut DÉTENIR une enveloppe qu'elle NE SAIT PAS OUVRIR : on vend la
+ *     conservation et la restauration sans jamais détenir les secrets du client ;
+ *   - une CLÉ DE SECOURS (hors ligne, chez le client) s'ajoute comme second destinataire —
+ *     ce qui atténue le « clé perdue = tout perdu » qu'il faudrait sinon contractualiser.
+ *
+ * X25519 et Ed25519 sont NATIFS dans node:crypto : zéro dépendance ajoutée.
+ */
+import type { Bytes } from './types.js';
+/** Paire de clés : clés BRUTES de 32 octets, faciles à stocker et à transporter. */
+export interface KeyPair {
+    publicKey: Buffer;
+    privateKey: Buffer;
+}
+/**
+ * Paire de signature. L'intégrité (SHA-256, tag AEAD) prouve qu'une archive n'a pas été
+ * corrompue PAR ACCIDENT ; la signature prouve QUI l'a produite. Pour une archive restaurée
+ * chez un client — et pour une garantie de déploiement — c'est une différence de nature.
+ */
+export declare function generateSigningKeyPair(): KeyPair;
+/** Signe des données (Ed25519, RFC 8032). */
+export declare function sign(privateKey: Bytes, data: Bytes | string): Buffer;
+/** Vérifie une signature. Retourne `false` — ne lève pas : une signature fausse est un cas normal. */
+export declare function verifySignature(publicKey: Bytes, data: Bytes | string, signature: Bytes): boolean;
+/**
+ * Dérive une sous-clé d'une clé DÉJÀ FORTE (RFC 5869).
+ *
+ * À ne pas confondre avec `deriveKey` (scrypt), qui transforme une PHRASE HUMAINE faible en
+ * clé et qui est lent À DESSEIN. Dériver une sous-clé d'une clé de 256 bits n'a aucune raison
+ * d'être lent : détourner scrypt pour cela est un contresens coûteux.
+ */
+export declare function deriveSubKey(masterKey: Bytes, info: string, opts?: {
+    salt?: Bytes;
+    length?: number;
+}): Buffer;
+/** Paire de destinataire (X25519). La clé PUBLIQUE peut être distribuée sans risque. */
+export declare function generateRecipientKeyPair(): KeyPair;
+/**
+ * Chiffre POUR un ou plusieurs destinataires, sans connaître aucun de leurs secrets.
+ *
+ * Format : `MJSE1 | n(1) | [ephPub(32) | len(2) | DEK enveloppée]×n | corps AEAD(DEK)`.
+ *
+ * Chaque destinataire reçoit sa propre enveloppe de la MÊME clé de données — d'où la
+ * possibilité d'ajouter une clé de secours sans dupliquer l'archive.
+ */
+export declare function seal(recipients: Bytes[], plaintext: Bytes | string): Buffer;
+/**
+ * Ouvre une enveloppe avec SA clé privée.
+ *
+ * On essaie chaque emplacement : un destinataire ne sait pas lequel est le sien (les
+ * enveloppes ne portent aucun identifiant — révéler POUR QUI une archive est chiffrée serait
+ * une fuite de métadonnée en soi).
+ */
+export declare function open(privateKey: Bytes, blob: Bytes): Buffer;

package/dist/envelope.js

@@ -0,0 +1,174 @@
+/**
+ * @mostajs/crypto-box — Signature Ed25519, échange X25519, et CHIFFREMENT PAR ENVELOPPE.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ *
+ * ─── LE MODÈLE D'ENVELOPPE, ET POURQUOI IL EST TRANCHÉ AINSI ─────────────────
+ *
+ * Chiffrer une archive DIRECTEMENT avec la phrase du client a deux conséquences fâcheuses :
+ *   1. changer de phrase impose de RE-CHIFFRER toutes les archives (40 Go pour un mot) ;
+ *   2. on ne peut pas chiffrer « pour » un client sans connaître sa phrase.
+ *
+ * Le modèle d'enveloppe (celui d'`age`) les supprime tous les deux :
+ *   - chaque archive est chiffrée par une clé de données ALÉATOIRE (DEK) ;
+ *   - la DEK est ENVELOPPÉE pour une ou plusieurs clés publiques de destinataires (KEK).
+ *
+ * Ce que cela permet, concrètement :
+ *   - le client change de phrase → on ré-enveloppe 32 OCTETS, pas les archives ;
+ *   - la console peut DÉTENIR une enveloppe qu'elle NE SAIT PAS OUVRIR : on vend la
+ *     conservation et la restauration sans jamais détenir les secrets du client ;
+ *   - une CLÉ DE SECOURS (hors ligne, chez le client) s'ajoute comme second destinataire —
+ *     ce qui atténue le « clé perdue = tout perdu » qu'il faudrait sinon contractualiser.
+ *
+ * X25519 et Ed25519 sont NATIFS dans node:crypto : zéro dépendance ajoutée.
+ */
+import { generateKeyPairSync, createPublicKey, createPrivateKey, diffieHellman, sign as nodeSign, verify as nodeVerify, hkdfSync, randomBytes, } from 'node:crypto';
+import { aeadEncrypt, aeadDecrypt } from './aead.js';
+const b64u = (b) => b.toString('base64url');
+function toPublic(raw, crv) {
+    return createPublicKey({
+        key: { kty: 'OKP', crv: crv === 'ed25519' ? 'Ed25519' : 'X25519', x: b64u(Buffer.from(raw)) },
+        format: 'jwk',
+    });
+}
+function toPrivate(raw, crv) {
+    // JWK exige la partie publique ; on la recalcule en important d'abord la privée en DER.
+    // Plus simple et sûr : on garde `d`, et Node dérive `x` lui-même ? Non — JWK OKP l'exige.
+    // On stocke donc la privée AVEC sa publique dans `privateKey` (64 o) ? Non plus : on
+    // recalcule `x` par une multiplication scalaire… indisponible en JS pur.
+    // Solution retenue : on encode la privée en PKCS#8 DER, ce que Node accepte sans `x`.
+    const prefix = crv === 'ed25519'
+        ? Buffer.from('302e020100300506032b657004220420', 'hex') // PKCS#8 Ed25519
+        : Buffer.from('302e020100300506032b656e04220420', 'hex'); // PKCS#8 X25519
+    return createPrivateKey({ key: Buffer.concat([prefix, Buffer.from(raw)]), format: 'der', type: 'pkcs8' });
+}
+/** Extrait les 32 octets bruts d'une clé (publique ou privée). */
+function rawOf(key) {
+    const jwk = key.export({ format: 'jwk' });
+    const b64 = key.type === 'private' ? jwk.d : jwk.x;
+    return Buffer.from(b64, 'base64url');
+}
+// ─── Signature (Ed25519) ────────────────────────────────────────────────────
+/**
+ * Paire de signature. L'intégrité (SHA-256, tag AEAD) prouve qu'une archive n'a pas été
+ * corrompue PAR ACCIDENT ; la signature prouve QUI l'a produite. Pour une archive restaurée
+ * chez un client — et pour une garantie de déploiement — c'est une différence de nature.
+ */
+export function generateSigningKeyPair() {
+    const { publicKey, privateKey } = generateKeyPairSync('ed25519');
+    return { publicKey: rawOf(publicKey), privateKey: rawOf(privateKey) };
+}
+/** Signe des données (Ed25519, RFC 8032). */
+export function sign(privateKey, data) {
+    return nodeSign(null, Buffer.from(data), toPrivate(privateKey, 'ed25519'));
+}
+/** Vérifie une signature. Retourne `false` — ne lève pas : une signature fausse est un cas normal. */
+export function verifySignature(publicKey, data, signature) {
+    try {
+        return nodeVerify(null, Buffer.from(data), toPublic(publicKey, 'ed25519'), Buffer.from(signature));
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Dérivation de sous-clés (HKDF) ─────────────────────────────────────────
+/**
+ * Dérive une sous-clé d'une clé DÉJÀ FORTE (RFC 5869).
+ *
+ * À ne pas confondre avec `deriveKey` (scrypt), qui transforme une PHRASE HUMAINE faible en
+ * clé et qui est lent À DESSEIN. Dériver une sous-clé d'une clé de 256 bits n'a aucune raison
+ * d'être lent : détourner scrypt pour cela est un contresens coûteux.
+ */
+export function deriveSubKey(masterKey, info, opts = {}) {
+    const salt = opts.salt ? Buffer.from(opts.salt) : Buffer.alloc(0);
+    const len = opts.length ?? 32;
+    return Buffer.from(hkdfSync('sha256', Buffer.from(masterKey), salt, Buffer.from(info, 'utf8'), len));
+}
+// ─── Enveloppe (X25519 + AEAD) ──────────────────────────────────────────────
+const MAGIC_SEAL = Buffer.from('MJSE1');
+const HKDF_INFO = 'mostajs-crypto-box/envelope/v1';
+/** Paire de destinataire (X25519). La clé PUBLIQUE peut être distribuée sans risque. */
+export function generateRecipientKeyPair() {
+    const { publicKey, privateKey } = generateKeyPairSync('x25519');
+    return { publicKey: rawOf(publicKey), privateKey: rawOf(privateKey) };
+}
+/**
+ * Clé d'enveloppement, dérivée du secret partagé X25519.
+ *
+ * Le secret brut de Diffie-Hellman ne doit JAMAIS servir de clé tel quel (sa distribution
+ * n'est pas uniforme) : on le passe par HKDF, en liant la dérivation aux DEUX clés publiques
+ * — sans quoi la même enveloppe pourrait être rejouée pour un autre destinataire.
+ */
+function wrapKeyFor(ourPriv, theirPub, ephPub, rcptPub) {
+    const shared = diffieHellman({ privateKey: ourPriv, publicKey: theirPub });
+    return deriveSubKey(shared, HKDF_INFO, { salt: Buffer.concat([ephPub, rcptPub]) });
+}
+/**
+ * Chiffre POUR un ou plusieurs destinataires, sans connaître aucun de leurs secrets.
+ *
+ * Format : `MJSE1 | n(1) | [ephPub(32) | len(2) | DEK enveloppée]×n | corps AEAD(DEK)`.
+ *
+ * Chaque destinataire reçoit sa propre enveloppe de la MÊME clé de données — d'où la
+ * possibilité d'ajouter une clé de secours sans dupliquer l'archive.
+ */
+export function seal(recipients, plaintext) {
+    if (recipients.length === 0)
+        throw new Error('crypto-box : au moins un destinataire est requis');
+    if (recipients.length > 255)
+        throw new Error('crypto-box : 255 destinataires au maximum');
+    const dek = randomBytes(32);
+    const slots = [];
+    for (const rcpt of recipients) {
+        const rcptPub = Buffer.from(rcpt);
+        if (rcptPub.length !== 32)
+            throw new Error('crypto-box : clé publique de destinataire invalide (32 octets)');
+        // Une paire ÉPHÉMÈRE par destinataire : la même DEK est enveloppée n fois, jamais le
+        // même secret partagé deux fois.
+        const eph = generateKeyPairSync('x25519');
+        const ephPub = rawOf(eph.publicKey);
+        const wrapKey = wrapKeyFor(eph.privateKey, toPublic(rcptPub, 'x25519'), ephPub, rcptPub);
+        const wrapped = aeadEncrypt(wrapKey, dek);
+        const len = Buffer.alloc(2);
+        len.writeUInt16BE(wrapped.length, 0);
+        slots.push(Buffer.concat([ephPub, len, wrapped]));
+    }
+    return Buffer.concat([
+        MAGIC_SEAL,
+        Buffer.from([recipients.length]),
+        ...slots,
+        aeadEncrypt(dek, plaintext),
+    ]);
+}
+/**
+ * Ouvre une enveloppe avec SA clé privée.
+ *
+ * On essaie chaque emplacement : un destinataire ne sait pas lequel est le sien (les
+ * enveloppes ne portent aucun identifiant — révéler POUR QUI une archive est chiffrée serait
+ * une fuite de métadonnée en soi).
+ */
+export function open(privateKey, blob) {
+    const buf = Buffer.from(blob);
+    if (!buf.subarray(0, 5).equals(MAGIC_SEAL))
+        throw new Error('crypto-box : format inconnu (pas une enveloppe MJSE1)');
+    const priv = toPrivate(privateKey, 'x25519');
+    const ourPub = rawOf(createPublicKey(priv));
+    const n = buf[5];
+    let off = 6;
+    const wrapped = [];
+    for (let i = 0; i < n; i++) {
+        const ephPub = buf.subarray(off, off + 32);
+        const len = buf.readUInt16BE(off + 32);
+        wrapped.push({ ephPub, blob: buf.subarray(off + 34, off + 34 + len) });
+        off += 34 + len;
+    }
+    const body = buf.subarray(off);
+    for (const slot of wrapped) {
+        try {
+            const wrapKey = wrapKeyFor(priv, toPublic(slot.ephPub, 'x25519'), slot.ephPub, ourPub);
+            const dek = aeadDecrypt(wrapKey, slot.blob);
+            return aeadDecrypt(dek, body);
+        }
+        catch { /* pas notre emplacement — on essaie le suivant */ }
+    }
+    throw new Error('crypto-box : aucune enveloppe ne correspond à cette clé (pas un destinataire)');
+}

package/dist/hash.d.ts

@@ -0,0 +1,43 @@
+import type { Bytes, Encoding } from './types.js';
+/** SHA-256. Défaut : hex (convention des checksums et de SigV4). */
+export declare function sha256(data: Bytes | string, encoding?: Encoding): string;
+/** SHA-256 brut — pour les chaînages. */
+export declare function sha256Bytes(data: Bytes | string): Buffer;
+/** HMAC-SHA256. Défaut : hex. */
+export declare function hmacSha256(key: Bytes | string, data: Bytes | string, encoding?: Encoding): string;
+/** HMAC-SHA256 brut — pour les chaînages (SigV4 dérive sa clé par HMAC successifs). */
+export declare function hmacSha256Bytes(key: Bytes | string, data: Bytes | string): Buffer;
+/**
+ * Compare deux valeurs en TEMPS CONSTANT. **Toute** comparaison de secret, de signature ou de
+ * jeton doit passer par ici — jamais par `===`, jamais par une boucle maison.
+ *
+ * `timingSafeEqual` de Node LÈVE si les tailles diffèrent : un appel naïf ferait tomber le
+ * serveur sur une signature tronquée, c'est-à-dire sur une entrée d'attaquant. On borne donc
+ * avant. La longueur ne fuit rien : celle d'un HMAC-SHA256 est publique et constante.
+ */
+export declare function equalsConstantTime(a: Bytes | string, b: Bytes | string): boolean;
+export interface DeriveKeyOptions {
+    /** Sel — 16 octets aléatoires recommandés. Généré si absent (et RETOURNÉ : conservez-le). */
+    salt?: Bytes;
+    /** Coût CPU/mémoire (puissance de 2). Défaut 2^17 — ~100 ms, coûteux à brute-forcer. */
+    cost?: number;
+}
+/**
+ * Dérive une clé AES-256 (32 octets) depuis une PHRASE SECRÈTE, par scrypt (RFC 7914).
+ *
+ * Un simple SHA-256 de la phrase serait INSTANTANÉ — donc une phrase faible se casserait par
+ * force brute à des millions d'essais par seconde. scrypt est lent et gourmand À DESSEIN.
+ *
+ * Argon2id serait l'état de l'art (OWASP), mais il n'existe pas dans `node:crypto` : il
+ * exigerait un binaire natif ou du WASM, ce qui détruirait le zéro-dépendance ET le .exe
+ * pur-JS. Choix ASSUMÉ, à réévaluer si Node l'intègre (cf. docs/01-ETUDE-ETAT-ART).
+ *
+ * Le `salt` est RETOURNÉ : sans lui la clé est irrécupérable. Il n'est pas secret et se
+ * conserve à côté du chiffré.
+ */
+export declare function deriveKey(passphrase: string, opts?: DeriveKeyOptions): Promise<{
+    key: Buffer;
+    salt: Buffer;
+}>;
+/** Secret aléatoire (défaut 32 octets) — clés, sels, jetons. */
+export declare function randomKey(bytes?: number): Buffer;

package/dist/hash.js

@@ -0,0 +1,70 @@
+/**
+ * @mostajs/crypto-box — Empreintes, HMAC, comparaison à temps constant.
+ * @author Dr Hamid MADANI <drmdh@msn.com>
+ * Licence : AGPL-3.0-or-later
+ */
+import { createHash, createHmac, timingSafeEqual as nodeTimingSafeEqual, randomBytes, scrypt as nodeScrypt } from 'node:crypto';
+const enc = (buf, encoding) => encoding === 'hex' ? buf.toString('hex') : buf.toString('base64url');
+/** SHA-256. Défaut : hex (convention des checksums et de SigV4). */
+export function sha256(data, encoding = 'hex') {
+    return enc(createHash('sha256').update(data).digest(), encoding);
+}
+/** SHA-256 brut — pour les chaînages. */
+export function sha256Bytes(data) {
+    return createHash('sha256').update(data).digest();
+}
+/** HMAC-SHA256. Défaut : hex. */
+export function hmacSha256(key, data, encoding = 'hex') {
+    return enc(createHmac('sha256', key).update(data).digest(), encoding);
+}
+/** HMAC-SHA256 brut — pour les chaînages (SigV4 dérive sa clé par HMAC successifs). */
+export function hmacSha256Bytes(key, data) {
+    return createHmac('sha256', key).update(data).digest();
+}
+/**
+ * Compare deux valeurs en TEMPS CONSTANT. **Toute** comparaison de secret, de signature ou de
+ * jeton doit passer par ici — jamais par `===`, jamais par une boucle maison.
+ *
+ * `timingSafeEqual` de Node LÈVE si les tailles diffèrent : un appel naïf ferait tomber le
+ * serveur sur une signature tronquée, c'est-à-dire sur une entrée d'attaquant. On borne donc
+ * avant. La longueur ne fuit rien : celle d'un HMAC-SHA256 est publique et constante.
+ */
+export function equalsConstantTime(a, b) {
+    const bufA = Buffer.isBuffer(a) ? a : Buffer.from(a);
+    const bufB = Buffer.isBuffer(b) ? b : Buffer.from(b);
+    if (bufA.length !== bufB.length)
+        return false;
+    if (bufA.length === 0)
+        return true;
+    return nodeTimingSafeEqual(bufA, bufB);
+}
+/**
+ * Dérive une clé AES-256 (32 octets) depuis une PHRASE SECRÈTE, par scrypt (RFC 7914).
+ *
+ * Un simple SHA-256 de la phrase serait INSTANTANÉ — donc une phrase faible se casserait par
+ * force brute à des millions d'essais par seconde. scrypt est lent et gourmand À DESSEIN.
+ *
+ * Argon2id serait l'état de l'art (OWASP), mais il n'existe pas dans `node:crypto` : il
+ * exigerait un binaire natif ou du WASM, ce qui détruirait le zéro-dépendance ET le .exe
+ * pur-JS. Choix ASSUMÉ, à réévaluer si Node l'intègre (cf. docs/01-ETUDE-ETAT-ART).
+ *
+ * Le `salt` est RETOURNÉ : sans lui la clé est irrécupérable. Il n'est pas secret et se
+ * conserve à côté du chiffré.
+ */
+export function deriveKey(passphrase, opts = {}) {
+    const salt = opts.salt ? Buffer.from(opts.salt) : randomBytes(16);
+    const cost = opts.cost ?? 2 ** 17;
+    return new Promise((resolve, reject) => {
+        // `maxmem` doit suivre le coût, sinon Node refuse (« memory limit exceeded »).
+        nodeScrypt(passphrase, salt, 32, { N: cost, r: 8, p: 1, maxmem: 256 * cost * 8 }, (err, key) => {
+            if (err)
+                reject(err);
+            else
+                resolve({ key: key, salt });
+        });
+    });
+}
+/** Secret aléatoire (défaut 32 octets) — clés, sels, jetons. */
+export function randomKey(bytes = 32) {
+    return randomBytes(bytes);
+}

package/dist/index.d.ts

@@ -5,99 +5,29 @@
  * Niveau : N0 (primitif) · ZÉRO dépendance (`node:crypto` uniquement)
  *
  * ─── POURQUOI CE MODULE EXISTE ───────────────────────────────────────────────
- * Le 13/07/2026, en consolidant les URLs signées, on a trouvé la MÊME comparaison de
- * signature implémentée deux fois : « best effort » (boucle JS) dans `@mostajs/url` — le
- * KERNEL, utilisé partout — et correcte (`timingSafeEqual`) dans `@mostajs/storage`, une
- * simple feuille. Le durcissement n'avait jamais circulé.
- *
- * Voilà le vrai coût d'un doublon cryptographique : ce n'est pas la place qu'il prend,
- * c'est que **les corrections ne remontent pas**. Une seule maison = un seul endroit à
- * durcir, un seul endroit à auditer.
+ * En consolidant les URLs signées (13/07/2026), on a trouvé la MÊME comparaison de signature
+ * implémentée deux fois : « best effort » dans @mostajs/url — le KERNEL, utilisé partout — et
+ * correcte (timingSafeEqual) dans @mostajs/storage, une simple feuille. Le durcissement
+ * n'avait jamais circulé. Voilà le vrai coût d'un doublon cryptographique : ce n'est pas la
+ * place qu'il prend, c'est que LES CORRECTIONS NE REMONTENT PAS.
  *
  * ─── CE QUE CE MODULE N'EST PAS ──────────────────────────────────────────────
- * Ce n'est PAS une « bibliothèque de crypto générique ». C'est une **enveloppe mince et
- * opinionée** sur `node:crypto` : pas de choix d'algorithme, pas de mode dangereux, pas
- * d'IV fourni par l'appelant. Un module de crypto qui offre des options est la manière
- * classique d'écrire du chiffrement cassé.
- *
- * Le périmètre est dicté par la DEMANDE RÉELLE, pas par la spéculation :
- *   - `hmacSha256` + `equalsConstantTime` → réclamés par @mostajs/url (URLs signées)
- *   - `sha256`                           → réclamé par blob-store (SigV4, checksums)
- *   - `aeadEncrypt` / `aeadDecrypt`      → réclamés par @mostajs/backup (archives chiffrées)
- *   - `deriveKey`                        → réclamé par @mostajs/backup (clé depuis un secret)
- * On l'enrichira au prochain besoin RÉEL. Pas avant.
- *
- * ─── CE DONT CE MODULE NE RÉPOND PAS ─────────────────────────────────────────
- * La GARDE de la clé n'est pas son affaire — c'est une décision produit. Pour les
- * sauvegardes TicketFlow : la clé reste chez le client, la console ne stocke que du chiffré
- * qu'elle ne peut pas lire. Corollaire assumé : **clé perdue = archive irrécupérable.**
+ * PAS une « bibliothèque de crypto ». Une enveloppe MINCE et OPINIONÉE sur node:crypto :
+ * pas de choix d'algorithme hasardeux, pas de mode dangereux, JAMAIS de nonce fourni par
+ * l'appelant. Un module de crypto qui offre des options est la façon classique d'écrire du
+ * chiffrement cassé. Il n'ajoute que ce qu'un consommateur RÉEL réclame.
+ *
+ * ─── CE DONT IL NE RÉPOND PAS ────────────────────────────────────────────────
+ * La GARDE de la clé est une décision produit. Le modèle d'ENVELOPPE (voir envelope.ts) est
+ * précisément ce qui permet de vendre la conservation d'archives SANS détenir les secrets du
+ * client : la console garde une enveloppe qu'elle ne sait pas ouvrir.
  */
+export type { Bytes, Encoding } from './types.js';
+export { sha256, sha256Bytes, hmacSha256, hmacSha256Bytes, equalsConstantTime, deriveKey, randomKey, type DeriveKeyOptions, } from './hash.js';
+export { aeadEncrypt, aeadDecrypt, aeadEncryptStream, aeadDecryptStream, CHUNK_SIZE, type AeadAlgo, } from './aead.js';
+export { generateSigningKeyPair, sign, verifySignature, deriveSubKey, generateRecipientKeyPair, seal, open, type KeyPair, } from './envelope.js';
 export declare const moduleInfo: {
     readonly name: "@mostajs/crypto-box";
-    readonly version: "0.1.0";
+    readonly version: "0.2.0";
     readonly level: "N0";
 };
-export type Bytes = Uint8Array | Buffer;
-type Encoding = 'hex' | 'base64url';
-/** SHA-256. Défaut : hex (convention des checksums et de SigV4). */
-export declare function sha256(data: Bytes | string, encoding?: Encoding): string;
-/** SHA-256 brut — pour les chaînages (dérivation de clé SigV4, par ex.). */
-export declare function sha256Bytes(data: Bytes | string): Buffer;
-/** HMAC-SHA256. Défaut : hex. */
-export declare function hmacSha256(key: Bytes | string, data: Bytes | string, encoding?: Encoding): string;
-/** HMAC-SHA256 brut — pour les chaînages (SigV4 dérive sa clé par HMAC successifs). */
-export declare function hmacSha256Bytes(key: Bytes | string, data: Bytes | string): Buffer;
-/**
- * Compare deux valeurs en TEMPS CONSTANT. **Toute** comparaison de secret, de signature ou
- * de jeton doit passer par ici — jamais par `===`, jamais par une boucle maison.
- *
- * C'est LA fonction dont l'absence d'un foyer unique a causé la divergence du 13/07 : le
- * kernel comparait « best effort » quand une feuille faisait correctement.
- *
- * La différence de longueur est renvoyée sans comparaison — elle ne fuit rien : la longueur
- * d'un HMAC-SHA256 est publique et constante.
- */
-export declare function equalsConstantTime(a: Bytes | string, b: Bytes | string): boolean;
-export interface DeriveKeyOptions {
-    /** Sel — 16 octets aléatoires recommandés. Généré si absent (et RETOURNÉ : conservez-le). */
-    salt?: Bytes;
-    /** Coût CPU/mémoire (puissance de 2). Défaut 2^17 — ~100 ms, coûteux à brute-forcer. */
-    cost?: number;
-}
-/**
- * Dérive une clé AES-256 (32 octets) depuis une phrase secrète, par **scrypt**.
- *
- * Pourquoi scrypt et pas un simple SHA-256 de la phrase : un hachage est INSTANTANÉ, donc
- * une phrase faible se casse par force brute à des millions d'essais par seconde. scrypt est
- * délibérément **lent et gourmand en mémoire** — c'est le but.
- *
- * Le `salt` est RETOURNÉ : sans lui, la clé est irrécupérable. Il n'est pas secret et doit
- * être stocké à côté du chiffré (c'est ce que fait `aeadEncrypt`).
- */
-export declare function deriveKey(passphrase: string, opts?: DeriveKeyOptions): Promise<{
-    key: Buffer;
-    salt: Buffer;
-}>;
-/** Secret aléatoire (défaut 32 octets) — clés, sels, jetons. */
-export declare function randomKey(bytes?: number): Buffer;
-/**
- * Chiffre en **AES-256-GCM** (chiffrement AUTHENTIFIÉ : confidentialité ET intégrité).
- *
- * Le format de sortie est **autoportant** — `MJSC1 | iv(12) | tag(16) | chiffré` : il n'y a
- * rien d'autre à conserver que la clé. Sans cela, l'appelant devrait gérer lui-même l'IV et
- * le tag, et un seul oubli rend le déchiffrement impossible… ou pire, l'IV est réutilisé.
- *
- * L'IV est TIRÉ AU HASARD À CHAQUE APPEL et n'est jamais fourni par l'appelant. Réutiliser un
- * IV en GCM est catastrophique — cela révèle le XOR des clairs et permet de forger des
- * messages. C'est la raison pour laquelle cette API n'offre pas l'option.
- */
-export declare function aeadEncrypt(key: Bytes, plaintext: Bytes | string): Buffer;
-/**
- * Déchiffre un blob produit par `aeadEncrypt`.
- *
- * Lève si la clé est fausse OU si le chiffré a été **altéré d'un seul bit** : c'est le tag
- * GCM qui l'impose. Un déchiffrement qui « réussit » sur des octets corrompus est exactement
- * ce qu'on ne veut pas d'une sauvegarde.
- */
-export declare function aeadDecrypt(key: Bytes, blob: Bytes): Buffer;
-export {};

package/dist/index.js

@@ -5,142 +5,27 @@
  * Niveau : N0 (primitif) · ZÉRO dépendance (`node:crypto` uniquement)
  *
  * ─── POURQUOI CE MODULE EXISTE ───────────────────────────────────────────────
- * Le 13/07/2026, en consolidant les URLs signées, on a trouvé la MÊME comparaison de
- * signature implémentée deux fois : « best effort » (boucle JS) dans `@mostajs/url` — le
- * KERNEL, utilisé partout — et correcte (`timingSafeEqual`) dans `@mostajs/storage`, une
- * simple feuille. Le durcissement n'avait jamais circulé.
- *
- * Voilà le vrai coût d'un doublon cryptographique : ce n'est pas la place qu'il prend,
- * c'est que **les corrections ne remontent pas**. Une seule maison = un seul endroit à
- * durcir, un seul endroit à auditer.
+ * En consolidant les URLs signées (13/07/2026), on a trouvé la MÊME comparaison de signature
+ * implémentée deux fois : « best effort » dans @mostajs/url — le KERNEL, utilisé partout — et
+ * correcte (timingSafeEqual) dans @mostajs/storage, une simple feuille. Le durcissement
+ * n'avait jamais circulé. Voilà le vrai coût d'un doublon cryptographique : ce n'est pas la
+ * place qu'il prend, c'est que LES CORRECTIONS NE REMONTENT PAS.
  *
  * ─── CE QUE CE MODULE N'EST PAS ──────────────────────────────────────────────
- * Ce n'est PAS une « bibliothèque de crypto générique ». C'est une **enveloppe mince et
- * opinionée** sur `node:crypto` : pas de choix d'algorithme, pas de mode dangereux, pas
- * d'IV fourni par l'appelant. Un module de crypto qui offre des options est la manière
- * classique d'écrire du chiffrement cassé.
- *
- * Le périmètre est dicté par la DEMANDE RÉELLE, pas par la spéculation :
- *   - `hmacSha256` + `equalsConstantTime` → réclamés par @mostajs/url (URLs signées)
- *   - `sha256`                           → réclamé par blob-store (SigV4, checksums)
- *   - `aeadEncrypt` / `aeadDecrypt`      → réclamés par @mostajs/backup (archives chiffrées)
- *   - `deriveKey`                        → réclamé par @mostajs/backup (clé depuis un secret)
- * On l'enrichira au prochain besoin RÉEL. Pas avant.
- *
- * ─── CE DONT CE MODULE NE RÉPOND PAS ─────────────────────────────────────────
- * La GARDE de la clé n'est pas son affaire — c'est une décision produit. Pour les
- * sauvegardes TicketFlow : la clé reste chez le client, la console ne stocke que du chiffré
- * qu'elle ne peut pas lire. Corollaire assumé : **clé perdue = archive irrécupérable.**
- */
-import { createHash, createHmac, timingSafeEqual as nodeTimingSafeEqual, randomBytes, createCipheriv, createDecipheriv, scrypt as nodeScrypt, } from 'node:crypto';
-export const moduleInfo = { name: '@mostajs/crypto-box', version: '0.1.0', level: 'N0' };
-const enc = (buf, encoding) => encoding === 'hex' ? buf.toString('hex') : buf.toString('base64url');
-// ─── Empreintes ──────────────────────────────────────────────────────────────
-/** SHA-256. Défaut : hex (convention des checksums et de SigV4). */
-export function sha256(data, encoding = 'hex') {
-    return enc(createHash('sha256').update(data).digest(), encoding);
-}
-/** SHA-256 brut — pour les chaînages (dérivation de clé SigV4, par ex.). */
-export function sha256Bytes(data) {
-    return createHash('sha256').update(data).digest();
-}
-/** HMAC-SHA256. Défaut : hex. */
-export function hmacSha256(key, data, encoding = 'hex') {
-    return enc(createHmac('sha256', key).update(data).digest(), encoding);
-}
-/** HMAC-SHA256 brut — pour les chaînages (SigV4 dérive sa clé par HMAC successifs). */
-export function hmacSha256Bytes(key, data) {
-    return createHmac('sha256', key).update(data).digest();
-}
-// ─── Comparaison ─────────────────────────────────────────────────────────────
-/**
- * Compare deux valeurs en TEMPS CONSTANT. **Toute** comparaison de secret, de signature ou
- * de jeton doit passer par ici — jamais par `===`, jamais par une boucle maison.
- *
- * C'est LA fonction dont l'absence d'un foyer unique a causé la divergence du 13/07 : le
- * kernel comparait « best effort » quand une feuille faisait correctement.
- *
- * La différence de longueur est renvoyée sans comparaison — elle ne fuit rien : la longueur
- * d'un HMAC-SHA256 est publique et constante.
- */
-export function equalsConstantTime(a, b) {
-    const bufA = Buffer.isBuffer(a) ? a : Buffer.from(a);
-    const bufB = Buffer.isBuffer(b) ? b : Buffer.from(b);
-    if (bufA.length !== bufB.length)
-        return false;
-    if (bufA.length === 0)
-        return true;
-    return nodeTimingSafeEqual(bufA, bufB);
-}
-/**
- * Dérive une clé AES-256 (32 octets) depuis une phrase secrète, par **scrypt**.
- *
- * Pourquoi scrypt et pas un simple SHA-256 de la phrase : un hachage est INSTANTANÉ, donc
- * une phrase faible se casse par force brute à des millions d'essais par seconde. scrypt est
- * délibérément **lent et gourmand en mémoire** — c'est le but.
- *
- * Le `salt` est RETOURNÉ : sans lui, la clé est irrécupérable. Il n'est pas secret et doit
- * être stocké à côté du chiffré (c'est ce que fait `aeadEncrypt`).
- */
-export function deriveKey(passphrase, opts = {}) {
-    const salt = opts.salt ? Buffer.from(opts.salt) : randomBytes(16);
-    const cost = opts.cost ?? 2 ** 17;
-    return new Promise((resolve, reject) => {
-        // `maxmem` doit suivre le coût, sinon Node refuse (« memory limit exceeded »).
-        nodeScrypt(passphrase, salt, 32, { N: cost, r: 8, p: 1, maxmem: 256 * cost * 8 }, (err, key) => {
-            if (err)
-                reject(err);
-            else
-                resolve({ key: key, salt });
-        });
-    });
-}
-/** Secret aléatoire (défaut 32 octets) — clés, sels, jetons. */
-export function randomKey(bytes = 32) {
-    return randomBytes(bytes);
-}
-// ─── Chiffrement authentifié (AEAD) ──────────────────────────────────────────
-const MAGIC = Buffer.from('MJSC1'); // 5 octets — repère de format, versionné
-const IV_LEN = 12; // GCM : 96 bits, la taille recommandée
-const TAG_LEN = 16;
-/**
- * Chiffre en **AES-256-GCM** (chiffrement AUTHENTIFIÉ : confidentialité ET intégrité).
- *
- * Le format de sortie est **autoportant** — `MJSC1 | iv(12) | tag(16) | chiffré` : il n'y a
- * rien d'autre à conserver que la clé. Sans cela, l'appelant devrait gérer lui-même l'IV et
- * le tag, et un seul oubli rend le déchiffrement impossible… ou pire, l'IV est réutilisé.
- *
- * L'IV est TIRÉ AU HASARD À CHAQUE APPEL et n'est jamais fourni par l'appelant. Réutiliser un
- * IV en GCM est catastrophique — cela révèle le XOR des clairs et permet de forger des
- * messages. C'est la raison pour laquelle cette API n'offre pas l'option.
- */
-export function aeadEncrypt(key, plaintext) {
-    if (key.length !== 32)
-        throw new Error('crypto-box : la clé AES-256 doit faire 32 octets (voir deriveKey)');
-    const iv = randomBytes(IV_LEN);
-    const cipher = createCipheriv('aes-256-gcm', Buffer.from(key), iv);
-    const body = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-    return Buffer.concat([MAGIC, iv, cipher.getAuthTag(), body]);
-}
-/**
- * Déchiffre un blob produit par `aeadEncrypt`.
- *
- * Lève si la clé est fausse OU si le chiffré a été **altéré d'un seul bit** : c'est le tag
- * GCM qui l'impose. Un déchiffrement qui « réussit » sur des octets corrompus est exactement
- * ce qu'on ne veut pas d'une sauvegarde.
+ * PAS une « bibliothèque de crypto ». Une enveloppe MINCE et OPINIONÉE sur node:crypto :
+ * pas de choix d'algorithme hasardeux, pas de mode dangereux, JAMAIS de nonce fourni par
+ * l'appelant. Un module de crypto qui offre des options est la façon classique d'écrire du
+ * chiffrement cassé. Il n'ajoute que ce qu'un consommateur RÉEL réclame.
+ *
+ * ─── CE DONT IL NE RÉPOND PAS ────────────────────────────────────────────────
+ * La GARDE de la clé est une décision produit. Le modèle d'ENVELOPPE (voir envelope.ts) est
+ * précisément ce qui permet de vendre la conservation d'archives SANS détenir les secrets du
+ * client : la console garde une enveloppe qu'elle ne sait pas ouvrir.
  */
-export function aeadDecrypt(key, blob) {
-    if (key.length !== 32)
-        throw new Error('crypto-box : la clé AES-256 doit faire 32 octets');
-    const buf = Buffer.from(blob);
-    if (buf.length < MAGIC.length + IV_LEN + TAG_LEN)
-        throw new Error('crypto-box : blob tronqué');
-    if (!buf.subarray(0, MAGIC.length).equals(MAGIC))
-        throw new Error('crypto-box : format inconnu (pas un blob MJSC1)');
-    const iv = buf.subarray(MAGIC.length, MAGIC.length + IV_LEN);
-    const tag = buf.subarray(MAGIC.length + IV_LEN, MAGIC.length + IV_LEN + TAG_LEN);
-    const body = buf.subarray(MAGIC.length + IV_LEN + TAG_LEN);
-    const decipher = createDecipheriv('aes-256-gcm', Buffer.from(key), iv);
-    decipher.setAuthTag(tag);
-    return Buffer.concat([decipher.update(body), decipher.final()]); // `final()` vérifie le tag
-}
+// Empreintes, HMAC, comparaison, clé depuis une phrase.
+export { sha256, sha256Bytes, hmacSha256, hmacSha256Bytes, equalsConstantTime, deriveKey, randomKey, } from './hash.js';
+// Chiffrement authentifié — en un coup ET EN FLUX (les archives ne tiennent pas en mémoire).
+export { aeadEncrypt, aeadDecrypt, aeadEncryptStream, aeadDecryptStream, CHUNK_SIZE, } from './aead.js';
+// Signature (Ed25519), sous-clés (HKDF), et chiffrement par ENVELOPPE (X25519).
+export { generateSigningKeyPair, sign, verifySignature, deriveSubKey, generateRecipientKeyPair, seal, open, } from './envelope.js';
+export const moduleInfo = { name: '@mostajs/crypto-box', version: '0.2.0', level: 'N0' };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+export type Bytes = Uint8Array | Buffer;
+export type Encoding = 'hex' | 'base64url';

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,23 +1,46 @@
 {
   "name": "@mostajs/crypto-box",
-  "version": "0.1.0",
-  "description": "Les primitives cryptographiques de l'écosystème, une seule maison : sha256, hmac, comparaison à temps constant, AES-256-GCM authentifié, dérivation de clé scrypt. Enveloppe MINCE et opinionée sur node:crypto — pas une bibliothèque de crypto. Primitive N0, zéro dépendance.",
+  "version": "0.2.0",
+  "description": "Les primitives cryptographiques de l'écosystème, une seule maison : AEAD EN FLUX (AES-GCM / ChaCha20-Poly1305), chiffrement par ENVELOPPE (X25519, modèle age), signature Ed25519, HKDF, scrypt, comparaison à temps constant. Enveloppe MINCE et opinionée sur node:crypto. Primitive N0, zéro dépendance.",
   "license": "AGPL-3.0-or-later",
   "author": "Dr Hamid MADANI <drmdh@msn.com>",
   "type": "module",
   "exports": {
-    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js", "default": "./dist/index.js" }
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
-  "files": ["dist", "README.md", "llms.txt", "LICENSE"],
+  "files": [
+    "dist",
+    "README.md",
+    "llms.txt",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "test": "bash test-scripts/run-tests.sh",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["crypto", "aes-256-gcm", "aead", "hmac", "scrypt", "timing-safe", "zero-dep", "mostajs"],
+  "keywords": [
+    "crypto",
+    "aead",
+    "streaming",
+    "envelope",
+    "x25519",
+    "ed25519",
+    "hkdf",
+    "chacha20",
+    "aes-256-gcm",
+    "scrypt",
+    "timing-safe",
+    "zero-dep",
+    "mostajs"
+  ],
   "devDependencies": {
     "@mostajs/mjs-unit": "^0.3.1",
     "@types/node": "^20",
     "typescript": "^5.6.0"
   }
-}
+}