第三十節：Asp.Net Core中JWT刷新Token解決方案

一. 前言

1.關於JWT的Token過期問題,到底設置多久過期？

(1).有的人設置過期時間很長，比如一個月，甚至更長，等到過期了退回登錄頁面,重新登錄重新獲取token，期間登錄的時候也是重新獲取token，然后過期時間又重置為了1個月。這樣一旦token被人截取，就可能被人長期使用，如果你想禁止，只能修改token頒發的密鑰，這樣就會導致所有token都失效，顯然不太可取。

(2).有的人設置比較短，比如10分鍾，在使用過程中，一旦過期也是退回登錄頁面，這樣就可能使用過程中經常退回登錄頁面，體驗很不好。

2. 這里介紹一種比較主流的解決方案---雙Token機制

(1).訪問令牌：accessToken，訪問接口是需要攜帶的，也就是我們之前一直使用的那個，過期時間一般設置比較短，根據實際項目分析，比如：10分鍾

(2).刷新令牌：refreshToken，當accessToken過期后，用於獲取新的accessToken的時候使用，過期時間一般設置的比較長，比如：7天

3.獲取新的accessToken的時候, 為什么還需要傳入舊accessToken，只傳入refreshToken不行么？

 仔細看下面的解決思路，只傳入refreshToken也可以，但是傳入雙Token安全性更高一些。

 

二. 解決方案

1. 登錄請求過來，將userId和userAccount存到payLoad中，設置不同的過期時間，分別生成accessToken和refreshToken，二者的區別密鑰不一樣，過期時間不一樣，然后把 生成refreshToken的相關信息存到對應的表中【id，userId，token，expire】，一個用戶對應一條記錄（也可以存到Redis中，這里為了測試，存在一個全局變量中）， 每次登錄的時候，添加或者更新記錄，最后將雙Token返回給前端，前端存到LocalStorage中。

 

2. 前端訪問GetMsg獲取信息接口，表頭需要攜帶accessToken，服務器端通過JwtCheck2過濾器進行校驗，驗證通過則正常訪問，如果不通過返回401和不通過的原因，前端在Error中進行獲取,這里區分造成401的原因。

//獲取信息接口
        function GetMsg() {
            var accessToken = window.localStorage.getItem("accessToken");      
            $.ajax({
                url: "/Home/GetMsg",
                type: "Post",
                data: {},
                datatype: "json",
                beforeSend: function (xhr) {
                    xhr.setRequestHeader("Authorization", "Bearer " + accessToken);
                },
                success: function (data) {
                    if (data.status == "ok") {
                        alert(data.msg);
                    } else {
                        alert(data.msg);
                    }
                },
                //當安全校驗未通過的時候進入這里
                error: function (xhr) {
                    if (xhr.status == 401) {
                        var errorMsg = xhr.responseText;
                        console.log(errorMsg);
                        //alert(errorMsg);
                        if (errorMsg == "expired") {
                            //表示過期，需要自動刷新
                            GetTokenAgain(GetMsg);
                        } else {
                            //表示是非法請求，給出提示，可以直接退回登錄頁
                            alert("非法請求");
                        }
                    }
                }
            });
        }

3. 如果是表頭為空、校驗錯誤等等，則直接提示請求非法，返回登錄頁。

4. 如果捕獲的是expired即過期，則調用GetTokenAgain(func)方法，即重新獲取accessToken和refreshToken，這里func代表傳遞進來一個方法名，以便調用成功后重新調用原方法，實現無縫刷新； 向服務器端傳遞 雙Token， 服務器端的驗證邏輯如下：

(1). 先通過純代碼校驗refreshToken的物理合法性,如果非法，前端直接報錯，返回到登錄頁面。

(2). 從accessToken中解析出來userId等其它數據(即使accessToken已經過期，依舊可以解析出來)

(3). 拿着userId、refreshToken、當前時間去RefreshToken表中查數據，如果查不到，直接返回前端報錯，返回到登錄頁面。

(4). 如果能查到，重新生成 accessToken和refreshToken，並寫入RefreshToken表

