- 在VisualStudio中部署GDAL库的C++版本(包括SQLite、PROJ等依赖)
- Android开机流程介绍
- STM32CubeMX教程31USB_DEVICE-HID外设_模拟键盘或鼠标
- 深入浅出Java多线程(五):线程间通信
Json web token
(JWT
), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准(RFC 7519
)服务器需要存储用户的token信息 。
服务端不需要存储用户token, 都存在客户端 。
JWT就是一段字符串, 由三段信息构成, 三段信息文本使用.(点) 拼接就构成了JWT字符串
eyJhbGciOiJIUzI1sNiIsIn.eyJzdWIiOiIxMjRG9OnRydWV9.TJVArHDcEfxjoYZgeFONFh7HgQ
header
payload
(类似于飞机上承载的物品)signature
头部,JWT 的元数据,也就是描述这个 token 本身的数据,一个 JSON 对象。由两部分组成
// 定义头部信息
header := map[string]interface{}{
"alg": "HS256", // 声明加密算法,可以根据需要修改
"typ": "JWT", // 声明类型
}
将头部使用base64编码构成第一部分 (base64编码方法, 该编码可以对称解码) 。
package main
import (
"encoding/base64"
"encoding/json"
"fmt"
)
func main() {
// 定义头部信息
header := map[string]interface{}{
"alg": "HS256", // 声明加密算法,可以根据需要修改
"typ": "JWT", // 声明类型
}
// 将头部信息序列化为JSON格式字符串
headerBytes, err := json.Marshal(header)
if err != nil {
fmt.Println("JSON encoding error:", err)
return
}
headerStr := base64.RawURLEncoding.EncodeToString(headerBytes)
fmt.Println(headerStr)
// eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
}
存放用户有效信息的地方,一个 JSON 对象, 这些有效信息包含三个部分:
iss
: JWT签发者sub
: JWT所面向的用户aud
: 接收JWT的一方exp
: JWT的过期时间,这个过期时间必须要大于签发时间nbf
: 定义在什么时间之前,该JWT都是不可用的iat
: JWT的签发时间jti
: JWT的唯一身份标识,主要用来作为一次性token,从而回避时序攻击公共的声明可以添加任何的信息,一般添加用户的相关信息或其他业务需要的必要信息。但不建议添加敏感信息,因为该部分在客户端可解密.
私有声明是提供者和消费者所共同定义的声明,一般不建议存放敏感信息,因为base64是对称解密的,意味着该部分信息可以归类为明文信息.
除了上面的字段, 你自己也可以添加自己想要的字段, 需要注意的是:这些信息是不加密的, 所以最好不要存敏感信息 。
package main
import (
"encoding/base64"
"encoding/json"
"fmt"
)
func main() {
// 定义Payload信息
payload := map[string]interface{}{
"sub": "1234567890", // 主题,表示该JWT的所有者
"name": "John Doe", // 自定义声明,可以根据需要添加其他声明
"iat": 1516239022, // 签发时间,表示JWT的签发时间,一般为当前时间的时间戳
"exp": 1516239022 + 3600, // 过期时间,表示JWT的过期时间,一般为签发时间加上有效期,以秒为单位
"roles": []string{"admin", "user"}, // 自定义声明,可以存储用户角色等信息
}
// 将Payload信息序列化为JSON格式字符串
payloadBytes, err := json.Marshal(payload)
if err != nil {
fmt.Println("JSON encoding error:", err)
return
}
payloadStr := base64.RawURLEncoding.EncodeToString(payloadBytes)
fmt.Println(payloadStr) // eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
}
然后将其进行base64加密,得到JWT的第二部分.
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
signature 是根据 header 和 token 生成, 由三部分构成
这个部分需要将base64加密后的header和base64加密后的payload使用.连接组成的字符串,然后通过header中声明的加密方式进行加盐secret组合加密,然后就构成了JWT的第三部分.
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"fmt"
)
func main() {
// 定义头部信息
header := map[string]interface{}{
"alg": "HS256",
"typ": "JWT",
}
// 定义Payload信息
payload := map[string]interface{}{
"sub": "1234567890",
"name": "John Doe",
"iat": 1516239022,
"exp": 1516239022 + 3600,
"roles": []string{"admin", "user"},
}
// 将头部信息序列化为JSON格式字符串
headerBytes, err := json.Marshal(header)
if err != nil {
fmt.Println("JSON encoding error:", err)
return
}
headerStr := base64.RawURLEncoding.EncodeToString(headerBytes)
// 将Payload信息序列化为JSON格式字符串
payloadBytes, err := json.Marshal(payload)
if err != nil {
fmt.Println("JSON encoding error:", err)
return
}
payloadStr := base64.RawURLEncoding.EncodeToString(payloadBytes)
// 定义秘钥
secret := "your-secret-key" // 替换为实际的秘钥
// 生成签名
signature := generateSignature(headerStr, payloadStr, secret)
fmt.Println(signature) // C-94Wc6olGK6CEbkA9Xj0ogDQIFdPsEefZKCZrz_fvA
// 生成的签名字符串
}
func generateSignature(headerStr, payloadStr, secret string) string {
// 构造要签名的数据
dataToSign := headerStr + "." + payloadStr
// 使用HMAC-SHA256算法生成签名
h := hmac.New(sha256.New, []byte(secret))
h.Write([]byte(dataToSign))
signatureBytes := h.Sum(nil)
// 对签名进行base64编码
signature := base64.RawURLEncoding.EncodeToString(signatureBytes)
return signature
}
算出签名之后, 把 header、payload、signatrue 三部分使用 .(点) 拼接成一个大字符串, 然后返回给客户端让其存储 。
package main
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"fmt"
)
func main() {
// 定义头部信息
header := map[string]interface{}{
"alg": "HS256",
"typ": "JWT",
}
// 定义Payload信息
payload := map[string]interface{}{
"sub": "1234567890",
"name": "John Doe",
"iat": 1516239022,
"exp": 1516239022 + 3600,
"roles": []string{"admin", "user"},
}
// 将头部信息序列化为JSON格式字符串
headerBytes, err := json.Marshal(header)
if err != nil {
fmt.Println("JSON encoding error:", err)
return
}
headerStr := base64.RawURLEncoding.EncodeToString(headerBytes)
// 将Payload信息序列化为JSON格式字符串
payloadBytes, err := json.Marshal(payload)
if err != nil {
fmt.Println("JSON encoding error:", err)
return
}
payloadStr := base64.RawURLEncoding.EncodeToString(payloadBytes)
// 将base64加密后的header和payload拼接起来
dataToSign := headerStr + "." + payloadStr
// 定义秘钥
secret := "your-secret-key" // 替换为实际的秘钥
// 生成签名
signature := generateSignature(dataToSign, secret)
// 最终的JWT字符串
jwtToken := dataToSign + "." + signature
fmt.Println(jwtToken)
// 最终生成的JWT字符串
// eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1MTYyNDI2MjIsImlhdCI6MTUxNjIzOTAyMiwibmFtZSI6IkpvaG4gRG9lIiwicm9sZXMiOlsiYWRtaW4iLCJ1c2VyIl0sInN1YiI6IjEyMzQ1Njc4OTAifQ.C-94Wc6olGK6CEbkA9Xj0ogDQIFdPsEefZKCZrz_fvA
}
func generateSignature(dataToSign, secret string) string {
// 使用HMAC-SHA256算法生成签名
h := hmac.New(sha256.New, []byte(secret))
h.Write([]byte(dataToSign))
signatureBytes := h.Sum(nil)
// 对签名进行base64编码
signature := base64.RawURLEncoding.EncodeToString(signatureBytes)
return signature
}
注意:secret 是保存在服务器端的,JWT的签发生成也是在服务器端的,secret 就是用来进行JWT的签发和JWT的验证,所以,它就是你服务端的私钥,在任何场景都不应该流露出去。一旦客户端得知这个 secret,那就意味着客户端是可以自我签发JWT了.
首先 base64 是一种编码方式, 并非加密方式; 它跟语言无关, 任何语言都能使用 base64 编码&解码 。
// 定义一个信息字段
dic := map[string]interface{}{"id": 1, "name": "jarvis", "age": "male"}
// 将其序列化成json格式字符串
jsonBytes, err := json.Marshal(dic)
if err != nil {
fmt.Println("JSON encoding error:", err)
return
}
jsonStr := string(jsonBytes)
// 将json格式字符串encode再使用base64编码成一串Bytes格式编码
base64Str := base64.StdEncoding.EncodeToString([]byte(jsonStr))
fmt.Println([]byte(base64Str))
// [101 121 74 112 90 67 73 54 73 68 69 115 73 67 50 70 109 90 121 66 67 74 112 73 106 111 103 73 109 70 48 105 71 108 112 77 97 86 120 73 106 111 103 73 109 116 65 87 120 108 73 106 111 103 73 109 116 65 87 120 108 73 106 111 103 73 109 116 65 87 120 108 73 106 111 103 73 61]
fmt.Println(base64Str)
// eyJhZ2UiOiJtYWxlIiwiaWQiOjEsIm5hbWUiOiJqYXJ2aXMifQ==
// 替换为你的 base64 编码字符串
base64Str := "eyJhZ2UiOiJtYWxlIiwiaWQiOjEsIm5hbWUiOiJqYXJ2aXMifQ=="
// base64 解码
decodedBytes, err := base64.StdEncoding.DecodeString(base64Str)
if err != nil {
fmt.Println("Base64 decoding error:", err)
return
}
// JSON 反序列化
var dic map[string]interface{}
err = json.Unmarshal(decodedBytes, &dic)
if err != nil {
fmt.Println("JSON decoding error:", err)
return
}
fmt.Println(dic)
// map[age:male id:1 name:jarvis]
/*
1)jwt分三段式:头.体.签名 (head.payload.sgin)
2)头和体是可逆加密,让服务器可以反解出user对象;签名是不可逆加密,保证整个token的安全性的
3)头体签名三部分,都是采用json格式的字符串,进行加密,可逆加密一般采用base64算法,不可逆加密一般采用hash(md5)算法
4)头中的内容是基本信息:公司信息、项目组信息、token采用的加密方式信息
{
"company": "公司信息",
...
}
5)体中的内容是关键信息:用户主键、用户名、签发时客户端信息(设备号、地址)、过期时间
{
"user_id": 1,
...
}
6)签名中的内容时安全信息:头的加密结果 + 体的加密结果 + 服务器不对外公开的安全码 进行md5加密
{
"head": "头的加密字符串",
"payload": "体的加密字符串",
"secret_key": "安全码"
}
*/
根据登录请求提交来的 账号 + 密码 + 设备信息 签发 token 。
token
字符串返回给前台根据客户端带 token 的请求 反解出 user 对象 。
.
(点) 拆分为三段字符串, 第一段编码后的头字符串一般不需要做任何处理用账号密码访问登录接口,登录接口逻辑中调用签发token算法,得到token,返回给客户端,客户端自己存到cookies中.
校验token的算法应该写在中间件中,所有请求都会进行认证校验,所以请求带了token,就会反解出用户信息.
使用Gin框架时,你可以选择一个适用于Go语言的JWT库。一个流行的选择是github.com/dgrijalva/jwt-go库.
go get -u github.com/golang-jwt/jwt/v5
在你的Go代码中导入github.com/golang-jwt/jwt/v5和github.com/gin-gonic/gin.
import (
"github.com/golang-jwt/jwt/v5"
"github.com/gin-gonic/gin"
)
JWT中间件: 创建一个JWT中间件,它将用于保护需要身份验证的路由.
package middleware
import (
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt/v5"
"net/http"
"strings"
"webook/internal/web"
)
// LoginJWTMiddlewareBuilder JWT 登录校验
type LoginJWTMiddlewareBuilder struct {
paths []string
}
func NewLoginJWTMiddlewareBuilder() *LoginJWTMiddlewareBuilder {
return &LoginJWTMiddlewareBuilder{}
}
// IgnorePaths 忽略的路径
func (l *LoginJWTMiddlewareBuilder) IgnorePaths(path string) *LoginJWTMiddlewareBuilder {
l.paths = append(l.paths, path)
return l
}
func (l *LoginJWTMiddlewareBuilder) Build() gin.HandlerFunc {
// 用 Go 的方式编码解码
return func(ctx *gin.Context) {
// 不需要登录校验的
for _, path := range l.paths {
if ctx.Request.URL.Path == path {
return
}
}
// 用 JWT 来校验
tokenHeader := ctx.GetHeader("Authorization")
if tokenHeader == "" {
// 没登录
ctx.AbortWithStatus(http.StatusUnauthorized)
return
}
segs := strings.Split(tokenHeader, " ")
if len(segs) != 2 {
// 没登录,有人瞎搞
ctx.AbortWithStatus(http.StatusUnauthorized)
return
}
tokenStr := segs[1]
claims := &web.UserClaims{}
// ParseWithClaims 里面,一定要传入指针
// 这里的95osj3fUD7fo0mlYdDbncXz4VD2igvf0 代表的是签发的时候的key,并且key 要和签发的时候一样
token, err := jwt.ParseWithClaims(tokenStr, claims, func(token *jwt.Token) (interface{}, error) {
return []byte("95osj3fUD7fo0mlYdDbncXz4VD2igvf0"), nil
})
if err != nil {
// 没登录
ctx.AbortWithStatus(http.StatusUnauthorized)
return
}
// token 验证不通过
if token == nil || !token.Valid {
// 没登录
ctx.AbortWithStatus(http.StatusUnauthorized)
return
}
// 将用户信息存储到上下文中
ctx.Set("claims", claims)
}
}
使用JWT中间件: 在需要身份验证的路由上使用JWT中间件.
func initWebServer() *gin.Engine {
ser := gin.Default()
ser.Use(cors.New(cors.Config{
//AllowOrigins: []string{"*"},
//AllowMethods: []string{"POST", "GET"},
AllowHeaders: []string{"Content-Type", "Authorization"},
// 允许跨域访问的响应头,不加这个前端拿不到token响应头
ExposeHeaders: []string{"x-jwt-token"},
// 是否允许你带 cookie 之类的东西
AllowCredentials: true,
AllowOriginFunc: func(origin string) bool {
if strings.HasPrefix(origin, "http://localhost") {
// 你的开发环境
return true
}
return strings.Contains(origin, "http://你的公司域名.com")
},
MaxAge: 12 * time.Hour,
}))
// 注册登录校验中间件以及不要登录校验的路径
ser.Use(middleware.NewLoginJWTMiddlewareBuilder().
IgnorePaths("/users/signup").
IgnorePaths("/users/login").Build())
return ser
}
生成JWT token: 在用户登录成功后,你可以生成JWT并将其返回给客户端.
// UserClaims 自定义的声明结构体并内嵌 jwt.StandardClaims
type UserClaims struct {
jwt.RegisteredClaims
// 声明你自己的要放进去 token 里面的数据
Uid int64
// 后续需要什么字段,就在这里添加
}
func (u *UserHandler) LoginJWT(ctx *gin.Context) {
type LoginReq struct {
Email string `json:"email"`
Password string `json:"password"`
}
var req LoginReq
if err := ctx.Bind(&req); err != nil {
return
}
user, err := u.svc.Login(ctx, req.Email, req.Password)
if err == service.ErrInvalidUserOrPassword {
ctx.String(http.StatusOK, "用户名或密码不对")
return
}
if err != nil {
ctx.String(http.StatusOK, "系统错误")
return
}
// 步骤2
// 在这里用 JWT 设置登录态
// 生成一个 JWT token
// 将用户信息存储到token中
claims := UserClaims{
Uid: user.Id,
}
token := jwt.NewWithClaims(jwt.SigningMethodHS512, claims)
tokenStr, err := token.SignedString([]byte("95osj3fUD7fo0mlYdDbncXz4VD2igvf0"))
if err != nil {
ctx.String(http.StatusInternalServerError, "系统错误")
return
}
ctx.Header("x-jwt-token", tokenStr)
fmt.Println(user)
ctx.String(http.StatusOK, "登录成功")
return
}
我们通过接口调试工具访问路由127.0.0.1:8080/users/login 签发用户token,header 中就会有X-Jwt-Token这个字段以及生成的token 对应值.
在平时开发中,我们一般不会直接传user_id 过来,一般是通过token来获取用户信息,比如我们需要查询用户信息,之前我们已经将用户ID放入到token中了,直接通过c, _ := ctx.Get("claims")来获取我们存放的用户信息,以下是具体代码; 。
func (u *UserHandler) ProfileJWT(ctx *gin.Context) {
c, _ := ctx.Get("claims")
// 你可以断定,必然有 claims
//if !ok {
// // 你可以考虑监控住这里
// ctx.String(http.StatusOK, "系统错误")
// return
//}
// ok 代表是不是 *UserClaims
claims, ok := c.(*UserClaims)
if !ok {
// 你可以考虑监控住这里
ctx.String(http.StatusOK, "系统错误")
return
}
fmt.Println("当前用户ID为:", claims.Uid)
ctx.String(http.StatusOK, "查询成功")
}
最后我们只需要访问路由:127.0.0.1:8080/users/profile,在header中加入token 即可.
最后此篇关于Gin框架之jwt介绍与基本使用的文章就讲到这里了,如果你想了解更多关于Gin框架之jwt介绍与基本使用的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
我有很多路线,从 gin.Default() 开始使用 Gin (默认情况下为所有路由启用日志记录和恢复)。但是有一条路由(即 /health )每 5 秒被 ping 一次。在不更改大部分代码的情况
gin 是目前 Go 里面使用最广泛的框架之一了,弄清楚 gin 框架的原理,有助于我们更好的使用 gin。这个系列 gin 源码阅读会逐步讲明白 gin 的原理,欢迎关注后续文章。 gin
我从 gin 文档中了解到,您可以将 json 绑定(bind)到类似 的结构 type Login struct { User string `form:"user" json:"u
我正在使用 API,GET 和 POST 工作正常,除非我尝试通过其 ID 获取选择记录(例如/articles/2)。文章存在,当通过/articles 路径检索所有记录时,我得到了正确的响应。这是
我找不到在 UNIX 中正确执行此代码的方法: package main import ( "time" "github.com/gin-gonic/gin" "net/http" ) t
我尝试使用作为 Golang 框架的 Gin。 https://github.com/gin-gonic/gin 我从官方github上复制了示例代码。 就像这样。 package main impo
下面访问gin-gonic服务器时,HTTP客户端应该收到code 500,却收到code 200。 package main import ( "github.com/gin-contrib
我使用 Guice/Gin 设计了一个新项目,因此我可以使我们的代码更加模块化和可交换,尤其是在测试时。 但是,我无法弄清楚如何在实践中完成这项工作。我的印象是我可以在我的测试中创建一个新的 Gin/
我正在尝试在 golang:alpine docker 镜像上运行一个非常简单的 go/gin 程序。这无法运行/构建。 运行容器: docker run -it --rm golang:1.10.1
本文介绍如何通过 rk-boot 快速搭建静态文件下载 Web 服务。什么是 静态文件下载 Web UI?通过配置文件,快速搭建可下载文件的 Web 服务。 请访问如下地址获取完整教程: r
这是我的一个例子 - public class GinDemoPresenter implements Presenter { private View view; @Inject
我正在尝试使用一种干净的方法,使用传递给我的类的父上下文来优雅地停止我的gin服务器。 这是我当前的代码 有没有更清洁的方法可以做到这一点?感觉像很多样板代码和不必要的例如使用无限循环完成如此简单的任
我有以下代码 public class AppGinModule extends AbstractGinModule{ @Override protected void configu
我正在使用OPTIONS方法获得204,但是似乎没有碰到终点 只需构建一个简单的文件上传端点,如下所示: package main import ( "cloud.google.com/go
在对其数据执行验证后,我试图用它的数据恢复上下文。我需要数据在下一个函数中根据需要继续移动。 我是 golang 的新手,下面的代码是我所能做的。非常感谢任何帮助和更好的方法。 提前致谢。 验证中间件
有一个使用gin-gonic框架以golang编写的服务。 我只想将application/json支持为mime类型,并且如果它始终以UTF-8格式运行,那就太好了。如果服务的业务逻辑将获得不同编码
我试图在我的 Handler 上进行一些处理后传递一些变量功能。我该怎么办 redirect到一个新页面并将一些 json 变量传递给这个新模板? // main package func main(
我运行关于文件上传的 gin 示例,这个 repo 来自 https://github.com/gin-gonic/examples/tree/5898505356e9064c49abb075eae8
我收到以下错误消息: controllers/user.go:4:2: cannot find package "(underscore)/home/ubuntu/goapi/src/github.c
我需要在中间件函数中操作响应数据。假设我有产品处理程序和客户处理程序。产品处理程序返回产品列表,客户返回客户列表。在中间件函数中,我想将这些响应转换为 ApiResponse 结构。 type Api
我是一名优秀的程序员,十分优秀!