三段代码搞懂go-jwt做token登录校验的基本使用

最新推荐文章于 2023-10-14 21:41:33 发布
置顶 最新推荐文章于 2023-10-14 21:41:33 发布
阅读量724 收藏 2
点赞数
分类专栏： golang 文章标签： golang Golang JWT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45566022/article/details/107209746
版权

由于本来搭建的是基于gin+go-micro+etcd的微服务架构，生成token放在了用户服务，校验则放在了api网关，因此两边代码可能重复。其实也可以共用，懒得改了😂

用户服务端

package handler

import (
	"context"
	"errors"
	"fmt"
	"github.com/dgrijalva/jwt-go"
	"math/rand"
	"micro-file-store/common"
	"micro-file-store/conf"
	"micro-file-store/databases/redisdb"
	"micro-file-store/model/user"
	userProto "micro-file-store/service/account/proto"
	"micro-file-store/util"
	"regexp"
	"time"
)
// 创建token之前需要检验用户有效性，就不放上来了

// 定义claim包含的内容
type jwtClaims struct {
	jwt.StandardClaims
	UserID   uint   `json:"user_id"`
	UserName string `json:"user_name"`
	Password string `json:"Password"`
	RedisKey string `json:"redis_key"`
	Status   uint32 `json:"Status"`
	UserType uint32 `json:"user_type"`
}

const (
	// 盐
	jwtSalt = "瞅你咋地？"
)

/**
 *@Method 获取token
 *@Params user usermodel.UserModel
 *@Return token string, err error
 */
func createToken(user usermodel.UserModel) (token string, err error) {
	var key string
	// 尝试获取上一次的redis key
	lastKey, err := redisdb.GetJWTPool().Get(user.UserName).Result()
	if err != nil {
    // 如果为空，说明未登入过或者已过期删除
		if err == redis.Nil{
			// 如果上次一的token过期了 使用username + 随机五位大写字母，作为redis查询token的key
			r := rand.New(rand.NewSource(time.Now().UnixNano()))
			adStr := make([]byte, 5)
			for i := 0; i < 5; i++ {
				b := r.Intn(26) + 65
				adStr[i] = byte(b)
			}
			key = user.UserName + string(adStr)
		}else{
			return "", err
		}
	}else{
    //如果上次一的token还未过期，继续用上一次的key
		key = lastKey
	}
	// 添加claims信息
	claims := jwtClaims{
		UserID:   user.ID,
		UserName: user.UserName,
		Password: user.Password,
		RedisKey: key,
		Status:   user.Status,
		UserType: user.UserType,
		StandardClaims: jwt.StandardClaims{
			// 签发时间
			IssuedAt: time.Now().Unix(),
			// 不早于。。。生效
			NotBefore: time.Now().Unix() - 1000,
			// 有效时间
			ExpiresAt: time.Now().Unix() + 60*60*24*7,
			Issuer:    "ironHuang",
		},
	}
	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	// 加盐转换为字符串
	token, err = jwtToken.SignedString([]byte(jwtSalt))
	if err != nil {
		return "", err
	}
	// 将token保存至redis
	err = saveToken(key, token, user.UserName)
	if err != nil {
		return "", err
	}
	return token, nil
}

/**
 *@Method 保存token
 *@Params redisKey, token, userName string
 *@Return error
 */
func saveToken(redisKey, token, userName string) error {
  err = redisdb.GetJWTPool().Set(redisKey, token, 60*60*24*7*1000*1000*1000).Err()
	if err != nil {
		fmt.Println(err.Error())
		return err
	}
  // 关联rediskey和username
	err := redisdb.GetJWTPool().Set(userName, redisKey, 60*60*24*7*1000*1000*1000).Err()
	if err != nil {
		fmt.Println(err.Error())
		return err
	}
	return nil
}

api网关端（关于ParseToken错误处理可以参考最后一段代码理解)

package middleware

import (
	"errors"
	"github.com/dgrijalva/jwt-go"
	"github.com/gin-gonic/gin"
	"micro-file-store/common"
	"micro-file-store/databases/redisdb"
	"net/http"
	"time"
)

