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

Analyse approfondie

Analyse approfondie

Pocket ID : contournement de vérification d'e-mail (CVE-2026-115770)

Pocket ID avant 2.12.0 conserve un jeton de vérification d'e-mail après le changement d'adresse, ce qui permet de vérifier une adresse non contrôlée.

En bref

  • Pocket ID liait le jeton de vérification à l'utilisateur, pas à l'adresse d'envoi. Un utilisateur pouvait obtenir un jeton pour sa propre adresse, basculer vers l'adresse d'une victime et l'utiliser pour marquer la nouvelle adresse comme vérifiée.
  • Toutes les versions de 2.2.0 à 2.11.x sont concernées lorsque la vérification d'e-mail est activée, ce qui est le cas par défaut.
  • La fiche CVE lui attribue un score CVSS v3.1 de 9,6 Critique. Aucune exploitation en conditions réelles n'est connue, et la faille n'est pas dans le catalogue KEV de la CISA au 2026-11-20.
  • Mettez à niveau vers 2.12.0 ou une version ultérieure, actuellement 2.19.3, et auditez les comptes dont l'adresse vérifiée a changé autour de la mise à niveau.

Suis-je concerné ?

Toutes ces conditions doivent être réunies pour qu'un déploiement de Pocket ID soit exposé :

  • La version est 2.2.0 ou ultérieure et antérieure à 2.12.0.
  • La vérification d'e-mail est utilisée, ce qui est le cas par défaut (emailsVerified=false : un changement d'adresse remet l'indicateur de vérification à false).
  • Les utilisateurs peuvent modifier leur propre compte, ce qui est le cas par défaut (allowOwnAccountEdit=true).
  • L'adresse qu'un attaquant veut revendiquer n'est pas déjà attribuée à un autre utilisateur Pocket ID.
  • Une partie de confiance lie ou provisionne des comptes à partir des revendications OIDC email et email_verified. Une application qui n'utilise que la revendication stable sub n'est pas concernée par la prise de contrôle en aval.
Branche Versions concernées Version corrigée
Pocket ID 2.x 2.2.0 à 2.11.x 2.12.0

Le correctif est sorti dans 2.12.0 le 2026-07-29. La version actuelle est 2.19.3, publiée le 2026-11-15. L'image officielle pocketid/pocket-id comptait 951 341 téléchargements Docker Hub le 2026-11-20, et le dépôt comptait 10 399 étoiles.

Vérifiez la version en cours d'exécution depuis le conteneur ou l'hôte :

# Official container image
docker exec <container> /app/pocket-id version

# Binary install
pocket-id version

# Kubernetes
kubectl exec deploy/pocket-id -- /app/pocket-id version

La sortie est pocket-id <version>. Si la commande n'est pas disponible, lisez le tag de l'image ou le nom de la version déployée.

Comment corriger ?

Mettez à niveau vers 2.12.0 ou une version ultérieure et recréez le conteneur. La mise à niveau ne dé-vérifie pas rétroactivement les adresses déjà marquées comme vérifiées, donc préparez l'audit de l'étape 4.

  1. Tirez la version actuelle et recréez le conteneur avec les mêmes volumes et variables d'environnement :
docker pull pocketid/pocket-id:v2.19.3
docker compose pull pocket-id
docker compose up -d pocket-id
  1. Pour une installation binaire, remplacez le binaire par l'archive de la version 2.19.3 pour votre plateforme et redémarrez le service. Conservez le répertoire de données et l'environnement existants.
  2. Pour une compilation depuis les sources, compilez et déployez le tag v2.19.3 ou ultérieur.
  3. Auditez les utilisateurs dont email_verified vaut vrai et dont l'adresse a changé près de la mise à niveau. Vérifiez à nouveau tout compte dont la vérification ne s'explique pas, et examinez les liens ou les provisionnements des parties de confiance qui ont utilisé l'adresse revendiquée.

Aucun contournement de configuration ne corrige le jeton périmé. Désactiver la modification d'e-mail en libre-service supprime l'étape qui rend le jeton utile. Cela change toutefois la gestion des utilisateurs pour tout le déploiement et ne répare pas les adresses déjà vérifiées.

Quelle est la cause racine ?

Pocket ID stockait le jeton de vérification uniquement contre l'identifiant utilisateur. Le changement d'adresse du compte réinitialisait l'indicateur email_verified mais ne supprimait ni ne reliait les jetons en cours. L'utilisation d'un jeton mettait email_verified à vrai sur l'adresse que le compte portait à ce moment-là.

