使用Cookie身份验证的Gorilla Golang Websocket优化

让我试着帮你找出哪里出了问题.首先，我稍微简化了您的示例，以便只关注相关部分.如果您需要省略的内容，请让我知道，我会更新答案.首先，让我从本地auth包中进行的JWT令牌生成/验证开始.

auth/auth.go file

package auth

import (
    "fmt"
    "strings"
    "time"

    "github.com/golang-jwt/jwt"
)

func ValidateToken(jwtToken string) (*jwt.MapClaims, error) {
    // parse the token
    token, err := jwt.Parse(strings.Replace(jwtToken, "Bearer ", "", 1), func(token *jwt.Token) (interface{}, error) {
        _, ok := token.Method.(*jwt.SigningMethodHMAC)
        if !ok {
            return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
        }
        return []byte("Abcd1234!!"), nil
    })
    // err while parsing the token
    if err != nil {
        return nil, err
    }
    // token valid
    var claims jwt.MapClaims
    var ok bool
    if claims, ok = token.Claims.(jwt.MapClaims); ok && token.Valid {
        return &claims, nil
    }
    return nil, fmt.Errorf("token not valid")
}

func GenerateToken(username, password string) (string, error) {
    // TODO: here you can add logic to check against a DB
    //...

    // create a new token by providing the cryptographic algorithm
    token := jwt.New(jwt.SigningMethodHS256)

    // set default/custom claims
    claims := token.Claims.(jwt.MapClaims)
    claims["exp"] = time.Now().Add(24 * time.Hour * 3).Unix()
    claims["username"] = username
    claims["password"] = password

    tokenString, err := token.SignedString([]byte("Abcd1234!!"))
    if err != nil {
        return "", err
    }
    return tokenString, nil
}

现在，让我们转到中间件部分.

middlewares/middlewares.go file

package middlewares

import (
    "net/http"

    "websocketauth/auth"

    "github.com/gin-gonic/gin"
)

func VerifyUser() gin.HandlerFunc {
    return func(c *gin.Context) {
        notAuth := []string{"/signin"}
        requestPath := c.Request.URL.Path
        for _, val := range notAuth {
            if val == requestPath {
                c.Next()
                return
            }
        }

        token, err := c.Cookie("chartJWT")
        if err != nil {
            c.Redirect(http.StatusPermanentRedirect, "/signin")
        }

        claims, err := auth.ValidateToken(token)
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        c.Set("jwt", *claims)
        c.Next()
    }
}

为了能够在上下文中上传一些东西，你应该使用c.Set(key, value)方法.现在，让我们来看看处理程序.

handlers/handlers.go file

package handlers

import (
    "fmt"
    "net/http"

    "websocketauth/auth"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt"
    "github.com/gorilla/websocket"
)

var Upgrader websocket.Upgrader

type LoginUserReq struct {
    Username string `json:"username" binding:"required"`
    Password string `json:"password" binding:"required"`
}

func LoginUser(c *gin.Context) {
    var input LoginUserReq
    if err := c.ShouldBind(&input); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // I don't know what you do within the handler.Service.LoginUser() method

    token, err := auth.GenerateToken(input.Username, input.Password)
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    c.SetCookie("chartJWT", token, 60*60*24, "/", "localhost", false, true)
    c.JSON(http.StatusOK, gin.H{"user": token})
}

func JoinRoom(c *gin.Context) {
    claims := c.MustGet("jwt").(jwt.MapClaims)
    fmt.Println("username", claims["username"])
    fmt.Println("password", claims["password"])
    ws, err := Upgrader.Upgrade(c.Writer, c.Request, nil)
    if err != nil {
        panic(err)
    }
    chartToken, err := c.Cookie("chartJWT")
    if err != nil {
        panic(err)
    }
    fmt.Println("chartToken", chartToken)
    _ = ws
}

缺少的部分，比如handler.Service.LoginUser()方法，由于我不知道它们是做什么的，所以被跳过了.要正确地从上下文中读取内容，您必须使用c.MustGet(key)方法.

main.go file

package main

import (
    "websocketauth/handlers"
    "websocketauth/middlewares"

    "github.com/gin-gonic/gin"
    "github.com/gorilla/websocket"
)

func main() {
    handlers.Upgrader = websocket.Upgrader{
        ReadBufferSize:  1024,
        WriteBufferSize: 1024,
    }
    gin.SetMode(gin.DebugMode)
    r := gin.Default()

    r.Use(middlewares.VerifyUser())
    r.GET("/join-room", handlers.JoinRoom)
    r.POST("/signin", handlers.LoginUser)

    r.Run(":8000")
}

This is the set up logic. Nothing worth mentioning here.
Let me know if you still need other help, thanks!