用go实现JWT

已于 2024-08-05 21:45:00 修改
阅读量1.1k 收藏 16
点赞数 21
文章标签： golang java 前端
于 2024-08-05 11:24:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75639894/article/details/140922218
版权

JWT

ISON Web Token，通过数字签名的方式，以JSON 对象为载体，在不同的服务终端之间安 全的传输信息。

JWT 最常见的场景就是授权认证，一旦用户登录，后续每个请求都将包含JWT，系统在每次处理用户请求的之前，都要先进行JWT安全校验，通过之后再进行处理

三部分组成：

  • Header

     {
 'type':'jwt', -- token 的类型
 'alg':"HS256" -- 加密方式
 }

  • Payload（载荷）

     {
 "sub":'1234567890',
 "name":'john',
 "admin":true
 }

  • Signature

     var encodedstring = base64Ur1Encode(header)+"."+base64Ur1Encode(payload)
 ​
 var signature = HMACSHA256(encodedstring，'secret')

具体后端代码实现：

         

C:.
│  go.mod
│  go.sum
│  main.go
│
├─.idea
│      .gitignore
│      modules.xml
│      test.iml
│      workspace.xml
│
└─app
        auth.go
        handler.go
        jwt.go
        jwtBucket.go
        middleware.go
        Rdb.go
        removeJWT.go
        start.go

  • Start.go
    func Start() {
	r := gin.Default()

	r.POST("/login", LoginHandler)

	auth := r.Group("/auth")
	auth.Use(AuthMiddleware())
	auth.Use(RateLimiterMiddleware())
	auth.Use(JWTAuthMiddleware())

	{
		auth.GET("/protected", ProtectedHandler)
	}

	err := r.Run(":8080")
	if err != nil {
		panic("启动失败")
		return
	}
}
    middleware.go
    
var tokenBucket = NewTokenBucket(10, 1*time.Second) // 10 tokens, refill every second

func RateLimiterMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		if !tokenBucket.Take() {
			c.JSON(http.StatusTooManyRequests, gin.H{"error": "rate limit exceeded"})
			c.Abort()
			return
		}
		c.Next()
	}
}

func JWTAuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		authHeader := c.GetHeader("Authorization")
		if authHeader == "" {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header is missing"})
			// 停止当前中间件链的执行，并阻止后续的中间件和处理函数的执行
			c.Abort()
			return
		}
		// 去掉Bearer前缀，获取完整的token字符串
		tokenString := strings.TrimPrefix(authHeader, "Bearer ")
		token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
			return secretKey, nil
		})
		// 判断err以及令牌是否有效
		if err != nil || !token.Valid {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
			c.Abort()
			return
		}
		//检查令牌是否在 Redis 中存在
		_, err = rdb.Get(context.Background(), tokenString).Result()
		if errors.Is(err, redis.Nil) {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "invalid token"})
			c.Abort()
			return
		} else if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"error": "server error"})
			c.Abort()
			return
		}


		if claims, ok := token.Claims.(*Claims); ok {
			c.Set("username", claims.Username)
		} else {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token claims"})
			c.Abort()
			return
		}

		c.Next()
	}
}

func AuthMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		token, err := c.Cookie("token")
		if err != nil {
			c.JSON(http.StatusUnauthorized, gin.H{"error": "no token provided"})
			c.Abort()
			return
		}

		fmt.Println(token)
		//将令牌添加到请求头中
		c.Request.Header.Set("Authorization", "Bearer "+token)
		c.Next()
	}
}
    jwtBucket.go
    type TokenBucket struct {
	capacity     int           // 令牌桶的容量，即桶中可以持有的最大令牌数
	tokens       int           // 桶中当前的令牌数
	fillInterval time.Duration // 令牌填充的间隔时间
	mu           sync.Mutex    // 互斥锁,防止并发访问时的数据竞争
	lastFill     time.Time     // 上次填充令牌的时间
}

func NewTokenBucket(capacity int, fillInterval time.Duration) *TokenBucket {
	return &TokenBucket{
		capacity:     capacity,
		tokens:       capacity,
		fillInterval: fillInterval,
		lastFill:     time.Now(),
	}
}

func (tb *TokenBucket) Take() bool {
	tb.mu.Lock()
	defer func() {
		tb.mu.Unlock()
	}()

	now := time.Now()
	// 当前时间和上一次填充的时间差
	elapsed := now.Sub(tb.lastFill)

	if elapsed >= tb.fillInterval {
		// 计算可以填充的令牌数
		fillTokens := int(elapsed / tb.fillInterval)
		// 更新桶中令牌数
		tb.tokens += fillTokens
		// 如果桶中令牌数大于容量，则将令牌数设置为容量
		if tb.tokens > tb.capacity {
			tb.tokens = tb.capacity
		}
		// 更新上次填充的时间
		tb.lastFill = now
	}
	// 检查是否还有令牌可以取
	if tb.tokens > 0 {
		tb.tokens--
		return true
	}
	return false
}
    auth.go
    var secretKey = []byte("mySecretKey")

