微服务越来越多，如何打通各个服务之间的登录状态？来试试JWT
- 我们知道，http是无状态的，即每次http请求对于服务器来说都是新用户，那么我们怎么解决登录的问题呢？
cookie
- 最早我们可以使用cookie，即一个用户第一次请求的时候，是没有cookie的，这个时候呢，服务器会自动生成一个session_id存放到cookie里面去，也就是说浏客户端的cookie，服务器不仅可以读，而且可以写，正是基于此我们就可以实现用户登录的功能。比如我们首次访问
https://www.acurd.com
- 我们第二次再访问
go操作session
go并不像php那样原生就支持session，我们可以根据自己的需求实现一个session库，也可以使用第三方的库，这也再次说明了session并不是什么神秘的技术，而是基于服务端对客户端cookie的读写来实现的。
这里我们使用第三方库来演示一下
package main
import (
"fmt"
"github.com/gorilla/mux"
"github.com/gorilla/sessions"
"log"
"net/http"
)
var store = sessions.NewCookieStore([]byte("secret-key"))
// 自定义一个账户和密码
var name, pwd = "acurd", "acurdpwd"
func LoginHandler(w http.ResponseWriter, r *http.Request) {
//获取session
session, _ := store.Get(r, "session_id")
//打印session信息
fmt.Printf("%+v", session.Values)
if !session.IsNew {
fmt.Fprintf(w, "你已经登录了
")
return
}
r.ParseForm() // 解析参数，默认是不会解析的
fmt.Println(r.Form) // 这些信息是输出到服务器端的打印信息
//有的话校验登录
username := r.FormValue("username")
password := r.FormValue("password")
if username == name && password == pwd {
session.Values["username"] = username
// 将session保存
err := session.Save(r, w)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fmt.Fprintf(w, "登录成功
")
return
}
//没有的话提示输入用户名密码
fmt.Fprintf(w, "用户名或密码失败
")
}
func main() {
// 创建路由
r := mux.NewRouter()
r.HandleFunc("/login", LoginHandler)
err := http.ListenAndServe(":8002", r)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
缺点
cookie+session这种方式的缺点
- 依赖cookie实现，所以客户端不能禁用cookie
- cookie可能被截获，别人利用我们的cookie信息就可以跳过登录验证
- session是如果是存储在服务器内存的话，当我们跨服务器访问的时候，不能识别登录状态
- 如果用户量很大的话，session占用的服务器内存也就越大。
Token
- 基于Token的认证是近几年非常流行的认证方式。基于token的认证中，最常用的是JSON Web Tokens,即JWT（JSON Web Token的缩写）,这种方式摒弃了传统的基于cookie和session的登录认证，可以实现跨域认证。
JWT
jwt登录的流程
- 第一次请求使用 用户名+密码完成登录
- 登录成功颁发token，token里面可以有你自定义的一些信息，比如用户名，用户id，会被加密后返回给前端
- 前端保留此token，每次请求的时候带上该token，后端解析后就可以读取token里的用户名和用户id
- 只要服务端使用的是同一个秘钥，token都会被解析成功，也就是说解决了跨域登录的问题。
jwt的数据结构
我们先来看一个token长什么样子，比如这个eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VybmFtZSI6ImFjdXJkIiwiVWlkIjoxMiwic3ViIjoiVG9rZW4iLCJleHAiOjE2ODc4Njk2NjYsImlhdCI6MTY4Nzg2NjA2Nn0._hIRJDrLV8co1gZPKKxG2AyMVFRapl-nt-Kqbb-r8bg,我们看到这个token被.分割成了三部分，那么这三部分代表什么含义呢？我们先来还原一下这三部分怎么来的
- 第一部分
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9是对算法和type的加密，加密算法是base64.urlencode，相关代码如下：
func TestDemoTwo28(t *testing.T) {
type JWTHeader struct {
Alg string `json:"alg"`
Typ string `json:"typ"`
}
header := JWTHeader{
Alg: "HS256",
Typ: "JWT",
}
headerBytes, _ := json.Marshal(header)
headerBase64 := base64.RawURLEncoding.EncodeToString(headerBytes) // 对字节数组进行 Base64 编码
fmt.Println(headerBase64) // 输出编码后的 JWT Header
}
执行结果是一模一样的
- 第二部分
eyJVc2VybmFtZSI6ImFjdXJkIiwiVWlkIjoxMiwic3ViIjoiVG9rZW4iLCJleHAiOjE2ODc4Njk2NjYsImlhdCI6MTY4Nzg2NjA2Nn0其实也是base64.urlencode加密得来的，加密的对象就是我们存储的数据，咱们可以用解码的方式解析一下看看
相关代码如下
func TestDemoTwo28(t *testing.T) {
str := "eyJVc2VybmFtZSI6ImFjdXJkIiwiVWlkIjoxMiwic3ViIjoiVG9rZW4iLCJleHAiOjE2ODc4Njk2NjYsImlhdCI6MTY4Nzg2NjA2Nn0"
decodeString, _ := base64.RawURLEncoding.DecodeString(str)
fmt.Printf("%s", string(decodeString))
}
执行结果如下
通过第一部分和第二部分我们看到了，这是一种可逆的加密，所以不要放重要数据（也可以再次对payload的数据对称加密，保证数据不外泄），比如登录密码，手机号。接下来看第三部分。这里我贴一份可逆加密的代码
package main
import (
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"encoding/hex"
"fmt"
)
func main() {
// 原始数据
source := "Hello, world!"
fmt.Println("原文：", source)
// 密钥，必须是 16、24 或 32 字节
key := "example key 1234"
// 加密
encryptCode := AESEncrypt([]byte(source), []byte(key))
fmt.Println("密文（byte）：", encryptCode)
// 使用 hex 编码打印
fmt.Println("密文（hex）：", hex.EncodeToString(encryptCode))
// 使用 base64 编码打印
fmt.Println("密文（base64）：", base64.StdEncoding.EncodeToString(encryptCode))
// 解密
decryptCode := AESDecrypt(encryptCode, []byte(key))
fmt.Println("解密后的原文：", string(decryptCode))
}
// AESEncrypt 使用 AES 加密数据
func AESEncrypt(data, key []byte) []byte {
block, err := aes.NewCipher(key)
if err != nil {
panic(err)
}
ciphertext := make([]byte, aes.BlockSize+len(data))
iv := ciphertext[:aes.BlockSize]
stream := cipher.NewCFBEncrypter(block, iv)
stream.XORKeyStream(ciphertext[aes.BlockSize:], data)
return ciphertext
}
// AESDecrypt 使用 AES 解密数据
func AESDecrypt(data, key []byte) []byte {
block, err := aes.NewCipher(key)
if err != nil {
panic(err)
}
if len(data) < aes.BlockSize {
panic("ciphertext too short")
}
iv := data[:aes.BlockSize]
data = data[aes.BlockSize:]
stream := cipher.NewCFBDecrypter(block, iv)
stream.XORKeyStream(data, data)
return data
}
- 第三部分
_hIRJDrLV8co1gZPKKxG2AyMVFRapl-nt-Kqbb-r8bg这个数值是怎么来的呢？就是基于前两段的值+秘钥计算得来，具体算法如下HMACSHA256( base64UrlEncode(header) + "." +base64UrlEncode(payload), secret )，这一部分才是校验我们数据的准确性，比如数据是否早到篡改。
我们可以通过https://jwt.io/更直观的观察结果
这个时候，是不是上来就是一句卧槽，原来token是可以被解析的，那我的token岂不是不安全，说的对，token只是实现登录认证，并不保证你的数据不外泄，所以我们不能把重要的信息放到token里面去。但是如果你篡改了数据，伪造登录，由于别人没有你的秘钥，导致第三段校验失败，就可以拦截非法登录了。
其实了解了jwt的实现机制，我们自己也可以定义一套自己的token机制来实现登录功能。
下面我们来看一下别人已经造好的轮子是怎么用的。
使用jwt实现登录功能
我们使用go的第三方包来实现jwt登录功能
怎么找包
怎么找包要认真说，还真是一个技术活，你要是网上随便搜一个，那么第一安全性，可靠性都可能会有问题，更别谈后期的维护了。那么一般我们怎么找包呢？github上面通过 语言+关键词来搜索，一般使用star最多的就行了，比如我们在github 搜 go jwt 我们看到第一个和第二个其实是一个仓库，所以我们使用github.com/golang-jwt/jwt/v5这个包
- 下面是jwt登录功能的相关代码
package main
import (
"fmt"
"github.com/golang-jwt/jwt/v5"
"github.com/gorilla/mux"
"log"
"net/http"
"time"
)
// 定义自己的秘钥 所有的服务必须用一个秘钥才能正确解析token
var privateKey = []byte("my_secret_key")
// 自定义一个账户和密码 用户uid 这里简单举个例子,一般是去数据库校验
var name, pwd, uid = "acurd", "acurdpwd", 12
// UserClaims 我们声明一个结构体,里面包含我们想要保存的信息
type UserClaims struct {
Username string
Uid int64
jwt.RegisteredClaims // 内嵌标准的声明
}
// GenToken 生成token
func GenToken(username string, uid int64) (string, error) {
//初始化结构体
claims := UserClaims{
Uid: uid,
Username: username,
RegisteredClaims: jwt.RegisteredClaims{
//设置过期时间
ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Second * 3600)),
//颁发时间
IssuedAt: jwt.NewNumericDate(time.Now()),
//主题
Subject: "Token",
},
}
//生成token 使用hs256 加密 结构体,然后再用秘钥对其做数字签名
return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(privateKey)
}
// 解析token
func parseToken(tokenString string) (*UserClaims, error) {
claims := new(UserClaims)
token, err := jwt.ParseWithClaims(tokenString, claims, keyFunc)
//建议token是否有效
if token.Valid {
return claims, nil
}
return nil, err
}
func keyFunc(token *jwt.Token) (interface{}, error) {
return privateKey, nil
}
func LoginHandler(w http.ResponseWriter, r *http.Request) {
//限制post提交
if r.Method != "POST" {
fmt.Fprintf(w, "非法登录
")
return
}
//获取token
auth := r.Header.Get("Authorization")
if len(auth) > 0 { //刺入还可以加入对
//打印token信息
fmt.Println(auth)
//校验token
claims, err := parseToken(auth)
if err != nil {
fmt.Fprintf(w, "解析token失败
")
return
}
//
fmt.Fprintf(w, "您已经登录了
相关token解析如下:%+v", claims)
return
}
r.ParseForm() // 解析参数，默认是不会解析的
fmt.Println(r.Form) // 这些信息是输出到服务器端的打印信息
//有的话校验登录
username := r.FormValue("username")
password := r.FormValue("password")
if username == name && password == pwd {
// 生成token并返回
token, err := GenToken(username, int64(uid))
if err != nil {
fmt.Fprintf(w, "生成token失败
")
}
// 将token保存
fmt.Fprintf(w, "登录成功
请保存好你的token:%s", token)
return
}
//没有的话提示输入用户名密码
fmt.Fprintf(w, "用户名或密码失败
")
}
func main() {
// 创建路由
r := mux.NewRouter()
r.HandleFunc("/login", LoginHandler)
err := http.ListenAndServe(":8002", r)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
- 我们运行一下上面的代码 第一次获取到token
- 第二次带token请求
- 如果修改里面的任意一个字符
jwt的刷新机制
场景1:我们用QQ或者微信，不可能每打开一次都执行一次登录操作，而是好长时间不用，比如一个月没有打开QQ，那么你再次打开QQ，可能就需要登录了，但是如果你经常打开QQ，可能好几个月都不需要登录，那么这是怎么实现的呢？
场景2：你设计了一套jwt的登录系统，token有效期是60分钟，用户在58分钟的时候打开了网页，在61分钟的时候点击提交，发现自己被退出登录了，你说用户气不气？
refresh_token
基于上面的两种场景，我们提出来refresh_token的机制，其实就是多了一个刷新token的触发机制，第一次登录的时候，我们给用户颁发两个token ，一个access_token，有效期比较短，比如是4小时，还有一个refresh_token ，就是刷新token，假设有效期是24小时。
- 第一次登录，我们返回access_token和refresh_token
- 后面的请求，我们校验access_token是否过期，没过期的放行通过，过期的话就要校验refresh_token是否过期，如果没有过期，则拿着refresh_token 下发新的access_token和新的refresh_token（下发新的refresh_token是为了避免活跃用户的频繁登录，比如24小时内只要用户登录过，就不会弹出登录窗口。具体根据业务看）。如果两个token都过期了，则重新登录。
- 相关代码如下
package main
import (
"fmt"
"github.com/golang-jwt/jwt/v5"
"github.com/gorilla/mux"
"log"
"net/http"
"time"
)
// 定义自己的秘钥 所有的服务必须用一个秘钥才能正确解析token
var privateKey = []byte("my_secret_key")
// 自定义一个账户和密码 用户uid 这里简单举个例子,一般是去数据库校验
var name, pwd, uid = "acurd", "acurdpwd", 12
// UserClaims 我们声明一个结构体,里面包含我们想要保存的信息
type UserClaims struct {
Username string
Uid int64
jwt.RegisteredClaims // 内嵌标准的声明
}
// RefreshClaims 用来生成refresh token
type RefreshClaims struct {
jwt.RegisteredClaims // 内嵌标准的声明
}
// GenToken 生成token
func GenToken(username string, uid int64) (string, error) {
//初始化结构体
claims := UserClaims{
Uid: uid,
Username: username,
RegisteredClaims: jwt.RegisteredClaims{
//设置过期时间
ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Second * 30)),
//颁发时间
IssuedAt: jwt.NewNumericDate(time.Now()),
//主题
Subject: "Token",
},
}
//生成token 使用hs256 加密 结构体,然后再用秘钥对其做数字签名
return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(privateKey)
}
// 解析token
func parseToken(tokenString string) (*UserClaims, error) {
claims := new(UserClaims)
_, err := jwt.ParseWithClaims(tokenString, claims, keyFunc)
return claims, err
}
func keyFunc(token *jwt.Token) (interface{}, error) {
return privateKey, nil
}
// GenRefreshToken 生成token
func GenRefreshToken() (string, error) {
//初始化结构体
claims := UserClaims{
RegisteredClaims: jwt.RegisteredClaims{
//设置过期时间
ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Second * 3600)),
//颁发时间
IssuedAt: jwt.NewNumericDate(time.Now()),
//主题
Subject: "RefreshToken",
},
}
//生成token 使用hs256 加密 结构体,然后再用秘钥对其做数字签名
return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(privateKey)
}
// 解析token
func parseRefreshToken(tokenString string) (*RefreshClaims, error) {
claims := new(RefreshClaims)
token, err := jwt.ParseWithClaims(tokenString, claims, keyFunc)
//建议token是否有效
if token.Valid {
return claims, nil
}
return nil, err
}
func LoginHandler(w http.ResponseWriter, r *http.Request) {
//限制post提交
if r.Method != "POST" {
fmt.Fprintf(w, "非法登录
")
return
}
//获取token
auth := r.Header.Get("Authorization")
tokenRefresh := r.Header.Get("AuthorizationRef")
fmt.Println(auth)
fmt.Println(tokenRefresh)
if len(auth) > 0 {
// 解析refresh token
claimsR, err := parseRefreshToken(tokenRefresh)
if err != nil {
fmt.Fprintf(w, "token 错误或过期%s", err)
return
}
fmt.Printf("claimsR %v", claimsR)
//解析token
claims, err := parseToken(auth)
fmt.Printf("claims %+v err:%v", claims, err)
//token未过期
if claims != nil && !claims.Expired() {
fmt.Fprintf(w, "您已经登录了
相关token解析如下:%+v", claims)
return
}
token, _ := GenToken(claims.Username, int64(uid))
refreshToken, _ := GenRefreshToken()
// 将token保存
fmt.Fprintf(w, "已经更新token
请保存好你的token:%s;refreshToken:%s", token, refreshToken)
return
}
r.ParseForm() // 解析参数，默认是不会解析的
fmt.Println(r.Form) // 这些信息是输出到服务器端的打印信息
//有的话校验登录
username := r.FormValue("username")
password := r.FormValue("password")
if username == name && password == pwd {
// 生成token并返回
token, _ := GenToken(username, int64(uid))
refreshToken, _ := GenRefreshToken()
// 将token保存
fmt.Fprintf(w, "登录成功
请保存好你的token:%s;refreshToken:%s", token, refreshToken)
return
}
//没有的话提示输入用户名密码
fmt.Fprintf(w, "用户名或密码失败
")
}
// Expired 检查自定义的token结构体是否过期
func (token *UserClaims) Expired() bool {
fmt.Println(time.Now().Unix())
fmt.Println(token.ExpiresAt.Unix())
return time.Now().Unix() > token.ExpiresAt.Unix()
}
func main() {
// 创建路由
r := mux.NewRouter()
r.HandleFunc("/login", LoginHandler)
err := http.ListenAndServe(":8002", r)
if err != nil {
log.Fatal("ListenAndServe: ", err)
}
}
jwt的缺点
由于jwt是无状态的，而且token是在登录时生成的，所以会有以下两个问题
- 数据更新的问题，如果用户信息发生变更，但是token解析的还是老数据
- token一旦签发无法收回和废弃。