主页 / 问题 / 1539054
Accepted
Willy Durt
Asked:2023-09-04 20:34:07 +0800 CST2023-09-04 20:34:07 +0800 CST

无法从令牌解析角色

  • 772

当用户注册时，他被赋予一个角色，随后可能会有更多角色，即逻辑是一个用户可以拥有多个角色。当您进入站点时，后端会向数据库发出请求，在数据库中提取所有角色以及用户 ID，然后生成令牌并将其发送给客户端。该令牌随后用于获取对 REST API 端点的访问权限。编写了一个函数，其中我对令牌进行反序列化并删除角色，然后在句柄中简单地检查这些角色是否有权访问句柄。下面是生成token的代码：

token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
            "user_id": existingUserID, // получаем запросом к бд
            "roles":   roles, // получаем запросом к бд
        })
        log.Printf("user_id: %v\n", existingUserID)
        log.Printf("roles: %v\n", roles)
        tokenString, err := token.SignedString([]byte(os.Getenv("SECRET_KEY")))
        if err != nil {
            c.JSON(500, gin.H{"message": "Failed to generate token", "error": err})
            return
        }

下面是我如何对令牌进行 Desariize 并尝试从中提取角色的代码：

package auth

import (
    "errors"
    "log"
    "os"

    "github.com/dgrijalva/jwt-go"
)

func CheckUserRole(tokenString string) ([]string, error) {

    log.Printf("Received token: %s", tokenString)

    token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
        return []byte(os.Getenv("SECRET_KEY")), nil
    })
    if err != nil || !token.Valid {
        log.Printf("Error parsing token: %v", err)
        return nil, errors.New("Invalid token")
    }

    claims, ok := token.Claims.(jwt.MapClaims)
    if !ok {
        log.Printf("Error getting claims from token")
        return nil, errors.New("Invalid token claims")
    }

    roles, ok := claims["roles"].([]string)
    if !ok {
        log.Printf("Roles not found in token")
        return nil, errors.New("Roles not found in token")
    }

    log.Printf("User roles: %v", roles)

    return roles, nil
}

一般来说，问题是在令牌中找不到角色：Roles not find in token。不知道为什么，我已经做了一百万次调试结论，所有的角色都定义正确了。以下是声明的输出： Claims: map[roles:[22 18] user_id:9] 最有可能的是我试图将它们错误地添加到角色中，但一切似乎都是正确的

golang

1 个回答

  1. Best Answer

    您的代码的问题在于claims["roles"]它是 type 的对象[]any，并且无法转换为 type []string。我们需要提取每个元素并将其转换为 type string。

    这是一个例子：

    package main

import (
    "fmt"
    "log"

    jwt "github.com/dgrijalva/jwt-go"
)

func main() {
    token_src := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user_id": "9",                 // получаем запросом к бд
        "roles":   []string{"8", "22"}, // получаем запросом к бд
    })
    tokenString, err := token_src.SignedString([]byte("secret"))
    if err != nil {
        panic(err)
    }

    token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
        return []byte("secret"), nil
    })
    if err != nil || !token.Valid {
        log.Printf("Error parsing token: %v", err)
        panic("Invalid token")
    }

    claims, ok := token.Claims.(jwt.MapClaims)
    if !ok {
        log.Printf("Error getting claims from token")
        panic("Invalid token claims")
    }

    claims_roles, ok := claims["roles"]
    log.Printf("Roles: %#v, type %T", claims_roles, claims_roles)
    if !ok {
        panic("no roles object")
    }
    _, ok = claims_roles.([]interface{})
    if !ok {
        panic(fmt.Errorf("unexpected roles object: expected []interface{}, got %T", claims_roles))
    }
    roles := []string{}
    for _, r := range claims_roles.([]interface{}) {
        role, ok := r.(string)
        if !ok {
            panic(fmt.Errorf("unexpected role object %#v: expected string, got %t", r, r))
        }
        roles = append(roles, role)
    }
    log.Printf("User roles: %v", roles)

}

    但事实上，它jwt支持类型化对象Claims- 解析器将为您带来所有类型并将它们放在正确的位置

    type RoleClaims struct {
    UserId uint   `json:"user_id"`
    Roles  []uint `json:"roles"`
}

func (rc RoleClaims) Valid() error {
    return nil
}

func main() {
    token_src := jwt.NewWithClaims(jwt.SigningMethodHS256,
        RoleClaims{
            UserId: 9,
            Roles:  []uint{8, 22},
        },
    )
    tokenString, err := token_src.SignedString([]byte("secret"))
    if err != nil {
        panic(err)
    }

    var token_claims RoleClaims
    token, err := jwt.ParseWithClaims(tokenString, &token_claims, func(t *jwt.Token) (interface{}, error) {
        return []byte("secret"), nil
    })
    if err != nil || !token.Valid {
        log.Printf("Error parsing token: %v", err)
        panic("Invalid token")
    }
    log.Printf("Claims: %#v", token_claims)

    log.Printf("User roles: %v", token_claims.Roles)
}

    该函数将从令牌中jwt.ParseWithClaims提取并将它们解析为类型的对象，并将结果保存在. 而且您不需要转换、解析单个元素。一切都会自动完成。claimsRoleClaimstoken_claims

    • 0

相关问题