Gin框架JWT刷新方案

在Gin框架中实现JWT刷新方案时遇到了几个问题：

  1. 如何设置合理的access token和refresh token过期时间？两者之间的时间差有没有最佳实践？

  2. 刷新token时是直接给新token，还是需要用户重新登录？哪种方案更安全？

  3. 在refresh token过期或被盗的情况下，应该如何防止恶意刷新？是否需要记录刷新历史？

  4. 有没有推荐的Gin中间件来实现JWT刷新流程？自己写的中间件总是出现各种边界问题。

  5. 在分布式系统中，如何保证多个服务都能验证refresh token的有效性？需要额外存储token状态吗？

目前项目中的实现感觉不太安全，希望能得到一些成熟的解决方案建议。


3 回复

Gin框架中实现JWT刷新方案通常涉及以下步骤：

  1. 生成初始Token和Refresh Token：用户登录时，生成一个短期的有效Token（如15分钟）和一个长期的Refresh Token（如7天）。将这两个Token分别返回给客户端。

  2. 存储Refresh Token：将Refresh Token安全地存储在服务器端，可以是数据库或Redis。确保它与用户的会话绑定，避免被滥用。

  3. Token验证：每次请求时，先验证有效的Token。如果Token过期但Refresh Token有效，则生成新的Token并返回给客户端。

  4. 刷新逻辑：

    • 客户端携带过期的Token和Refresh Token发起请求。
    • 服务器验证Refresh Token是否合法且未被撤销。
    • 如果合法，生成新的Token并返回，同时更新Refresh Token的过期时间。

  5. 安全性注意事项：

    • 使用HTTPS防止Token在传输过程中被窃取。
    • Refresh Token应具备短期有效期，并定期轮换。
    • 检测异常行为，如多个设备同时使用同一账户。

通过这种方式，既保证了Token的安全性，又提升了用户体验，避免频繁重新登录的问题。


使用Gin框架实现JWT刷新机制时，可以设计如下：

  1. 初次登录：用户登录后生成JWT（含userId、过期时间exp等），同时生成一个短期的刷新Token（如UUID），存储在服务器端（如Redis，关联userId和过期时间）。

  2. JWT验证：在Gin中间件中验证JWT，若过期且有刷新Token，则验证刷新Token：

    • 检查Redis中的刷新Token是否有效。
    • 若有效，生成新的JWT和刷新Token，更新Redis，返回新Token给客户端。

  3. 刷新Token安全性：确保刷新Token仅能通过安全的HTTPS请求访问，并设置较短的有效期（如30分钟）。刷新Token需与设备绑定（如存用户Agent或IP），防止跨设备滥用。

  4. 异常处理：若刷新Token无效或丢失，强制用户重新登录。避免Token泄露，定期更换刷新Token。

  5. 代码示例：

func JWTMiddleware(c *gin.Context) {
    token := c.GetHeader("Authorization")
    if !validateJWT(token) && c.GetHeader("RefreshToken") != "" {
        newToken, err := refreshJWT(c.GetHeader("RefreshToken"))
        if err == nil {
            c.Header("New-Token", newToken)
            return
        }
    }
    c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
}

通过这种方式，既保障了安全性，又提升了用户体验。

在Gin框架中实现JWT刷新方案，可以通过以下步骤完成：

  1. 基本配置：
// 定义密钥
var jwtKey = []byte("your_secret_key")

// 声明Claims结构体
type Claims struct {
    UserID uint `json:"user_id"`
    jwt.StandardClaims
}
  1. 生成双Token方案（access_token + refresh_token）：
func GenerateTokens(userID uint) (string, string, error) {
    // access_token 有效期短(如30分钟)
    accessClaims := &Claims{
        UserID: userID,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: time.Now().Add(30 * time.Minute).Unix(),
        },
    }
    accessToken := jwt.NewWithClaims(jwt.SigningMethodHS256, accessClaims)
    
    // refresh_token 有效期长(如7天)
    refreshClaims := &Claims{
        UserID: userID,
        StandardClaims: jwt.StandardClaims{
            ExpiresAt: time.Now().Add(168 * time.Hour).Unix(),
        },
    }
    refreshToken := jwt.NewWithClaims(jwt.SigningMethodHS256, refreshClaims)
    
    // 生成签名令牌
    aToken, err := accessToken.SignedString(jwtKey)
    rToken, err := refreshToken.SignedString(jwtKey)
    
    return aToken, rToken, err
}
  1. 刷新Token接口：
func Refresh(c *gin.Context) {
    // 从请求中获取refresh_token
    refreshToken := c.GetHeader("Authorization")
    
    // 验证refresh_token
    claims := &Claims{}
    token, err := jwt.ParseWithClaims(refreshToken, claims, func(token *jwt.Token) (interface{}, error) {
        return jwtKey, nil
    })
    
    if err != nil || !token.Valid {
        c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid refresh token"})
        return
    }
    
    // 生成新的access_token
    newAccessToken, newRefreshToken, err := GenerateTokens(claims.UserID)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate tokens"})
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "access_token":  newAccessToken,
        "refresh_token": newRefreshToken,
    })
}
  1. 中间件验证：
func JWTAuth() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token == "" {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Token required"})
            return
        }
        
        claims := &Claims{}
        _, err := jwt.ParseWithClaims(token, claims, func(token *jwt.Token) (interface{}, error) {
            return jwtKey, nil
        })
        
        if err != nil {
            if err == jwt.ErrSignatureInvalid {
                c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
                return
            }
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Token expired"})
            return
        }
        
        c.Set("user_id", claims.UserID)
        c.Next()
    }
}

关键点：

  1. 使用双Token机制，refresh_token比access_token有效期更长
  2. refresh_token只能用于获取新的token，不能用于业务请求
  3. 每次刷新生成新的双Token，可以设置refresh_token单次使用
  4. 需要考虑安全存储refresh_token（推荐用HttpOnly Cookie）

这种方案既保证了安全性，又提供了良好的用户体验。

回到顶部