crypto11 : réutilisation de nonce GCM et falsification de chiffrés (CVE-2026-115407)
crypto11 accepte des nonces GCM vides, exposant le clair et permettant de falsifier des chiffrés ; corrigé en v2.0.0-rc9, les modules v1 restent non corrigés.
En bref
- crypto11, une bibliothèque Go pour les jetons PKCS#11 et les modules matériels, transmettait n'importe quel nonce à AES-GCM sans vérifier sa longueur, donc un nonce vide chiffrait chaque message avec le même IV.
- Les applications qui appellent
NewGCM()et passent un nonce vide ou fixe sont exposées. Le module v2 jusqu'à 2.0.0-rc8 et les chemins de module v1 dépréciés jusqu'à leur dernière version sont concernés. - La Fondation Eclipse a publié CVE-2026-115407 le 2026-11-20, notée CVSS v4.0 9,1 Critique. La fiche SSVC de la CISA signale une preuve de concept publique, sans exploitation connue, et la CVE n'est pas dans le KEV au 2026-11-20.
- Mettez à niveau vers v2.0.0-rc9 ou une version ultérieure et réglez
GCMIVLengthsur la taille de nonce utilisée. Les chemins de module v1 sont dépréciés et ne seront pas corrigés.
Suis-je concerné ?
Toutes ces conditions doivent être réunies pour qu'une application soit exposée :
- Elle importe
github.com/eclipse-keypont/crypto11/v2en 2.0.0-rc8 ou antérieur, ou l'un des chemins de module v1 dépréciés à sa dernière version ou avant. - Elle appelle
SecretKey.NewGCM()et passe un nonce vide, fixe ou autrement répété ; l'API acceptait n'importe quelle longueur, y compris zéro. - Ou elle active
UseGCMIVFromHSMsansSupplyIvForHSMGCMEncryptet passe un nonce vide. - Le jeton accepte un IV GCM de longueur nulle. SoftHSM2 l'accepte ; le comportement d'un autre jeton dépend du fournisseur.
La présence d'un module dans les dépendances ne prouve pas l'exposition. La faille se trouve dans l'enveloppe GCM, donc un programme qui n'utilise crypto11 que pour la signature ou la gestion de clés n'atteint jamais le code vulnérable. Le go.mod de Teleport épingle github.com/ThalesIgnite/crypto11 v1.2.5, et le go.mod de Sigstore Fulcio épingle github.com/eclipse-keypont/crypto11 v1.6.8. Les deux versions sont dans les plages concernées, donc un inventaire des dépendances les trouvera ; une revue du code répond à la question de l'usage de l'enveloppe GCM.
| Chemin de module | Versions concernées | Version corrigée |
|---|---|---|
github.com/eclipse-keypont/crypto11/v2 |
2.0.0-rc8 et antérieures | 2.0.0-rc9 |
github.com/eclipse-keypont/crypto11 |
1.6.8 et antérieures | Aucune, déprécié |
github.com/ThalesGroup/crypto11 |
1.7.0-rc1 et antérieures | Aucune, déprécié |
github.com/ThalesIgnite/crypto11 |
1.2.5 et antérieures | Aucune, déprécié |
La fiche CVE lui attribue un score CVSS v4.0 de 9,1 Critique (CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N) et cite CWE-323, CWE-1204 et CWE-20. Le score CVSS v3.1 de l'avis GitHub est de 7,4 Élevé (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N).
Le correctif est sorti dans v2.0.0-rc9 le 2026-10-21. Les chemins de module v1 sont dépréciés et l'avis indique qu'ils ne sont pas corrigés, y compris le défaut de recopie de l'IV généré par le HSM. Vérifiez les modules que votre programme compile :
go list -m all | grep crypto11
go mod graph | grep crypto11
Cherchez ensuite les appels GCM et la configuration qui les contrôle :
grep -rn "NewGCM()" --include="*.go" .
grep -rn "UseGCMIVFromHSM\|GCMIVLength" --include="*.go" --include="*.yaml" --include="*.json" .
Si NewGCM() apparaît, lisez chaque appel à Seal et Open qui utilise la valeur retournée et vérifiez la longueur du nonce. Une tranche vide, une valeur nil ou une chaîne d'octets fixe constituent l'exposition.
Comment corriger ?
Mettez à niveau vers v2.0.0-rc9 ou une version ultérieure, réglez la longueur d'IV configurée sur la taille de nonce utilisée par l'application, puis recompilez.
- Passez le module à la version corrigée et nettoyez la compilation :
go get github.com/eclipse-keypont/crypto11/v2@v2.0.0-rc9
go mod tidy
go build ./...
- Si l'application passe des nonces de 12 octets, réglez
GCMIVLength: 12dans la configuration crypto11. La valeur par défaut est 16, et leSealcorrigé panique lorsque la longueur du nonce diffère deNonceSize(). - Si l'application active
UseGCMIVFromHSM, activez aussiGCMIVFromHSMControl.SupplyIvForHSMGCMEncryptetSupplyIvForHSMGCMDecrypt, et passez un tampon de nonce deNonceSize()octets. Sans le tampon de chiffrement, le jeton doit ajouter l'IV au chiffré, et le code corrigé vérifie qu'il l'a fait. - Migrez tout import v1 vers le module v2. Les chemins v1 sont dépréciés, ne reçoivent aucun correctif et conservent le défaut de recopie de l'IV en mode HSM.
Si la mise à niveau doit attendre, passez un nonce aléatoire neuf d'exactement NonceSize() octets à chaque appel à Seal et Open, et refusez toute autre longueur avant l'appel. N'utilisez pas UseGCMIVFromHSM sur la ligne v1.6.x. Ce contournement protège les sites d'appel que vous modifiez ; il ne corrige pas la bibliothèque pour les autres appelants du même programme.
Quelle est la cause racine ?
crypto11 ne comparait jamais la longueur du nonce avec le NonceSize() de l'AEAD, donc un nonce vide atteignait le jeton comme un IV GCM de longueur nulle et chaque message était chiffré avec le même IV.
La bibliothèque enveloppe un jeton PKCS#11 dans l'interface cipher.AEAD de Go. NewGCM() enregistre la longueur d'IV configurée comme NonceSize() de l'AEAD, puis construit chaque bloc de paramètres de mécanisme à partir du nonce fourni par l'appelant. Le code vulnérable se trouve dans aead.go au commit eb2806e, avant le correctif :
func (key *SecretKey) NewGCM() (cipher.AEAD, error) {
if key.Cipher.GCMMech == 0 {
return nil, fmt.Errorf("GCM not implemented for key type %#x", key.Cipher.GenParams[0].KeyType)
}
g := genericAead{
key: key,
overhead: 16,
nonceSize: key.context.cfg.GCMIVLength,
makeMech: func(nonce []byte, additionalData []byte, encrypt bool) (*pkcs11.Mechanism, *pkcs11.GCMParams, error) {
var params *pkcs11.GCMParams
if (encrypt && key.context.cfg.UseGCMIVFromHSM &&
!key.context.cfg.GCMIVFromHSMControl.SupplyIvForHSMGCMEncrypt) || (!encrypt &&
key.context.cfg.UseGCMIVFromHSM && !key.context.cfg.GCMIVFromHSMControl.SupplyIvForHSMGCMDecrypt) {
params = pkcs11.NewGCMParams(nil, additionalData, 16*8 /*bits*/)
} else {
params = pkcs11.NewGCMParams(nonce, additionalData, 16*8 /*bits*/)
}
return pkcs11.NewMechanismWithParams(key.Cipher.GCMMech, params), params, nil
},
}
return g, nil
}
NewGCM() règle nonceSize à partir de GCMIVLength, qui vaut 16 octets par défaut. La fermeture makeMech transmet ensuite le nonce de l'appelant à pkcs11.NewGCMParams comme IV, ou transmet nil lorsque le jeton est configuré pour générer l'IV. Le Seal ne vérifie jamais le nonce par rapport à nonceSize :
func (g genericAead) Seal(dst, nonce, plaintext, additionalData []byte) []byte {
var result []byte
if err := g.key.context.withSession(func(session *pkcs11Session) (err error) {
mech, params, err := g.makeMech(nonce, additionalData, true)
if err = session.ctx.EncryptInit(session.handle, mech, g.key.handle); err != nil {
err = fmt.Errorf("C_EncryptInit: %w", err)
return
}
if result, err = session.ctx.Encrypt(session.handle, plaintext); err != nil {
err = fmt.Errorf("C_Encrypt: %w", err)
return
}
if g.key.context.cfg.UseGCMIVFromHSM {
hsmIV := params.IV()
if len(nonce) != len(hsmIV) {
return errBadGCMNonceSize
}
copy(nonce, hsmIV)
}
return
}); err != nil {
panic(err)
}
dst = append(dst, result...)
return dst
}
Trois chemins découlent de ces lignes. Avec la configuration par défaut, le nonce part vers le jeton comme IV, et un nonce de longueur nulle est un IV de longueur nulle. En mode IV généré par le HSM sans tampon d'IV, params.IV() vaut nil après le chiffrement, donc un nonce vide passe la vérification de longueur, ne copie rien et renvoie un chiffré sous l'IV vide ; un nonce non vide échoue après le chiffrement du clair, et Seal panique. Sur la ligne v1, le mode IV généré par le HSM ne recopie jamais l'IV généré par le jeton.
Comment la faille est-elle exploitée ?
Un attaquant qui observe les chiffrés d'une application qui réutilise un IV récupère le OU exclusif des clairs et, grâce à la clé GHASH exposée, peut forger un chiffré que Open accepte.
- L'application appelle
NewGCM()puisSealavec un nonce vide ou fixe, donc le jeton chiffre chaque message avec le même IV. - L'attaquant observe au moins deux chiffrés produits sous cet IV, depuis le réseau, un journal, une sauvegarde ou un espace de stockage.
- L'attaquant applique un OU exclusif aux chiffrés et récupère le OU exclusif des clairs, ce qui expose la structure et le contenu répété.
- L'IV répété expose aussi la clé d'authentification GHASH, et l'attaquant s'en sert pour calculer une étiquette valide pour un chiffré de son choix.
Openaccepte le chiffré forgé parce que l'étiquette se vérifie sous la clé récupérée.
L'avis décrit cette chaîne et cite l'analyse de Joux sur les échecs d'authentification de GCM. Il ne publie aucun script d'exploitation. La fiche Vulnrichment de la CISA indique Exploitation: poc, et les tests de régression du correctif reproduisent les chemins du nonce vide et de l'IV généré par le HSM. Aucune exploitation en conditions réelles n'est connue au 2026-11-20.
Consultez « Suis-je concerné ? » pour connaître les conditions d’exposition. Quand l’application gère l’IV, fournir un nouveau nonce aléatoire de la longueur configurée évite la réutilisation décrite ici.
Comment se déroule l'attaque ?
L'application fournit un nonce vide, crypto11 le transmet au jeton comme un IV de longueur nulle, chaque message est chiffré avec le même IV, et un observateur transforme cette réutilisation en récupération du clair et en falsification de chiffré.
sans vérifier la longueur"] B --> C["SoftHSM2 accepte un IV de longueur nulle"] C --> D["Chaque message utilise le même IV"] D --> E["L'observateur applique un OU exclusif
et récupère le clair"] E --> F["Clé GHASH récupérée
chiffré forgé accepté par Open"]
Que peut faire un attaquant ?
La réutilisation de l’IV compromet la confidentialité et l’intégrité des messages. L’application peut aussi s’arrêter si elle appelle Seal avec un nonce non vide en mode IV généré par le HSM, sans tampon pour l’IV.
- Récupérer le clair. Deux chiffrés sous le même IV donnent, par OU exclusif, le OU exclusif de leurs clairs. Les répétitions, les champs connus et les données structurées exposent alors le contenu.
- Forger des chiffrés. La même réutilisation expose la clé d'authentification GHASH. L'attaquant peut calculer une étiquette valide pour un message de son choix, et
Openl'accepte. - Provoquer un déni de service. En mode IV généré par le HSM sans tampon d'IV, un nonce non vide fait paniquer
Sealaprès le chiffrement du clair, ce qui termine le processus.
Les conditions sont énumérées ici en entier. L'application doit appeler NewGCM() et passer un nonce vide, fixe ou répété ; un nonce vide est le cas le plus clair. Le jeton doit accepter un IV de longueur nulle ; SoftHSM2 l'accepte, et l'avis précise que le comportement d'un autre jeton dépend du fournisseur. L'attaquant doit pouvoir observer les chiffrés. Aucune authentification ni position réseau sur l'hôte n'est requise au-delà de cette observation, ce qui explique l'importance d'un réseau partagé, d'une chaîne de journaux ou d'un lecteur de stockage.
Pourquoi le correctif fonctionne-t-il ?
Le correctif fait respecter par l'AEAD son propre contrat de nonce et vérifie qu'un jeton censé générer l'IV l'a réellement fait, donc un nonce court ou vide ne peut plus atteindre le chiffrement.
+var errGCMNonceLength = errors.New("crypto11: incorrect nonce length given to GCM")
+var errGCMIVNotGenerated = errors.New("crypto11: UseGCMIVFromHSM is set but the token did not generate a GCM IV")
+const minGCMNonceSize = 12
+
func (key *SecretKey) NewGCM() (cipher.AEAD, error) {
if key.Cipher.GCMMech == 0 {
return nil, fmt.Errorf("GCM not implemented for key type %#x", key.Cipher.GenParams[0].KeyType)
}
+ if n := key.context.cfg.GCMIVLength; n < minGCMNonceSize {
+ return nil, fmt.Errorf("GCMIVLength %d is too short: GCM IVs must be at least %d bytes", n, minGCMNonceSize)
+ }
@@
func (g genericAead) Seal(dst, nonce, plaintext, additionalData []byte) []byte {
+ hsmIV := g.key.context.cfg.UseGCMIVFromHSM
+ supplied := g.ivSupplied(true)
+ if len(nonce) != g.nonceSize && (supplied || len(nonce) != 0) {
+ panic(errGCMNonceLength)
+ }
@@
if hsmIV {
- hsmIV := params.IV()
- if len(nonce) != len(hsmIV) {
- return errBadGCMNonceSize
+ if supplied {
+ iv := params.IV()
+ if len(nonce) != len(iv) {
+ return errBadGCMNonceSize
+ }
+ if bytes.Equal(iv, nonce) {
+ return errGCMIVNotGenerated
+ }
+ copy(nonce, iv)
+ } else if len(result) != len(plaintext)+g.overhead+g.nonceSize {
+ return errGCMIVNotGenerated
}
- copy(nonce, hsmIV)
}
La nouvelle vérification de longueur dans Seal refuse tout nonce qui ne fait pas NonceSize() octets, sauf le cas documenté où le jeton génère l'IV sans tampon fourni. Open reçoit la même vérification pour le cas où l'IV est fourni. NewGCM refuse une longueur d'IV inférieure à 12 octets, la longueur de 96 bits recommandée par le NIST. En mode IV généré par le HSM, le correctif exige que le jeton écrive un IV différent dans le tampon et le recopie, ou qu'il ajoute l'IV au chiffré, donc un chiffré sous un IV fixe ou vide n'est jamais renvoyé.
Le correctif ferme les chemins GCM du module v2. Il ne l'est pas pour tout l'écosystème : les trois chemins de module v1 dépréciés ne sont pas corrigés, y compris le défaut de recopie de l'IV en mode HSM, et l'avis demande à leurs utilisateurs de migrer. La même version v2.0.0-rc9 corrige aussi deux problèmes Moyens de liaison de clés, GHSA-7842-qc22-qh4x et GHSA-2xw8-72pq-h8wg, distincts de cette CVE.
Comment vérifier si j'ai été compromis ?
Aucun indicateur de compromission n'est publié pour cette faille, et une falsification réussie ne laisse aucune erreur : Open renvoie le clair de l'attaquant comme s'il était légitime. Les vérifications portent donc sur le code et la configuration, pas sur les journaux.
- Trouvez chaque appel à
NewGCM()et inspectez le nonce passé àSealetOpen:
grep -rn "NewGCM()" --include="*.go" .
grep -rn "\.Seal(\|\.Open(" --include="*.go" .
- Cherchez un nonce vide ou fixe à ces sites d'appel :
nil,[]byte{},make([]byte, 0), une constante de paquet, ou un tampon réutilisé entre les messages. - Vérifiez la configuration crypto11 pour
UseGCMIVFromHSMetGCMIVLength, et regardez siSupplyIvForHSMGCMEncryptest activé. - Si le programme utilise SoftHSM2, traitez un nonce vide comme un vrai événement de réutilisation d'IV. S'il utilise un autre jeton, confirmez avec le fournisseur qu'il accepte un IV GCM de longueur nulle.
Une falsification ratée ressemble à un échec d'authentification normal, donc une entrée de journal seule ne distingue pas une attaque d'une corruption. Si vous trouvez un nonce vide dans du code de production, faites tourner les clés de données utilisées avec ce nonce et rechiffrez les chiffrés concernés.
Chronologie
Le correctif est sorti 30 jours avant la publication de la CVE.
- 2026-10-21 : crypto11 v2.0.0-rc9 sort avec le correctif, commit
8d99b73cet demande de fusion #172. - 2026-10-22 : publication de l'avis GitHub GHSA-c2cp-4qw8-q4jg.
- 2026-11-20 16:10 UTC : publication de CVE-2026-115407 par la Fondation Eclipse.
- 2026-11-20 18:35 UTC : la fiche SSVC de la CISA indique Exploitation: poc.
- 2026-11-20 : aucune exploitation en conditions réelles n'est connue.
FAQ
La faille touche-t-elle tous les utilisateurs de crypto11 ?
Non. Elle touche les programmes qui appellent SecretKey.NewGCM() et passent un nonce vide, fixe ou répété. Un programme qui n'utilise crypto11 que pour la signature, la génération de clés ou les certificats n'atteint pas le code vulnérable.
Existe-t-il un exploit public ?
La fiche Vulnrichment de la CISA indique Exploitation: poc au 2026-11-20, et les tests de régression de l'avis reproduisent les chemins du nonce vide et de l'IV généré par le HSM. L'avis ne publie aucun script d'exploitation, et aucune exploitation en conditions réelles n'est connue.
Que se passe-t-il si je passe un nonce de 12 octets à la version corrigée ?
Le Seal corrigé panique si la longueur du nonce diffère de NonceSize(). La valeur par défaut de GCMIVLength est 16, donc une application qui utilise des nonces de 12 octets doit régler GCMIVLength: 12 avant d'appeler NewGCM(). Un nonce aléatoire de 12 octets est cryptographiquement valable ; la longueur doit simplement correspondre à la configuration.
Les modules v1 sont-ils corrigés ?
Non. L'avis marque les chemins de module v1 comme dépréciés et non corrigés, et le commit du correctif ne modifie que le module v2. Teleport épingle github.com/ThalesIgnite/crypto11 v1.2.5, qui est dans la plage concernée et n'a aucune version v1 corrigée, donc ses mainteneurs doivent migrer vers v2 pour recevoir le correctif.
CVE-2026-115407 est-elle dans le KEV de la CISA ?
Non. Le catalogue KEV de la CISA ne contient pas CVE-2026-115407 au 2026-11-20. La fiche SSVC de la CISA indique Exploitation: poc, ce qui reste sous le seuil d'exploitation active que le catalogue KEV enregistre.
Le correctif change-t-il le format des chiffrés ?
Non. Le correctif change les nonces acceptés, pas la façon dont AES-GCM produit les chiffrés. Les chiffrés existants restent déchiffrables avec le nonce utilisé lors de leur création. Le changement de comportement est qu'un nonce de mauvaise longueur fait désormais paniquer Seal et renvoie une erreur depuis Open.
Trouvez les versions de crypto11 dans vos modules Go avec Ostorlab
L'analyse de composition logicielle et le SBOM d'Ostorlab inventorient les modules tiers de vos dépôts, y compris les modules Go, afin de trouver les versions de crypto11 dans les plages concernées et de suivre la mise à niveau vers v2.0.0-rc9. Inventoriez vos dépendances avec Ostorlab.
Références
- Fondation Eclipse, « AES-GCM
Sealaccepts nonces of any length, including empty, leading to IV reuse;UseGCMIVFromHSMsends no IV buffer by default », GHSA-c2cp-4qw8-q4jg, publié le 2026-10-22. https://github.com/eclipse-keypont/crypto11/security/advisories/GHSA-c2cp-4qw8-q4jg (vérifié le 20 novembre 2026) - Fondation Eclipse, « CVE-2026-115407 », publié le 2026-11-20. https://www.cve.org/CVERecord?id=CVE-2026-115407 (vérifié le 20 novembre 2026)
- crypto11, commit de correctif
8d99b73c721c173ad85c0ca4e063c3da360a611d, « fix: harden key-pair pairing, ML-KEM, AES-GCM and RSA; bump pkcs11-go to v1.2.0-rc4 (#172) », 2026-10-21. https://github.com/eclipse-keypont/crypto11/commit/8d99b73c721c173ad85c0ca4e063c3da360a611d (vérifié le 20 novembre 2026) - crypto11, demande de fusion #172. https://github.com/eclipse-keypont/crypto11/pull/172 (vérifié le 20 novembre 2026)
- crypto11, version v2.0.0-rc9, 2026-10-21. https://github.com/eclipse-keypont/crypto11/releases/tag/v2.0.0-rc9 (vérifié le 20 novembre 2026)
- crypto11, fichier
aead.govulnérable au commiteb2806e. https://github.com/eclipse-keypont/crypto11/blob/eb2806e/aead.go (vérifié le 20 novembre 2026) - NIST, « Recommendation for Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC », SP 800-38D. https://csrc.nist.gov/pubs/sp/800/38/d/final (vérifié le 20 novembre 2026)
- Antoine Joux, « Authentication Failures in NIST version of GCM », 2006. https://csrc.nist.gov/csrc/media/projects/block-cipher-techniques/documents/bcm/comments/800-38-series-drafts/gcm/joux_comments.pdf (vérifié le 20 novembre 2026)
- CISA, catalogue des vulnérabilités exploitées. https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)
- Teleport,
go.modde la branche par défaut, épinglantgithub.com/ThalesIgnite/crypto11v1.2.5. https://github.com/gravitational/teleport/blob/master/go.mod (vérifié le 20 novembre 2026) - Sigstore Fulcio,
go.modde la branche par défaut, épinglantgithub.com/eclipse-keypont/crypto11v1.6.8. https://github.com/sigstore/fulcio/blob/main/go.mod (vérifié le 20 novembre 2026)