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

La v5 nombra el tipo esperado («ECDSA verify expects *ecdsa.PublicKey», «HMAC verify expects []byte»); la v4 solo imprime «key is of invalid type». Como la v5 lo clasifica como `ErrTokenSignatureInvalid`, a primera vista parece un fallo de firma.

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

Qué significa

El valor que devuelve tu `Keyfunc` (o la clave que se pasa a `SignedString`) tiene el tipo de Go equivocado para el algoritmo del token. golang-jwt hace una aserción de tipo sobre la clave: la verificación ES* necesita `*ecdsa.PublicKey`, RS*/PS* necesitan `*rsa.PublicKey`, EdDSA necesita `ed25519.PublicKey` y HS* necesita `[]byte`; para firmar hace falta la clave privada correspondiente. No se llega a ejecutar nada criptográfico: la clave no tuvo ocasión de ser incorrecta, porque era un objeto de otro tipo.

Por qué ocurre

• Se devuelven bytes PEM en lugar de una clave analizada

  frecuente

  Devolver los `[]byte` leídos de un archivo `.pem` funciona con HMAC, pero no con algoritmos asimétricos. Primero hay que analizar los bytes para obtener un `*ecdsa.PublicKey` o un `*rsa.PublicKey`.

• Se pasa la clave privada para la verificación

  frecuente

  `*ecdsa.PrivateKey` no se acepta donde se requiere `*ecdsa.PublicKey`. Devuelve `&priv.PublicKey` o, mejor aún, mantén las claves privadas totalmente fuera de los verificadores.

• Un secreto HMAC devuelto como cadena

  frecuente

  Para HS256, la Keyfunc debe devolver `[]byte`. Un `string` (por ejemplo, el que devuelve `os.Getenv`) no supera la aserción de tipo.

• Un struct o un map de JWK en lugar de una clave criptográfica

  ocasional

  Las claves decodificadas de un JWKS a un struct o a un `map[string]any` no son claves criptográficas. Conviértelas (por ejemplo, con `JSONWebKey.Key` de go-jose o con las funciones de JWKS de keyfunc).

Cómo solucionarlo

1. 1.

   Convertir el PEM en una clave tipada una sola vez

   golang-jwt incluye funciones auxiliares para cada tipo de clave. Analiza el PEM al arrancar y devuelve la clave tipada desde 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.

   Devolver los secretos HMAC como []byte

   Convierte el secreto a bytes y fija `WithValidMethods` en el algoritmo HMAC para que los tokens con un `alg` asimétrico no puedan llegar a esa ruta de código.

   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"}))

← Explorar toda la base de datos de errores de firma