Le modèle dans backend/internal/model/email_verification_token.go, lignes 5 à 13 de la version 2.11.0, n'a pas de champ d'adresse :

type EmailVerificationToken struct {
    Base

    Token     string
    ExpiresAt datatype.DateTime

    UserID string
    User   User
}

SendEmailVerification(), dans backend/internal/service/user_service.go, lignes 599 à 633, crée le jeton avec UserID, Token et ExpiresAt, puis envoie le lien à l'adresse du compte à ce moment-là :

emailVerificationToken := &model.EmailVerificationToken{
    UserID:    user.ID,
    Token:     randomToken,
    ExpiresAt: datatype.DateTime(expiration),
}

updateUserInternal() réinitialise la vérification lorsque l'adresse change, aux lignes 430 à 435 :

if (user.Email == nil && updatedUser.Email != nil) || (user.Email != nil && updatedUser.Email != nil && *user.Email != *updatedUser.Email) {
    // Email has changed, reset email verification status
    user.EmailVerified = s.appConfigService.GetDbConfig().EmailsVerified.IsTrue()
}

user.Email = updatedUser.Email

Cette réinitialisation est le seul lien entre le changement d'adresse et la vérification. Aucun code ne supprime les lignes de email_verification_tokens pour l'utilisateur, donc un jeton émis pour l'ancienne adresse reste utilisable.

VerifyEmail(), aux lignes 635 à 661, recherche le jeton par valeur, identifiant utilisateur et expiration, puis met EmailVerified à vrai sur l'enregistrement utilisateur :

err := tx.WithContext(ctx).Where("token = ? AND user_id = ? AND expires_at > ?",
    token, userID, datatype.DateTime(time.Now())).First(&emailVerificationToken).Error

La recherche ne compare jamais l'adresse à laquelle le jeton a été envoyé avec l'adresse actuelle du compte. Le jeton prouve le contrôle de l'ancienne adresse, mais il met l'indicateur à vrai sur la nouvelle.

Comment la faille est-elle exploitée ?

Un attaquant disposant d'un compte Pocket ID ordinaire demande un jeton de vérification pour une adresse qu'il contrôle. Il change ensuite le compte vers une adresse qu'il ne contrôle pas, puis utilise l'ancien jeton. Pocket ID publie alors la nouvelle adresse comme vérifiée.

L'avis donne ces étapes de reproduction via l'API :

  1. Connectez-vous en tant qu'utilisateur ordinaire dont l'adresse actuelle est contrôlée par l'attaquant, par exemple attacker@example.test.
  2. Appelez POST /api/users/me/send-email-verification.
  3. Lisez le jeton dans le message livré à attacker@example.test, mais ne l'utilisez pas encore.
  4. Appelez PUT /api/users/me et changez l'e-mail du compte vers une adresse que l'attaquant ne contrôle pas, par exemple victim@example.test.
  5. Observez que la nouvelle adresse est stockée avec emailVerified: false.
  6. Appelez POST /api/users/me/verify-email avec le jeton livré à attacker@example.test.
  7. Appelez GET /api/users/me. L'adresse est maintenant victim@example.test et emailVerified vaut true.
  8. Terminez un flux OIDC avec le scope email. Pocket ID émet :
{
  "email": "victim@example.test",
  "email_verified": true
}

Aucun privilège administrateur, aucune interaction de la victime et aucun accès à sa boîte mail ne sont nécessaires. La seule limite est que l'adresse cible ne doit pas déjà appartenir à un autre utilisateur Pocket ID.

Comment se déroule l'attaque ?

Un attaquant transforme un jeton pour sa propre adresse en revendication vérifiée pour l'adresse d'un autre, parce que la vérification du jeton ne compare jamais les deux adresses.

flowchart LR A["Compte Pocket ID ordinaire
attacker@example.test"] --> B["Demande d'un jeton
envoyé à l'adresse de l'attaquant"] B --> C["Changement de l'e-mail
vers victim@example.test"] C --> D["Utilisation du jeton émis
pour l'ancienne adresse"] D --> E{"Jeton lié
à l'adresse ?"} E -->|"Non, identifiant seul"| F["email_verified = true
sur l'adresse de la victime"] F --> G["La revendication OIDC lie l'attaquant
au compte de la victime"]

Que peut faire un attaquant ?

Un attaquant peut faire affirmer à Pocket ID qu'il contrôle une adresse qu'il ne possède pas. L'impact apparaît chez chaque partie de confiance qui fait confiance à la revendication d'e-mail vérifié.

  • Prise de contrôle de compte chez une partie de confiance qui lie un compte existant par e-mail. L'identité Pocket ID de l'attaquant est attachée au compte local de la victime.
  • Provisionnement non autorisé chez un service qui crée des comptes à partir de email et email_verified, avec l'adresse de la victime et l'identité de l'attaquant.
  • Les flux de réinitialisation de mot de passe ou d'invitation qui font confiance à l'e-mail vérifié du fournisseur d'identité peuvent être redirigés vers la session de l'attaquant.

L'impact exige que l'application en aval fasse confiance à la revendication d'e-mail vérifié pour lier ou provisionner. Une application qui identifie les comptes uniquement par la revendication OIDC sub n'est pas prise par cette faille, car la valeur sub ne change pas.

Pourquoi le correctif fonctionne-t-il ?

Le correctif lie le jeton à l'adresse pour laquelle il a été émis et vérifie à nouveau cette adresse lors de l'utilisation. Un jeton émis pour l'ancienne adresse ne vérifie plus la nouvelle.

emailverification/service.go dans 2.12.0 stocke l'adresse et un hachage du jeton dans l'état d'acteur de l'utilisateur :

state := State{
    TokenHash: utils.CreateSha256Hash(token),
    Email:     *user.Email,
    ExpiresAt: time.Now().Add(tokenLifetime),
}

Verify() met l'utilisateur à jour uniquement lorsque l'identifiant et l'adresse actuelle correspondent à l'état stocké avec le jeton :

update := s.db.
    WithContext(ctx).
    Model(&model.User{}).
    Where("id = ? AND email = ?", userID, result.State.Email).
    Updates(map[string]any{
        "email_verified": true,
        "updated_at":     new(datatype.DateTime(time.Now())),
    })

if update.RowsAffected != 1 {
    return &common.InvalidEmailVerificationTokenError{}
}

Si l'adresse du compte a changé après l'émission du jeton, email ne correspond plus et la mise à jour affecte zéro ligne. Pocket ID renvoie une erreur de jeton invalide et laisse email_verified à faux. Le jeton est stocké sous forme de hachage SHA-256 plutôt qu'en clair, donc une lecture de la base n'expose pas de jeton utilisable.

Le correctif est complet pour le chemin de vérification. Les comptes déjà marqués comme vérifiés avant la mise à niveau ne changent pas, d'où l'importance de l'audit dans « Comment corriger ? ».

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

Pocket ID ne publie aucun indicateur de compromission pour cette faille, et aucune exploitation en conditions réelles n'est connue.

Vérifiez le journal d'audit des comptes et les parties de confiance qui utilisent les revendications de Pocket ID :

  • Dans le journal d'audit de l'administration Pocket ID, cherchez un compte qui a changé son e-mail puis vérifié dans la durée de vie du jeton de 24 heures.
  • Dans les journaux des parties de confiance, cherchez un nouveau lien ou un provisionnement pour un compte existant au même moment.
  • Examinez les comptes dont email_verified vaut vrai mais dont l'adresse a changé après l'émission du jeton.
  • Demandez aux parties de confiance si elles lient les comptes par e-mail vérifié. Une partie qui n'utilise que sub ne crée pas le chemin de prise de contrôle.

Un événement de vérification seul est normal. Le signal est une vérification qui suit immédiatement un changement d'adresse, surtout lorsque la nouvelle adresse appartient à un utilisateur existant chez un service en aval.

Chronologie

  • 2026-07-27 : le commit 43aaccd5 remplace le modèle de jeton par un acteur par utilisateur qui stocke le hachage du jeton et l'adresse.
  • 2026-07-29 : Pocket ID 2.12.0 sort avec le correctif.
  • 2026-11-04 : CVE-2026-115770 est publié.
  • 2026-11-09 : l'avis GitHub GHSA-rm8c-2cv8-jwf6 est publié avec les étapes de reproduction.
  • 2026-11-15 : Pocket ID 2.19.3, la version actuelle, est publiée.

Chronologie de CVE-2026-115770 : le commit de correction et la version 2.12.0 en juillet 2026, puis le CVE et l'avis en novembre 2026
Figure 1 : le correctif 2.12.0 est sorti le 2026-07-29, 98 jours avant la publication du CVE. Source : dépôt Pocket ID et avis GitHub, vérifiés le 20 novembre 2026.

FAQ

Un attaquant a-t-il besoin d'un compte sur mon instance Pocket ID ?

Oui. L'attaquant a besoin d'un compte utilisateur ordinaire qui peut changer son propre e-mail et demander une vérification. Aucun rôle administrateur n'est requis.

Tous les déploiements Pocket ID sont-ils concernés ?

Non. Le déploiement doit exécuter 2.2.0 à 2.11.x avec la vérification d'e-mail activée et la modification de compte en libre-service autorisée. Les deux sont des valeurs par défaut, donc un déploiement non modifié dans cette plage est exposé.

Existe-t-il une preuve de concept publique ?

Oui. L'avis publie les étapes de reproduction via l'API et un test de régression Go exécutable. Le test démontre la transition d'état sans exploit fonctionnel contre un tiers.

La faille a-t-elle été exploitée en conditions réelles ?

Aucune exploitation n'est connue. La fiche CVE et l'avis ne signalent pas d'attaques, et le CVE n'est pas dans le catalogue KEV de la CISA au 2026-11-20.

La mise à niveau annule-t-elle une vérification frauduleuse ?

Non. La mise à niveau empêche les nouvelles vérifications incohérentes. Une adresse déjà marquée comme vérifiée le reste, donc auditez les comptes vérifiés avant la mise à niveau et vérifiez à nouveau ceux qui ne s'expliquent pas.

Cela affecte-t-il les clients OIDC qui utilisent la revendication sub ?

Non. Un client qui identifie les utilisateurs uniquement par la revendication stable sub n'est pas pris par cette faille. L'impact concerne les clients qui lient ou provisionnent des comptes à partir de email et email_verified.

Trouver les déploiements Pocket ID exposés avec Ostorlab

Le Web Agentic Deep Scan d'Ostorlab cartographie les routes exposées et les surfaces d'authentification d'une application web. Utilisez-le pour inventorier les points de terminaison OIDC et les pages de gestion de compte devant votre fournisseur d'identité ; la détection de ce CVE n'est pas confirmée.

Références

  • GitHub Advisory Database, GHSA-rm8c-2cv8-jwf6, « Pocket ID: Email verification token remains valid after address change » : https://github.com/pocket-id/pocket-id/security/advisories/GHSA-rm8c-2cv8-jwf6 (vérifié le 20 novembre 2026)
  • CVE Program, CVE-2026-115770 : https://www.cve.org/CVERecord?id=CVE-2026-115770 (vérifié le 20 novembre 2026)
  • Pocket ID, commit de correction 43aaccd5bfacb76283b11ce039fb3f0716196fcb : https://github.com/pocket-id/pocket-id/commit/43aaccd5bfacb76283b11ce039fb3f0716196fcb (vérifié le 20 novembre 2026)
  • Pocket ID, version v2.12.0 : https://github.com/pocket-id/pocket-id/releases/tag/v2.12.0 (vérifié le 20 novembre 2026)
  • Pocket ID, version v2.19.3 : https://github.com/pocket-id/pocket-id/releases/tag/v2.19.3 (vérifié le 20 novembre 2026)
  • Pocket ID, source vulnérable en v2.11.0, user_service.go : https://github.com/pocket-id/pocket-id/blob/v2.11.0/backend/internal/service/user_service.go (vérifié le 20 novembre 2026)
  • Pocket ID, modèle de jeton vulnérable en v2.11.0 : https://github.com/pocket-id/pocket-id/blob/v2.11.0/backend/internal/model/email_verification_token.go (vérifié le 20 novembre 2026)
  • Pocket ID, service de vérification corrigé en v2.12.0 : https://github.com/pocket-id/pocket-id/blob/v2.12.0/backend/internal/emailverification/service.go (vérifié le 20 novembre 2026)
  • Dépôt Pocket ID : https://github.com/pocket-id/pocket-id (vérifié le 20 novembre 2026)
  • Docker Hub, pocketid/pocket-id : https://hub.docker.com/r/pocketid/pocket-id (vérifié le 20 novembre 2026)
  • Catalogue des vulnérabilités exploitées de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)