golang+gin+jwt实现用户登录认证与 Token 鉴权

package main

import (
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt/v5"
	"golang.org/x/crypto/bcrypt"
)

// 定义一个结构体来表示用户
type User struct {
	ID       uint   `json:"id"`
	Username string `json:"username"`
	Password string `json:"-"` // 密码字段在返回给前端时应隐藏
}

// 模拟一个用户数据库
var users = []User{
	// 密码是 "password123"
	{ID: 1, Username: "admin", Password: "$2a$10$xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}, // 这里应该是一个真实的 bcrypt 哈希值
}

// 定义一个结构体来接收登录请求的 JSON 数据
type LoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

// JWT 的密钥，在生产环境中，这应该从环境变量或配置文件中读取，并且要保证其安全性
var jwtSecret = []byte("your-secret-key-keep-it-safe-and-long")

// generateToken 生成一个 JWT Token
func generateToken(userID uint, username string) (string, error) {
	// 设置 Token 的过期时间，例如 24 小时
	expirationTime := time.Now().Add(24 * time.Hour)

	// 创建一个新的 JWT claims，包含用户 ID 和用户名，并设置过期时间
	claims := &jwt.MapClaims{
		"sub":  userID,
		"name": username,
		"exp":  expirationTime.Unix(),
	}

	// 使用 HS256 算法和我们的密钥创建一个新的 Token
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	// 将 Token 签名并转换为字符串
	tokenString, err := token.SignedString(jwtSecret)
	if err != nil {
		return "", err
	}

	return tokenString, nil
}

// authMiddleware 是一个 Gin 中间件，用于验证 JWT Token
func authMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 从 HTTP Header 的 "Authorization" 字段获取 Token
		authHeader := c.GetHeader("Authorization")
		if authHeader == "" {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header is required"})
			c.Abort() // 终止请求链
			return
		}

		// 通常 Token 的格式是 "Bearer <token>"
		var tokenString string
		// 简单检查格式
		if len(authHeader) > 7 && authHeader[:7] == "Bearer " {
			tokenString = authHeader[7:]
		} else {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid authorization header format. Use Bearer <token>"})
			c.Abort()
			return
		}

		// 解析 Token
		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
			// 验证签名方法是否为我们预期的 HS256
			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
			}
			return jwtSecret, nil
		})

		if err != nil {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
			c.Abort()
			return
		}

		// 检查 Token 是否有效
		if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
			// 将用户信息存储在 Gin 的上下文 (Context) 中，以便后续的处理函数可以使用
			c.Set("userID", int(claims["sub"].(float64))) // JWT claims 中的数字默认是 float64
			c.Set("username", claims["name"].(string))
			c.Next() // 继续处理下一个中间件或路由处理函数
		} else {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token claims"})
			c.Abort()
			return
		}
	}
}

func main() {
	// 创建一个默认的 Gin 路由器
	r := gin.Default()

	// 公开的登录接口
	r.POST("/login", func(c *gin.Context) {
		var req LoginRequest
		// 绑定并验证请求体中的 JSON 数据
		if err := c.ShouldBindJSON(&req); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}

		// 在真实场景中，这里应该是查询数据库
		var foundUser *User
		for i := range users {
			if users[i].Username == req.Username {
				foundUser = &users[i]
				break
			}
		}

		// 检查用户是否存在以及密码是否正确
		if foundUser == nil {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid username or password"})
			return
		}

		// 使用 bcrypt 比较明文密码和数据库中存储的哈希值
		err := bcrypt.CompareHashAndPassword([]byte(foundUser.Password), []byte(req.Password))
		if err != nil {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid username or password"})
			return
		}

		// 登录成功，生成 Token
		token, err := generateToken(foundUser.ID, foundUser.Username)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate token"})
			return
		}

		// 返回 Token 给客户端
		c.JSON(http.StatusOK, gin.H{
			"message": "Login successful",
			"token":   token,
		})
	})

	// 需要认证的路由组
	authorized := r.Group("/")
	authorized.Use(authMiddleware()) // 应用我们的 JWT 中间件
	{
		// 用户个人资料接口，只有携带有效 Token 的请求才能访问
		authorized.GET("/profile", func(c *gin.Context) {
			// 从上下文中获取用户信息
			userID, _ := c.Get("userID")
			username, _ := c.Get("username")

			// 返回用户信息
			c.JSON(http.StatusOK, gin.H{
				"userID":   userID,
				"username": username,
			})
		})
	}

	// 启动服务器，默认在 8080 端口
	r.Run(":8080")
}

package main

import (
	"fmt"

	"golang.org/x/crypto/bcrypt"
)

func main() {
	password := []byte("password123") // 你想要加密的密码
	hashedPassword, err := bcrypt.GenerateFromPassword(password, bcrypt.DefaultCost)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(hashedPassword))
}