discovery-media-player 0.1.21 → 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(),
@@ -408,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.21",
+  "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

@@ -1182,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; }
@@ -2337,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 || ""));
@@ -2365,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
@@ -2398,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;
@@ -2471,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 || ""));
@@ -2520,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 });
@@ -2556,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
@@ -2573,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);
@@ -2595,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);
@@ -2645,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
@@ -2731,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;
@@ -2790,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] });