const (
	// 盐
	jwtSalt = "瞅你咋地？"
)

// 定义claim
type JwtClaims struct {
	jwt.StandardClaims
	UserID   int64  `json:"user_id"`
	UserName string `json:"user_name"`
	Password string `json:"Password"`
	RedisKey string `json:"redis_key"`
	Status   uint32 `json:"Status"`
	UserType uint32 `json:"user_type"`
}

// 预设错误信息
var (
	TokenExpired     = errors.New("Token is expired")
	TokenNotValidYet = errors.New("Token not active yet")
	TokenMalformed   = errors.New("That's not even a token")
	TokenInvalid     = errors.New("Couldn't handle this token:")
)

/**
 *@Method jwt认证主函数
 *@Params
 *@Return gin.HandlerFunc
 */
func JWTAuth() gin.HandlerFunc {
	return func(ctx *gin.Context) {
		// 获取前端传回的token(传递方式不同，获取的位置也不同，根据实际情况选择)
		authToken := ctx.Request.FormValue("auth_token")
		// 无token直接返回错误
		if authToken == "" {
			ctx.JSON(http.StatusOK, gin.H{
				// 返回代码
				"code": common.StatusTokenInvalid,
				// 返回信息
				"msg": "未登录或非法访问",
			})
			// 校验失败终止后续操作
			ctx.Abort()
			return
		}
		// 解析token
		claims, err := ParseToken(authToken)
		// 错误处理
		if err != nil {
			// token过期
			if err == TokenExpired {
				ctx.JSON(http.StatusOK, gin.H{
					"code": common.StatusTokenInvalid,
					"msg":  "授权过期，请重新登录",
				})
				ctx.Abort()
				return
			}
			ctx.JSON(http.StatusOK, gin.H{
				"code": common.StatusTokenInvalid,
				"msg":  err.Error(),
			})
			ctx.Abort()
			return
		}
		if storeToken := redisdb.GetJWTPool().Get(claims.RedisKey).Val(); authToken != storeToken {
			ctx.JSON(http.StatusOK, gin.H{
				"code": common.StatusTokenInvalid,
				"msg":  "授权过期，请重新登录",
			})
			ctx.Abort()
			return
		}
		// 将claim加入上下文，便于后续使用
		ctx.Set("user_claims", claims)

		/*
			claimObj, _ := ctx.Get("user_claims")
			转成JwtClaims
			claimsObj := claimObj.(*JwtClaims)
			userId := claimsObj.UserID
			fmt.Println(userId)
		*/

		ctx.Next()
	}
}

/**
 *@Method 解析token
 *@Params token String
 *@Return *JwtClaims, error
 */
func ParseToken(tokenString string) (*JwtClaims, error) {
	token, err := jwt.ParseWithClaims(tokenString, &JwtClaims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(jwtSalt), nil
	})
	if err != nil {
		// 如果强转*jwt.ValidationError成功，对错误进行判断
		if validationError, ok := err.(*jwt.ValidationError); ok {
			/*
				当validationError中的错误信息由错误的token结构引起时，
				**************************************************
				源码vErr.Errors |= ValidationErrorExpired，
				或运算，只有都为0才为0，0000 0000|0000 0101 = 0000 0101
				由于vErr.Errors的初始值为0，所以等价于将ValidationErrorMalformed赋值给validationError的Errors，
				*****************************************************
				如果没有赋值，Errors的初始值为0，那么validationError.Errors&jwt.ValidationErrorMalformed = 0，
				赋值后造成validationError.Errors不为0，那么validationError.Errors&jwt.ValidationErrorMalformed != 0
			*/
			if validationError.Errors&jwt.ValidationErrorMalformed != 0 {
				return nil, TokenMalformed
				// 以下与上方原理相同
			} else if validationError.Errors&jwt.ValidationErrorExpired != 0 {
				return nil, TokenExpired
			} else if validationError.Errors&jwt.ValidationErrorNotValidYet != 0 {
				return nil, TokenNotValidYet
			} else {
				return nil, TokenInvalid
			}
		}
	}
	if token != nil {
		// 强转成jwtClaims
		if claims, ok := token.Claims.(*JwtClaims); ok && token.Valid {
			// 如果合法返回claims
			return claims, nil
		}
		return nil, TokenInvalid
	} else {
		return nil, TokenInvalid
	}
}

