discovery-media-player 0.1.112 → 0.1.114

package/context/standalone.js

@@ -685,6 +685,13 @@ function createStandaloneContext(env = process.env) {
       // Une fois les bundles déployés des deux côtés ET `presence.sansJeton` retombé à zéro : un
       // battement sans jeton de présence valide cesse d'être enregistré. Off par défaut (transition).
       presenceStrict: String(env.PLAYER_PRESENCE_STRICT || "") === "1",
+      // ⚠️ SEL DU HACHAGE D'IP. Un SHA-256 d'adresse IPv4 n'anonymise rien : l'espace entier se
+      // recalcule en quelques minutes, et la CNIL considère une IP hachée comme une donnée
+      // PSEUDONYMISÉE — toujours personnelle. Avec un sel secret, elle cesse d'être recalculable par
+      // qui obtient la base. Dédié si l'hôte en pose un ; à défaut on réutilise le secret de présence
+      // avec une SÉPARATION DE DOMAINE (préfixe distinct) — il est déjà requis par la fonctionnalité
+      // qui produit ce hachage, ce qui évite une variable obligatoire de plus.
+      ipHashSecret: String(env.PLAYER_IP_HASH_SECRET || env.PLAYER_PRESENCE_SECRET || ""),
     },
   };
 }

package/docs/RETENTION.md

@@ -92,7 +92,7 @@ Une présentation **inactive** (terminée ou abandonnée) est une archive : **pu
 | `doc_presentation_messages.client_key` | clé d'idempotence d'envoi | idem |
 | `doc_presentation_attendees.name` / `doc_presentation_attendees.email` / `doc_presentation_attendees.avatar` | identité du participant | purgées avec la présentation |
 | `doc_presentation_attendees.attendee_key` | identifiant de présence | idem |
-| `doc_presentation_attendees.creator_ip_hash` | **empreinte tronquée** de l'IP qui a créé la ligne (jamais l'IP en clair) — sert au plafond de création anonyme (migration 0015) | purgée avec la présentation |
+| `doc_presentation_attendees.creator_ip_hash` | **empreinte tronquée** de l'IP qui a créé la ligne (jamais l'IP en clair) — sert au plafond de création anonyme (migration 0015). ⚠️ **Donnée PSEUDONYMISÉE, pas anonyme** : une IP hachée reste une donnée personnelle au sens du RGPD, et un SHA-256 non salé se recalcule intégralement sur l'espace IPv4. Depuis 0.1.114 l'empreinte est un HMAC salé par `PLAYER_IP_HASH_SECRET` (à défaut `PLAYER_PRESENCE_SECRET`, avec séparation de domaine) et liée au `slug`, ce qui empêche de corréler une même adresse d'une présentation à l'autre. Sans sel configuré, l'ancienne empreinte non salée subsiste. | purgée avec la présentation |
 | `doc_presentation_attendees.last_token_at` / `doc_presentation_attendees.last_no_token_at` | horodatage du dernier battement avec / sans jeton de présence — sert au compteur de transition (migration 0017), aucune donnée d'identité | purgés avec la présentation |
 | `doc_presentation_attendees.pages` | pages vues par le participant | idem |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.112",
+  "version": "0.1.114",
   "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/gabarit-live.js

