Golang 中实现基于 JWT 的身份验证

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIxIiwiZXhwIjoxNTQ3OTc0MDgyfQ.2Ye5_w1z3zpD4dSGdRp3s98ZipCNQqmsHRB9vioOx54

package main

import (
    "log"
    "net/http"
)

func main() {
    // we will implement these handlers in the next sections
    http.HandleFunc("/signin", Signin)
    http.HandleFunc("/welcome", Welcome)
    http.HandleFunc("/refresh", Refresh)
    http.HandleFunc("/logout", Logout)

    // start the server on port 8000
    log.Fatal(http.ListenAndServe(":8000", nil))
}

import (
    //...
    // import the jwt-go library
    "github.com/golang-jwt/jwt/v5"
    //...
)

// Create the JWT key used to create the signature
var jwtKey = []byte("my_secret_key")

// 为简化起见，我们在代码中将用户信息存储为内存map
var users = map[string]string{
    "user1": "password1",
    "user2": "password2",
}

// 创建一个结构体，从请求正文中读取用户名和密码
type Credentials struct {
    Password string `json:"password"`
    Username string `json:"username"`
}

//创建一个将编码为 JWT 的结构。
// 我们添加 jwt.RegisteredClaims 作为嵌入式类型，以提供到期时间等字段
type Claims struct {
    Username string `json:"username"`
    jwt.RegisteredClaims
}

// Create the Signin handler
func Signin(w http.ResponseWriter, r *http.Request) {
    var creds Credentials
    // Get the JSON body and decode into credentials
    err := json.NewDecoder(r.Body).Decode(&creds)
    if err != nil {
        // If the structure of the body is wrong, return an HTTP error
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    //从内存映射中获取预期密码
    expectedPassword, ok := users[creds.Username]

    // If a password exists for the given user
    // AND, if it is the same as the password we received, the we can move ahead
    // if NOT, then we return an "Unauthorized" status
    if !ok || expectedPassword != creds.Password {
        w.WriteHeader(http.StatusUnauthorized)
        return
    }

    //声明令牌的失效时间
    // 在这里，我们将其保留为 5 分钟
    expirationTime := time.Now().Add(5 * time.Minute)
    // 创建 JWT 声明，其中包括用户名和过期时间
    claims := &Claims{
        Username: creds.Username,
        RegisteredClaims: jwt.RegisteredClaims{
            // In JWT, the expiry time is expressed as unix milliseconds
            ExpiresAt: jwt.NewNumericDate(expirationTime),
        },
    }

    // 声明令牌和用于签名的算法，以及权利要求
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    // Create the JWT string
    tokenString, err := token.SignedString(jwtKey)
    if err != nil {
        // If there is an error in creating the JWT return an internal server error
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    // 最后，我们将 "token "的客户端 cookie 设置为刚刚生成的 JWT
    // 我们还设置了与令牌本身相同的到期时间
    http.SetCookie(w, &http.Cookie{
        Name:    "token",
        Value:   tokenString,
        Expires: expirationTime,
    })
}

func Welcome(w http.ResponseWriter, r *http.Request) {
    //我们可以从请求 Cookie 中获取会话标记，每次请求都会附带 Cookie
    c, err := r.Cookie("token")
    if err != nil {
        if err == http.ErrNoCookie {
            // If the cookie is not set, return an unauthorized status
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
        // For any other type of error, return a bad request status
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    // Get the JWT string from the cookie
    tknStr := c.Value

    // Initialize a new instance of `Claims`
    claims := &Claims{}

   // 解析 JWT 字符串并将结果存储在`claims`.
   //注意，我们在此方法中也传递了密钥。如果令牌无效（根据我们在登录时设置的有效期过期），
    //或者签名不匹配，本方法将返回错误信息
    tkn, err := jwt.ParseWithClaims(tknStr, claims, func(token *jwt.Token) (any, error) {
        return jwtKey, nil
    })
    if err != nil {
        if err == jwt.ErrSignatureInvalid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    if !tkn.Valid {
        w.WriteHeader(http.StatusUnauthorized)
        return
    }
    // 最后，向用户返回欢迎信息，以及用户在令牌中给出的
    // 用户名。
    w.Write([]byte(fmt.Sprintf("Welcome %s!", claims.Username)))
}

func Refresh(w http.ResponseWriter, r *http.Request) {
    // (BEGIN) 在此之前的代码与 "Welcome "路由的第一部分相同
    c, err := r.Cookie("token")
    if err != nil {
        if err == http.ErrNoCookie {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    tknStr := c.Value
    claims := &Claims{}
    tkn, err := jwt.ParseWithClaims(tknStr, claims, func(token *jwt.Token) (any, error) {
        return jwtKey, nil
    })
    if err != nil {
        if err == jwt.ErrSignatureInvalid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    if !tkn.Valid {
        w.WriteHeader(http.StatusUnauthorized)
        return
    }
    // (END) The code until this point is the same as the first part of the `Welcome` route

   // 我们确保在足够长的时间过去后才会签发新令牌
   //在这种情况下，只有当旧令牌在 30 秒内到期时，才会签发新令牌。否则，将返回不良请求状态
    if time.Until(claims.ExpiresAt.Time) > 30*time.Second {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

   // 现在，为当前使用创建一个新的令牌，并延长有效期
    expirationTime := time.Now().Add(5 * time.Minute)
    claims.ExpiresAt = jwt.NewNumericDate(expirationTime)
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenString, err := token.SignedString(jwtKey)
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

   // 将新标记设置为用户的 "token "cookie
    http.SetCookie(w, &http.Cookie{
        Name:    "token",
        Value:   tokenString,
        Expires: expirationTime,
    })
}

func Logout(w http.ResponseWriter, r *http.Request) {
    // immediately clear the token cookie
    http.SetCookie(w, &http.Cookie{
        Name:    "token",
        Expires: time.Now(),
    })
}

go build
./jwt-go-example

POST http://localhost:8000/signin

{"username":"user1","password":"password1"}

GET http://localhost:8000/welcome
结果：
Welcome user1!