79 % contre 51 % : les néobanques indépendantes en retard sur la sécurité des applications. Lire le rapport

Analyse approfondie

Analyse approfondie

XSS stockée sur la page de connexion de Keycloak, corrigée en 26.8.2 (CVE-2026-107889)

Le JavaScript d'un administrateur de royaume s'exécute sur la page de connexion de Keycloak, car une correction d'URL annule l'encodage ; corrigé en 26.8.2.

En bref

  • Un administrateur de royaume avec manage-realm stocke un lien au schéma javascript: masqué par une référence numérique. La correction d'URL la décode après l'assainissement, et le script s'exécute chez les visiteurs. Red Hat a publié CVE-2026-107889 le 2026-10-09.
  • Keycloak 26.1.3 à 26.8.1 est concerné. La correction communautaire est 26.8.2 ; le rétroportage 26.6 est étiqueté 26.6.8 et est livré dans Red Hat build of Keycloak 26.6.8. Red Hat Single Sign-On 7 n'est pas concerné.
  • Red Hat, l'autorité de numérotation des CVE, attribue un score CVSS v3.1 5,5 (Medium) avec CWE-79. Aucun exploit public n'a été signalé et la CVE n'est pas dans le catalogue KEV de la CISA au 2026-11-20.
  • Mettez à niveau vers 26.8.2. Les utilisateurs de Red Hat build of Keycloak sur 26.6 ont besoin de 26.6.8. Red Hat ne liste aucun contournement pris en charge ; voir « Comment corriger ? » pour les mesures provisoires.

Suis-je concerné ?

Vous êtes concerné si votre royaume exécute une version concernée, affiche son HTML de nom d'affichage via kcSanitize, et laisse une personne disposant de manage-realm modifier ce réglage.

  • La version de Keycloak ou de Red Hat build of Keycloak est concernée selon le tableau des versions.
  • Le thème de connexion du royaume passe realm.displayNameHtml à kcSanitize. Les thèmes intégrés base et keycloak.v2 le font.
  • Au moins une personne ou un groupe disposant de manage-realm peut modifier les réglages du royaume. Un administrateur de royaume délégué, une session administrateur volée ou un initié remplit cette condition.
  • Des utilisateurs chargent la page de connexion de ce royaume dans un navigateur.

La faille est un problème de frontière de privilèges. manage-realm est déjà une permission puissante, mais elle ne devrait pas donner à son titulaire l'exécution de scripts dans le navigateur des autres utilisateurs. Un royaume dont tous les titulaires de manage-realm sont pleinement de confiance est moins exposé, mais une session administrateur volée suffit.

Le rapport amont indique une plage concernée de 26.1.3 à 26.8.0. La version 26.8.1, publiée avant le rétroportage, porte le même code. Keycloak publie 26.8.2 comme correction communautaire et étiquette le rétroportage 26.6 en 26.6.8. La branche 26.7 et les branches plus anciennes portent le même code et n'ont pas de version corrigée ; les déploiements sur ces branches doivent passer à 26.8.2.

Branche Versions concernées Version corrigée
Keycloak 26.8 26.8.0 à 26.8.1 26.8.2 (publiée le 2026-11-05)
Keycloak 26.6 26.6.0 à 26.6.7 Aucune version communautaire ; l'étiquette 26.6.8 porte le rétroportage. Passer à 26.8.2
Keycloak 26.7 26.7.0 à 26.7.5 Aucune version corrigée ; passer à 26.8.2
Keycloak 26.1.3 à 26.5.x concernées selon le rapport amont Aucune version corrigée ; passer à 26.8.2
Red Hat build of Keycloak 26.6 concerné 26.6.8 (RHSA-2026:95761, publié le 2026-11-06)
Red Hat Single Sign-On 7 non concerné sans objet

Vérifiez la version en cours sur l'hôte et dans chaque conteneur :

/opt/keycloak/bin/kc.sh --version
docker ps --format '{{.Image}}' | grep -i keycloak
docker exec <container-name> /opt/keycloak/bin/kc.sh --version
kubectl get deploy -A -o jsonpath='{..image}' | tr ' ' '\n' | grep -i keycloak

Listez ensuite le HTML de nom d'affichage de chaque royaume avec l'outil d'administration :