/**
 *@Method 刷新token
 *@Params token String
 *@Return string,error
 */
func RefreshToken(tokenString string) (string, error) {
	// 重写TimeFunc初始化过期时间
	jwt.TimeFunc = func() time.Time {
		return time.Unix(0, 0)
	}
	// 解析*jwt.Token
	token, err := jwt.ParseWithClaims(tokenString, &JwtClaims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(jwtSalt), nil
	})
	if err != nil {
		return "", err
	}
	// 强转成定义的jwtClaims，成功继续操作，失败返回错误
	if claims, ok := token.Claims.(JwtClaims); ok && token.Valid {
		// 设置为当前时间过期
		jwt.TimeFunc = time.Now
		// 过期时间加1小时
		claims.StandardClaims.ExpiresAt = time.Now().Local().Add(1 * time.Hour).Unix()
		// 加密
		jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
		// 加盐转字符串
		token, err := jwtToken.SignedString([]byte(jwtSalt))
		// 更新redis,使用ExpireAt(claims.RedisKey, time.Now().Local().Add(1*time.Hour)可能会有误差
		// 可以用第二种更新过期时间
		//redisdb.GetJWTPool().ExpireAt(claims.RedisKey, time.Now().Local().Add(1*time.Hour))
		redisdb.GetJWTPool().Expire(claims.RedisKey, 60*60*1000*1000*1000)
		return token, err
	}
	return "", TokenInvalid
}

关于ParseToken错误处理原理

package main

import (
	"fmt"
	"github.com/pkg/errors"
)

// 定义一个错误码
const myValidErr = 1

// 定义一个结构体
type user struct {
	userName string
}

// 自定义错误
type myError struct {
	// 用于存放外部返回的错误
	Inner error
	// 可以理解为错误代码
	Errors uint32
	// 如果没有另外返回的错误，可以使用text中设置的错误信息
	text string
}

func (u *user) valid() error {
	// 实例化myError
	vErr := new(myError)
	// 假设如果用户名不等于lalala
	if u.userName != "lalala" {
		// 添加错误信息
		vErr.Inner = errors.New("这是一个错误信息")
		// 或运算，只有都为0才为0，0000 0000|0000 0101 = 0000 0101，
		//vErr.Errors初始值为0，这里相当于将myValidErr赋值给vErr.Errors。
		vErr.Errors |= myValidErr
	}
	return vErr
}


/* 源码builtin.go中,error是接口类型意味着可以自定义
type error interface {
	Error() string
}
*/
func (e myError) Error() string {
	if e.Inner != nil {
		return e.Inner.Error()
	} else if e.text != "" {
		return e.text
	} else {
		return "上面都没有，只能靠我拯救世界了"
	}
}

