golang原生实现JWT的示例代码_开发_开发者

获取Token

我们在此封装一个JWT的struct结构体(由于除了Payload，其他很大可能不会在其他地方用到，所以不公开)

type JWT struct {
    header    string
    Payload   string
    signature string
}

将base64的编码封装一下方便使用

func encodeBase64(data string) string {
	return base64.RawURLEncoding.EncodeToString([]byte(data))
}

我们封装一个用来生成签名的方法

func generateSignature(key []byte, data []byte) (string, error) {
	// 创建一个哈希对象
	hash := hmac.New(sha256.New, key)
	// 将要签名的信息写入哈希对象中 hash.Write(data)
	_, err := hash.Write(data)
	if err != nil {
		return "", err
	}
	开发者_Python教程// hash.Sum()计算签名，在这里会返回签名内容
	// 将签名经过base64编码生成字符串形php式返回。
	return encodeBase64(string(hash.Sum(nil))), nil
}

我们封装一个CreateToken用于生成Token(该方法的参数key为（生成签名所使用的密钥）)

func CreateToken(key []byte, payloadData any) (string, error) {
    // 标准头部
	header := `{"alg":"HS256","typ":"JWT"}`
    // 将负载的数据转换为json
	payload, jsonErr := json.Marshal(payloadData)
	if jsonErr != nil {
		return "", fmt.Errorf("负载json解析错误")
	}
    // 将头部和负载通过base64编码，并使用.作为分隔进行连接
	encodedHeader := encodeBase64(header)
	encodedPayload := encodeBase64(string(payload))
	HeaderAndPayload := encodedHeader + "." + encodedPayload
    // 使用签名使用的key将传入的头部和负载连接所得的数据进行签名
	signature, err := generateSignature(key, []byte(HeaderAndPayload))
	if err != nil {
		return "", err
	}
    // 将token的三个部分使用.进行连接并返回
	return HeaderAndPayload + "." + signature, nil
}

解析Token

我们封装一个解析token的方法

func ParseJwt(token string, key []byte) (*JWT, error) {
    // 分解规定，我们使用.进行分隔，所以我们通过.进行分隔成三个字符串的数组
	jwtParts := strings.Split(token, ".")
    // 数据数组长度不是3就说明token在格式上就不合法
	if len(jwtParts) != 3 {
		return nil, fmt.Errorf("非法token")
	}
	// 分别拿出
	encodedHeader := jwtParts[0]
	encodedPayload := jwtParts[1]
	signature := jwtParts[2]
	// 使用key将token中的头部和负载用.连接后进行签名
    // 这个签名应该个token中第三部分的签名一致
	confirmSignature, err := generateSignature(key, []byte(encodedHeader+"."+encodedPayload))
	if err != nil {
		return nil, fmt.Errorf("生成签名错误")
	}
    // 如果不一致
	if signature != confirmSignature {
		return nil, fmt.Errorf("token验证失败")
	}
	// 将payload解base64编码
	dstPayload, _ := base64.RawURLEncoding.DecodeString(encodedPayload)
    // 返回我们的JWT对象以供后续使用
	return &JWT{encodedHeader, string(dstPayload), signature}, nil
}

实际使用

我们构造一个用户的结构体

type UserInfo struct {
	Name     string `json:"androidname"`
	Password string `json:"password"`
}

我们这次使用123456作为密钥简单的验证一下

var Key []byte = []byte("12346")

在此我们构造一个验证的中间件

func jwtConfirm(context *gin.Context) {
	// 登录不需要token
	if context.Request.RequestURI == "/login" {
		return
	}
	// 拿出token
	token := context.GetHeader("Token")
    // 进行解析验证
	jwt, err := utils.ParseJwt(token, Key)
	if err != nil {
		context.JSON(200, gin.H{
			"msg": err.Error(),
		})
        // 有问题就流产掉（我也不知道怎么翻译好了，香蕉猫.jpg）
		context.Abort()
	}
    // 验证通过就将负载返回回去
	context.JSON(200, gin.H{
		"payload": jwt.Payload,
	编程客栈})
}

我们在此基础上就可以使用了，这边使用gin框架简单的测试一下

func main() {
    // 使用默认路由
	router := gin.Default()
    // 注册中间件
	router.Use(jwtConfirm)
    // 简单做两个服务
	router.POST("/login", func(context *gin.Context) {
		// 接收用户参数
		var userInfo UserInfo = UserInfo{}
        // 使用jsonbind接收
		bindErr := context.ShouldBindJSON(&userInfo)
		if bindErr != nil {
			context.JSON(200, gin.H{
				"msg": bindErr.Error(),
			})
		}
		// 使用密钥做出token
		jwt, err := utils.CreateJwt(Key, userInfo)
		if err != nil {
			fmt.Println(err)
		}
         // 我们将tok编程客栈en直接返回用于测试
		context.JSON(200, gin.H{
			"token": jwt,
		})
	})
	router.GET("/doing")
	router.Run()
}