/opt/keycloak/bin/kcadm.sh config credentials \
  --server https://keycloak.example.com --realm master --user admin
/opt/keycloak/bin/kcadm.sh get realms --fields realm,displayNameHtml

Un royaume sans valeur displayNameHtml n'utilise pas ce champ. Une valeur qui contient &# mérite un examen attentif, car c'est l'encodage dont le contournement a besoin.

Comment corriger ?

Mettez à niveau vers Keycloak 26.8.2, publiée le 2026-11-05. C'est la version communautaire qui contient le correctif. Le rétroportage 26.6 est étiqueté 26.6.8 et est livré dans Red Hat build of Keycloak 26.6.8.

  1. Pour un déploiement en conteneur, récupérez l'image corrigée et recréez le conteneur. Un conteneur en cours d'exécution garde son ancienne image jusqu'à sa recréation. bash docker pull quay.io/keycloak/keycloak:26.8.2 docker compose up -d --force-recreate keycloak
  2. Pour Kubernetes, mettez à jour l'image et attendez le déploiement : bash kubectl set image deployment/<deployment> <container>=quay.io/keycloak/keycloak:26.8.2 kubectl rollout status deployment/<deployment>
  3. Pour une installation ZIP, téléchargez keycloak-26.8.2.zip depuis la page de version. Sauvegardez la configuration et la base de données, puis remplacez l'installation.
  4. Pour Red Hat build of Keycloak, mettez à niveau vers 26.6.8 avec RHSA-2026:95761 pour les paquets serveur ou RHSA-2026:95762 pour les images OpenShift. Les étiquettes d'image corrigées sont 26.6-24.
  5. Les déploiements sur 26.7 ou une branche plus ancienne doivent passer à 26.8.2, car ces branches n'ont pas de version corrigée.

Red Hat ne liste aucune atténuation qui réponde à ses critères de sécurité produit, et l'enregistrement CVE dit la même chose. Si vous ne pouvez pas encore mettre à niveau, ces mesures réduisent l'exposition mais ne corrigent pas la faille :

  1. Effacez displayNameHtml sur chaque royaume et vérifiez-le de nouveau régulièrement : bash /opt/keycloak/bin/kcadm.sh update realms/<realm> -s displayNameHtml=''
  2. Réduisez l'ensemble des comptes et des groupes qui disposent de manage-realm, et vérifiez cet ensemble pour détecter des attributions inattendues.
  3. Activez les événements d'administration sur le royaume master et sur tout royaume à administration déléguée, afin qu'une modification ultérieure des réglages du royaume laisse une trace.

Un attaquant qui dispose encore de manage-realm peut stocker la charge de nouveau après l'une de ces étapes. Effacer le champ ne supprime que les charges déjà stockées.

Quelle est la cause racine ?

L'assainisseur approuve une URL qu'il lit comme relative, puis une correction ultérieure restaure la référence de caractère qui en fait une URL javascript:. kcSanitize est une méthode FreeMarker que les thèmes Keycloak appellent avec ?no_esc pour afficher du HTML fourni par l'administrateur après l'avoir nettoyé.

La page de connexion lit realm.displayNameHtml et le passe à cette méthode. Le thème intégré le fait dans themes/src/main/resources/theme/base/login/template.ftl, à la ligne 105 :

<div id="kc-header-wrapper"
     class="${properties.kcHeaderWrapperClass!}">${kcSanitize(msg("loginTitleHtml",(realm.displayNameHtml!'')))?no_esc}</div>

La méthode est KeycloakSanitizerMethod, dans services/src/main/java/org/keycloak/theme/KeycloakSanitizerMethod.java. À la version 26.8.0, elle exécute trois étapes à la suite :

String html = list.get(0).toString();

html = decodeHtmlFull(html);

String sanitized = KeycloakSanitizerPolicy.POLICY_DEFINITION.sanitize(html);

return fixURLs(sanitized);

decodeHtmlFull appelle Encoding.decodeHtml du sanitiser HTML Java d'OWASP jusqu'à cinq fois. L'assainisseur applique ensuite KeycloakSanitizerPolicy. Cette politique autorise href sur les éléments a lorsque la valeur correspond à un motif d'URL locale ou distante, et elle active allowStandardUrlProtocols() :

