token signature is invalid: key is of invalid type: ECDSA verify expects *ecdsa.PublicKey

La v5 nomme le type attendu (« ECDSA verify expects *ecdsa.PublicKey », « HMAC verify expects []byte ») ; la v4 affiche seulement « key is of invalid type ». Comme la v5 la classe sous `ErrTokenSignatureInvalid`, l’erreur ressemble à première vue à un échec de signature.

golang-jwt/jwt (Go) — jwt.ErrInvalidKeyType

Ce que cela signifie

La valeur renvoyée par votre `Keyfunc` (ou la clé passée à `SignedString`) n’a pas le bon type Go pour l’algorithme du jeton. golang-jwt effectue une assertion de type sur la clé : la vérification ES* exige `*ecdsa.PublicKey`, RS*/PS* exigent `*rsa.PublicKey`, EdDSA exige `ed25519.PublicKey`, HS* exige `[]byte` ; la signature exige la clé privée correspondante. Aucune opération cryptographique n’a eu lieu : la clé n’a même pas pu se révéler incorrecte, ce n’était tout simplement pas le bon type d’objet.

Pourquoi cela se produit

• Octets PEM renvoyés au lieu d’une clé analysée

  fréquente

  Renvoyer un `[]byte` lu dans un fichier `.pem` fonctionne pour HMAC, mais pas pour les algorithmes asymétriques. Les octets doivent d’abord être analysés en `*ecdsa.PublicKey` ou `*rsa.PublicKey`.

• La clé privée passée pour la vérification

  fréquente

  `*ecdsa.PrivateKey` n’est pas accepté là où `*ecdsa.PublicKey` est requis. Renvoyez `&priv.PublicKey`, ou mieux, tenez les clés privées entièrement à l’écart des vérificateurs.

• Un secret HMAC renvoyé sous forme de chaîne (string)

  fréquente

  Pour HS256, la Keyfunc doit renvoyer `[]byte`. Une valeur `string` (par exemple issue de `os.Getenv`) échoue à l’assertion de type.

• Une structure ou une map JWK au lieu d’une clé cryptographique

  occasionnelle

  Les clés décodées d’un JWKS dans une structure ou une `map[string]any` ne sont pas des clés cryptographiques. Convertissez-les (par exemple avec `JSONWebKey.Key` de go-jose ou la prise en charge des JWKS de keyfunc).

Comment corriger l’erreur

1. 1.

   Analyser le PEM une seule fois en clé typée

   golang-jwt fournit des fonctions utilitaires pour chaque type de clé. Analysez la clé au démarrage et renvoyez la clé typée depuis la Keyfunc.

   pub, err := jwt.ParseECPublicKeyFromPEM(pemBytes)      // ES256/384/512
   // rsaPub, err := jwt.ParseRSAPublicKeyFromPEM(pemBytes) // RS*/PS*
   // edPub, err := jwt.ParseEdPublicKeyFromPEM(pemBytes)   // EdDSA
   if err != nil {
   	log.Fatal(err)
   }
   token, err := jwt.Parse(raw, func(t *jwt.Token) (any, error) { return pub, nil },
   	jwt.WithValidMethods([]string{"ES256"}))

2. 2.

   Renvoyer les secrets HMAC sous forme de []byte

   Convertissez le secret en octets et limitez `WithValidMethods` à l’algorithme HMAC, afin que les jetons dont l’`alg` est asymétrique ne puissent pas atteindre ce chemin de code.

   secret := []byte(os.Getenv("JWT_HMAC_SECRET")) // []byte, not string
   token, err := jwt.Parse(raw, func(t *jwt.Token) (any, error) { return secret, nil },
   	jwt.WithValidMethods([]string{"HS256"}))

← Parcourir toute la base de données des erreurs de signature