type LoginRequest struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type Claims struct {
	Username string `json:"username"`
	jwt.RegisteredClaims
}

func generateToken(username string) (string, error) {
	claims := &Claims{
		Username: username,
		RegisteredClaims: jwt.RegisteredClaims{
			Issuer:    "Flipped1001",                                      // 发行者
			Subject:   "test",                                             // 主题"
			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)), // 设置过期时间
			NotBefore: jwt.NewNumericDate(time.Now()),                     // 设置token生效开始时间
			IssuedAt:  jwt.NewNumericDate(time.Now()),                     // 设置发行时间
		},
	}
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	tokenString,err := token.SignedString(secretKey) // 把密钥写进去
	if err != nil {
		return "", err
	} // 把密钥写进去

	// 存储令牌到 Redis
	err = rdb.Set(context.Background(), tokenString, username, 3600*time.Second).Err()
	if err != nil {
		return "", err
	}

	return tokenString, nil
}

func LoginHandler(c *gin.Context) {
	var req LoginRequest
	// ShouldBindJSON直接将json数据解析到req
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(400, gin.H{"error": "Invalid request"})
		return
	}

	// 模拟用户认证
	if req.Username == "Flipped" && req.Password == "021001" {
		token, err := generateToken(req.Username)
		if err != nil {
			c.JSON(500, gin.H{"error": "Failed to generate token"})
			return
		}
		c.SetCookie("token", token, 3600, "/", "localhost", false, true)
		c.JSON(http.StatusOK, gin.H{"message": "login successful"})
		return
	} else {
		c.JSON(401, gin.H{"error": "Unauthorized"})
	}
}
    handler.go
    func ProtectedHandler(c *gin.Context) {
	username, _ := c.Get("username")
	c.JSON(200, gin.H{"message": "Hello " + username.(string)})
}
    Rdb.go
    var (
	rdb *redis.Client
)