func main() {
	testUser := user{
		userName: "hahaha",
	}
	err := testUser.valid()
	// 强转成myError
	errtest := err.(*myError)

	fmt.Println(errtest.Errors)
	// 如果Inner没有信息将打印text的错误信息，如果text也没用，只能放大招了
	fmt.Println(errtest.Error())
}
Iron_Huang
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot-JWT-Token:JWT令牌，Spring-Security
03-22
JWT（Json Web Token）则是一种安全的身份验证机制，被广泛应用于微服务架构和API授权。本篇文章将深入探讨如何在Spring Boot应用中结合Spring Security实现JWT令牌的认证和授权。 首先，JWT令牌是一种轻量级的身份...
golang 使用jwt进行权限认证
、Edgar的博客
08-07 706
具体代码见GitHub 创建一个工具包，对jwt相关操作进行封装 package utils import ( "github.com/dgrijalva/jwt-go" "time" ) var jwtKey = []byte("bbs_secret_key") type Claims struct { Username string `json:"username"` jwt.StandardClaims } func ReleaseToken(username string) (tok
Go 语言：使用 GoJWT 库实现 JSON Web Token（JWT）认证
m0_62153576的博客
10-14 435
JSON Web Token（JWT）是一种轻量级的身份验证协议，广泛用于跨域身份验证。Go 语言提供了许多优秀的库来处理 JWT，其中之一就是 GoJWT。本博客将详细介绍如何使用 GoJWT 库来实现 JWT 认证。
go jwt实现token
PerfectUrl的博客
11-17 350
package main import ( "fmt" "github.com/dgrijalva/jwt-go"//这里用的这个包 "github.com/labstack/echo" "net/http" "time" ) func main() { e := echo.New() e.GET("/", func(c echo.Context) error { token := jwt.New(jwt.SigningMethodHS256)//初始化token选择HS256 .
go jwt 实现验证，存储token，获取token中的信息
yqymzj的博客
01-13 1243
go jwt 实现验证，存储token，获取token中的信息
Go开发中的JWT的创建和解析的功能实现
weixin_47024018的博客
12-13 940
`Json web token (JWT)`, 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准.该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该`token`也可直接被用于认证，也可被加密。下面就以一个标准的jwt功能实现方式进行编码。并且这个jwt也会相对安全一点，因为是有加密过的。一般用户登录后生成的token都
shiro-jwt-wx:微信小程序登录，使用shiro+JWT(Token）
05-14
使用Shiro+JWT完成的微信小程序的登录 你也可以在csdn中查看讲解 微信小程序用户登陆，完整流程可参考下面官方地址，本例中是按此流程开发 你需要了解的点 微信小程序的登录流程 Shiro的基础知识 JWT以及Token 项目...
js代码-JWT（json-web-token）-认识与学习
07-16
- 使用短期JWT并配合刷新令牌（Refresh Token）策略，当JWT过期时，用户可以通过刷新令牌获取新的JWT，而无需重新登录。 - 保持签名密钥的安全，不要暴露在客户端代码中。 5. 应用场景： - 单页应用（SPA）的...
详解Go-JWT-RESTful身份认证教程
09-18
综上所述，本文讲解了JWT、Go语言以及RESTful API的基本概念和应用，提供了生成、解析和验证JWT的具体方法和代码示例，并强调了在使用过程中需要注意的安全性问题。通过这些知识的介绍，开发者可以更好地掌握在Go...
gin框架学习-JWT认证
林钟一的博客
07-12 1507
gin框架学习-JWT认证
go语言使用jwt认证
sywdebug的博客
04-03 6500
这几天在学习nodejs，进一步了解npm，学习过程中解开了以前的一个疑惑，以前不知道token可以携带信息，只以为是用来做对比的，学到了jwt身份认证，知道了如何使用的，感觉很好用，但是我不用nodejs开发，所以有自己去看了下go的，做下记录 刚学，博客内容写的可能不大对，因为基本都是自己的理解，术语用的可能也不到位，但是用起来倒是没问题，见谅 golang-jwt 项目仓库 使用以下命令获取 go get github.com/golang-jwt/jwt 加密 首先声明一串用于加密解密的秘钥 .
JWT登录认证
qq_45709416的博客
08-06 304
WebMvcConfigurer配置类其实是Spring内部的一种配置方式，采用JavaBean的形式来代替传统的xml配置文件形式进行针对框架个性化定制，可以自定义一些Handler，Interceptor，ViewResolver，MessageConverter。如果您使用的是带有 JWS 签名的 JWT，则必须使用 parseClaimsJws 方法才能正确解析 JWT 并验证签名。如果使用的是未签名的 JWT，则可以使用 parseClaimsJwt 方法；
Go JWT学习笔记,核心代码解析
08-03 1019
对JWT中的核心代码,逐步解析学习 package jwt import ( "errors" "fmt" "time" "github.com/dgrijalva/jwt-go" ) //注意下方的User其实应该定义在module数据模型里 这里定义支付辅助显示一下下 type User struct { name string Password string juese string shouji string } //验证与解密当中的密匙设置的复杂一点, //viper.Get
【sduoj】生成和解析 JWT
weixin_45922876的博客
10-20 694
2021SC@SDUSC 在sduoj项目中，我们有四种角色：管理员、教师、学生、普通用户。如果仅仅是通过调用的接口路径的不同来区分这些角色的话，容易引发一些危险的行为。比如，当一个普通用户知道了该项目的管理员接口，那他的行为就有可能造成系统的混乱。因此，我们需要给项目加一点防御，对接口进行访问控制。
Go的Gin框架拦截器实现登录认证结合JWT实现会话记录
个人学习笔记库，一篇一篇记录成长的足迹
04-17 2308
jwt会话技术替代session技术，go语言的演示及代码编写，使用gin web框架完成。
【node】node中使用redis缓存-04
我的开源项目:https://gitee.com/derekgo/vue-cms_xg
02-08 921
1.下载在windows下载redis http://www.redis.cn/download.html 2.开启redis 1进入redis文件夹后 再进入cmd，开启redis redis-server.exe redis.windows.conf 如果出现一下报错 需要进入redis，关闭redis，才能启动 3.项目中创建redis类 特别注意：使用redis的3.1.2版本，否者会报错 redis.js文件 let redis = require("redis"); //redis链接的
go jwt 生成token报错 ：key is of invalid type
weixin_43109587的博客
12-26 2570
jwt.SigningMethodES256 两种类型 *SigningMethodECDSA 和 *SigningMethodHMAC jwts := jwt.NewWithClaims(jwt.SigningMethodES256, c) // SigningMethodES256 *SigningMethodECDSA 此类型会报错： key is of invalid type` jwts := jwt.NewWithClaims(jwt.SigningMethodHS256, c) // S
Go语言学习笔记——jwt跨域鉴权
qq_39280718的博客
09-07 1037
JWT全称JSON Web Token是一种跨域认证解决方案，属于一个开放的标准，它规定了一种Token实现方式，目前多用于前后端分离项目和OAuth2.0业务场景下。
Gin中使用jwt-go实现JWT鉴权登陆
mjiarong的博客
10-01 1752
JWT全称Json web token ，是一种用于通信双方之间传递安全信息的简洁的、URL安全的表述性声明规范，是目前最流行的跨域身份验证解决方案。JWT基于token的鉴权机制类似于http协议也是无状态的，它不需要在服务端去保留用户的认证信息或者会话信息，一旦用户完成了登陆，在接下来的每个请求中都会包含JWT，可以用来验证用户身份以及对路由，服务和资源的访问权限的验证。由于它的开销非常小，可以轻松的在不同域名的系统中传递，这也为应用的扩展提供了便利。JWT 以 JSON 对象的形式安全传递信息。
gin-jwt/v2 与 "github.com/golang-jwt/jwt/v4" 使用jwt 冲突
最新发布
03-17
gin-jwt/v2 和 "github.com/golang-jwt/jwt/v4" 都是 Go 语言中用于处理 JSON Web Token (JWT) 的库，它们之间可能存在一些使用上的冲突。 gin-jwt/v2 是一个专门为 Gin 框架设计的 JWT 中间件，它提供了一些方便的功能来验证和生成 JWT。它使用了 "github.com/dgrijalva/jwt-go" 这个库来处理 JWT 的生成和验证。 而 "github.com/golang-jwt/jwt/v4" 是一个通用的 JWT 库，它提供了一些基本的功能来生成和验证 JWT。它是由 Go 官方团队维护的，相对来说更加稳定和可靠。 由于这两个库都涉及到 JWT 的生成和验证，所以在使用时可能会存在一些冲突。例如，可能会出现导入冲突或者函数命名冲突的情况。 为了解决这个问题，你可以考虑以下几种方法： 1. 使用不同的别名导入库：可以给其中一个库起一个别名，以避免导入冲突。 2. 手动处理 JWT：如果你只需要基本的 JWT 功能，你也可以选择手动处理 JWT，而不使用这两个库中的任何一个。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值