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

v5 nennt den erwarteten Typ („ECDSA verify expects *ecdsa.PublicKey“, „HMAC verify expects []byte“); v4 gibt nur „key is of invalid type“ aus. Da v5 den Fehler unter `ErrTokenSignatureInvalid` meldet, sieht er auf den ersten Blick wie eine fehlgeschlagene Signaturprüfung aus.

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

Was der Fehler bedeutet

Der Wert, den deine `Keyfunc` zurückgegeben hat (oder der an `SignedString` übergebene Schlüssel), hat den falschen Go-Typ für den Algorithmus des Tokens. golang-jwt prüft den Schlüssel per Type Assertion: Die Prüfung von ES* braucht `*ecdsa.PublicKey`, RS*/PS* brauchen `*rsa.PublicKey`, EdDSA braucht `ed25519.PublicKey`, HS* braucht `[]byte`; zum Signieren ist der passende private Schlüssel nötig. Es lief keinerlei Kryptografie – der Schlüssel hatte gar keine Gelegenheit, falsch zu sein, er war die falsche Art von Objekt.

Warum der Fehler auftritt

• PEM-Bytes statt eines geparsten Schlüssels zurückgegeben

  häufig

  `[]byte` zurückzugeben, das aus einer `.pem`-Datei gelesen wurde, funktioniert für HMAC, aber nicht für asymmetrische Algorithmen. Die Bytes müssen zuerst zu `*ecdsa.PublicKey` oder `*rsa.PublicKey` geparst werden.

• Der private Schlüssel wurde zur Prüfung übergeben

  häufig

  `*ecdsa.PrivateKey` wird nicht akzeptiert, wo `*ecdsa.PublicKey` verlangt ist. Gib `&priv.PublicKey` zurück – oder besser: Halte private Schlüssel ganz von der prüfenden Seite fern.

• Ein HMAC-Secret als String zurückgegeben

  häufig

  Für HS256 muss die Keyfunc `[]byte` zurückgeben. Ein `string` (zum Beispiel aus `os.Getenv`) scheitert an der Type Assertion.

• Ein JWK-Struct oder eine Map statt eines Kryptoschlüssels

  gelegentlich

  Schlüssel, die aus einem JWKS in ein Struct oder eine `map[string]any` dekodiert wurden, sind keine Kryptoschlüssel. Konvertiere sie (zum Beispiel mit `JSONWebKey.Key` von go-jose oder mit der JWKS-Unterstützung von keyfunc).

So behebst du den Fehler

1. 1.

   PEM einmal in einen typisierten Schlüssel parsen

   golang-jwt bringt Hilfsfunktionen für jeden Schlüsseltyp mit. Parse den Schlüssel beim Start und gib den typisierten Schlüssel aus der Keyfunc zurück.

   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.

   HMAC-Secrets als []byte zurückgeben

   Wandle das Secret in Bytes um und lege `WithValidMethods` auf den HMAC-Algorithmus fest, damit Tokens mit einem asymmetrischen `alg` diesen Codepfad nicht erreichen können.

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

← Gesamte Signaturfehler-Datenbank durchsuchen