Sécurité du rendu personnalisé des sites¶
Cette page explique pourquoi Kirexo laisse un utilisateur écrire du HTML et du CSS pour son site public sans pour autant ouvrir une porte au stored XSS, et pourquoi la protection est conçue en défense en profondeur : plusieurs barrières indépendantes, chacune supposée faillible. Elle décrit les quatre barrières — la sandbox Twig, le sanitizer HTML, le filtre CSS et la Content-Security-Policy — qui traitent le contenu écrit par l'utilisateur avant, et jusqu'à, son arrivée dans le navigateur d'un visiteur.
Pour le rendu public par défaut (celui qui n'implique aucun HTML utilisateur), voir Rendu public d'un site (plugin web). Pour le socle à plugins isolés et le worker mode FrankenPHP qui contraignent plusieurs de ces choix, voir Architecture.
Le problème : du HTML utilisateur servi à tous les visiteurs¶
Un site Kirexo est multi-tenant : chaque utilisateur qui active le plugin web dispose de son propre site, servi sur son propre domaine. Son apparence est portée par un thème, fait de quatre sources : un en-tête, un corps, un pied de page — trois gabarits Twig — et une feuille de style (voir Modèle de thème et catalogue fourni).
Les trois thèmes fournis sont du code versionné, relu en revue. Mais le modèle prévoit des thèmes personnels, écrits par l'utilisateur : ce sont alors des données qu'il écrit, que Kirexo stocke, puis sert à tous les visiteurs de son site. C'est ce régime-là que les barrières décrites ici prennent en charge — et elles s'appliquent indistinctement aux deux origines, à une exception documentée près (le CSS d'un thème fourni, voir plus bas).
Cette combinaison — contenu écrit par une personne, exécuté dans le navigateur d'une autre — est la définition même du stored XSS (cross-site scripting persistant). Sans protection, il suffirait qu'un fragment contienne <script>…</script> pour que le code s'exécute chez chaque visiteur : vol de session, défiguration, redirection, exfiltration de données. Le fragment étant stocké, l'attaque n'est pas ponctuelle : elle frappe tout le trafic du site, en continu, jusqu'à ce que le fragment soit retiré.
La difficulté propre à Kirexo est qu'on ne peut pas simplement interdire le HTML : le laisser écrire son site est une fonctionnalité assumée. Il faut donc l'autoriser tout en garantissant qu'aucun vecteur d'exécution ne survive au rendu. C'est un problème de neutralisation, pas d'interdiction.
La réponse : une défense en profondeur¶
Plutôt que de miser sur un unique filtre « parfait » — un pari perdant, car un seul contournement suffirait à tout ouvrir —, Kirexo empile plusieurs barrières indépendantes. Chacune est conçue en supposant que les autres peuvent échouer. Une attaque ne réussit que si elle franchit toutes les barrières à la fois ; chaque couche ajoutée réduit d'un ordre de grandeur la surface restante.
Le contenu utilisateur traverse ce pipeline dans l'ordre : il est d'abord rendu dans une sandbox Twig isolée (couche 1), puis filtré par un sanitizer HTML (couche 2). Deux barrières supplémentaires prolongent la même logique en dehors du HTML : le filtre CSS et, en tout dernier ressort, la Content-Security-Policy.
flowchart LR
H["Gabarits du thème<br/>(en-tête / corps / pied)"] --> C1["Couche 1<br/>Sandbox Twig isolée & jetable"]
C1 --> C2["Couche 2<br/>Sanitizer HTML (site_public)"]
C2 --> OUT["HTML sûr servi au visiteur"]
L'implémentation de ces deux couches vit dans un service unique, HtmlOverrideRenderer (src/Plugin/Web/src/Security/HtmlOverrideRenderer.php), point de passage obligé de tout rendu de HTML utilisateur : il n'existe pas de chemin de rendu parallèle qui contournerait ces barrières.
Couche 1 — une sandbox Twig isolée et jetable¶
Les trois zones d'un thème ne sont pas de simples fragments statiques : c'est du Twig. On veut en effet qu'un thème puisse afficher les données du site — la liste des articles, les pages spéciales du menu, le profil — avec des boucles et des conditions. Or Twig est un langage de gabarits complet : mal encadré, il ouvre une seconde classe de vulnérabilité, le SSTI (Server-Side Template Injection), où l'on ne se contente plus d'injecter du JavaScript côté client, mais où l'on rebondit depuis le template pour exécuter du code ou lire des données côté serveur.
La réponse est de rendre ce Twig dans un environnement volontairement appauvri, isolé et jetable. Trois propriétés le caractérisent.
Un environnement neuf à chaque rendu. Pour chaque appel, HtmlOverrideRenderer (src/Plugin/Web/src/Security/HtmlOverrideRenderer.php) construit un Twig\Environment vierge, à partir d'un ArrayLoader, sans aucune extension applicative ni aucun global de l'application (pas d'AppVariable, pas de path(), url(), csrf_token()…). L'environnement Twig principal de Kirexo n'est jamais réutilisé. En worker mode FrankenPHP, où l'interpréteur reste chargé entre les requêtes, cet isolement est capital : le service est final readonly sans état mutable, l'environnement est reconstruit à chaque appel et le cache de compilation est désactivé. Aucun template compilé, aucune donnée, aucun état ne peut fuiter d'un tenant à l'autre.
Aucune fonction, aucune méthode, aucune propriété. La sandbox est pilotée par une SecurityPolicy Twig qui déclare, en liste blanche, ce qui est autorisé — et rien d'autre n'existe. Les fonctions, les méthodes et les propriétés d'objet sont toutes trois vides. Ce n'est pas un excès de prudence : c'est exactement ce qui ferme le SSTI.
- Aucune fonction neutralise les rebonds classiques :
template_from_string(),include(),source(),attribute(),constant(),dump(). Ce sont les primitives par lesquelles un template s'évade vers l'exécution de code arbitraire ou la lecture de fichiers. - Aucune méthode ni propriété empêche l'introspection d'objet —
article.getClass(), l'accès à_selfou_context. Même si un objet parvenait dans le contexte, on ne pourrait invoquer aucun de ses membres : la surface d'appel est réduite à zéro.
De même, les tags de composition (include, extends, embed, use, import, macro) sont exclus de la liste blanche : composer avec d'autres templates est en soi une surface d'évasion. Seuls subsistent quelques tags de présentation (if, for, set, apply). Et l'auto-échappement HTML est actif et non contournable — le filtre raw, qui l'annulerait, ne fait pas partie des filtres autorisés.
Seules des données aplaties entrent dans la sandbox. La frontière est matérialisée par un DTO, SiteRenderContext (src/Plugin/Web/src/Security/SiteRenderContext.php), qui ne transporte que des scalaires et des tableaux de scalaires : les teasers d'articles, les pages, le profil du site. Jamais une entité Doctrine. C'est une décision de sécurité par construction : exposer une entité offrirait une surface d'appel de méthodes (getters, chargement paresseux de relations) — précisément ce que l'interdiction des méthodes cherche à fermer. En aplatissant les entités en données inertes avant d'entrer dans la sandbox, on garantit qu'il n'y a, à l'intérieur, rien sur quoi appeler quoi que ce soit. La sandbox et le contexte se renforcent mutuellement : l'un interdit les appels, l'autre s'assure qu'il n'y a pas d'objet à appeler.
Couche 2 — un sanitizer HTML en filet¶
Une fois le Twig rendu, on obtient une chaîne de HTML. La sandbox a neutralisé le SSTI et l'auto-échappement a neutralisé le HTML issu des données — mais le template lui-même est du HTML littéral écrit par l'utilisateur, et l'auto-échappement ne s'applique pas au texte statique du gabarit. Rien n'empêche donc, à ce stade, que le fragment contienne littéralement <script> ou un attribut onclick.
C'est le rôle de la couche 2 : un sanitizer HTML (SitePublicSanitizer, src/Plugin/Web/src/Security/SitePublicSanitizer.php) appliqué après la sandbox. Il s'appuie sur un profil dédié site_public de symfony/html-sanitizer (config/packages/html_sanitizer.yaml) qui fonctionne en liste blanche stricte : seuls les éléments et attributs explicitement listés survivent, tout le reste est supprimé avec ses enfants. Il n'y a ni script, ni style, ni iframe, ni object, ni form ; et comme aucun attribut on* n'est jamais listé, les gestionnaires d'événements (onclick, onload…) sont retirés d'office. Les styles inline sont également supprimés.
On pourrait objecter que la sandbox suffit déjà à rendre du HTML sûr. Mais c'est justement l'esprit de la défense en profondeur : deux barrières indépendantes valent mieux qu'une. Le sanitizer ne fait aucune hypothèse sur ce qui l'a précédé ; il repart du HTML brut et le filtre pour son propre compte. Si une régression, une évolution de Twig ou un contournement inattendu laissait passer une balise dangereuse à travers la sandbox, le sanitizer la retire quand même. Les deux couches ne partagent aucun mécanisme : elles ne peuvent pas échouer ensemble pour la même raison. C'est ce qui fait la valeur du filet.
La liste des capacités : une seule source de vérité¶
Décrire « ce que l'utilisateur a le droit d'écrire » — quels tags Twig, quels filtres, quelles balises HTML, quels attributs, plus tard quelles propriétés CSS — est une information qui, si elle était dupliquée, finirait immanquablement par diverger. Le jour où une déclaration autorise une balise que l'autre interdit, on obtient soit un trou de sécurité, soit un comportement incompréhensible pour l'utilisateur (« je l'écris, mais ça disparaît »).
Kirexo centralise donc cette description dans un objet unique, CapabilityWhitelist (src/Plugin/Web/src/Security/CapabilityWhitelist.php), derrière une interface (CapabilityWhitelistInterface). Cet objet est déterministe et sans état : il ne fait que déclarer, exhaustivement, les listes autorisées. C'est l'unique source de vérité des capacités du rendu personnalisé, et il est conçu pour être partagé par plusieurs consommateurs :
- il pilote la
SecurityPolicyde la sandbox ici même (couche 1) ; - il pilote le filtrage CSS (voir Le CSS d'un thème) ;
- il fixe la liste des variables exposées aux gabarits d'un thème, celle-là même que documente Référence — Thèmes de site.
L'intérêt est que ce qui est autorisé à l'exécution et ce qui est décrit comme autorisé proviennent du même objet. Les surfaces d'édition de thème en vivent toutes : l'autocomplétion du champ CSS, le panneau d'aide « Ce que vous pouvez écrire » et les messages de refus lisent cette liste au lieu d'en tenir une copie — c'est la seule façon qu'elles ne promettent pas une balise que la sandbox refuserait, ni l'inverse.
Une exception documentée : le profil du sanitizer
Le profil site_public du sanitizer (couche 2) est configuré statiquement en YAML (config/packages/html_sanitizer.yaml), car symfony/html-sanitizer ne se configure pas depuis une classe PHP. Sa liste de balises et d'attributs doit donc rester synchronisée manuellement avec CapabilityWhitelist. C'est le seul point où la description existe en deux endroits : la whitelist reste la source de description (ce qu'on documente et ce qu'on affichera), le YAML est la source d'exécution du filet. Ce couplage est vérifié en revue et peut être verrouillé par un test qui asserte la liste attendue.
Le mode rapport : expliquer plutôt que planter¶
Le rendu a deux usages très différents, qui appellent deux comportements.
En production, quand un visiteur consulte un site, on veut un rendu strict : si le HTML stocké viole la sandbox, la méthode render() lève une SandboxRenderException. C'est un comportement fail-closed : en cas de doute, on ne sert rien de douteux.
Mais sur une surface d'édition, où l'utilisateur est en train d'écrire les gabarits de son thème, faire remonter une exception serait une piètre expérience. Une erreur brute, un template à moitié rendu, un message technique en anglais n'aident pas l'auteur à corriger. Pour ce cas, HtmlOverrideRenderer expose une variante, renderWithReport(), qui ne lève jamais. Elle rend le HTML sûr disponible et l'accompagne d'un HtmlOverrideResult (src/Plugin/Web/src/Security/HtmlOverrideResult.php) porteur de notices en français expliquant ce qui a été retiré et pourquoi : « Le tag « include » n'est pas autorisé. », « Le filtre « raw » n'est pas autorisé. », ou encore « Des balises HTML non autorisées ont été retirées par le filtre de sécurité. »
Le raisonnement est simple : là où le rendu public exige une barrière qui tranche, l'édition exige un retour qui renseigne. La même logique de sécurité alimente les deux — c'est le même pipeline, la même whitelist — mais l'un s'exprime par une exception, l'autre par un compte rendu pédagogique. Les notices ne divulguent d'ailleurs rien de sensible : elles nomment l'élément refusé, jamais un détail interne de l'application.
Ce mode rapport a un consommateur : l'enregistrement d'un thème personnel, qui rejoue les trois zones avec un contexte d'exemple et rend les notices à l'auteur au lieu de refuser sa saisie. Le détail de cet arbitrage — pourquoi avertir plutôt que bloquer, et pourquoi le retrait HTML se mesure en nombre de balises — est développé dans Écrire ses propres thèmes : les arbitrages.
Où le HTML sûr s'affiche : trois zones, et un repli plutôt qu'une erreur¶
Les deux couches décrites plus haut produisent du HTML sûr, mais elles ne disent pas où ce HTML atterrit. Le câblage vit dans le rendu public lui-même (SiteRenderer, src/Plugin/Web/src/Service/SiteRenderer.php) : pour chaque page servie, il résout le thème du site, prend ses trois gabarits, les passe un par un dans HtmlOverrideRenderer::render(), et ne transporte vers le gabarit de page (SitePageView, src/Plugin/Web/src/Dto/SitePageView.php) que le résultat déjà assaini — jamais la source. Le layout (layout.html.twig) émet ces trois chaînes avec le filtre raw, mais uniquement parce qu'elles sont la sortie du pipeline : ré-échapper à ce stade afficherait les balises littérales. C'est le point clé de sécurité, vérifié en revue : |raw ne porte que du HTML déjà passé par sandbox + sanitizer, jamais une source de thème brute.
Chaque zone rendue est posée à l'intérieur d'un landmark que le layout, lui, garde sous son contrôle : <header class="site-header">, <main id="main" class="site-main">, <footer class="site-footer">. Un thème décide de ce qu'il met dans chaque zone, jamais de la structure de la page ni du lien d'évitement — il ne peut donc pas dégrader l'accessibilité par omission.
Un repli sûr plutôt qu'une page en erreur. La section précédente décrit un render() fail-closed qui lève en cas de HTML douteux. Sur le domaine public, on ne veut pourtant pas qu'un thème mal formé renvoie une erreur 500 à tous les visiteurs. Le rendu concilie les deux : il intercepte la SandboxRenderException et rejoue les trois zones avec le thème fourni « Par défaut ». Le repli est complet — les trois zones ensemble, jamais un mélange de deux chartes — et il est de dernier recours : si c'est « Par défaut » lui-même qui échoue, l'exception remonte, car il s'agit alors d'un défaut de packaging et non d'une saisie utilisateur. Le principe reste fail-closed — en cas de doute on ne sert rien de douteux — mais sa traduction sur le domaine public est un repli discret, jamais un plantage ni un trou vide.
Une limite fonctionnelle assumée : articles n'est peuplé que sur la home. Les variables exposées à la sandbox sont construites uniquement à partir des données déjà chargées pour la page servie, sans requête supplémentaire (SiteRenderContext bâti dans SiteRenderer). Conséquence : la variable articles ne contient la liste que sur la page d'accueil (la seule qui charge déjà des articles) ; sur une page d'article, une page spéciale ou un aperçu, elle vaut []. Un en-tête ou un pied de thème qui itère articles n'affichera donc la liste que sur la home. Les variables pages et profile, elles, sont toujours peuplées. C'est un compromis de performance (zéro requête en plus), catalogué dans Référence — Thèmes de site.
L'injection du contenu : une sentinelle plutôt qu'un bloc¶
Le corps d'un thème ne contient pas la page : il contient un emplacement, la variable content, que le rendu remplace ensuite par le contenu demandé (flux d'articles, article, page spéciale, aperçu). Ce contenu est produit par les gabarits du plugin et déjà assaini par le rendu markdown du cœur — c'est le seul HTML que le plugin maîtrise de bout en bout.
L'ordre des opérations est le point important : le gabarit du thème est assaini d'abord, le contenu est injecté ensuite. Trois conséquences en découlent, et ce sont elles qui motivent le mécanisme.
- Le contenu n'est jamais re-sanitisé. Le repasser au sanitizer coûterait à chaque page et, surtout, lui ferait perdre des balises légitimes que le profil
site_publicne connaît pas. En l'injectant après, on ne touche pas à un HTML déjà sûr. - La sandbox ne voit jamais le contenu. À l'intérieur du gabarit,
contentne vaut qu'une chaîne inerte : un thème ne peut ni l'inspecter, ni le découper, ni le réinjecter ailleurs. - La sentinelle traverse le pipeline sans altération. Elle est volontairement alphanumérique : ni l'auto-échappement Twig ni le sanitizer HTML ne la modifient, ce qui garantit qu'on la retrouve intacte au moment de substituer.
Cette sentinelle est imprévisible à chaque rendu (des octets aléatoires tirés pour la requête, SiteRenderContext::newContentPlaceholder()), et non une constante. La raison est directe : sa valeur transite par des données que l'utilisateur contrôle — le titre de son site, les teasers de ses articles. Une sentinelle fixe serait donc forgeable ; il suffirait de nommer son site comme elle pour détourner le point d'injection.
Deux garde-fous complètent la substitution, tous deux orientés « dégrader plutôt que casser » :
- Une seule occurrence est substituée. Écrire la sentinelle en clair dans son thème ne permet donc pas de dupliquer le contenu.
- La substitution n'a lieu qu'en position de texte. Si l'emplacement se retrouve dans une valeur d'attribut (
<div id="…">), injecter le contenu le ferait atterrir entre les guillemets : le navigateur ressortirait en contexte de balise, et le sanitizer — appliqué en amont — ne serait plus la dernière barrière. Ce cas est refusé, et le contenu est simplement concaténé en fin de zone.
Même logique pour un corps qui ne contient pas d'emplacement : le contenu est ajouté à la fin. Un thème mal écrit dégrade la mise en page ; il ne fait jamais disparaître les articles.
Le CSS d'un thème : filtré, puis servi en fichier externe¶
Le HTML n'est pas la seule source d'un thème : la quatrième est une feuille de style. On croit volontiers le CSS inoffensif — il ne « fait » rien, il décrit une apparence. C'est faux. Le CSS est, lui aussi, un vecteur d'attaque :
@import url(https://exemple-malveillant.tld/x.css)charge une ressource externe au moment du rendu — à la fois une fuite (le simple chargement de l'URL renseigne un tiers) et une porte pour injecter d'autres règles ;expression(...)etbehavior: url(...)exécutaient du script sur d'anciens navigateurs (Internet Explorer) — surface historique, mais réelle ;background: url(javascript:...)glisse un scheme d'exécution là où on n'attend qu'une image.
La réponse suit la même logique que pour le HTML : un filtre (CssFilter, src/Plugin/Web/src/Security/CssFilter.php) qui ne laisse passer que ce qui est une propriété de mise en page sûre et retire tout le reste. Ce filtre ne réinvente pas sa liste d'autorisations : il lit la même CapabilityWhitelist que la sandbox HTML (voir La liste des capacités) — les propriétés CSS acceptées, les schemes d'URL et les hôtes autorisés y sont déclarés une seule fois. Le filtre HTML et le filtre CSS parlent ainsi de la même définition de « ce que l'utilisateur a le droit d'écrire ».
Le principe fail-safe. En cas de doute sur une déclaration — propriété inconnue, url() vers une cible non autorisée, motif suspect —, le filtre retire ; il ne tente jamais de « réparer » ni de laisser passer par défaut. Le résultat peut être plus pauvre que ce que l'auteur du thème a écrit, mais il n'est jamais dangereux : on préfère un site un peu moins stylé à un site vulnérable. Et comme pour le rendu HTML (voir Le mode rapport), le filtre ne tranche pas en silence : il produit un rapport (CssFilterResult et CssRemoval, src/Plugin/Web/src/Security/CssFilterResult.php) qui liste, en français, chaque fragment retiré et pourquoi. Le rendu public n'exploite pas ce rapport — il sert simplement le CSS assaini — mais c'est lui qu'affiche l'édition d'un thème, à l'enregistrement comme au clic sur « Vérifier le CSS ».
Une exception documentée : les thèmes fournis ne sont pas filtrés. Le CSS des trois thèmes livrés est servi tel quel, sans passer par le filtre. Ce n'est pas une brèche : ce sont des fichiers versionnés, relus en revue de code, auxquels aucune saisie utilisateur n'a accès (voir Modèle de thème et catalogue fourni). Filtrer un thème personnel à chaque service, alors qu'il est déjà filtré à l'écriture, relève au contraire de la défense en profondeur : ce second passage couvre tout ce qui entrerait par un autre chemin — fixtures, import, écriture SQL directe. Un invariant testé garantit par ailleurs qu'aucune déclaration des thèmes fournis ne serait retirée par le filtre : les deux régimes décrivent bien le même langage.
Pourquoi servir le CSS en fichier .css externe, jamais inline. Le CSS assaini n'est pas réinjecté dans une balise <style> de la page : il est servi comme une ressource distincte, en Content-Type: text/css, par un contrôleur dédié (WebPluginPublicStylesheetController, src/Plugin/Web/src/Controller/WebPluginPublicStylesheetController.php). Ce détail de transport a une conséquence de sécurité directe. Couplé à la directive CSP style-src 'self' (voir la section suivante), servir le style uniquement depuis une URL du domaine permet d'interdire tout style inline : un attribut style="..." ou une balise <style> glissés dans le HTML seront alors ignorés par le navigateur. Il ne reste qu'une seule source de style, contrôlée, passée par le filtre. Le filtre est la barrière de contenu (ce que le CSS a le droit de dire), la CSP est la barrière de contexte (d'où le style a le droit de venir) ; les deux se renforcent.
La CSP : le verrou final, posé seulement sur le domaine public¶
Les couches précédentes agissent sur le contenu avant qu'il ne parte. La dernière barrière agit sur la réponse HTTP elle-même, via un en-tête que le navigateur applique : la Content-Security-Policy (CSP). C'est le verrou final de la défense en profondeur — celui qui tient même si toutes les autres avaient cédé.
La policy est stricte. Sa directive centrale est script-src 'none' : sur un site public Kirexo, aucun JavaScript ne s'exécute — ni script inline, ni script externe, jamais. C'est ce qui rend le stored-XSS inoffensif dans son effet : même si, par l'effet d'une régression ou d'un contournement inattendu, une balise <script> ou un attribut onclick franchissait la sandbox et le sanitizer (couches 1 et 2), le navigateur refuserait de l'exécuter. On ne parie pas sur la perfection des couches amont ; on ajoute une couche qui reste debout quand elles tombent. Les autres directives ferment chacune une surface :
object-src 'none'interdit les<object>/<embed>, donc les plugins (Flash, applets) — vecteurs d'exécution hérités ;base-uri 'none'empêche un<base href>injecté de détourner la résolution des URLs relatives de la page ;frame-ancestors 'none'interdit que le site soit mis en cadre dans une iframe tierce — la protection anti-clickjacking.
À cela s'ajoutent, dans la même réponse, quelques en-têtes compagnons : X-Content-Type-Options: nosniff (empêche le navigateur de « deviner » un type MIME — d'où l'importance du text/css exact sur la feuille de style), Referrer-Policy, X-Frame-Options et Cross-Origin-Opener-Policy.
Pourquoi seulement sur le domaine public. Ces en-têtes ne sont posés que sur les réponses du domaine public d'un site tenant, jamais sur l'application ni sur l'admin. Un subscriber kernel.response (SecurityHeadersSubscriber, src/Plugin/Web/src/EventSubscriber/SecurityHeadersSubscriber.php) vérifie qu'il s'agit bien d'une requête de site public avant d'agir ; sur un domaine app/admin, il ne touche à rien. Deux raisons :
- Isolation — l'app et l'admin ont leur propre politique de sécurité. Elles ont légitimement besoin de JavaScript (Live Components, éditeur…) ; une CSP
script-src 'none'y casserait l'interface. Le contexte hostile — du HTML écrit par un tiers et servi à des visiteurs — n'existe que sur le domaine public ; c'est là, et seulement là, qu'on applique le régime le plus strict. - « Admin ≠ publication » — l'invariant du projet veut que l'admin ne serve jamais de contenu utilisateur. La frontière de sécurité épouse cette frontière fonctionnelle : le rendu de contenu non fiable est confiné au domaine public, et c'est ce périmètre-là qu'on verrouille.
Une source unique pour la policy. La CSP et la liste des en-têtes ne sont pas écrites dans le subscriber : elles vivent dans un objet déterministe unique, SecurityHeaders (src/Plugin/Web/src/Security/SecurityHeaders.php). La raison rejoint celle de la CapabilityWhitelist, et elle a un second consommateur bien réel : l'aperçu d'un article dans l'éditeur (src/Plugin/Web/src/Controller/WebPluginArticlePreviewController.php) sert le HTML de l'utilisateur sous exactement la même politique que le rendu public, en reprenant la constante plutôt qu'en recopiant une chaîne. Sans cette source unique, un contenu accepté en aperçu pourrait se comporter différemment en production, et les deux CSP divergeraient à la première évolution de l'une des deux. L'aperçu se distingue sur un seul point : il ne pose pas le marqueur de site public — il vit sur le domaine de l'application — et pose donc son en-tête lui-même, là où le rendu public le reçoit du subscriber.
Voir aussi¶
- Modèle de thème et catalogue fourni — pourquoi l'apparence est un thème, pourquoi les thèmes fournis vivent en fichiers et pourquoi le repli est complet.
- Référence — Thèmes de site — le contrat d'écriture : variables exposées, emplacement du contenu, classes CSS, limites du filtre.
- Rendu public d'un site (plugin web) — les trois surfaces publiques, le SEO et l'invalidation du cache par tag de site.
- Multi-tenant : résolution d'un domaine vers un site — la double isolation réseau qui accompagne, en amont, la sécurité du rendu.
- Architecture — le socle à plugins isolés et le worker mode FrankenPHP qui imposent une sandbox jetable et sans état.