@@ -274,15 +274,29 @@ var Live=(function(){
   // Refus d'usurpation : cette clé appartient à quelqu'un qui détient son jeton. On ne perd PAS la
   // présence en silence — on fait TOURNER notre clé pour repartir sur une ligne neuve au battement
   // suivant. Une mesure qui s'arrête sans le dire est le pire des deux côtés de cette porte.
+  // Jeter le jeton SEULEMENT — la clé reste valide, c'est la nôtre ; seule la preuve est périmée.
+  function ptOublie(){ _ptJeton=''; try{var s=_store();if(s)s.removeItem(CLE_PT+':'+SLUG);}catch(e){} }
   function rotationCle(){ try{var s=_store();if(s){s.removeItem('3dd-present-attkey');s.removeItem(CLE_PT+':'+SLUG);}}catch(e){} _ptJeton=''; }
-  function sendAttend(){ if(!SLUG||!ME)return; try{ var h={'Content-Type':'application/json'};var jw=accessToken();if(jw)h.Authorization='Bearer '+jw;
+  // ⚠️ UN SEUL BATTEMENT EN VOL. Le filet périodique, l'arrivée, le changement de page et la fermeture
+  // peuvent tomber ensemble : deux battements concurrents sur la même clé font que la réponse la plus
+  // ANCIENNE peut arriver la dernière et réinstaller un jeton périmé par-dessus le frais.
+  var _attEnVol=false;
+  function sendAttend(){ if(!SLUG||!ME||_attEnVol)return; try{ var h={'Content-Type':'application/json'};var jw=accessToken();if(jw)h.Authorization='Bearer '+jw;
     var corps={action:'present-attend',slug:SLUG,control:CONTROL,key:attKey(),name:ME.name||'',email:ME.email||'',avatar:ME.avatar||''};
     var pt=ptLu();
     if(pt)corps.pt=pt;else corps.wantToken='1';
     fetch('/api/doc',{method:'POST',headers:h,body:JSON.stringify(corps)})
       .then(function(r){return r.json();})
-      .then(function(d){ if(d&&d.pt)ptRange(d.pt); else if(d&&d.usurpe)rotationCle(); })
-      .catch(function(){}); }catch(e){} }
+      .then(function(d){ if(d&&d.pt)ptRange(d.pt);
+        // ⚠️ UN JETON REFUSÉ SE JETTE, SINON ON LE RENVOIE POUR TOUJOURS. Expiré, ou signé avec un
+        // secret que l'hôte a changé, il produit un 403 presence-token à CHAQUE battement — et le
+        // client, qui ne réagissait qu'à pt ou usurpe, le gardait en stockage et le représentait
+        // indéfiniment : la présence cessait d'être enregistrée sans que rien ne reparte. On jette le
+        // JETON (pas la clé : elle est encore la nôtre) et le battement suivant redemande une émission.
+        else if(d&&d.error==='presence-token')ptOublie();
+        else if(d&&d.usurpe)rotationCle(); })
+      .catch(function(){})
+      .then(function(){_attEnVol=false;},function(){_attEnVol=false;}); _attEnVol=true; }catch(e){_attEnVol=false;} }
   var EMOJIS=['👍','❤️','😂','😮','👏','🎉'];
   var RSVG='<svg viewBox="0 0 24 24" fill=none stroke=currentColor stroke-width=2 stroke-linecap=round><circle cx=12 cy=12 r=9 /><path d="M8.5 14.5s1.4 1.7 3.5 1.7 3.5-1.7 3.5-1.7"/><line x1=9 y1=9.2 x2=9.01 y2=9.2 /><line x1=15 y1=9.2 x2=15.01 y2=9.2 /></svg>';
   function esc(s){return Player.live.escapeHtml(s);}

package/server/handler.js

@@ -598,7 +598,18 @@ async function handler(req, res) {
         // ⚠️ La porte du jeton de présence (P1c étape 2) est-elle fermée ? Même raison
         // qu'internalStrict : un cockpit doit voir l'état des DEUX hôtes sans lire un journal — c'est
         // ce booléen, lu avec `presence: { avecJeton, sansJeton }` de la carte, qui dit quand fermer.
-        presenceStrict: !!(PLAYER.config && PLAYER.config.presenceStrict),
+        // ⚠️ EFFECTIF, PAS DÉCLARÉ. Posé sans capacité d'émettre (pas de secret), STRICT est INERTE :
+        // le refuser vraiment expulserait 100 % des participants anonymes, puisque aucun ne peut
+        // obtenir de jeton. Annoncer `true` dans ce cas serait dire qu'une porte est fermée quand elle
+        // est grande ouverte — et c'est ce booléen qu'un cockpit lit pour décider. On rend donc ce qui
+        // s'applique RÉELLEMENT ; `presenceJetons` juste en dessous dit pourquoi, quand les deux
+        // divergent. (Même famille que la carte qui disait « complet » sans couvrir une migration.)
+        presenceStrict: !!(PLAYER.config && PLAYER.config.presenceStrict) && (() => {
+          try {
+            const signer = PLAYER.identity && PLAYER.identity.signPresenceToken;
+            return typeof signer === "function" && !!signer("carte-sonde", "carte-sonde", 60);
+          } catch { return false; }
+        })(),
         // ⚠️ LES JETONS DE PRÉSENCE SONT-ILS RÉELLEMENT ÉMIS ? Sans ce booléen, un exploitant qui vient
         // de poser `PLAYER_PRESENCE_SECRET` n'a AUCUN moyen de vérifier que son réglage a pris : la
         // carte affiche `presence: {0,0}` aussi bien quand le secret est actif que quand la variable est

package/server/routes-direct.js

@@ -94,11 +94,6 @@ async function traiter(req, res, body, _slug) {
           // On dérive donc la clé de ce qui est prouvé, et jamais de ce qui est affirmé. Un anonyme,
           // lui, ne peut rien prouver : sa clé reste la sienne, mais enfermée dans un espace de noms
           // dont elle ne peut pas sortir — elle ne pourra jamais ressembler à l'e-mail d'un membre.
-          // ⚠️ L'IP NE PART PAS EN CLAIR VERS LA BASE : le plafond de création anonyme compte par
-          // (slug, empreinte d'IP), et une empreinte tronquée suffit à mesurer la pression d'un même
-          // appelant sans conserver de donnée personnelle. Le plafond lui-même est configurable par
-          // l'hôte, défaut ATTENDEES_PER_EGRESS × 1,3 (325) — la même cible que le quota de battement.
-          const ipHash = require("crypto").createHash("sha256").update("att:" + ip).digest("hex").slice(0, 32);
           const anonCap = (PLAYER.config && Number(PLAYER.config.presenceAnonCap) > 0)
             ? Math.trunc(Number(PLAYER.config.presenceAnonCap))
             : Math.ceil(ATTENDEES_PER_EGRESS * 1.3);
@@ -111,18 +106,71 @@ async function traiter(req, res, body, _slug) {
           const jetonEntrant = (typeof PLAYER.identity.verifyPresenceToken === "function")
             ? PLAYER.identity.verifyPresenceToken(String(body.pt || "")) : null;
           const jetonValide = !!(jetonEntrant && jetonEntrant.slug === slug && jetonEntrant.key);
-          const bootstrap = !profil && !jetonValide && String(body.wantToken || "") === "1";
           const cleAnon = jetonValide ? String(jetonEntrant.key) : cleAnonyme(body.key);
-          // Le compteur de transition : true = moderne/prouvé (membre, jeton, ou bootstrap moderne) ;
-          // false = legacy (anonyme, ni jeton ni wantToken). Deux champs distincts en base (0017).
-          const hasToken = !!(profil || jetonValide || bootstrap);
+          // ⚠️ L'IP NE PART PAS EN CLAIR VERS LA BASE — mais NE PRÉTENDONS PAS QUE C'EST ANONYME.
+          //
+          // Ce commentaire disait « sans conserver de donnée personnelle », et c'était FAUX : un
+          // SHA-256 d'adresse IPv4 se recalcule intégralement (quatre milliards de valeurs, quelques
+          // minutes), donc l'empreinte se remonte à l'adresse par qui obtient la base. La CNIL est
+          // explicite : une IP hachée reste une donnée PSEUDONYMISÉE, soumise au RGPD. La description
+          // était plus forte que l'implémentation — la classe même qu'on traque ailleurs.
+          //
+          // Avec un SEL SECRET, la table cesse d'être recalculable sans lui. Le `slug` entre dans
+          // l'empreinte pour qu'on ne puisse pas CORRÉLER la présence d'une même adresse d'une
+          // présentation à l'autre — le plafond, lui, compte déjà par (slug, empreinte), donc rien ne
+          // change pour lui. Le préfixe de domaine sépare cet usage de toute autre signature faite
+          // avec le même secret. Sans sel (hôte qui n'en pose aucun), on retombe sur l'ancienne
+          // empreinte : la fonction marche, la protection est moindre, et c'est écrit ici plutôt que
+          // découvert plus tard. Le plafond reste configurable, défaut ATTENDEES_PER_EGRESS × 1,3.
+          const sel = String((PLAYER.config && PLAYER.config.ipHashSecret) || "");
+          const ipHash = sel
+            ? require("crypto").createHmac("sha256", sel).update("attendance-ip\0" + slug + "\0" + ip).digest("hex").slice(0, 32)
+            : require("crypto").createHash("sha256").update("att:" + ip).digest("hex").slice(0, 32);
+
+          // ⚠️ ON SIGNE AVANT D'ÉCRIRE, ET C'EST CE QUI FERMAIT UNE BOUCLE. Le jeton était fabriqué
+          // APRÈS l'écriture : on déclarait donc un bootstrap « moderne » sans savoir si un jeton
+          // pourrait seulement sortir. Sans `PLAYER_PRESENCE_SECRET`, la ligne était marquée réclamée
+          // et AUCUN jeton n'était renvoyé — le battement suivant repartait en bootstrap, tombait sur
+          // sa propre ligne réclamée (409), et le client faisait tourner sa clé. Chaque battement
+          // créait alors un participant de plus, jusqu'au plafond de 325. Une protection qui produit
+          // exactement ce qu'elle interdit. (Relevé par un audit externe.)
+          const jetonCandidat = (!profil && typeof PLAYER.identity.signPresenceToken === "function")
+            ? PLAYER.identity.signPresenceToken(slug, cleAnon, 7 * 24 * 3600) : "";
+          const peutEmettre = !!jetonCandidat;
+          // Un bootstrap n'est un bootstrap que si l'hôte peut RÉELLEMENT émettre. Sinon ce battement
+          // ne porte aucune preuve et n'en portera jamais : c'est un battement sans jeton, et le
+          // compteur doit le dire — c'est même ce qui empêche d'armer STRICT sur un hôte sans secret,
+          // puisque `sansJeton` n'y retombera jamais à zéro.
+          const bootstrap = !profil && !jetonValide && String(body.wantToken || "") === "1" && peutEmettre;
+          // ⚠️ TROIS ÉTATS, PAS DEUX. true = PROUVÉ (membre ou jeton valide) → last_token_at, la ligne
+          // devient réclamée. false = sans preuve (legacy, ou moderne sur un hôte sans secret) →
+          // last_no_token_at. null = BOOTSTRAP : ni l'un ni l'autre. Un bootstrap ne prouve rien — il
+          // ne doit donc pas réclamer la ligne (sinon un client qui perd son jeton se refuse lui-même)
+          // ni compter comme legacy (sinon `sansJeton` ne retomberait jamais à zéro, chaque nouveau
+          // visiteur en produisant un). La ligne est créée LIBRE ; elle sera réclamée au battement
+          // suivant, celui qui portera le jeton.
+          const hasToken = (profil || jetonValide) ? true : (bootstrap ? null : false);
           // ⚠️ PORTE STRICTE : une fois la transition finie (sansJeton===0) et PLAYER_PRESENCE_STRICT
           // posé, un battement LEGACY (anonyme, sans jeton ni bootstrap) n'est plus enregistré. Off par
           // défaut → aucun effet pendant la transition. ⚠️ RÉSIDU CONNU (à durcir en suivant) : un
           // bootstrap `wantToken` portant la clé d'un anonyme EXISTANT pourrait l'écraser sous strict —
           // exploitabilité faible (l'attaquant doit connaître un uid anonyme aléatoire, jamais exposé) ;
           // le fermer proprement demande à la RPC de refuser un bootstrap sur une clé déjà existante.
-          if (PLAYER.config && PLAYER.config.presenceStrict && !profil && !jetonValide && !bootstrap) {
+          // ⚠️ STRICT EST INERTE SANS CAPACITÉ D'ÉMETTRE — sinon il refuserait 100 % des participants
+          // anonymes, une panne auto-infligée : sans secret, personne ne PEUT obtenir de jeton. On
+          // dégrade donc, et on le DIT (la carte rend `presenceStrict` effectif, pas déclaré).
+          if (PLAYER.config && PLAYER.config.presenceStrict && !peutEmettre && !profil) {
+            try {
+              if (await PLAYER.limits.allow("presence:strict-inerte", 1, 3600)) {
+                PLAYER.errors.capture(new Error(
+                  "PLAYER_PRESENCE_STRICT est posé mais AUCUN jeton ne peut être émis "
+                  + "(PLAYER_PRESENCE_SECRET absent) : la porte reste OUVERTE. Armé tel quel, elle "
+                  + "refuserait tous les participants anonymes.",
+                ), { route: "present-attend" });
+              }
+            } catch { /* jamais bloquant */ }
+          }
+          if (PLAYER.config && PLAYER.config.presenceStrict && peutEmettre && !profil && !jetonValide && !bootstrap) {
             return jp(403, { ok: false, error: "presence-token" });
           }
           const r = await recordAttendance(slug, {
@@ -158,10 +206,7 @@ async function traiter(req, res, body, _slug) {
           // le visiteur repart sur une ligne neuve — une présence coupée en deux dans les statistiques
           // pour rien. Le rejeu reste borné par le scellé d'archive (0007, il porte aussi sur la table
           // des présences) : une présentation close refuse toute écriture, jeton valide ou non.
-          let pt = "";
-          if (!profil && r.ok && typeof PLAYER.identity.signPresenceToken === "function") {
-            pt = PLAYER.identity.signPresenceToken(slug, cleAnon, 7 * 24 * 3600);
-          }
+          const pt = (r.ok && jetonCandidat) ? jetonCandidat : "";
           return jp(r.ok ? 200 : (r.status || 400), pt ? { ...r, pt } : r);
         } catch { return jp(500, { ok: false }); }
       }