.allowAttributes("href").matching(ONSITE_OR_OFFSITE_URL)
    .onElements("a")
.allowStandardUrlProtocols()

Le motif local est la partie décisive :

private static final Pattern ONSITE_URL = Pattern.compile(
    "(?:[\\p{L}\\p{N}\\\\\\.\\#@\\$%\\+&;\\-_~,\\?=/!]+|\\#(\\w)+)");

ONSITE_URL accepte les lettres, les chiffres, &, ;, #, =, ? et d'autres caractères, mais il n'exige pas de deux-points. La valeur javascript&#58alert(xss) ne contient aucun deux-points littéral, elle correspond donc au motif d'URL relative. La politique de protocole ne filtre que les valeurs qui portent un schéma, elle ne voit donc jamais javascript. L'assainisseur sérialise la valeur avec l'esperluette échappée en &amp;, ce qui garde la référence inerte dans la page servie.

La dernière étape, fixURLs, réécrit les liens après l'assainissement :

private String fixURLs(String msg) {
    Matcher matcher = HREF_PATTERN.matcher(msg);
    if (matcher.find()) {
        int last = 0;
        StringBuilder result = new StringBuilder(msg.length());
        do {
            String href = matcher.group(1).replaceAll("&#61;", "=")
                    .replaceAll("\\.\\.", ".")
                    .replaceAll("&amp;", "&");
            result.append(msg.substring(last, matcher.start(1))).append(href);
            last = matcher.end(1);
        } while (matcher.find());
        result.append(msg.substring(last));
        return result.toString();
    }
    return msg;
}

HREF_PATTERN correspond à chaque href="..." du balisage assaini. Les trois remplacements décodent &#61; en =, réduisent .. à . et transforment &amp; en &. Le dernier remplacement supprime exactement l'encodage que l'assainisseur utilisait pour garder la référence de caractère inerte. La sortie porte href="javascript&#58alert(xss)", et le navigateur décode &#58 en : lorsqu'il analyse l'attribut. Le lien cible désormais une URL javascript:.

fixURLs réécrit chaque lien après l'assainissement : il décode &#61;, réduit .. et restaure &. Ces réparations supposent que la valeur est une URL que l'assainisseur a déjà approuvée. Les deux étapes ne sont pas d'accord sur la représentation qui fait foi : l'assainisseur contrôle une forme, et le post-traitement en sert une autre.

Comment la faille est-elle exploitée ?

Un utilisateur disposant de manage-realm stocke un lien forgé dans le HTML de nom d'affichage du royaume. Un visiteur charge la page de connexion, et l'activation du lien exécute son script dans l'origine Keycloak. Les tests du commit de correction utilisent cette charge :

<a href="javascript&#58alert(xss)">link</a>
  1. L'attaquant envoie PUT /admin/realms/<realm> avec displayNameHtml défini sur la charge. La console d'administration expose le même champ dans les réglages de nom d'affichage du royaume.
  2. Keycloak stocke la chaîne dans la configuration du royaume. L'API d'administration accepte du HTML dans ce champ par conception, donc aucune validation ne rejette le deux-points encodé.
  3. Un visiteur charge la page de connexion du royaume. Le thème passe la valeur stockée à kcSanitize.
  4. decodeHtmlFull laisse la référence encodée car elle n'a pas de point-virgule. L'assainisseur ne voit aucun deux-points littéral, traite la valeur comme une URL relative et l'autorise, puis échappe l'esperluette.
  5. fixURLs remplace &amp; par &. La page servie porte href="javascript&#58alert(xss)".
  6. Le navigateur décode la référence numérique et le lien cible javascript:alert(xss). L'activation du lien exécute le script dans l'origine Keycloak.

Le rapport amont décrit un impact sans interaction au-delà du chargement de la page, et il signale une variante sans clic sur la page d'erreur WebAuthn. Les tests du correctif couvrent le lien du nom d'affichage. Le dossier public ne contient pas la charge WebAuthn, donc cet article ne reconstitue pas cette variante.

Le vecteur CVSS de Red Hat indique UI:N. Considérez l'affirmation du rapport amont sur l'absence de clic comme faisant partie du dossier, et non comme un détail que ces étapes démontrent.

