discovery-media-player 0.1.20 → 0.1.22

package/context/standalone.js

@@ -304,6 +304,65 @@ function createStandaloneContext(env = process.env) {
         return a.length === b.length && crypto.timingSafeEqual(a, b);
       },
 
+      /**
+       * Qui appelle ? **La socket, pas l'en-tête** — sauf si l'exploitant déclare son proxy.
+       *
+       * ⚠️ `X-Forwarded-For` est une affirmation du client. Toutes les limites de débit s'y
+       * appuyaient : un appelant direct — le cas du serveur autonome — en changeait à chaque
+       * requête et n'était jamais limité. La limite existait, elle ne limitait rien.
+       *
+       * `PLAYER_TRUSTED_PROXY_HOPS=1` dit « il y a UN proxy devant moi, sa dernière valeur ajoutée
+       * est l'IP réelle ». On lit alors depuis la FIN de la chaîne, pas depuis le début : le début
+       * est ce que le client a écrit, la fin est ce que les proxys ont constaté. C'est l'inverse
+       * de ce que faisait le code, et c'est l'erreur classique sur cet en-tête.
+       *
+       * Non configuré ⇒ l'en-tête est ignoré. Un hôte sans proxy est protégé sans rien faire.
+       */
+      clientIp(req) {
+        const sauts = Math.max(0, Math.min(10, Number(env.PLAYER_TRUSTED_PROXY_HOPS || 0) || 0));
+        const socket = String((req && req.socket && req.socket.remoteAddress) || "");
+        if (!sauts) return socket;
+        const chaine = String((req && req.headers && req.headers["x-forwarded-for"]) || "")
+          .split(",").map((v) => v.trim()).filter(Boolean);
+        if (!chaine.length) return socket;
+        // Le proxy le plus proche a ajouté la dernière valeur : on remonte de `sauts` depuis la fin.
+        const i = chaine.length - sauts;
+        return chaine[i >= 0 ? i : 0] || socket;
+      },
+
+      /**
+       * Vérifie un jeton de session INTERNE, émis par l'hôte pour son propre membre.
+       *
+       * ⚠️ POURQUOI DANS LE CORPS ET PAS EN EN-TÊTE. Le suivi de lecture part par `sendBeacon`,
+       * seul transport qui survive à la fermeture d'un onglet — et il ne sait pas porter
+       * d'en-tête. Exiger un JWT reviendrait à perdre la mesure au moment où elle compte le plus.
+       *
+       * Format : base64url(JSON) + "." + HMAC-SHA256 du même JSON, signé avec le secret que
+       * l'hôte détient déjà. Charge utile : { email, name, docId, exp }.
+       *
+       * ⚠️ Comparaison à temps constant, et `exp` obligatoire : un jeton sans expiration signé une
+       * fois vaudrait pour toujours, y compris après le départ du membre de l'entreprise.
+       */
+      verifyInternalToken(jeton) {
+        const secret = String(env.PLAYER_HOST_FETCH_SECRET || "");
+        const brut = String(jeton || "");
+        if (!secret || !brut) return null;
+        const sep = brut.lastIndexOf(".");
+        if (sep <= 0) return null;
+        const corps = brut.slice(0, sep);
+        const signature = brut.slice(sep + 1);
+        try {
+          const attendue = crypto.createHmac("sha256", secret).update(corps).digest("base64url");
+          const a = Buffer.from(attendue, "utf8"); const b = Buffer.from(signature, "utf8");
+          if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) return null;
+          const d = JSON.parse(Buffer.from(corps, "base64url").toString("utf8"));
+          if (!d || typeof d !== "object") return null;
+          if (!Number.isFinite(d.exp) || d.exp * 1000 < Date.now()) return null;
+          if (!d.email || !d.docId) return null;
+          return { email: String(d.email), name: d.name ? String(d.name) : "", docId: String(d.docId) };
+        } catch { return null; }
+      },
+
       // ⚠️ Le rôle vient d'`app_metadata`, JAMAIS d'`user_metadata` : ce dernier est modifiable par
       // l'utilisateur lui-même. S'y fier revient à laisser chacun choisir ses droits.
       roleOf: (user) => String(((user || {}).app_metadata || {}).role || "").trim().toLowerCase(),
