discovery-media-player 0.1.32 → 0.1.34

package/context/standalone.js

@@ -318,6 +318,19 @@ function createStandaloneContext(env = process.env) {
        *
        * Non configuré ⇒ l'en-tête est ignoré. Un hôte sans proxy est protégé sans rien faire.
        */
+      /**
+       * Comment LIRE votre utilisateur — nom, e-mail, avatar — à partir de ce que `verifyToken`
+       * a rendu. Le cœur s'en sert pour signer les messages et les lignes d'assistance : ce qui est
+       * prouvé remplace ce que l'appelant affirme.
+       *
+       * Défaut : les formes usuelles d'un utilisateur Supabase. Redéfinissez-le si le vôtre range
+       * son nom ailleurs — sans quoi le message d'un membre porterait le nom qu'il a tapé.
+       */
+      profileOf(u) {
+        const meta = (u && u.user_metadata) || {};
+        return { email: (u && u.email) || "", name: meta.name || meta.full_name || "", avatar: meta.avatarUrl || meta.avatar_url || "" };
+      },
+
       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) || "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "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

@@ -1344,11 +1344,38 @@ function cleSessionHote() {
 const CLE_SESSION_PLAYER = "dmp-live-auth";
 const CLE_INVITE = "dmp-present-me";
 
-async function membreVerifie(req) {
+/**
+ * Le profil PROUVÉ de l'appelant : ce que son jeton dit de lui, jamais ce qu'il affirme.
+ *
+ * ⚠️ `isPresenter` et `isMember` étaient vérifiés depuis 0.1.25/0.1.28, mais `name`, `email` et
+ * `avatar` venaient toujours du corps de la requête — même quand un jeton valide accompagnait
+ * l'appel. Un membre authentifié pouvait donc publier un message portant le nom et l'adresse d'un
+ * collègue, AVEC le badge membre : l'attribution visuelle disait quelqu'un d'autre.
+ *
+ * ⚠️ Ça ne donnait aucun droit — modifier et supprimer s'autorisent par `author_hash`, pas par
+ * l'e-mail (cf. `editMessage`). Le dommage est l'attribution, pas la prise de contrôle. C'est déjà
+ * assez : dans une discussion, un message signé du nom d'un autre est le problème.
+ *
+ * L'hôte peut fournir `identity.profileOf` pour dire comment lire SON utilisateur. Sans ce
+ * crochet, on lit les formes courantes — et l'e-mail, lui, est universel.
+ *
+ * Signalé par la seconde passe d'audit (P1-6).
+ */
+async function profilDuJeton(req) {
   try {
     const u = await PLAYER.identity.verifyToken((req.headers && req.headers.authorization) || "");
-    return !!(u && u.email);
-  } catch { return false; }
+    if (!u || !u.email) return null;
+    if (typeof PLAYER.identity.profileOf === "function") {
+      const p = PLAYER.identity.profileOf(u) || {};
+      return { email: String(p.email || u.email), name: String(p.name || ""), avatar: String(p.avatar || "") };
+    }
+    const meta = (u && u.user_metadata) || {};
+    return {
+      email: String(u.email),
+      name: String(u.name || meta.name || meta.full_name || ""),
+      avatar: String(u.avatar || meta.avatarUrl || meta.avatar_url || ""),
+    };
+  } catch { return null; }
 }
 
 async function relayerFichier(res, r, disposition) {
@@ -2738,8 +2765,16 @@ async function handler(req, res) {
           const pres = await getPresentation(String(body.slug || ""));
           if (!pres) return jp(404, { ok: false });
           const estPresentateur = !!(body.control && require("crypto").createHash("sha256").update(String(body.control)).digest("hex") === pres.control_hash);
-          const estMembre = await membreVerifie(req);
-          const r = await recordAttendance(String(body.slug || ""), { key: body.key, name: body.name, email: body.email, avatar: body.avatar, isMember: estMembre, isPresenter: estPresentateur });
+          // ⚠️ Une identité prouvée REMPLACE celle qu'on affirme — elle ne s'y ajoute pas. Sinon la
+          // vérification ne servirait qu'à décorer une affirmation qu'on croit toujours.
+          const profil = await profilDuJeton(req);
+          const r = await recordAttendance(String(body.slug || ""), {
+            key: body.key,
+            name: (profil && profil.name) || body.name,
+            email: profil ? profil.email : body.email,
+            avatar: (profil && profil.avatar) || body.avatar,
+            isMember: !!profil, isPresenter: estPresentateur,
+          });
           return jp(r.ok ? 200 : (r.status || 400), r);
         } catch { return jp(500, { ok: false }); }
       }
@@ -2782,7 +2817,12 @@ async function handler(req, res) {
           // `isMember` restait l'affirmation du client, alors que `isPresenter` était vérifié juste
           // au-dessus. Deux poids sur la même ligne : le badge « présentateur » se méritait, celui
           // de collègue se réclamait.
-          const r = await addMessage(String(body.slug || ""), { name: body.name, email: body.email, avatar: body.avatar, isPresenter: validControl, isMember: await membreVerifie(req), body: body.body, replyTo: body.replyTo, replyName: body.replyName, replyText: body.replyText, authorToken: body.authorToken, attachment: body.attachment });
+          const profil = await profilDuJeton(req);
+          const r = await addMessage(String(body.slug || ""), {
+            name: (profil && profil.name) || body.name,
+            email: profil ? profil.email : body.email,
+            avatar: (profil && profil.avatar) || body.avatar,
+            isPresenter: validControl, isMember: !!profil, body: body.body, replyTo: body.replyTo, replyName: body.replyName, replyText: body.replyText, authorToken: body.authorToken, attachment: body.attachment });
           return jp(r.ok ? 200 : (r.status || 400), r);
         } catch { return jp(500, { ok: false }); }
       }
@@ -2996,15 +3036,30 @@ async function handler(req, res) {
             // 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.
+            // ⚠️ UNE ALERTE N'EST PAS UNE INTERDICTION.
+            //
+            // 0.1.21 posait `PLAYER_PUBLIC_URL`, retombait sur `Host` quand elle manquait, et
+            // SIGNALAIT le repli. C'était le bon réflexe de compatibilité et la mauvaise
+            // conclusion : le journal ne bloque pas un email d'hameçonnage. Une instance mal
+            // configurée continuait d'envoyer, signée de sa marque, avec un bouton pointant où le
+            // lecteur voulait — et l'exploitant l'apprenait dans un rapport d'abus.
+            //
+            // ⚠️ CE QU'ON REFUSE, C'EST L'ENVOI — PAS LE LIEN. Le lien enfant est créé, tracé, et
+            // rendu à l'appelant : il peut le transmettre lui-même. Ce qui est retenu est la seule
+            // chose qu'on ne peut pas rattraper — un courrier parti de nos serveurs, avec notre
+            // domaine dans l'en-tête et notre réputation d'expéditeur derrière.
+            //
+            // La compatibilité invoquée en 0.1.21 ne tenait donc pas : refuser l'envoi ne casse
+            // pas la création du lien, qui est la fonction principale de cette route.
+            //
+            // Signalé par la seconde passe d'audit (P1-1).
             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 */ }
+              try { PLAYER.errors.capture(new Error("PLAYER_PUBLIC_URL non configurée : envoi refusé (le lien de l'email serait construit depuis l'en-tête Host, que le client choisit)"), { route: "reshare" }); } catch { /* jamais bloquant */ }
+              refusEnvoi = "public-url-unconfigured";
+              throw new Error("URL publique non configurée");
             }
-            const origin = publique || `https://${req.headers.host}`;
+            const origin = publique;
             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 */ }