(5). 向前端返回雙token，前端進行覆蓋存儲，然后自動調用原方法，攜帶新的accessToken，進行訪問，從而實現無縫刷新token的問題。

 //重新獲取訪問令牌和刷新令牌
        function GetTokenAgain(func) {
            var model = {
                accessToken: window.localStorage.getItem("accessToken"),
                refreshToken: window.localStorage.getItem("refreshToken")
            };
            $.ajax({
                url: '/Home/UpdateAccessToken',
                type: "POST",
                dataType: "json",
                data: model,
                success: function (data) {
                    if (data.status == "error") {
                        debugger;
                        // 表示重新獲取令牌失敗，可以退回登錄頁
                        alert("重新獲取令牌失敗");

                    } else {
                        window.localStorage.setItem("accessToken", data.data.accessToken);
                        window.localStorage.setItem("refreshToken", data.data.refreshToken);
                        func();
                    }
                }
            });

PS：以上方案，適用於單個頁面發送單個ajax請求，如果是多個請求，有順序的發送，比如第一個發送完，然后再發送第二個，這種場景是沒問題的。

但是，特殊情況如果一個頁面多個ajax並行的過來了，如果其中有一個accessToken過期了，那么它會走更新token的機制，這時候refreshToken和accessToken都更新了（數據庫中refreshToken也更新了），會導致剛才同時進來的其它ajax的refreshToken驗證不過，從而無法刷新雙token。

針對這種特殊情況，作為取舍，更新accessToken的方法中，不更新refreshToken， 那么refreshToken過期，本來也是要進入 登錄頁的，所以針對這類情況，這種取舍也無可厚非。

下面分享完整版代碼：

前端代碼：

@{
    Layout = null;
}

<!DOCTYPE html>

<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>Index</title>
    <script src="~/lib/jquery/dist/jquery.js"></script>
    <script>
        $(function () {
            $('#btn1').click(function () {
                Login();
            });
            $('#btn2').click(function () {
                GetMsg();
            });
        });

        //登錄接口
        function Login() {
            $.ajax({
                url: "/Home/CheckLogin",
                type: "Post",
                data: { userAccount: "admin", userPwd: "123456" },
                datatype: "json",
                success: function (data) {
                    if (data.status == "ok") {
                        alert(data.msg);
                        console.log(data.data.accessToken);
                        console.log(data.data.refreshToken);
                        window.localStorage.setItem("accessToken", data.data.accessToken);
                        window.localStorage.setItem("refreshToken", data.data.refreshToken);

                    } else {
                        alert(data.msg);
                    }
                },
                //當安全校驗未通過的時候進入這里
                error: function (xhr) {
                    if (xhr.status == 401) {
                        console.log(xhr.responseText);
                        alert(xhr.responseText)
                    }
                }
            });

        }

        //獲取信息接口
        function GetMsg() {
            var accessToken = window.localStorage.getItem("accessToken");      
            $.ajax({
                url: "/Home/GetMsg",
                type: "Post",
                data: {},
                datatype: "json",
                beforeSend: function (xhr) {
                    xhr.setRequestHeader("Authorization", "Bearer " + accessToken);
                },
                success: function (data) {
                    if (data.status == "ok") {
                        alert(data.msg);
                    } else {
                        alert(data.msg);
                    }
                },
                //當安全校驗未通過的時候進入這里
                error: function (xhr) {
                    if (xhr.status == 401) {
                        var errorMsg = xhr.responseText;
                        console.log(errorMsg);
                        //alert(errorMsg);
                        if (errorMsg == "expired") {
                            //表示過期，需要自動刷新
                            GetTokenAgain(GetMsg);
                        } else {
                            //表示是非法請求，給出提示，可以直接退回登錄頁
                            alert("非法請求");
                        }
                    }
                }
            });
        }

        //重新獲取訪問令牌和刷新令牌
        function GetTokenAgain(func) {
            var model = {
                accessToken: window.localStorage.getItem("accessToken"),
                refreshToken: window.localStorage.getItem("refreshToken")
            };
            $.ajax({
                url: '/Home/UpdateAccessToken',
                type: "POST",
                dataType: "json",
                data: model,
                success: function (data) {
                    if (data.status == "error") {
                        debugger;
                        // 表示重新獲取令牌失敗，可以退回登錄頁
                        alert("重新獲取令牌失敗");

                    } else {
                        window.localStorage.setItem("accessToken", data.data.accessToken);
                        window.localStorage.setItem("refreshToken", data.data.refreshToken);
                        func();
                    }
                }
            });
        }

    </script>
</head>
<body>
    <button id="btn1">模擬登陸邏輯</button>
    <button id="btn2">獲取系統信息</button>

</body>
</html>

服務器端代碼1：

（PS：如果有上面提到的特殊情況，則去掉更新機制中 4.2和4.3的代碼）

   public class HomeController : Controller
    {
        private static List<RefreshToken> rTokenList = new List<RefreshToken>();

        public IConfiguration _Configuration { get; }

        public HomeController(IConfiguration Configuration)
        {
            this._Configuration = Configuration;
        }

        /// <summary>
        /// 測試頁面
        /// </summary>
        /// <returns></returns>
        public IActionResult Index()
        {
            return View();
        }

        /// <summary>
        /// 校驗登錄
        /// </summary>
        /// <param name="userAccount"></param>
        /// <param name="userPwd"></param>
        /// <returns></returns>
        [HttpPost]
        public IActionResult CheckLogin(string userAccount, string userPwd)
        {

            if (userAccount == "admin" && userPwd == "123456")
            {

                string AccessTokenKey = _Configuration["AccessTokenKey"];
                string RefreshTokenKey = _Configuration["RefreshTokenKey"];

                //1.先去數據庫中吧userId查出來
                string userId = "001";

                //2. 生成accessToken
                //過期時間(下面表示簽名后 5分鍾過期，這里設置20s為了演示)
                double exp = (DateTime.UtcNow.AddSeconds(20) - new DateTime(1970, 1, 1)).TotalSeconds;
                var payload = new Dictionary<string, object>
                    {
                         {"userId", userId },
                         {"userAccount", userAccount },
                         {"exp",exp }
                    };
                var accessToken = JWTHelp.JWTJiaM(payload, AccessTokenKey);

                //3.生成refreshToken
                //過期時間(可以不設置，下面表示 2天過期)
                var expireTime = DateTime.Now.AddDays(2);
                double exp2 = (expireTime - new DateTime(1970, 1, 1)).TotalSeconds;
                var payload2 = new Dictionary<string, object>
                    {
                         {"userId", userId },
                         {"userAccount", userAccount },
                         {"exp",exp2 }
                    };
                var refreshToken = JWTHelp.JWTJiaM(payload2, RefreshTokenKey);

                //4.將生成refreshToken的原始信息存到數據庫/Redis中 （這里暫時存到一個全局變量中）
                //先查詢有沒有，有則更新，沒有則添加
                var RefreshTokenItem = rTokenList.Where(u => u.userId == userId).FirstOrDefault();
                if (RefreshTokenItem == null)
                {
                    RefreshToken rItem = new RefreshToken()
                    {
                        id = Guid.NewGuid().ToString("N"),
                        userId = userId,
                        expire = expireTime,
                        Token = refreshToken
                    };
                    rTokenList.Add(rItem);

                }
                else
                {
                    RefreshTokenItem.Token = refreshToken;
                    RefreshTokenItem.expire = expireTime;   //要和前面生成的過期時間相匹配

                }
                return Json(new
                {
                    status = "ok",
                    msg="登錄成功",
                    data = new
                    {
                        accessToken,
                        refreshToken
                    }
                });
            }
            else
            {
                return Json(new
                {
                    status = "error",
                    msg = "登錄失敗",
                    data = new { }
                });
            }


        }



        /// <summary>
        /// 獲取系統信息接口
        /// </summary>
        /// <returns></returns>
        [TypeFilter(typeof(JwtCheck2))]
        public IActionResult GetMsg()
        {
            string msg = "windows10";
            return Json(new { status = "ok", msg = msg });
        }



        /// <summary>
        /// 更新訪問令牌(同時也更新刷新令牌)
        /// </summary>
        /// <returns></returns>
        public IActionResult UpdateAccessToken(string accessToken, string refreshToken)
        {

            string AccessTokenKey = _Configuration["AccessTokenKey"];
            string RefreshTokenKey = _Configuration["RefreshTokenKey"];

            //1.先通過純代碼校驗refreshToken的物理合法性
            var result = JWTHelp.JWTJieM(refreshToken, _Configuration["RefreshTokenKey"]);
            if (result== "expired"|| result == "invalid" || result == "error")
            {
                return Json(new { status = "error", data = "" });
            }

            //2.從accessToken中解析出來userId等其它數據(即使accessToken已經過期，依舊可以解析出來)
            JwtData myJwtData = JsonConvert.DeserializeObject<JwtData>(this.Base64UrlDecode(accessToken.Split('.')[1]));

            //3. 拿着userId、refreshToken、當前時間去RefreshToken表中查數據
            var rTokenItem = rTokenList.Where(u => u.userId == myJwtData.userId && u.Token == refreshToken && u.expire > DateTime.Now).FirstOrDefault();
            if (rTokenItem==null)
            {
                return Json(new { status = "error", data = "" });
            }

            //4.重新生成 accessToken和refreshToken，並寫入RefreshToken表
            //4.1. 生成accessToken
            //過期時間(下面表示簽名后 5分鍾過期，這里設置20s為了演示)
            double exp = (DateTime.UtcNow.AddSeconds(20) - new DateTime(1970, 1, 1)).TotalSeconds;
            var payload = new Dictionary<string, object>
                    {
                         {"userId", myJwtData.userId },
                         {"userAccount", myJwtData.userAccount },
                         {"exp",exp }
                    };
            var MyAccessToken = JWTHelp.JWTJiaM(payload, AccessTokenKey);

            //4.2.生成refreshToken
            //過期時間(可以不設置，下面表示簽名后 2天過期)
            var expireTime = DateTime.Now.AddDays(2);
            double exp2 = (expireTime - new DateTime(1970, 1, 1)).TotalSeconds;
            var payload2 = new Dictionary<string, object>
                    {
                         {"userId", myJwtData.userId },
                         {"userAccount", myJwtData.userAccount },
                         {"exp",exp2 }
                    };
            var MyRefreshToken = JWTHelp.JWTJiaM(payload2, RefreshTokenKey);

            //4.3 更新refreshToken表
            rTokenItem.Token = MyRefreshToken;
            rTokenItem.expire = expireTime;


            //5. 返回雙Token
            return Json(new
            {
                status = "ok",
                data = new
                {
                    accessToken= MyAccessToken,
                    refreshToken= MyRefreshToken
                }
            });

        }


        /// <summary>
        /// Base64解碼
        /// </summary>
        /// <param name="base64UrlStr"></param>
        /// <returns></returns>

        public string Base64UrlDecode(string base64UrlStr)
        {
            base64UrlStr = base64UrlStr.Replace('-', '+').Replace('_', '/');
            switch (base64UrlStr.Length % 4)
            {
                case 2:
                    base64UrlStr += "==";
                    break;
                case 3:
                    base64UrlStr += "=";
                    break;
            }
            var bytes = Convert.FromBase64String(base64UrlStr);
            return Encoding.UTF8.GetString(bytes);
        }
     

    }

 服務器端代碼2：

 /// <summary>
    /// Jwt的加密和解密
    /// 注：加密和加密用的是用一個密鑰
    /// 依賴程序集：【JWT】
    /// </summary>
    public class JWTHelp
    {

        /// <summary>
        /// JWT加密算法
        /// </summary>
        /// <param name="payload">負荷部分，存儲使用的信息</param>
        /// <param name="secret">密鑰</param>
        /// <param name="extraHeaders">存放表頭額外的信息,不需要的話可以不傳</param>
        /// <returns></returns>
        public static string JWTJiaM(IDictionary<string, object> payload, string secret, IDictionary<string, object> extraHeaders = null)
        {
            IJwtAlgorithm algorithm = new HMACSHA256Algorithm();
            IJsonSerializer serializer = new JsonNetSerializer();
            IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
            IJwtEncoder encoder = new JwtEncoder(algorithm, serializer, urlEncoder);
            var token = encoder.Encode(payload, secret);
            return token;
        }

        /// <summary>
        /// JWT解密算法
        /// </summary>
        /// <param name="token">需要解密的token串</param>
        /// <param name="secret">密鑰</param>
        /// <returns></returns>
        public static string JWTJieM(string token, string secret)
        {
            try
            {
                IJsonSerializer serializer = new JsonNetSerializer();
                IDateTimeProvider provider = new UtcDateTimeProvider();
                IJwtValidator validator = new JwtValidator(serializer, provider);
                IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
                IJwtDecoder decoder = new JwtDecoder(serializer, validator, urlEncoder);
                
                var json = decoder.Decode(token, secret, true);
                //校驗通過，返回解密后的字符串
                return json;
            }
            catch (TokenExpiredException)
            {
                //表示過期
                return "expired";
            }
            catch (SignatureVerificationException)
            {
                //表示驗證不通過
                return "invalid";
            }
            catch (Exception)
            {
                return "error";
            }
        }


    }

 服務器端代碼3：

 public class RefreshToken
    {
        //主鍵
        public string id { get; set; }
        //用戶編號
        public string userId { get; set; }
        //refreshToken
        public string Token { get; set; }
        //過期時間
        public DateTime expire { get; set; }
    }
}

   public class JwtData
    {
        public DateTime expire { get; set; }  //代表過期時間

        public string userId { get; set; }  

        public string userAccount { get; set; }
    }

