Golang轻量级JWT生成与验证指南

JWT(JSON Web Token)是一种流行的跨域认证解决方案，下面我将介绍如何在Go中使用轻量级的jwt库进行JWT的生成与验证。

推荐库

在Go生态中，最常用的JWT库是github.com/golang-jwt/jwt(原github.com/dgrijalva/jwt-go)，它是一个轻量级且功能完整的实现。

go get github.com/golang-jwt/jwt/v5

基本使用示例

1. 生成JWT Token

package main

import (
	"fmt"
	"time"
	
	"github.com/golang-jwt/jwt/v5"
)

// 自定义Claims结构体
type CustomClaims struct {
	UserID   int    `json:"user_id"`
	Username string `json:"username"`
	jwt.RegisteredClaims
}

func GenerateJWT(userID int, username string, secretKey string) (string, error) {
	// 创建Claims
	claims := CustomClaims{
		UserID:   userID,
		Username: username,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)), // 过期时间
			IssuedAt:  jwt.NewNumericDate(time.Now()),                    // 签发时间
			NotBefore: jwt.NewNumericDate(time.Now()),                    // 生效时间
			Issuer:    "myapp",                                           // 签发者
			Subject:   "user-auth",                                       // 主题
		},
	}

	// 创建Token
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	// 使用密钥签名
	signedToken, err := token.SignedString([]byte(secretKey))
	if err != nil {
		return "", fmt.Errorf("生成JWT失败: %v", err)
	}

	return signedToken, nil
}

func main() {
	secretKey := "your-256-bit-secret"
	token, err := GenerateJWT(123, "john_doe", secretKey)
	if err != nil {
		fmt.Println("生成Token失败:", err)
		return
	}
	
	fmt.Println("生成的JWT Token:", token)
}

2. 验证JWT Token

func ParseJWT(tokenString string, secretKey string) (*CustomClaims, error) {
	// 解析Token
	token, err := jwt.ParseWithClaims(tokenString, &CustomClaims{}, func(token *jwt.Token) (interface{}, error) {
		// 验证签名方法
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("意外的签名方法: %v", token.Header["alg"])
		}
		return []byte(secretKey), nil
	})

	if err != nil {
		return nil, fmt.Errorf("解析JWT失败: %v", err)
	}

	// 验证Claims
	if claims, ok := token.Claims.(*CustomClaims); ok && token.Valid {
		return claims, nil
	}

	return nil, fmt.Errorf("无效的JWT Token")
}

func main() {
	// 假设这是从客户端收到的Token
	tokenString := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoxMjMsInVzZXJuYW1lIjoiam9obl9kb2UiLCJleHAiOjE2ODA5MzQwMDAsImlzcyI6Im15YXBwIiwic3ViIjoidXNlci1hdXRoIn0.abcdef1234567890" // 示例Token，实际使用时替换
	
	secretKey := "your-256-bit-secret"
	claims, err := ParseJWT(tokenString, secretKey)
	if err != nil {
		fmt.Println("验证Token失败:", err)
		return
	}
	
	fmt.Printf("验证成功! 用户ID: %d, 用户名: %s\n", claims.UserID, claims.Username)
}

高级用法

1. 使用RS256非对称加密

// 生成RSA密钥对
// openssl genrsa -out private.pem 2048
// openssl rsa -in private.pem -pubout -out public.pem

func GenerateRSAJWT(userID int, username string, privateKeyPath string) (string, error) {
	privateKeyBytes, err := os.ReadFile(privateKeyPath)
	if err != nil {
		return "", err
	}

	privateKey, err := jwt.ParseRSAPrivateKeyFromPEM(privateKeyBytes)
	if err != nil {
		return "", err
	}

	claims := CustomClaims{
		UserID:   userID,
		Username: username,
		RegisteredClaims: jwt.RegisteredClaims{
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
		},
	}

	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
	return token.SignedString(privateKey)
}

func VerifyRSAJWT(tokenString string, publicKeyPath string) (*CustomClaims, error) {
	publicKeyBytes, err := os.ReadFile(publicKeyPath)
	if err != nil {
		return nil, err
	}

	publicKey, err := jwt.ParseRSAPublicKeyFromPEM(publicKeyBytes)
	if err != nil {
		return nil, err
	}

	token, err := jwt.ParseWithClaims(tokenString, &CustomClaims{}, func(token *jwt.Token) (interface{}, error) {
		if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
			return nil, fmt.Errorf("意外的签名方法: %v", token.Header["alg"])
		}
		return publicKey, nil
	})

	if err != nil {
		return nil, err
	}

	if claims, ok := token.Claims.(*CustomClaims); ok && token.Valid {
		return claims, nil
	}

	return nil, fmt.Errorf("无效的JWT Token")
}

2. 刷新Token

func RefreshJWT(tokenString string, secretKey string) (string, error) {
	claims, err := ParseJWT(tokenString, secretKey)
	if err != nil {
		return "", err
	}

	// 检查Token是否即将过期(例如在30分钟内过期)
	if time.Until(claims.ExpiresAt.Time) > 30*time.Minute {
		return "", fmt.Errorf("token尚未接近过期")
	}

	// 更新过期时间
	claims.ExpiresAt = jwt.NewNumericDate(time.Now().Add(24 * time.Hour))
	
	newToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	return newToken.SignedString([]byte(secretKey))
}

最佳实践

1. 密钥管理：不要将密钥硬编码在代码中，使用环境变量或配置管理系统
2. 过期时间：设置合理的过期时间(通常几小时到几天)
3. 敏感数据：不要在JWT中存储敏感信息，因为JWT可以被解码
4. HTTPS：始终通过HTTPS传输JWT
5. 存储方式：客户端通常将JWT存储在localStorage或cookie中

这个轻量级的JWT实现可以满足大多数应用场景的需求，既保证了安全性又保持了简单性。