func init() {
	rdb = redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
	})
}
    removeJWT.go
    func RevokeToken(c *gin.Context) {
	tokenString, err := c.Cookie("token")
	if err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "no token provided"})
		return
	}

	// 从 Redis 中删除令牌
	err = rdb.Del(context.Background(), tokenString).Err()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "server error"})
		return
	}

	// 删除 cookie
	c.SetCookie("token", "", -1, "/", "localhost", false, true)
	c.JSON(http.StatusOK, gin.H{"message": "token revoked"})
}
Flipped100112
关注
  • 21
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go实现jwt
滢光点点
04-20 6297
版权声明：本文为博主原创文章，博客地址： https://blog.csdn.net/zxy_666/article/details/80021331，未经博主允许不得转载。 基础知识前瞻 前言： 因为http协议是一种无状态协议，这就涉及用户访问系统的状态保持问题。 在登录系统的设计中，当用户访问系统时，服务器需要认证用户登录相关的信息，以决定用户能否登录到系...
go使用JWT
22333
05-01 793
JWT 包： “github.com/dgrijalva/jwt-go” 声明结构体： type MyStandardClaims struct { Username string `json:"username"` jwt.StandardClaims } 添加属性：jwt.StandardClaims 设置密钥： myKey := []byte(“qwertyuiop”) 创建结构体： ms := MyStandardClaims{ Username: "hzyy", S
go的jwt生成
小人物也有大梦想
07-03 469
在GOPATH目录下执行 go get -u github.com/dgrijalva/jwt-go下载工具包 package main import ( "encoding/json" "errors" "fmt" "github.com/dgrijalva/jwt-go" "time" ) //定义结构体（继承jwt.StandardClaims 结构体） type MyClaims struct { Username string `json:"username"` Role str
Go JWT 全面指南
最新发布
cmy_top的博客
03-07 1846
本文首先对 JWT 进行了概述，随后深入讲解了在 Go 语言下使用 JWT 的全过程。内容包括安装 Go 的 JWT 模块、创建 JWT 对象、生成 JWT 字符串以及解析 JWT 字符串的详细指南。
golang之JWT实现
无风的雨
05-30 2131
什么是JSON Web Token？ JSON Web Token（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间以JSON方式安全地传输信息。由于此信息是经过数字签名的，因此可以被验证和信任。可以使用秘密（使用HMAC算法）或使用RSA或ECDSA的公钥/私钥对对JWT进行签名。 直白的讲jwt就是一种用户认证（区别于session、cookie）的解决方案。 出现的背景 众所周知，在jwt出现之前，我们已经有session、cookie来解决用户登录等认证问题
Go中使用JWT
寻找到底哪里有蓝天
04-20 191
原文链接：https://blog.csdn.net/m0_58121644/article/details/129643351 JWT (JSON Web Tokens) 是一种基于 JSON 格式的轻量级身份验证和授权方案。在 Go 项目中使用 JWT，一般需要完成以下步骤： 1. 安装 JWT 库 在 Go 项目中使用 JWT 需要先安装 JWT 库，可以使用以下命令安装： go ge...
Go语言使用JWT
weixin_46272577的博客
06-07 1023
Go语言使用JWT
[golang] 实现 jwt 方式登录
咸鱼老罗的博客
02-13 994
JSON Web Token（缩写 JWT）是目前流行的跨域认证解决方案，原理是生存的凭证包含标题 header，有效负载 payload 和签名组成。用户信息payload中，后端接收时只验证凭证是否有效，有效就使用凭证中的用户信息。签名是通过标题 header，有效负载 payload 和密钥（后端保存，不可泄露）生成。JWT 介绍：https://www.ruanyifeng.com/blog/2018/07/json_web_token-tutorial.html。
go 实现 jwt 签名和验证
____
03-16 1397
变化 上古时代的开发方式，都是通过COOKIE来认证。现在是使用JWT header 来认证。 golang中很方便自带的签发jwt的token。最新使用的库是 go get -u github.com/golang-jwt/jwt/v4 注意 很多老人都在使用github.com/dgrijalva/jwt-go，而这个实际上已经不维护和更新了。 现在都转交给官方去维护了，官方说明 https://github.com/golang-jwt/jwt/blob/main/MIGRATION_GUIDE.m
实战——golang实现JWT验证登录
qq_42215697的博客
09-18 1097
g
jwt:Go的快速，简单的JWT实现
05-07
智威汤逊 用编写的快速简单的实现。 该软件包在设计时考虑了安全性，性能和简便性，它保护令牌免受。 请为这个开源项目加注以吸引更多的开发人员，以便我们共同改善它！ 安装 唯一的要求是。 $ go get github.com/kataras/jwt 导入为import "github.com/kataras/jwt"并将其用作jwt.XXX 。 目录 验证令牌 解码自定义声明 JSON必需标签标准索偿验证器 阻止令牌 令牌对 JSON Web算法 选择正确的算法 使用您自己的算法 产生金钥 加载和解析键 加密 基准测试 例子 基本的 自定义标题 HTTP中间件 黑名单 JSON必需标签 自定义验证 进阶：Iris中间件 高级：Redis阻止列表 参考 执照 入门 使用Sign方法签名并生成令牌，以紧凑形式返回令牌。 （可选）设置到期时间，如果有效负载中缺少"exp" ，请使用jwt
Go-jwthelper是一个Golang包提供了JWT(JSONWebToken)功能基于jwt-go.
08-14
jwthelper是一个Golang包提供了JWT(JSON Web Token)功能基于jwt-go.
golang之JWT实现的示例代码
09-16
本文将详细介绍如何使用Golang实现JWT，并通过具体的示例代码帮助读者更好地理解和掌握JWT的工作原理。 #### 二、JWT 概念详解 **1. JSON Web Token (JWT) 定义** JWT是一种开放标准(RFC7519)，它提供了一种紧凑且...
在 Go 项目中使用 JWT
weixin_52906070的博客
09-06 307
它接受用户的 ID 和用户名作为参数，并返回一个签名的 JWT 字符串。需要注意的是，在实际应用中，需要更加严格地设置 JWT 的有效期、密钥等参数，以确保安全性。在实际应用中，应该使用更安全的方法来存储密钥，而不是硬编码在代码中。结构体：这是 JWT 中的声明，包括用户的 ID、用户名以及标准的 JWT 声明（如过期时间和签发者）。函数：这个函数用于验证 JWT。它接受一个 JWT 字符串作为参数，并返回 JWT 的声明（在 Go 项目中，可以使用 JWT 库的。函数来验证 JWT 的签名，并返回声明。
go代码实现jwt
qianzongCui的博客
12-29 1711
go代码实现jwt
go jwt使用
Bug制造者
07-28 761
go jwt加密解密
go 进阶 三方库之 jwt-go
qq_29799655的博客
05-11 1346
根据JWT Token中是否存在Signature签名又将JWT分为两类: 不使用Signature签名的JWT称为nonsecure JWT未经过签名,不安全的JWT,其header部分也没有指定签名算法, 使用了Signature签名的通过签名保证jwt不能被他人随意篡改,我们又称为JWS。
Go 语言：使用 GoJWT 库实现 JSON Web Token（JWT）认证
m0_62153576的博客
10-14 472
JSON Web Token（JWT）是一种轻量级的身份验证协议，广泛用于跨域身份验证。Go 语言提供了许多优秀的库来处理 JWT，其中之一就是 GoJWT。本博客将详细介绍如何使用 GoJWT 库来实现 JWT 认证。
golang-jwt
09-16
golang-jwt是一个在Go中实现JWT的流行包。它提供了生成和验证JWT的功能，并且因其特性和易用性而受到欢迎。要使用golang-jwt包，您需要在安装后创建一个Go文件并导入所需的包和模块。您可以使用`import`语句导入以下包： ``` import ( "log" "encoding/json" "github.com/golang-jwt/jwt" "net/http" "time" ) ``` 安装golang-jwt包的先决条件是设置好Go工作区并初始化Go模块文件。在终端上的工作区目录中运行以下命令以安装包： ``` go get github.com/golang-jwt/jwt ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值