Question

我目前正在研究Golang应用程序。我从客户端收到一个JWT令牌，在Go中我需要解码该令牌并获取信息：用户，名称等。我正在检查可用的库处理JWT令牌，我来到this，但我不知道如何简单地制作我需要的东西。我有令牌，我需要将信息解码为地图或至少一个json。我在哪里可以找到如何做的指南？谢谢！

Answer 1

函数jwt.ParseWithClaims接受jwt.Claims的接口作为第二个参数。除了基于结构的自定义声明之外，该程序包还提供基于map的声明，即jwt.MapClaims。因此，您可以简单地将令牌解码为MapClaims，例如

tokenString := "<YOUR TOKEN STRING>"    
claims := jwt.MapClaims{}
token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
    return []byte("<YOUR VERIFICATION KEY>"), nil
})
// ... error handling

// do something with decoded claims
for key, val := range claims {
    fmt.Printf("Key: %v, value: %v\n", key, val)
}

Answer 2

使用github.com/dgrijalva/jwt-go go liabary来实施。我们可以按照以下方式从api请求中提取JWT令牌信息。

从使用帖子请求发布JWT令牌时。您必须在路由部分中提取JWT信息。

  func RequireTokenAuthentication(inner http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            token, err := jwt.ParseFromRequest(
                r,
                func(token *jwt.Token) (interface{}, error) {
                    return VERIFICATION.PublicKey, nil
                })
            if err != nil || !token.Valid) {
                log.Debug("Authentication failed " + err.Error())
                w.WriteHeader(http.StatusForbidden)
                return
            } else {
                r.Header.Set("username", token.Claims["username"].(string))
                r.Header.Set("userid", strconv.FormatFloat((token.Claims["userid"]).(float64), 'f', 0, 64))
            }
            inner.ServeHTTP(w, r)
        })
    }

VERIFICATION.PublicKey：验证密钥（从系统中的public.key文件获取公钥）

任何问题都会发生。请让我知道。我可以帮你。

Answer 3

免责声明：我不隶属于图书馆。我只是一个用户，发现它有用并且想分享。

现在是2019年。我想建议一个alternate library，它可以使用JWS和/或JWE在JWT上做得很好。

以下是有关如何使用该库的一些示例：

import (
    "gopkg.in/square/go-jose.v2/jwt"
    "gopkg.in/square/go-jose.v2"
)
...

var claims map[string]interface{} // generic map to store parsed token

// decode JWT token without verifying the signature
token, _ := jwt.ParseSigned(tokenString)
_ = token.UnsafeClaimsWithoutVerification(&claims)

// decode JWT token and verify signature using JSON Web Keyset
token, _ := jwt.ParseSigned(tokenString)
jwks := &jose.JSONWebKeySet { // normally you can obtain this from an endpoint exposed by authorization server
            Keys: []jose.JSONWebKey { // just an example
                {
                    Key: publicKey, 
                    Algorithm: jose.RS256, // should be the same as in the JWT token header
                    KeyID: "kid", // should be the same as in the JWT token header
                },
            },
        }
_ = jwt.Claims(jwks, &claims)

请注意，claims可以是包含默认JWT字段以及令牌内的自定义字段的结构例如：

import (
    "github.com/mitchellh/mapstructure"
    "gopkg.in/square/go-jose.v2/jwt"
)
...
type CustomClaims struct {
    *jwt.Claims
    // additional claims apart from standard claims
    extra map[string]interface{}
}

func (cc *CustomClaims) UnmarshalJSON(b []byte) error {
    var rawClaims map[string]interface{}
    if err := json.Unmarshal(b, &rawClaims); err != nil {
        return nil
    }
    var claims jwt.Claims
    var decoderResult mapstructure.Metadata
    decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
        Result:   &claims,
        Metadata: &decoderResult,
        TagName:  "json",
    })
    if err != nil {
        return err
    }
    if err := decoder.Decode(rawClaims); err != nil {
        return err
    }
    cc.Claims = &claims
    cc.extra = make(map[string]interface{})
    for _, k := range decoderResult.Unused {
        cc.extra[k] = rawClaims[k]
    }
    return nil
}

我还构建了a command line tool，它使用library执行各种编码/解码活动。这对于使用该库也可能是有用的参考。

Answer 4

如果您想从jwt令牌中获得索赔，无需验证

import "github.com/dgrijalva/jwt-go"
...
    token, err := jwt.Parse(tokenStr, nil)
    if token == nil {
        return nil, err
    }
    claims, _ := token.Claims.(jwt.MapClaims)
    // claims are actually a map[string]interface{}

Answer 5

由于问题和答案都提到了 JWT 库 github.com/dgrijalva/jwt-go，请注意这个库现在已经很久没有维护了。

截至 2021 年 6 月，社区分叉 golang-jwt/jwt，由原作者 Dave Grijalva 正式 blessed。

这也意味着库导入路径发生了变化。请注意，当前的主要版本 v3 不在 Go 模块中，因此您仍会在 v3.x.x+incompatible 中看到 go.mod。

fork 使用原始库修复了 an important security issue。在修复之前，该库没有正确处理 JWT 声明中的多个 aud，使其实际上不符合 JWT 规范。

除此之外，主要 API 仍然相同。例如使用 HMAC 验证解析 JWT：

    tokenString := /* raw JWT string*/

    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, errors.New("unexpected signing method")
        }
        return []byte(/* your JWT secret*/), nil
    })
    if err != nil {
        // handle err
    }

    // validate the essential claims
    if !token.Valid {
        // handle invalid tokebn
    }

要使用自定义声明解析 JWT，您可以定义自己的结构类型并将 jwt.StandardClaims 嵌入其中：

    type MyClaims struct {
        jwt.StandardClaims
        MyField string `json:"my_field"`
    }

    tokenString := /* raw JWT string*/

    // pass your custom claims to the parser function
    token, err := jwt.ParseWithClaims(tokenString, &MyClaims{}, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, errors.New("unexpected signing method")
        }
        return []byte(/* your JWT secret*/), nil
    })

    // type-assert `Claims` into a variable of the appropriate type
    myClaims := token.Claims.(*MyClaims)

此库的有效替代方案是 lestrrat-go/jwx。 API 略有不同，但也非常易于使用：

    tokenString := /* raw JWT string*/

    // parse and verify signature
    tok, err := jwt.Parse(tokenString, jwt.WithVerify(jwa.HS256, []byte(/* your JWT secret */)))
    if err != nil {
        // handle err
    }

    // validate the essential claims
    if err := jwt.Validate(tok); err != nil {
        // handle err
    }

解码Golang中的JWT令牌

5 个答案: