JWT 用法

1. 前端通过一个获取用户信息的接口，传给后端一个 code，后端给返回一个 jwt
   jwt 包含三部分：
   header.payload.Signature
   最终格式

const token = base64(header) + '.' + base64(payload) + '.'+ base64(Signature)

比如：

eyJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjoiMGMxMDczOTYtZTRmZC00ZWI5LWE4M2ItNjQ2ZTRhZWE1NTZmIiwiZXhwIjoxNjU1ODkwODU2fQ.PULc3JkxEj1c0OJ7l6kL0IrGSu5eB37PaJBZlTSiI38
header: eyJhbGciOiJIUzI1NiJ9
payload: eyJ1c2VyX2lkIjoiMGMxMDczOTYtZTRmZC00ZWI5LWE4M2ItNjQ2ZTRhZWE1NTZmIiwiZXhwIjoxNjU1ODkwODU2fQ
Signature: PULc3JkxEj1c0OJ7l6kL0IrGSu5eB37PaJBZlTSiI38

1). header: 算法的类型

{
  'alg': 'HS256' 用到的算法
  'typ': 'JWT' 类型用来做什么的（登录、刷新...）
}

2). payload: 我们需要的 body 内容

{
  "loggedInAs": "admin",
  "exp": 1111111 // 过期时间
}

3). Signature: 加密(私钥, base64(header), base64(payload))

2. 前端拿到 jwt，把jwt存到 localStroage 里
3. 配置请求库在所有的 header 里的Authorization字段里都带上 这个 jwt

如果我们想看具体每部分的内容可以反 base64

// 将base64转成普通格式
window.atob('xxx')
// 将普通格式转成 base64
window.btoa('xxx')

实现

1. 创建路由

• config/routes.rb

Rails.application.routes.draw do
  get '/', to: 'home#index'
  # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html

  namespace :api do
    namespace :v1 do
      # /api/v1
      resource :session, only: [:create, :destroy]
    end
  end
end

2. 创建对应的 controller

bin/rails g controller api/v1/sessions_controller

3. 写测试用例

• sessions_spec.rb

require 'rails_helper'

RSpec.describe "Sessions", type: :request do
  describe "会话" do
    it "登录（创建会话）" do
      post '/api/v1/session', params: {email: 'wanglifa1995@qq.com', code: '123456'}
      expect(response).to have_http_status(200)
      json = JOSN.parse response.body
      expect(json['jwt']).to be_a(String)
    end
  end
end

• sessions_controller.rb

class Api::V1::SessionsController < ApplicationController
  def create
    # 如果是测试环境， code 就永远是 123456
    if Rails.env.test?
      code = '123456'
    else
      code = params[:code]
    end
  end
end

4. 实现 controller

• sessions_controller.rb

class Api::V1::SessionsController < ApplicationController
  def create
    # 如果是测试环境
    if Rails.env.test?
      # 如果code不等于123456，则返回 401
      if params[:code] != '123456'
        return render status: 401
      end
    else
      # 如果不是测试环境，通过数据表里有没有email 是用户传的 email code 是用户传的 code, used_at 是空（说明这个code没用过）
      # 来判断可不可以登录
      canSignin = ValidationCodes.exists? email: params[:email], code: params[:code], used_at: nil
      if !canSignin
        return  render status: 401
      end
    end
    # 通过 email 来查找这个用户
    user = User.find_by_email params[:email]
    # 如果用户不存在
    if user.nil?
      render status: 404, json: {error: '用户不存在'}
    else
      render status: 200, json: {
        jwt: 'xxxxx'
      }
    end
  end
end

然后在测试用例里先创建一个email

describe "会话" do
    it "登录（创建会话）" do
+      User.create email: 'wanglifa1995@qq.com'
      post '/api/v1/session', params: {email: 'wanglifa1995@qq.com', code: '123456'}
      expect(response).to have_http_status(200)
      json = JSON.parse response.body
      expect(json['jwt']).to be_a(String)
    end
  end

生成JWT

gem 'jwt'
bundle install

修改 controller

require 'jwt'
if user.nil?
      render status: 404, json: {error: '用户不存在'}
    else
      # 私钥
+      hmac_secret = 'my$ecretKey'
+      payload = { user_id: user.id }
+      token = JWT.encode payload, hmac_secret, 'HS256'
      render status: 200, json: {
        jwt: token
      }
    end

将我们的私钥通过临时文件保存

EDITOR="code --wait" bin/rails credentials:edit

添加一个 hmac_secret 的key

hmac_secret: xxxxxxx

然后替换

hmac_secret = Rails.application.credentials.hmac_secret

解密

创建 router

resource :me, only: [:show]

创建 controller

bin/rails g controller api/v1/me_controller

写测试

• me_spec.rb

require 'rails_helper'

RSpec.describe "Me", type: :request do
  describe "获取当前用户" do
    it "登录后成功获取" do
      user = User.create email: 'wanglifa1995@qq.com'
      post '/api/v1/session', params: {email: 'wanglifa1995@qq.com', code: '123456'}
      json = JSON.parse response.body
      jwt = json['jwt']
       # 在请求头添加Authorization 值为 jwt
      get '/api/v1/me', headers: {'Authorization': "Bearer #{jwt}"}
      expect(response).to have_http_status(200)
      json = JSON.parse response.body
      expect(json['resource']['id']).to eq user.id
    end
  end
end 

实现 controller

class Api::V1::MesController < ApplicationController
  def show
    header = request.headers['Authorization']
    # 如果 header.split(' ')[1] 获取报错就让它等于空字符串，rescue 就相当于 try catch
    jwt = header.split(' ')[1] rescue ''
    payload = JWT.decode jwt, Rails.application.credentials.hmac_secret, true, { algorithm: 'HS256' } rescue ''
    if payload.nil?
      return head 400
    end
    user_id = payload[0]['user_id'] rescue nil
    user = User.find user_id
    if user.nil?
      head 404
    else
      render json: { resource: user }
    end
  end 
end

将 JWT 做成中间件

原因：我们每个接口里面都需要获取 jwt，这样我们在每个接口的 Controller 都需要写重复的代码
中间件可以帮助我们在每次进入这个 Controller 之前先获取到我们需要的 jwt
1). 在 lib 目录下新建

• auto_jwt.rb

class AutoJwt
  # 初始化函数
  def initialize(app)
  end
  # call 中间件被调用的时候要执行的函数
  # env 参数就包含你所有需要的信息包括请求和响应信息
  def call(env)
    # ruby 默认会 return 最后一句
    # call 必须返回三个值，分别为状态码，响应头，响应体
    {200, {}, ['Hello, world', 'hi']}
  end
end

2). 使用

• config/application.rb

# require_relative 引入相对路径
+ require_relative "../lib/auto_jwt"
module Mangosteen1
  class Application < Rails::Application
+    config.middleware.use AutoJwt
  end
end

直接运行上面的代码我们的所有controller 都不会执行，所以要想执行 controller 我们得修改一下我们的 Auto_jwt

class AutoJwt
  def initialize(app)
    @app = app
  end
  def call(env)
    # 获取 header 里的 authorization
    header = env['HTTP_AUTHORIZATION'] 
    # 从authorization获取 jwt
    jwt = header.split(' ')[1] rescue ''
    # 获取解密后的结果 
    payload = JWT.decode jwt, Rails.application.credentials.hmac_secret, true, { algorithm: 'HS256' } rescue nil
    # 拿到 payload 第一部分里的user_id把它放到 env['current_user_id'] 里
    env['current_user_id'] = payload[0]['user_id'] rescue nil
    # 执行我们所有的 controller，@status, @headers, @response 这三个变量是执行每个 controller 给我们返回的
    @status, @headers, @response = @app.call(env)
    [@status, @headers, @response]
  end
end 

在我们的 controller 里获取到 current_user_id

• mes_controller.rb

- header = request.headers["Authorization"]
- jwt = header.split(' ')[1] rescue ''
- payload = JWT.decode jwt, - Rails.application.credentials.hmac_secret, true, { algorithm: 'HS256' } rescue nil
- return head 400 if payload.nil?
- user_id = payload[0]['user_id'] rescue nil
+ user_id = request.env['current_user_id'] rescue nil

直接使用 rspec -e 用例的名字 跑指定用例

$ rspec -e "登录后成功获取"

设置 JWT 过期时间

• app/models/user.rb

- payload = { user_id: self.id }
# exp 过期时间字段：(Time.now + 2.hours).to_i  当前时间加两个小时转整数
+ payload = { user_id: self.id, exp: (Time.now + 2.hours).to_i }

• lib/auto_jwt.rb

def call(env)
+    # jwt 跳过以下路径
 +   return @app.call(env) if ['/api/v1/session'].include? env['PATH_INFO']

    header = env['HTTP_AUTHORIZATION']
    jwt = header.split(' ')[1] rescue ''
-    payload = JWT.decode jwt, Rails.application.credentials.hmac_secret, true, { algorithm: 'HS256' } rescue nil
+    begin
+      payload = JWT.decode jwt, Rails.application.credentials.hmac_secret, true, { algorithm: 'HS256' } 
+    rescue JWT::ExpiredSignature
+      return [401, {}, [JSON.generate({reason: 'token已过期'})]]
+    rescue  
+      return [401, {}, [JSON.generate({reason: 'token无效'})]]
+    end

测试 JWT 过期

• api/v1/me_spec.rb

+ require 'active_support/testing/time_helpers'

it "jwt过期" do
      # 更改时间为三小时前
      travel_to Time.now - 3.hours
      user1 = User.create email: '1@qq.com'
      jwt = user1.generate_jwt
      
      # 把时间恢复到现在
      travel_back
      # 把三小时前生成的 jwt 放进 header 里
      get '/api/v1/me', headers: {'Authorization': "Bearer #{jwt}"}
      expect(response).to have_http_status(401)
    end
    it "jwt没过期" do
      travel_to Time.now - 1.hours
      user1 = User.create email: '1@qq.com'
      jwt = user1.generate_jwt

      travel_back
      get '/api/v1/me', headers: {'Authorization': "Bearer #{jwt}"}
      expect(response).to have_http_status(200)
    end

refreshToken

我们设置了我们的jwt过期时间为2小时，那么2小时后就失效了，所以我们有两个选择
1). 让用户重新登录，但是这样交互体验不太好
2). 后端除了生成一个jwt还帮我生成一个随机数xxx（这个随机数就是一个hash表也就是 refreshToken 表，通过这个随机数对应相关联的用户），下次再次请求的时候如果jwt过期了，直接用这个随机数请求一个新的 refresh api，然后就会下发给前端一个新的 jwt，如果这个随机数的有效期是七天的话，七天后再次请求会提示用户重新登录

内容

1. 随机数
2. 无状态的jwt，可以是空对象，也可以里面有type: refresh