Comment se déroule l'attaque ?

Un administrateur de royaume stocke un lien dont le deux-points est encodé en entité. L'assainisseur l'approuve comme URL relative, et la correction d'URL restaure la référence qui le rend exécutable.

flowchart LR A["Un administrateur de royaume
stocke la charge dans displayNameHtml"] --> B["kcSanitize décode
et applique l'assainisseur"] B --> C["Aucun deux-points littéral :
URL relative acceptée"] C --> D["L'assainisseur échappe &
la charge reste inerte"] D --> E["fixURLs restaure &
après le contrôle"] E --> F["Le navigateur décode &#58
et voit javascript:"] F --> G["Le script s'exécute
dans l'origine Keycloak"]

Que peut faire un attaquant ?

L'attaquant peut exécuter du JavaScript dans l'origine Keycloak, dans le navigateur d'un utilisateur qui charge la page de connexion du royaume.

Toutes les conditions suivantes doivent être réunies :

  • L'attaquant dispose de manage-realm sur le royaume ciblé, via un rôle délégué, une session volée ou un accès d'initié.
  • Le royaume exécute une version concernée et utilise un thème qui affiche displayNameHtml via kcSanitize.
  • Un utilisateur charge la page de connexion de ce royaume dans un navigateur.
  • Pour le lien de nom d'affichage des tests du correctif, l'utilisateur active le lien. Le rapport amont signale une variante sans clic sur la page d'erreur WebAuthn, et le vecteur de Red Hat indique UI:N.

Le script s'exécute dans l'origine Keycloak, pas dans l'application qui utilise Keycloak comme fournisseur d'identité. Dans cette origine, il peut faire trois choses :

  • Lire ce que l'utilisateur saisit dans le formulaire de connexion avant l'envoi du formulaire.
  • Remplacer le formulaire par un autre qui envoie les identifiants vers un hôte différent.
  • Réécrire la page en une invite de hameçonnage.

Il peut aussi envoyer des requêtes de même origine, qui portent les cookies Keycloak de l'utilisateur même lorsque ces cookies sont HttpOnly. Il ne peut pas lire directement la valeur d'un cookie HttpOnly.

Red Hat note la faille CVSS v3.1 5,5 avec CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:L/I:L/A:N. PR:H reflète l'exigence de manage-realm. S:C reflète le passage du script d'un réglage contrôlé par l'administrateur vers le navigateur des autres utilisateurs.

C:L et I:L enregistrent un impact limité en lecture et en écriture sur la page de connexion, et non sur le serveur Keycloak.

Pourquoi le correctif fonctionne-t-il ?

Le correctif revérifie chaque href après les remplacements de correction, sous la forme décodée que le navigateur verra. Il vide toute valeur dont le schéma n'est ni http, ni https, ni mailto. Le nouveau contrôle se place entre les remplacements et la sortie :

             String href = matcher.group(1).replaceAll("&#61;", "=")
                     .replaceAll("\\.\\.", ".")
                     .replaceAll("&amp;", "&");
+            if (hasDisallowedScheme(href)) {
+                href = "";
+            }
             result.append(msg.substring(last, matcher.start(1))).append(href);

hasDisallowedScheme décode les références de caractères numériques avant d'interroger la politique d'URL d'OWASP :

private boolean hasDisallowedScheme(String href) {
    return URL_PROTOCOL_POLICY.apply("a", "href", decodeNumericEntities(href)) == null;
}

La politique est construite avec les trois schémas dont la page de connexion a besoin :

private static final FilterUrlByProtocolAttributePolicy URL_PROTOCOL_POLICY =
        new FilterUrlByProtocolAttributePolicy(List.of("http", "https", "mailto"));

Pour javascript&#58alert(xss), decodeNumericEntities produit javascript:alert(xss), la politique rejette le schéma javascript, et l'attribut devient href="". Les URL relatives passent toujours, car elles ne portent aucun schéma, et les liens http, https ou mailto restent inchangés.

Les tests du même commit couvrent les formes décimale, hexadécimale, complétée par des zéros, en majuscules et minuscules. Ils couvrent aussi les formes avec saut de ligne et tabulation, ainsi que les schémas vbscript et data.

Ils vérifient également que le texte en gras et les liens http, https et mailto survivent. Le correctif ferme la voie de la référence numérique décrite par cette CVE. Il ne retire pas le HTML de displayNameHtml et ne modifie pas le reste de la politique d'assainissement ; le champ reste donc une surface HTML contrôlée par l'administrateur.

Comment vérifier si j'ai été compromis ?

Aucun indicateur de compromission public n'a été publié, donc la vérification fiable est la configuration du royaume elle-même. Une charge qui n'a jamais été activée laisse sa chaîne dans displayNameHtml, et le navigateur décode cette chaîne en une URL javascript:.

Listez le HTML de nom d'affichage de chaque royaume et cherchez l'encodage dont le contournement a besoin :

/opt/keycloak/bin/kcadm.sh get realms --fields realm,displayNameHtml | grep -n '&#'

Inspectez ensuite les valeurs qui correspondent. Un nom d'affichage légitime peut contenir une référence numérique, par exemple &#39; pour une apostrophe. Cherchez une référence dans un href, surtout une référence qui se décode en :.

Si les événements d'administration sont activés, examinez les événements de mise à jour de royaume pour les changements que vous ne pouvez pas expliquer :

/opt/keycloak/bin/kcadm.sh get admin-events -r <realm> \
  --query operationTypes=UPDATE --query resourceTypes=REALM

L'événement indique qui a modifié le royaume et quand, à condition que les événements d'administration aient été activés avant le changement. Un royaume qui ne les a jamais activés n'a aucun historique à examiner.

Les journaux du proxy inverse peuvent montrer qu'une page de connexion a été servie, mais pas si un lien stocké a été activé. Une charge qui s'est exécutée dans un navigateur peut ne laisser aucune trace sur le serveur. Aucune signature ni aucun motif de journal n'a été publié par le fournisseur pour cette CVE.

Chronologie

  • 2026-10-08 : signalement à Red Hat et publication, selon l'enregistrement CVE.
  • 2026-10-09 : Red Hat publie l'enregistrement CVE, et le rapport amont est ouvert.
  • 2026-10-13 : le commit de correction 3e0fda9 arrive sur la branche main.
  • 2026-10-14 : les rétroportages 26.8 et 26.6 sont fusionnés.
  • 2026-11-05 : Keycloak 26.8.2 est publiée.
  • 2026-11-06 : Red Hat publie RHSA-2026:95761 et RHSA-2026:95762 pour Red Hat build of Keycloak 26.6.8.

La correction communautaire est sortie 28 jours après le signalement
Figure 1 : Keycloak a publié la correction communautaire 28 jours après le signalement. Source : enregistrement CVE, rapport Keycloak 53813 et errata Red Hat, vérifié le 20 novembre 2026.

FAQ

Un attaquant non authentifié peut-il exploiter cette faille ?

Non. L'attaquant doit disposer de manage-realm sur le royaume ciblé avant qu'un utilisateur puisse être exposé. Les voies réalistes sont un administrateur délégué malveillant, une session administrateur volée ou un initié. Tous les visiteurs de la page de connexion de ce royaume sont alors concernés.

La victime doit-elle cliquer sur le lien ?

Pour la charge de nom d'affichage, oui : les tests du correctif stockent un lien, et un navigateur exécute une URL javascript: lorsque le lien est activé. Le rapport amont signale une variante sans clic sur la page d'erreur WebAuthn, et le vecteur de Red Hat indique UI:N.

Traitez une visite sur la page de connexion d'un royaume concerné comme une exposition, plutôt que de compter sur le fait que les utilisateurs ne cliquent pas.

Les thèmes personnalisés sont-ils concernés ?

Uniquement lorsque le thème affiche displayNameHtml via kcSanitize. Les thèmes intégrés base et keycloak.v2 le font. Un thème personnalisé qui n'affiche pas le champ est hors de cette voie, et un thème qui l'affiche sans kcSanitize présente un autre problème.

26.6.8 suffit-il pour la branche 26.6 ?

Pour Red Hat build of Keycloak, oui : 26.6.8 contient le rétroportage fusionné le 2026-10-14. Keycloak n'a publié aucune version communautaire 26.6.8, donc les déploiements communautaires sur 26.6 doivent passer à 26.8.2. Les déploiements sur 26.7 ou plus anciens doivent aussi passer à 26.8.2.

Red Hat Single Sign-On 7 est-il concerné ?

Non. L'enregistrement CVE classe Red Hat Single Sign-On 7 comme non concerné. Red Hat build of Keycloak 26.6 est concerné et corrigé en 26.6.8.

La faille a-t-elle été exploitée dans la nature ?

Non. L'entrée de l'Authorized Data Publisher de la CISA indique une exploitation « none », et la CVE n'est pas dans le catalogue KEV de la CISA au 2026-11-20. Les tests du correctif publient des formes de charge, donc la technique est publique même si aucun exploit fonctionnel n'a été signalé.

Tester les pages de connexion Keycloak avec Ostorlab

Le Web Agentic Deep Scan d'Ostorlab exerce les pages d'authentification et les champs qu'elles affichent, y compris le cross-site scripting stocké. Vous pouvez évaluer une page de connexion Keycloak avant qu'une charge stockée n'atteigne les utilisateurs : voir comment fonctionne Web Agentic Deep Scan.

Références

  • Enregistrement CVE-2026-107889, publié le 2026-10-09. https://www.cve.org/CVERecord?id=CVE-2026-107889 (vérifié le 20 novembre 2026)
  • Page CVE de Red Hat pour CVE-2026-107889. https://access.redhat.com/security/cve/CVE-2026-107889 (vérifié le 20 novembre 2026)
  • Bugzilla Red Hat 2548355, le rapport privé migré vers le suivi public. https://bugzilla.redhat.com/show_bug.cgi?id=2548355 (vérifié le 20 novembre 2026)
  • Errata Red Hat RHSA-2026:95761, « Red Hat build of Keycloak 26.6.8 Security Update », publié le 2026-11-06. https://access.redhat.com/errata/RHSA-2026:95761 (vérifié le 20 novembre 2026)
  • Errata Red Hat RHSA-2026:95762, « Red Hat build of Keycloak 26.6.8 Images Security Update », publié le 2026-11-06. https://access.redhat.com/errata/RHSA-2026:95762 (vérifié le 20 novembre 2026)
  • Rapport Keycloak 53813, « [CVE-2026-107889] Stored XSS on the login page via kcSanitize bypass », ouvert le 2026-10-09. https://github.com/keycloak/keycloak/issues/53813 (vérifié le 20 novembre 2026)
  • Commit de correction 3e0fda9765c4b911c2d79c65549115c0b4e643fb, « prevent kcSanitize from re-activating disallowed URL schemes after link fixup », 2026-10-13. https://github.com/keycloak/keycloak/commit/3e0fda9765c4b911c2d79c65549115c0b4e643fb (vérifié le 20 novembre 2026)
  • Pull request de rétroportage 53969 pour la branche 26.8, fusionnée le 2026-10-14. https://github.com/keycloak/keycloak/pull/53969 (vérifié le 20 novembre 2026)
  • Version Keycloak 26.8.2, publiée le 2026-11-05. https://github.com/keycloak/keycloak/releases/tag/26.8.2 (vérifié le 20 novembre 2026)
  • Étiquette Keycloak 26.6.8. https://github.com/keycloak/keycloak/tree/26.6.8 (vérifié le 20 novembre 2026)
  • KeycloakSanitizerMethod.java à la version 26.8.0. https://github.com/keycloak/keycloak/blob/26.8.0/services/src/main/java/org/keycloak/theme/KeycloakSanitizerMethod.java (vérifié le 20 novembre 2026)
  • KeycloakSanitizerPolicy.java à la version 26.8.0. https://github.com/keycloak/keycloak/blob/26.8.0/services/src/main/java/org/keycloak/theme/KeycloakSanitizerPolicy.java (vérifié le 20 novembre 2026)
  • Modèle de connexion à la version 26.8.0. https://github.com/keycloak/keycloak/blob/26.8.0/themes/src/main/resources/theme/base/login/template.ftl (vérifié le 20 novembre 2026)
  • Catalogue Known Exploited Vulnerabilities de la CISA, version 2026.11.20. https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json (vérifié le 20 novembre 2026)