@@ -360,6 +419,18 @@ function createStandaloneContext(env = process.env) {
     errors: journal,
 
     legal: {
+      /**
+       * L'URL PUBLIQUE de cette instance, telle que l'exploitant l'a écrite.
+       *
+       * ⚠️ Sert à fabriquer les liens qui partent par email. L'en-tête `Host` ne convient pas :
+       * il est choisi par le client, donc un lecteur pouvait faire envoyer un message signé de
+       * l'hôte dont le bouton pointe ailleurs. Vide ⇒ repli sur `Host`, mais signalé.
+       */
+      get publicUrl() {
+        const v = sansBarreFinale(env.PLAYER_PUBLIC_URL).trim();
+        return v.startsWith("https://") ? v : "";
+      },
+
       get sourceUrl() { return String(env.PLAYER_SOURCE_URL || "https://github.com/Juli1artha/discovery-media-player").trim(); },
       get legalUrl() { return String(env.PLAYER_LEGAL_URL || "").trim(); },
       get privacyUrl() { return String(env.PLAYER_PRIVACY_URL || "").trim(); },
@@ -396,6 +467,8 @@ function createStandaloneContext(env = process.env) {
       // sont deux questions, et seule la seconde explique un refus.
       hostShare: !!String(env.PLAYER_HOST_SHARE_SECRET || ""),
       hostMail: !!String(env.PLAYER_HOST_MAIL_URL || "").trim(),
+      // Porte fermée : sans jeton de l'hôte, aucune session interne n'est écrite.
+      internalStrict: String(env.PLAYER_INTERNAL_STRICT || "") === "1",
     },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Self-hosted document viewer: per-recipient tracked links, reading analytics, live presentation. The core knows nothing about the application hosting it — everything it borrows arrives through an injected context.",
   "keywords": [
     "pdf-viewer",

package/server/handler.js

@@ -49,6 +49,21 @@ const dispositionInline = (name) => {
   return `inline; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(raw)}`;
 };
 const originOf = (u) => { try { return new URL(u).origin; } catch { return ""; } };
+// ⚠️ CETTE VERSION EST DANS LA PLAGE DE CVE-2024-4367 (exécution de script à l'ouverture d'un PDF
+// forgé, quand `isEvalSupported` garde sa valeur par défaut). Deux raisons pour lesquelles elle
+// est encore là, et il faut les distinguer :
+//
+//   1. Notre CSP n'autorise pas `unsafe-eval`, ce qui bloque le chemin d'exploitation. Mais cette
+//      atténuation était IMPLICITE — une modification de CSP la rouvrait sans que rien ne le dise.
+//      Les quatre appels à `getDocument` forcent donc désormais `isEvalSupported: false`, en
+//      défense en profondeur : la protection ne dépend plus d'un en-tête écrit ailleurs.
+//   2. La montée vers 4.x n'est PAS un changement de numéro : cdnjs ne publie plus que des modules
+//      ES (`pdf.min.mjs`) à partir de 4.0, alors qu'on charge un script classique et qu'on
+//      configure le worker à la main. C'est une migration, elle est suivie séparément dans
+//      docs/AUDIT-2026-08-14-SUIVI.md (P1-3) avec l'embarquement de la bibliothèque, qui règle
+//      aussi la dépendance CDN sans intégrité (P2-4).
+//
+// Signalé par un audit externe. Fermer le chemin d'abord, migrer ensuite — dans cet ordre.
 const PDFJS = "https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.11.174";
 const SUPAJS = "https://cdn.jsdelivr.net/npm/@supabase/supabase-js@2/dist/umd/supabase.js";
 
@@ -286,7 +301,7 @@ var Live=(function(){
   function renderMsgInner(m){return Player.chat.renderMessage(m,{me:ME,reactIcon:RSVG});}
   function cmClass(m){return Player.chat.messageClassName(m,ME,isMentioned(m));}
   function hydratePdf(d,m){if(m&&m.attachment&&m.attachment.kind==='pdf'&&!m.deleted){var ph=d.querySelector('.cm-att-ph');if(ph)pdfThumb(m.attachment.url,ph);}}
-  function pdfThumb(url,ph){if(!ph)return;if(pdfCache[url]){ph.innerHTML='<img src="'+pdfCache[url]+'" alt="">';return;}if(!window.pdfjsLib)return;try{pdfjsLib.getDocument(url).promise.then(function(pdf){return pdf.getPage(1);}).then(function(pg){var v0=pg.getViewport({scale:1}),sc=Math.min(1.6,208/v0.width),vp=pg.getViewport({scale:sc}),cv=document.createElement('canvas');cv.width=Math.ceil(vp.width);cv.height=Math.ceil(vp.height);return pg.render({canvasContext:cv.getContext('2d'),viewport:vp}).promise.then(function(){var u=cv.toDataURL('image/jpeg',0.8);pdfCache[url]=u;ph.innerHTML='<img src="'+u+'" alt="">';});}).catch(function(){});}catch(e){}}
+  function pdfThumb(url,ph){if(!ph)return;if(pdfCache[url]){ph.innerHTML='<img src="'+pdfCache[url]+'" alt="">';return;}if(!window.pdfjsLib)return;try{pdfjsLib.getDocument({url:url,isEvalSupported:false}).promise.then(function(pdf){return pdf.getPage(1);}).then(function(pg){var v0=pg.getViewport({scale:1}),sc=Math.min(1.6,208/v0.width),vp=pg.getViewport({scale:sc}),cv=document.createElement('canvas');cv.width=Math.ceil(vp.width);cv.height=Math.ceil(vp.height);return pg.render({canvasContext:cv.getContext('2d'),viewport:vp}).promise.then(function(){var u=cv.toDataURL('image/jpeg',0.8);pdfCache[url]=u;ph.innerHTML='<img src="'+u+'" alt="">';});}).catch(function(){});}catch(e){}}
   // Renvoie true seulement si le message a réellement été AJOUTÉ. Pendant la transition, il
   // arrive par deux voies (diffusion et lecture de table) : sans cette réponse, l'affichage était
   // bien dédoublonné mais le compteur de non-lus comptait deux fois — une pastille à 2 pour un
@@ -1167,6 +1182,31 @@ function botMarkup(share, pitch) {
 // formats du README ne connaît que le PDF et les images bitmap).
 const TYPES_EXECUTABLES = /^(image\/svg|text\/html|application\/xhtml|application\/xml|text\/xml)/i;
 
+// ⚠️ `X-Forwarded-For` EST UN EN-TÊTE, DONC UNE AFFIRMATION DU CLIENT.
+//
+// Onze endroits en prenaient la première valeur pour identifier l'appelant, et toutes les limites
+// de débit s'appuyaient dessus. Un client qui atteint directement le serveur — c'est le cas du
+// serveur autonome, et de toute instance dont le proxy ne réécrit pas cet en-tête — pouvait donc
+// en changer à chaque requête et n'être jamais limité. La limite existait, elle ne limitait rien.
+//
+// Le caractère « par processus » des compteurs était documenté ; la confiance dans un en-tête non
+// authentifié ne l'était pas. C'est la différence entre une limite approximative et une limite
+// décorative.
+//
+// La décision revient à l'hôte, parce que lui seul sait s'il y a un proxy devant lui :
+// `identity.clientIp(req)` s'il la fournit, sinon l'adresse de la socket — jamais l'en-tête. Un
+// hôte derrière un proxy déclare sa politique dans son câblage ; un hôte sans proxy n'a rien à
+// faire, et il est protégé par défaut.
+function adresseAppelant(req) {
+  try {
+    if (PLAYER.identity && typeof PLAYER.identity.clientIp === "function") {
+      const v = PLAYER.identity.clientIp(req);
+      if (v) return String(v).slice(0, 60);
+    }
+  } catch { /* une IP indisponible ne doit pas empêcher de lire un document */ }
+  return String((req.socket && req.socket.remoteAddress) || "").slice(0, 60);
+}
+
 async function relayerFichier(res, r, disposition) {
   if (!r) { res.statusCode = 404; res.end("Fichier indisponible"); return; }
   if (!r.ok && r.status !== 206) { res.statusCode = 502; res.end("Fichier indisponible"); return; }
@@ -1934,7 +1974,7 @@ ${LEGAL_CSS}
     }
     function render(){
       if(IS_IMG){ renderImage(); return; }
-      var task=pdfjsLib.getDocument(CFG.fileUrl);
+      var task=pdfjsLib.getDocument({url:CFG.fileUrl,isEvalSupported:false});
       task.onProgress=function(p){ if(p&&p.total){ var pct=Math.max(8,Math.min(99,Math.round(p.loaded/p.total*100))); var bar=document.getElementById('lbar'); if(bar)bar.classList.remove('idle'); var f=document.getElementById('lbarFill'); if(f)f.style.width=pct+'%'; var l=document.getElementById('lpct'); if(l)l.textContent=pct+' %'; } };
       task.promise.then(function(pdf){
         pdfDoc=pdf; numPages=pdf.numPages; window.__n=pdf.numPages; T.setPageCount(pdf.numPages);
@@ -2161,7 +2201,7 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
       }).catch(function(){ pdfjsLib.GlobalWorkerOptions.workerSrc=wsrc; load(); });
     }
     function load(){
-      pdfjsLib.getDocument(CFG.fileUrl).promise.then(function(pdf){
+      pdfjsLib.getDocument({url:CFG.fileUrl,isEvalSupported:false}).promise.then(function(pdf){
         PDF=pdf; total=pdf.numPages; ready=true;
         var tot=document.getElementById('tot'); if(tot)tot.textContent=total;
         show(cur); hideLoader();
@@ -2322,7 +2362,7 @@ async function handler(req, res) {
         const jv = (status, obj, cookie) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); if (cookie) res.setHeader("Set-Cookie", cookie); res.end(JSON.stringify(obj)); };
         const V = PLAYER.plugins.visitors;
         if (!V) return jv(404, { ok: false, error: "disabled" });
-        const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || "ip";
+        const ip = adresseAppelant(req) || "ip";
         if (body.action === "visitor-request") {
           if (!(await PLAYER.limits.allow(`vcode:${ip}`, 20, 3600))) return jv(429, { ok: false, error: "rate" });
           const sh = await getShareBySlug(String(body.slug || ""));
@@ -2350,7 +2390,7 @@ async function handler(req, res) {
         try {
           if (body.action === "present-start") {
             if (!isAllowedStorageUrl(String(body.fileUrl || ""))) return jp(400, { ok: false, error: "url" });
-            const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+            const ip = adresseAppelant(req) || "anon";
             const allowed = await PLAYER.limits.allow(`pstart:${ip}`, 60, 3600);
             if (!allowed) return jp(429, { ok: false, error: "rate" });
             // On rattache la présentation au membre (JWT) → reprise / liste / transfert. Best-effort : sans
@@ -2383,7 +2423,7 @@ async function handler(req, res) {
           if (!share || !share.bot_enabled) return jp(404, { ok: false, error: "bot" });
           const text = String(body.text || "").replace(/\s+/g, " ").trim().slice(0, 700);
           if (!text) return jp(400, { ok: false, error: "empty" });
-          const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+          const ip = adresseAppelant(req) || "anon";
           if (!(await PLAYER.limits.allow(`doctts:${ip}`, 400, 3600))) return jp(429, { ok: false, error: "rate" });
           const defaultVoiceId = process.env.ELEVENLABS_VOICE_ID || "21m00Tcm4TlvDq8ikWAM";
           let voiceId = defaultVoiceId;
@@ -2456,7 +2496,7 @@ async function handler(req, res) {
         const jp = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
         if (!docbot) return jp(404, { ok: false, error: "disabled" });
         try {
-          const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+          const ip = adresseAppelant(req) || "anon";
           const allowed = await PLAYER.limits.allow(`docbot:${ip}`, 120, 3600);
           if (!allowed) return jp(429, { ok: false, error: "rate" });
           const share = await getShareBySlug(String(body.slug || ""));
@@ -2505,7 +2545,7 @@ async function handler(req, res) {
       if (body.action === "present-attend") {
         const jp = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
         try {
-          const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+          const ip = adresseAppelant(req) || "anon";
           const allowed = await PLAYER.limits.allow(`patt:${ip}`, 1000, 3600);
           if (!allowed) return jp(429, { ok: false, error: "rate" });
           const r = await recordAttendance(String(body.slug || ""), { key: body.key, name: body.name, email: body.email, avatar: body.avatar, isMember: !!body.isMember, isPresenter: !!body.isPresenter });
@@ -2541,7 +2581,7 @@ async function handler(req, res) {
         try {
           const pres = await getPresentation(String(body.slug || ""));
           if (!pres) return jp(404, { ok: false });
-          const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+          const ip = adresseAppelant(req) || "anon";
           const allowed = await PLAYER.limits.allow(`pchat:${ip}`, 60, 3600);
           if (!allowed) return jp(429, { ok: false, error: "rate" });
           // Le badge « présentateur » n'est accordé QUE si le control_token est valide (sinon n'importe quel
@@ -2558,7 +2598,7 @@ async function handler(req, res) {
         try {
           const pres = await getPresentation(String(body.slug || ""));
           if (!pres) return jp(404, { ok: false });
-          const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+          const ip = adresseAppelant(req) || "anon";
           const allowed = await PLAYER.limits.allow(`pup:${ip}`, 30, 3600);
           if (!allowed) return jp(429, { ok: false, error: "rate" });
           const r = await createUploadUrl(String(body.slug || ""), body.name, body.type);
@@ -2580,7 +2620,7 @@ async function handler(req, res) {
       if (body.action === "present-react") {
         const jp = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
         try {
-          const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+          const ip = adresseAppelant(req) || "anon";
           const allowed = await PLAYER.limits.allow(`preact:${ip}`, 200, 3600);
           if (!allowed) return jp(429, { ok: false, error: "rate" });
           const r = await toggleReaction(String(body.slug || ""), body.msgId, body.emoji, body.reactor);
@@ -2630,7 +2670,7 @@ async function handler(req, res) {
             const docId = String(body.docId || "").trim();
             if (!docId || !body.fileUrl) return jd(400, { ok: false, error: "docId/fileUrl requis" });
 
-            const ipH = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "hote";
+            const ipH = adresseAppelant(req) || "hote";
             if (!(await PLAYER.limits.allow(`hshare:${ipH}`, 120, 3600))) return jd(429, { ok: false, error: "rate" });
 
             // ⚠️ La clé d'idempotence n'a PAS demandé de colonne : « le lien de l'hôte pour ce
@@ -2716,7 +2756,7 @@ async function handler(req, res) {
         const mail = String(body.email || "").trim().toLowerCase();
         const j = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
         if (!/.+@.+\..+/.test(mail)) return j(400, { ok: false, error: "email" });
-        const ip = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "anon";
+        const ip = adresseAppelant(req) || "anon";
         const allowed = await PLAYER.limits.allow(`reshare:${ip}`, 8, 3600);
         if (!allowed) return j(429, { ok: false, error: "rate", message: "Trop de partages, réessayez plus tard." });
         let out = null;
@@ -2750,7 +2790,21 @@ async function handler(req, res) {
               refusEnvoi = "no-recipient";
               throw new Error("envoi réservé aux liens nominatifs");
             }
-            const origin = `https://${req.headers.host}`;
+            // ⚠️ `Host` EST CHOISI PAR LE CLIENT. Le lien inséré dans un email signé par l'hôte
+            // était construit avec cet en-tête : sur le serveur autonome, ou derrière un proxy qui
+            // ne le réécrit pas strictement, un lecteur pouvait demander un envoi parfaitement
+            // légitime dont le bouton pointe vers SON domaine. L'email part de l'hôte, avec sa
+            // marque et sa réputation, vers le destinataire choisi par l'attaquant.
+            //
+            // `PLAYER_PUBLIC_URL` d'abord — une valeur que l'exploitant a écrite. Le repli sur
+            // `Host` reste pour ne casser aucune instance existante, mais il est SIGNALÉ : une
+            // instance qui envoie des emails sans URL publique configurée doit le savoir avant de
+            // le découvrir dans un rapport d'hameçonnage.
+            const publique = String(PLAYER.legal.publicUrl || "").trim();
+            if (!publique) {
+              try { PLAYER.errors.capture(new Error("PLAYER_PUBLIC_URL non configurée : le lien de l'email est construit depuis l'en-tête Host, que le client choisit"), { route: "reshare" }); } catch { /* jamais bloquant */ }
+            }
+            const origin = publique || `https://${req.headers.host}`;
             const r = await sendReshareEmail({ parent, childSlug: out.slug, origin, toEmail: mail, toName: body.name });
             sent = !!(r && r.sent);
           } catch { /* best-effort : le lien existe quand même */ }
@@ -2761,10 +2815,55 @@ async function handler(req, res) {
         return j(200, { ok: true, slug: out.slug, sent, ...(refusEnvoi ? { sendRefused: refusEnvoi } : {}) });
       }
       const ua0 = req.headers["user-agent"];
-      const ip0 = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "";
-      // Consultation INTERNE (aperçu interne) : session dédiée, séparée des stats prospects. Pas de slug.
+      const ip0 = adresseAppelant(req);
+      // ⚠️ CONSULTATION INTERNE : L'IDENTITÉ EST AFFIRMÉE PAR LE NAVIGATEUR, PAS PROUVÉE.
+      //
+      // La population interne est celle que le produit promet de ne jamais mélanger aux prospects.
+      // Or cette route acceptait n'importe quel e-mail, n'importe quel document, sans jeton ni
+      // limite : on pouvait fabriquer « tel collègue a lu ce document trois heures ».
+      //
+      // Le suivi part par `sendBeacon`, qui ne sait pas porter d'en-tête — exiger un JWT casserait
+      // le seul transport qui survive à la fermeture d'un onglet, c'est-à-dire le moment où la
+      // mesure compte le plus. La preuve doit donc voyager dans le CORPS, et venir de l'hôte :
+      // lui seul sait qui est son membre.
+      //
+      // `PLAYER_INTERNAL_STRICT` laisse chaque hôte fermer la porte à son rythme :
+      //   • absent  → on accepte, borné et limité, et on le SIGNALE une fois de temps en temps ;
+      //   • posé    → sans jeton valide, rien n'est écrit.
+      // Une fermeture par défaut casserait les instances en service, dont la nôtre. Une porte
+      // qu'on laisse ouverte sans le dire est un défaut ; une porte qu'on laisse ouverte en le
+      // disant, avec le verrou fourni, est une transition.
       if (body.internal && body.event === "session") {
-        try { await upsertInternalSession({ sessionId: body.sessionId, docId: body.docId, userEmail: body.email, userName: body.name, numPages: body.numPages, maxPage: body.maxPage, totalSeconds: body.totalSeconds, pagesTime: body.pagesTime }, { ip: ip0, ua: ua0 }); } catch { /* best-effort */ }
+        const ipInt = ip0 || "anon";
+        if (!(await PLAYER.limits.allow(`intsess:${ipInt}`, 120, 3600))) {
+          res.statusCode = 429; res.setHeader("Content-Type", "application/json"); res.end('{"ok":false,"error":"rate"}');
+          return;
+        }
+        const jeton = typeof PLAYER.identity.verifyInternalToken === "function"
+          ? PLAYER.identity.verifyInternalToken(String(body.it || ""))
+          : null;
+        const strict = !!(PLAYER.config && PLAYER.config.internalStrict);
+        if (strict && !jeton) {
+          res.statusCode = 403; res.setHeader("Content-Type", "application/json"); res.end('{"ok":false,"error":"internal-token"}');
+          return;
+        }
+        if (!strict && !jeton) {
+          // Une fois par heure et par instance : assez pour être vu dans les journaux, pas assez
+          // pour les noyer — un avertissement répété à chaque battement ne se lit plus.
+          if (await PLAYER.limits.allow("intsess:avert", 1, 3600)) {
+            try { PLAYER.errors.capture(new Error("session interne écrite sans jeton : l'identité vient du navigateur. Poser PLAYER_INTERNAL_STRICT=1 une fois l'hôte à jour"), { route: "internal-session" }); } catch { /* ignore */ }
+          }
+        }
+        // Le jeton fait foi quand il est là : c'est l'hôte qui se porte garant, pas l'appelant.
+        try {
+          await upsertInternalSession({
+            sessionId: body.sessionId,
+            docId: jeton ? jeton.docId : body.docId,
+            userEmail: jeton ? jeton.email : body.email,
+            userName: jeton ? (jeton.name || body.name) : body.name,
+            numPages: body.numPages, maxPage: body.maxPage, totalSeconds: body.totalSeconds, pagesTime: body.pagesTime,
+          }, { ip: ip0, ua: ua0 });
+        } catch { /* best-effort */ }
         res.statusCode = 200; res.setHeader("Content-Type", "application/json"); res.end('{"ok":true}');
         return;
       }

package/server/presentations.js

@@ -251,8 +251,28 @@ async function setChatLock(slug, control, locked) {
 async function toggleReaction(slug, msgId, emoji, reactor) {
   const id = Math.trunc(+msgId); const e = String(emoji || "").slice(0, 8); const who = String(reactor || "").slice(0, 160).toLowerCase();
   if (!id || !e || !who) return { ok: false, status: 400 };
+  // ⚠️ Une réaction est un EMOJI. Refuser tout ce qui ressemble à un identifiant ferme la porte à
+  // la source, en plus de l'objet sans prototype : `toString` stocké resterait affiché aux
+  // participants comme une réaction, ce qui est absurde même sans être dangereux. Deux barrières,
+  // parce que la seconde protège le jour où quelqu'un lève le plafond de longueur.
+  if (/[A-Za-z_$]/.test(e)) return { ok: false, status: 400 };
   const rows = await PLAYER.db.request(`doc_presentation_messages?id=eq.${id}&slug=eq.${enc(String(slug || ""))}&select=reactions&limit=1`);
-  const cur = (Array.isArray(rows) && rows[0] && rows[0].reactions && typeof rows[0].reactions === "object") ? rows[0].reactions : {};
+  // ⚠️ LE NOM DE PROPRIÉTÉ ÉCRIT ICI VIENT DU CLIENT — et la garde posée en 0.1.2 ne couvrait que
+  // les LECTURES. `Object.hasOwn` empêchait de LIRE `constructor` ; rien n'empêchait de l'ÉCRIRE.
+  //
+  // Le plafond de 8 caractères bloquait le pire par accident : `__proto__` (9) et `constructor`
+  // (11) sont tronqués en clés inoffensives. Mais `toString` (8) et `valueOf` (7) passaient, et
+  // devenaient des propriétés PROPRES de l'objet stocké — masquant celles du prototype pour tout
+  // consommateur, y compris le navigateur qui itère cet objet pour dessiner les réactions.
+  //
+  // ⚠️ Et cette protection accidentelle est fragile : les emojis composés (famille, drapeaux
+  // régionaux, séquences ZWJ) dépassent 8 caractères. Le jour où quelqu'un lèvera le plafond pour
+  // les accepter — un changement d'apparence anodin — `__proto__` et `constructor` passeront avec.
+  //
+  // Un objet SANS prototype retire la classe entière : il n'y a plus rien à masquer ni à
+  // atteindre, quelle que soit la clé et quel que soit le plafond.
+  const brut = (Array.isArray(rows) && rows[0] && rows[0].reactions && typeof rows[0].reactions === "object" && !Array.isArray(rows[0].reactions)) ? rows[0].reactions : {};
+  const cur = Object.assign(Object.create(null), brut);
   const arr = Array.isArray(cur[e]) ? cur[e] : [];
   const i = arr.indexOf(who);
   if (i >= 0) arr.splice(i, 1); else arr.push(who);

package/server/shares.js

@@ -291,15 +291,44 @@ async function setShareAuth(slug, requireAuth) {
 
 // — Consultations INTERNES (équipe), table dédiée → n'affecte PAS les stats prospects. —
 // Upsert d'une session interne (depuis l'aperçu interne de la visionneuse).
+// ⚠️ CES CHAMPS VIENNENT DU NAVIGATEUR, DONC ILS SONT DES AFFIRMATIONS, PAS DES MESURES.
+//
+// La population INTERNE est celle dont le produit dit qu'elle ne doit jamais être mélangée aux
+// prospects : « ce client a lu douze minutes » ne vaut que si un collègue relisant le document
+// n'entre pas dans le même compte. Or n'importe qui pouvait écrire une session interne avec
+// n'importe quel e-mail et n'importe quelle durée.
+//
+// Les bornes ci-dessous ne rendent pas la donnée authentique — elles empêchent qu'elle soit
+// ABSURDE, et qu'un appel répété fasse grossir la base sans limite. L'authenticité, elle, demande
+// que l'hôte se porte garant de l'identité (jeton signé) : c'est le second volet, et il est
+// signalé au point d'entrée plutôt qu'ici.
+const BORNES = { pages: 10_000, secondes: 24 * 3600, entreesPagesTime: 2_000 };
+
 async function upsertInternalSession(p, { ip, ua }) {
   const num = (v) => (Number.isFinite(+v) ? Math.trunc(+v) : null);
+  const borne = (v, max) => { const n = num(v); return n == null ? null : Math.max(0, Math.min(n, max)); };
   const sessionId = String(p.sessionId || "").slice(0, 64);
   if (!sessionId || !p.docId) return;
   const { device, os, browser } = parseUa(ua);
   const row = {
-    session_id: sessionId, doc_id: String(p.docId), user_email: low(p.userEmail) || null, user_name: (p.userName || "").trim() || null,
-    num_pages: num(p.numPages), max_page: num(p.maxPage), total_seconds: num(p.totalSeconds) || 0,
-    pages_time: (p.pagesTime && typeof p.pagesTime === "object") ? p.pagesTime : {},
+    session_id: sessionId, doc_id: String(p.docId).slice(0, 200), user_email: low(p.userEmail).slice(0, 160) || null,
+    user_name: (p.userName || "").trim().slice(0, 120) || null,
+    num_pages: borne(p.numPages, BORNES.pages), max_page: borne(p.maxPage, BORNES.pages),
+    total_seconds: borne(p.totalSeconds, BORNES.secondes) || 0,
+    // ⚠️ Un objet libre venu du dehors : sans plafond, un seul appel peut écrire un JSON de la
+    // taille qu'il veut, autant de fois qu'il veut. On garde la forme, bornée.
+    pages_time: (() => {
+      const src = (p.pagesTime && typeof p.pagesTime === "object" && !Array.isArray(p.pagesTime)) ? p.pagesTime : {};
+      const out = {};
+      let n = 0;
+      for (const k in src) {
+        if (++n > BORNES.entreesPagesTime) break;
+        const page = num(k);
+        if (page == null || page < 0 || page > BORNES.pages) continue;
+        out[String(page)] = borne(src[k], BORNES.secondes) || 0;
+      }
+      return out;
+    })(),
     ua: String(ua || "").slice(0, 300), ip: String(ip || "").slice(0, 60), device, os, browser, last_at: new Date().toISOString(),
   };
   await PLAYER.db.request("commercial_doc_internal_sessions?on_conflict=session_id", { method: "POST", headers: { Prefer: "resolution=merge-duplicates,return=minimal" }, body: [row] });