discovery-media-player 0.1.16 → 0.1.18

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.16",
+  "version": "0.1.18",
   "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",
@@ -53,6 +53,7 @@
     "./package.json": "./package.json"
   },
   "scripts": {
+    "prepare": "node tools/install-hooks.mjs",
     "start": "node bin/serve.js",
     "build": "node build/bundle.mjs && tsc -p tsconfig.build.json && node -e \"import('./build/bundle.mjs').then(m=>m.marquerDistEsm())\"",
     "test": "vitest run",

package/server/handler.js

@@ -1199,6 +1199,17 @@ function sendHtml(res, status, html, scriptSrc, imgExtra, frameAncestors) {
     `media-src 'self'${supaOrigin ? " " + supaOrigin : ""}`,
     "style-src 'unsafe-inline'",
     "base-uri 'none'",
+    // ⚠️ `form-action` NE RETOMBE PAS SUR `default-src`. C'est l'une des rares directives à ne pas
+    // hériter : une page en `default-src 'none'` peut malgré tout poster un formulaire n'importe
+    // où. Aucune de nos pages ne contient de `<form>` — les envois passent par `fetch`, donc par
+    // `connect-src` — mais un script injecté pourrait en fabriquer un pour exfiltrer vers un
+    // domaine tiers, et rien ne l'en empêchait.
+    //
+    // `'self'` plutôt que `'none'` : le mur d'accès et la connexion visiteur peuvent avoir besoin
+    // d'un envoi de même origine, et casser une authentification pour fermer une porte que
+    // personne n'a franchie serait un mauvais échange. `'self'` ferme l'exfiltration, qui est le
+    // risque réel.
+    "form-action 'self'",
     // Aperçu interne : framing MÊME ORIGINE autorisé (iframe DocViewer). Page publique : 'none' (anti-clickjacking).
     `frame-ancestors ${frameAncestors || "'none'"}`,
   ].join("; "));
@@ -1220,6 +1231,17 @@ function sendSoftWallHtml(res, html, nonce, imgExtra, frameAncestors) {
     `img-src 'self' data: blob:${imgExtra ? " " + imgExtra : ""}`,
     "style-src 'unsafe-inline' https://accounts.google.com/gsi/style",
     "base-uri 'none'",
+    // ⚠️ `form-action` NE RETOMBE PAS SUR `default-src`. C'est l'une des rares directives à ne pas
+    // hériter : une page en `default-src 'none'` peut malgré tout poster un formulaire n'importe
+    // où. Aucune de nos pages ne contient de `<form>` — les envois passent par `fetch`, donc par
+    // `connect-src` — mais un script injecté pourrait en fabriquer un pour exfiltrer vers un
+    // domaine tiers, et rien ne l'en empêchait.
+    //
+    // `'self'` plutôt que `'none'` : le mur d'accès et la connexion visiteur peuvent avoir besoin
+    // d'un envoi de même origine, et casser une authentification pour fermer une porte que
+    // personne n'a franchie serait un mauvais échange. `'self'` ferme l'exfiltration, qui est le
+    // risque réel.
+    "form-action 'self'",
     `frame-ancestors ${frameAncestors || "'self'"}`,
   ].join("; "));
   res.end(html);
@@ -1963,6 +1985,17 @@ function sendPresentHtml(res, html, nonce, supaUrl, imgExtra, frameAncestors) {
     "style-src 'unsafe-inline' https://unpkg.com https://fonts.googleapis.com",
     "font-src https://fonts.gstatic.com data:",
     "base-uri 'none'",
+    // ⚠️ `form-action` NE RETOMBE PAS SUR `default-src`. C'est l'une des rares directives à ne pas
+    // hériter : une page en `default-src 'none'` peut malgré tout poster un formulaire n'importe
+    // où. Aucune de nos pages ne contient de `<form>` — les envois passent par `fetch`, donc par
+    // `connect-src` — mais un script injecté pourrait en fabriquer un pour exfiltrer vers un
+    // domaine tiers, et rien ne l'en empêchait.
+    //
+    // `'self'` plutôt que `'none'` : le mur d'accès et la connexion visiteur peuvent avoir besoin
+    // d'un envoi de même origine, et casser une authentification pour fermer une porte que
+    // personne n'a franchie serait un mauvais échange. `'self'` ferme l'exfiltration, qui est le
+    // risque réel.
+    "form-action 'self'",
     `frame-ancestors ${frameAncestors || "'none'"}`,
   ].join("; "));
   res.end(html);