discovery-media-player 0.1.17 → 0.1.19

package/context/storage.js

@@ -218,15 +218,56 @@ function isAllowedStorageUrl(candidate, origins, hostBase, root) {
  * ⚠️ Le secret n'accompagne QUE la route de l'hôte. L'envoyer à un Storage public le ferait fuiter
  * dans les journaux d'un tiers, où il n'a rien à faire.
  */
+// ⚠️ `fetch` SUIT LES REDIRECTIONS PAR DÉFAUT, ET N'EN REVALIDE AUCUNE.
+//
+// La garde ci-dessus n'examinait que l'URL de DÉPART. Un amont autorisé — la route de l'hôte, ou
+// n'importe quelle origine de Storage listée — qui répond `302` emmenait donc l'appel où il
+// voulait : `localhost`, une adresse privée, une API de métadonnées cloud. L'invariant annoncé
+// dans le README (« no redirect following into your private network ») était faux.
+//
+// ⚠️ ET LE SECRET SUIVAIT. `fetch` ne retire que `Authorization`, `Cookie` et
+// `Proxy-Authorization` lors d'une redirection inter-origines — un en-tête maison comme
+// `x-player-fetch-secret` est transmis tel quel. Mesuré avec deux serveurs locaux avant de
+// corriger : la destination recevait le secret partagé de l'hôte en clair. Ce n'est donc pas
+// seulement une SSRF, c'est une exfiltration de la clé qui autorise à lire TOUS ses documents.
+//
+// On suit donc les sauts à la main. Trois propriétés, et chacune ferme une porte différente :
+//   1. chaque saut repasse la garde complète — une redirection n'ouvre rien que l'URL de départ
+//      n'aurait pas ouvert ;
+//   2. le secret est recalculé À CHAQUE SAUT — il ne part que si CE saut-là est sous la route de
+//      l'hôte, jamais parce que le premier l'était ;
+//   3. le nombre de sauts est borné, et le protocole ne peut pas changer de nature : une
+//      redirection vers `file:` transformerait un amont distant en lecture de disque local.
+const MAX_REDIRECTIONS = 5;
+const DELAI_MAX_MS = 60_000;
+
 async function fetchAllowedFile(url, { range } = {}, { origins, hostBase, root, secret } = {}) {
   if (!isAllowedStorageUrl(url, origins || [], hostBase, root)) return null;
   const local = root && resolveLocal(url, root);
   if (local) return readLocal(local, range);
 
-  const headers = { "accept-encoding": "identity" };
-  if (range) headers.range = range;
-  if (isHostFetchUrl(url, hostBase) && secret) headers["x-player-fetch-secret"] = secret;
-  return fetch(url, { headers });
+  let cible = String(url);
+  for (let saut = 0; saut <= MAX_REDIRECTIONS; saut++) {
+    const headers = { "accept-encoding": "identity" };
+    if (range) headers.range = range;
+    // Recalculé à chaque tour : c'est CE saut-ci qui doit être sous la route de l'hôte.
+    if (isHostFetchUrl(cible, hostBase) && secret) headers["x-player-fetch-secret"] = secret;
+
+    // Un amont qui ne répond jamais immobiliserait la requête et ses ressources indéfiniment.
+    // Le délai est large — un gros document met du temps — mais il est borné.
+    const r = await fetch(cible, { headers, redirect: "manual", signal: AbortSignal.timeout(DELAI_MAX_MS) });
+    if (r.status < 300 || r.status > 399) return r;
+
+    const suivante = r.headers.get("location");
+    if (!suivante) return r; // 3xx sans destination : on rend la réponse telle quelle
+    let absolue;
+    try { absolue = new URL(suivante, cible); } catch { return null; }
+    // ⚠️ Jamais de changement de nature : `file:` ferait d'un amont distant une lecture de disque.
+    if (absolue.protocol !== "https:" && absolue.protocol !== "http:") return null;
+    if (!isAllowedStorageUrl(absolue.href, origins || [], hostBase, root)) return null;
+    cible = absolue.href;
+  }
+  return null; // boucle de redirections : on refuse plutôt que de tourner
 }
 
 /**

package/package.json

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

@@ -399,12 +399,53 @@ var Live=(function(){
       ch.on('presence',{event:'sync'},function(){renderPres(ch.presenceState());});
       // Plus d'abonnement à la table des messages : elle n'est plus publiée ni lisible
       // publiquement. Tout passe par la diffusion, et l'historique par la route de chat.
-      ch.on('broadcast',{event:'msg'},function(p){if(p&&p.payload&&addMsg(p.payload))notifyMsg(p.payload);});
-      ch.on('broadcast',{event:'msg-upd'},function(p){if(p&&p.payload)updateMsg(p.payload);});
+      // ⚠️ UNE DIFFUSION EST UN SIGNAL, PAS UNE VÉRITÉ.
+      //
+      // Ce canal est PUBLIC : la clé publiable et le slug sont dans la page, donc tout participant
+      // peut émettre. Appliquer directement la charge utile revenait à laisser n'importe quel
+      // spectateur annoncer la fin de la présentation, changer la page affichée, verrouiller le
+      // chat, ou publier un message signé du nom de quelqu'un d'autre.
+      //
+      // Déplacer l'émission vers le serveur n'y changerait rien : sur un canal public, un
+      // attaquant émet quand même, et le client ne distingue pas les deux sources. La seule
+      // défense qui tienne est de CESSER DE CROIRE le transport — on relit auprès du serveur, qui
+      // est déjà la source de vérité (routes state=1 et chat=1, elles existaient).
+      //
+      // Un attaquant peut donc toujours émettre : il déclenche une relecture, et n'obtient rien.
+      // C'est une meilleure propriété que d'essayer de l'empêcher — elle vaut aussi le jour où le
+      // transport lui-même a un défaut.
+      //
+      // ⚠️ 'map' et 'typing' restent appliqués tels quels, et c'est un choix : ce sont des signaux
+      // ÉPHÉMÈRES (mouvements de carte, « untel écrit »), sans état serveur à confronter et à
+      // fréquence élevée. Les revérifier coûterait un aller-retour par déplacement de souris pour
+      // protéger… un déplacement de souris. Ce qui fait autorité — la page affichée, le document,
+      // la fin de la présentation — passe par 'state', qui est relu.
+      function relire(url,applique){
+        fetch('/api/doc?present='+encodeURIComponent(SLUG)+url)
+          .then(function(r){return r.json();})
+          .then(function(d){if(d&&d.ok)applique(d);})
+          .catch(function(){});
+      }
+      var _relEtat=null,_relChat=null;
+      // Groupé : dix diffusions d'affilée ne doivent pas produire dix requêtes.
+      function relireEtat(){clearTimeout(_relEtat);_relEtat=setTimeout(function(){
+        relire('&state=1',function(d){if(d.state&&_onState)_onState(d.state);});
+      },120);}
+      function relireChat(){clearTimeout(_relChat);_relChat=setTimeout(function(){
+        relire('&chat=1',function(d){
+          if(d.messages)d.messages.forEach(function(m){if(!addMsg(m))updateMsg(m);});
+          if(typeof d.locked!=='undefined')applyLock(d.locked);
+        });
+      },120);}
+
+      // Le message reçu sert à savoir QU'IL SE PASSE quelque chose, et à notifier ; son CONTENU
+      // vient de la relecture. Sans ça, une notification pourrait afficher un texte forgé.
+      ch.on('broadcast',{event:'msg'},function(){relireChat();});
+      ch.on('broadcast',{event:'msg-upd'},function(){relireChat();});
+      ch.on('broadcast',{event:'lock'},function(){relireChat();});
+      ch.on('broadcast',{event:'state'},function(){relireEtat();});
       ch.on('broadcast',{event:'typing'},function(p){onTyping(p&&p.payload);});
-      ch.on('broadcast',{event:'lock'},function(p){if(p&&p.payload)applyLock(p.payload.locked);});
       ch.on('broadcast',{event:'map'},function(p){if(_onMap&&p&&p.payload)_onMap(p.payload);});
-      ch.on('broadcast',{event:'state'},function(p){if(_onState&&p&&p.payload)_onState(p.payload);});
       ch.subscribe(function(st){if(st==='SUBSCRIBED'){ch.track({name:me.name,email:me.email,avatar:me.avatar,role:me.role,member:!!me.member,uid:attKey(me)});sendAttend();}});
       _tyIv=setInterval(renderTyping,1500);
       _atIv=setInterval(sendAttend,25000);