Wie verifiziert man AWS Cognito JWT-Tokens in Go?

AWS Cognito JWT-Tokens in Go überprüfen

Einführung

Informationen aus JWT validieren und extrahieren Von Amazon Cognito ausgegebene Token können in Go eine Herausforderung darstellen. Dieser Artikel bietet eine kurze Anleitung zur effektiven Bewältigung dieser Aufgabe.

Voraussetzungen

AWS Cognito-Benutzer müssen den öffentlichen JSON Web Key (JWK)-Satz vom JWKS-Endpunkt abrufen:

https://cognito-idp.{region}.amazonaws.com/{userPoolId}/.well-known/jwks.json

JWKs analysieren und überprüfen JWTs

Um den JWK-Satz zu analysieren und JWTs zu überprüfen, sollten Sie Folgendes verwenden:

• [jwk](https://github.com/lestrrat-go/jwx): Für JWK Parsen
• [jwt-go](https://github.com/dgrijalva/jwt-go): Für JWT-Validierung

Implementierung

1. Rufen und analysieren Sie den JWK-Satz mit jwk.Fetch().
2. Verwenden Sie jwt.Parse(), um das JWT-Token zu analysieren.
3. Extrahieren Sie das Feld „kid“ aus dem JWT-Header, um den passenden öffentlichen Schlüssel im JWK-Satz zu identifizieren .
4. Verwenden Sie keySet.LookupKeyID(kid), um den öffentlichen Schlüssel abzurufen, der dem „Kind“ zugeordnet ist. Header.
5. Weisen Sie den öffentlichen Schlüssel dem Rückruf func(token *jwt.Token) (interface{}, error) zu, wenn Sie das JWT-Token analysieren.

Beispiel Code

package main

import (
    "fmt"

    jwt "github.com/dgrijalva/jwt-go"
    "github.com/lestrrat-go/jwx/jwk"
)

func main() {
    // Replace with your Cognito token and Cognito JWKS endpoint
    tokenString := "YOUR_JWT_TOKEN"
    endpoint := "YOUR_COGNITO_JWKS_ENDPOINT"

    keySet, err := jwk.Fetch(endpoint)
    if err != nil {
        fmt.Println(err)
        return
    }

    // Parse the JWT token and validate its signature using the public key
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodRS256); !ok {
            return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
        }
        kid, ok := token.Header["kid"].(string)
        if !ok {
            return nil, errors.New("kid header not found")
        }
        keys := keySet.LookupKeyID(kid)
        if !ok {
            return nil, fmt.Errorf("key with specified kid is not present in jwks")
        }
        var publickey interface{}
        err = keys.Raw(&publickey)
        if err != nil {
            return nil, fmt.Errorf("could not parse pubkey")
        }
        return publickey, nil
    })

    if err != nil {
        fmt.Println(err)
        return
    }

    // Access the claims from the validated JWT token
    claims := token.Claims.(jwt.MapClaims)
    fmt.Println("User ID: ", claims["sub"])
}

Fazit

Durch die Verwendung von Bibliotheken wie jwk und jwt-go können Entwickler Daten von Cognito-JWT-Tokens in Go effizient überprüfen und abrufen Dies bietet eine sichere und bequeme Möglichkeit, Benutzer in ihren Anwendungen zu authentifizieren.

Das obige ist der detaillierte Inhalt vonWie verifiziert man AWS Cognito JWT-Tokens in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!