過濾器代碼：

 /// <summary>
    /// Bearer認證,返回ajax中的error
    /// 校驗訪問令牌的合法性
    /// </summary>
    public class JwtCheck2 : ActionFilterAttribute
    {

        private IConfiguration _configuration;
        public JwtCheck2(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        /// <summary>
        /// action執行前執行
        /// </summary>
        /// <param name="context"></param>
        public override void OnActionExecuting(ActionExecutingContext context)
        {
            //1.判斷是否需要校驗
            var isSkip = context.ActionDescriptor.EndpointMetadata.Any(x => x.GetType() == typeof(SkipAttribute));
            if (isSkip == false)
            {
                //2. 判斷是什么請求(ajax or 非ajax)
                var actionContext = context.HttpContext;
                if (IsAjaxRequest(actionContext.Request))
                {
                    //表示是ajax
                    var token = context.HttpContext.Request.Headers["Authorization"].ToString();    //ajax請求傳過來
                    string pattern = "^Bearer (.*?)$";
                    if (!Regex.IsMatch(token, pattern))
                    {
                        context.Result = new ContentResult { StatusCode = 401, Content = "token格式不對!格式為:Bearer {token}" };
                        return;
                    }
                    token = Regex.Match(token, pattern).Groups[1]?.ToString();
                    if (token == "null" || string.IsNullOrEmpty(token))
                    {
                        context.Result = new ContentResult { StatusCode = 401, Content = "token不能為空" };
                        return;
                    }
                    //校驗auth的正確性
                    var result = JWTHelp.JWTJieM(token, _configuration["AccessTokenKey"]);
                    if (result == "expired")
                    {
                        context.Result = new ContentResult { StatusCode = 401, Content = "expired" };
                        return;
                    }
                    else if (result == "invalid")
                    {
                        context.Result = new ContentResult { StatusCode = 401, Content = "invalid" };
                        return;
                    }
                    else if (result == "error")
                    {
                        context.Result = new ContentResult { StatusCode = 401, Content = "error" };
                        return;
                    }
                    else
                    {
                        //表示校驗通過,用於向控制器中傳值
                        context.RouteData.Values.Add("auth", result);
                    }

                }
                else
                {
                    //表示是非ajax請求，則auth拼接在參數中傳過來
                    context.Result = new RedirectResult("/Home/NoPerIndex?reason=null");
                    return;
                }
            }

        }


        /// <summary>
        /// 判斷該請求是否是ajax請求
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private bool IsAjaxRequest(HttpRequest request)
        {
            string header = request.Headers["X-Requested-With"];
            return "XMLHttpRequest".Equals(header);
        }
    }

 

三. 測試

 　　將accessToken的過期時間設置為20s，點擊登錄授權后，等待20s，然后點擊獲取信息按鈕，依舊能獲取信息，無縫銜接，進行了雙token的更新。

 

 

 

 

 

 

 

!

• 作       者 : Yaopengfei(姚鵬飛)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 聲     明1 : 如有錯誤，歡迎討論，請勿謾罵^_^。
• 聲     明2 : 原創博客請在轉載時保留原文鏈接或在文章開頭加上本人博客地址，否則保留追究法律責任的權利。