Vue、Vuex+Cookie 实现自动登陆 。

概述

　　1、自动登陆实现思路。

　　2、vuex + cookie 多标签页状态保持。

自动登陆的需求：

　　1、登陆时勾选自动登陆，退出登陆或登陆到期后再次登陆后自动填写表单（记住密码）或访问登陆页自动登陆。

　　2、安全性需求，cookie 的有效性判断应该放到服务端。

实现细节

　　1、后台：一个静态的登陆管理类 负责管理登陆用户，这里设计了两个 cookie 一个用来保存登陆信息、一个用来保存自动登陆信息。

登陆cookie 的有效时间是 30 分钟，自动登陆cookie 的有效时间是 3 天，分别保存了用户名、编码、密码；用户名、编码、密码、时间戳。

后台包含，RSA加密算法、cookie 管理、登陆相关业务（登入、登出、过滤器）。不干兴趣跳过，看前端代码。

    /// <summary>
    /// 登录用户管理
    /// </summary>
    public static class LoginUserManager
    {
        public const string DBENLOGININ = "DBEN.OP.LOGININ";
        public const string DBENAUTOLOGIN = "DBEN.OP.AUTOLOGIN";
        public const string DBENUSERCODE = "DBEN.OP.USERCODE";
        public const string DBENUSERNAME = "DBEN.OP.USERNAME";
        public const string DBENUSERPWD = "DBEN.OP.USERPASSWORD";

        /// <summary>
        /// RSA 加解密实例
        /// </summary>
        public static RSAApply RSAApply
        {
            get
            {
                return new RSAApply(
         ConfigHelper.GetAppSetting("DBEN.StaticRSAPublicKey", @"MIGfM
A0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDBRxFQos7Nc77goLB6cz2SM6Ae7OuuOTkycG2eyP
Lds7+hE8s6bqJMfdY6EOlPjGraATXSCsrPnowWeq2p59xyejJLlCfX3dE+Br5FuUG+MwK7K6i
HQ2lJLZlvnnmDqjmHO2+k14VOFwlXNOKkciWVsjT/mr4Xj4olG2gjOhWvqQIDAQAB"),
         ConfigHelper.GetAppSetting("DBEN.StaticRSAPrivateKey", @"MIIC
dwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMFHEVCizs1zvuCgsHpzPZIzoB7s6
645OTJwbZ7I8t2zv6ETyzpuokx91joQ6U+MatoBNdIKys+ejBZ6rann3HJ6MkuUJ9fd0T4Gvk
W5Qb4zArsrqIdDaUktmW+eeYOqOYc7b6TXhU4XCVc04qRyJZWyNP+avhePiiUbaCM6Fa+pAgM
BAAECgYAePxDmnZPfcw2b+YmkoAQyrQGR1WHMkgfxbMa64pefOlHy0zYqnsWnUsoDrEHWwRK3
qxjRFf9HHnity+UBgddtjRrSW9ly+5zSvTTVb3wHfSqV/xJsakZ3M8MjVLCQXZarXTbRlYBnx
eFLcvvfouDHbefK6cqIpEk1uWllq7eNQQJBAOpWf2gsvGnFTU0vrx77Ed1QHH0C4ldss63N91
/YbrmNl9jQNcWD2DG3tw3ToSM8JIAb1Rdw9/kwpoqW9qp0mI8CQQDTJOWQum/+oovU7MZrgzR
K3N/wVXt4GIDgL4k48NSvzA+jRGf5MdphsqQKHuws9F4O+P7w/mK2QOHx4ys8OqBHAkEAnj6L
Cu4qzcJO0TDCMUmaZrkSg9jOv/rH2zabNj4Rh3v2bpMrvJWsCObm1o9y4Thb7abd31aKHdycm
joXmEPkQQJAW62hn/3TsxSQ8pr8bKJDil3tPkVfnv3Et5LsWjT3pH1OLO3+10y2LcWLRHm4wq
w4SvgCelF6OvhhIs4ob7Zk8QJBAIXEwsLcy9xZaRt85dIWuJFfbuAmCXiNWSJEhIFYPkLUvi2
QHZTdLHpSbi5oCPIVKw4CDTAP4b+JfGrrFaZjWNc="));
            }
        }

        /// <summary>
        /// 已登录
        /// </summary>
        /// <param name="userCode"></param>
        public static void SetLoginIn(string userCode, string userName, string userPassword)
        {
            var dic = new Dictionary<string, string>
            {
                { DBENUSERCODE, userCode },
                { DBENUSERNAME, userName },
                { DBENUSERPWD, userPassword }
            };
            CookieManager.SetCookie(DBENLOGININ, RSAApply.GetCiphertext(dic, false));
        }

        public static void SetLoginOut()
        {
            CookieManager.RemoveCookie(DBENLOGININ);
        }

        /// <summary>
        /// 自动登录
        /// </summary>
        /// <param name="userCode"></param>
        public static void SetAutoLogin(string userCode, string userName, string userPassword)
        {
            if (CookieManager.GetCookie(DBENAUTOLOGIN) == null)
            {
                //首次勾选自动登录，创建自动登录的cookie。
                var dic = new Dictionary<string, string>
                {
                    { DBENUSERCODE, userCode },
                    { DBENUSERNAME, userName },
                    { DBENUSERPWD, userPassword }
                };
                CookieManager.SetCookie(new HttpCookie(DBENAUTOLOGIN, RSAApply.GetCiphertext(dic, true)) { Expires = DateTime.Now.AddDays(RSAApply.ValidityDays) });
            }
            //通过自动登录也要设置已登录的 cookie
            SetLoginIn(userCode, userName, userPassword);
        }

        /// <summary>
        /// 检查客户端状态
        /// </summary>
        /// <returns></returns>
        public static bool CheckClientStatus(out Dictionary<string, string> user)
        {
            /****
             * 如果存在 已登录 cookie 且译文有效，用户未被禁用，则返回true
             * 否则检验 自动登录 cookie。
             * 自动登录 cookie 存在且译文有效，自动登录后返回 true。
             * */

            var cookie = CookieManager.GetCookie(DBENLOGININ);
            if (cookie != null)
            {
                return CheckCiphertext(cookie.Value, out user);
            }
            else
            {
                // 如果不是已登录，检查是否存在自动登录 cookie
                cookie = CookieManager.GetCookie(DBENAUTOLOGIN);
                if (cookie != null)
                {
                    if (CheckCiphertext(cookie.Value, out user))
                    {
                        //将此用户设置为已登录
                        SetLoginIn(user[DBENUSERCODE], user[DBENUSERNAME], user[DBENUSERPWD]);
                        return true;
                    }
                }
                user = null;
                return false;
            }
        }

        /// <summary>
        /// 获取客户端用户信息
        /// </summary>
        /// <returns>返回一个从 cookie 创建的新实例</returns>
        public static OPUserEntity GetClientUserInfo()
        {
            OPUserEntity res = null;
            if (CheckClientStatus(out Dictionary<string, string> user))
            {
                res = new OPUserEntity
                {
                    Code = user[DBENUSERCODE],
                    UserName = user[DBENUSERNAME],
                    Password = user[DBENUSERPWD]
                };
            }
            return res;
        }

        /// <summary>
        /// 校验密文有效性，包括密文能否解密、账户有效性。
        /// </summary>
        /// <param name="ciphertext">密文</param>
        /// <param name="user">如果返回值为方式则返回一个空实例</param>
        /// <returns></returns>
        private static bool CheckCiphertext(string ciphertext, out Dictionary<string, string> user)
        {
            user = new Dictionary<string, string>();
            var repo = RF.ResolveInstance<OPUserEntityRepository>();
            if (RSAApply.TryGetSource(ciphertext, ref user))
            {
                if (user.TryGetValue(DBENUSERCODE, out string userCode))
                {
                    if (user.TryGetValue(DBENUSERPWD, out string userPwd))
                    {
                        if (user.TryGetValue(DBENUSERNAME, out string userName))
                        {
                            var count = repo.CountBy(new CommonQueryCriteria
                            {
                                { OPUserEntity.UserNameProperty,userName },
                                { OPUserEntity.CodeProperty,userCode },
                                { OPUserEntity.PasswordProperty,userPwd },
                                { OPUserEntity.EnabledProperty,true },
                            });
                            return count > 0;
                        }
                    }
                }
            }

            return false;
        }


    }

• 组合类 RSA 加密实例

    /// <summary>
    /// RSA 加密应用实例
    /// </summary>
    public class RSAApply
    {
        readonly string xmlPublicKey;
        readonly string xmlPrivateKey;
        readonly RSACryption rSACryption;
        const string TIMESTAMPKEY = "RSAApply_timeStamp";

        /// <summary>
        /// 追加时间戳情况下的有效天数 
        /// </summary>
        public int ValidityDays { get; internal set; }

        public RSAApply(string base64PublicKey, string base64PrivateKey)
        {
            this.xmlPublicKey = RSAKeyConvert.RSAPublicKeyBase64ToXml(base64PublicKey);
            this.xmlPrivateKey = RSAKeyConvert.RSAPrivateKeyBase64ToXml(base64PrivateKey);
            rSACryption = new RSACryption();
        }

        /// <summary>
        /// 获取密文
        /// </summary>
        /// <returns></returns>
        public string GetCiphertext(Dictionary<string, string> source, bool timestamp = false)
        {
            if (timestamp)
            {
                source.Add(TIMESTAMPKEY, TimeHelper.GetTStamp());
            }
            var sourceStr = JsonConvert.SerializeObject(source, Formatting.Indented);
            var ciphertext = rSACryption.RSAEncrypt(xmlPublicKey, sourceStr);
            return ciphertext;
        }

        /// <summary>
        /// 获取明文
        /// </summary>
        /// <returns></returns>
        public bool TryGetSource(string cipertext, ref Dictionary<string, string> source)
        {
            var sourceStr = rSACryption.RSADecrypt(xmlPrivateKey, cipertext);
            source = JsonConvert.DeserializeObject<Dictionary<string, string>>(sourceStr);

            if (source.TryGetValue(TIMESTAMPKEY, out string timeStemp))
            {
                if ((DateTime.Now - long.Parse(timeStemp).ToTimeStamp()).TotalDays > ValidityDays)
                {
                    return false;
                }
                source.Remove(TIMESTAMPKEY);
            }
            return true;
        }
    }

•  RSA 加密帮助类

public class RSACryption
    {

        #region 私有属性

        private Encoding rsaEncoding
        {
            get
            {
                return Encoding.Unicode;
            }
        }

        private Encoding hashEncoding
        {
            get
            {
                return Encoding.UTF8;
            }
        }

        #endregion

        #region RSA 加密解密

        #region RSA 的密钥产生

        /// <summary>  
        /// RSA产生密钥  
        /// </summary>  
        /// <param name="xmlPrivateKey">私钥</param>  
        /// <param name="xmlPublicKey">公钥</param>
        /// <returns></returns>
        public bool RSACreateKey(out string xmlPrivateKey, out string xmlPublicKey)
        {
            try
            {
                var rsaProvider = new RSACryptoServiceProvider(1024);
                xmlPrivateKey = rsaProvider.ToXmlString(true);
                xmlPublicKey = rsaProvider.ToXmlString(false);
                return true;
            }
            catch (Exception)
            {
                xmlPrivateKey = string.Empty;
                xmlPublicKey = string.Empty;
                return false;
            }
        }

        #endregion

        #region RSA加密函数

        /// <summary>
        /// RSA 加密
        ///   首先对原始字符串做MD5哈希，然后再对哈希值加密。
        /// </summary>
        /// <param name="publicKeyBase64String"></param>
        /// <param name="source"></param>
        /// <returns></returns>
        public string RSAEncryption(string publicKeyBase64String, string source)
        {
            string hashValue = string.Empty;
            this.ComputeMD5Hash(source, ref hashValue);
            var pck = RSAKeyConvert.RSAPublicKeyBase64ToXml(publicKeyBase64String);
            var ciphertext = this.RSAEncrypt(pck, hashValue);
            return ciphertext;
        }

        /// <summary>  
        /// RSA的加密函数  
        /// </summary>  
        /// <param name="xmlPublicKey">公钥</param>
        /// <param name="srouce">待加密文本</param>
        /// <returns></returns>
        public string RSAEncrypt(string xmlPublicKey, string srouce)
        {
            byte[] plainTextBytes = this.rsaEncoding.GetBytes(srouce);
            return this.RSAEncrypt(xmlPublicKey, plainTextBytes);
        }

        /// <summary>  
        /// RSA的加密函数   
        /// </summary>  
        /// <param name="xmlPublicKey">公钥</param>  
        /// <param name="sourceBytes">加密后的字节数组</param>  
        /// <returns></returns>  
        public string RSAEncrypt(string xmlPublicKey, byte[] sourceBytes)
        {
            try
            {
                byte[] cypherTextBytes;
                string res = string.Empty;
                var rsaProvider = new RSACryptoServiceProvider();
                rsaProvider.FromXmlString(xmlPublicKey);
                cypherTextBytes = rsaProvider.Encrypt(sourceBytes, false);
                res = Convert.ToBase64String(cypherTextBytes);
                return res;
            }
            catch (Exception) { return string.Empty; }
        }

        #endregion

        #region RSA的解密函数

        /// <summary>  
        /// RSA 解密
        ///   解密失败则返回空字符串
        /// </summary>  
        /// <param name="xmlPrivateKey">XML格式的私钥</param>  
        /// <param name="encryptString">加密后的字符串</param>  
        /// <returns>解密后的字符串</returns>  
        public string RSADecrypt(string xmlPrivateKey, string encryptString)
        {
            byte[] encryptBytes = Convert.FromBase64String(encryptString);
            return this.RSADecrypt(xmlPrivateKey, encryptBytes);
        }

        /// <summary>  
        /// RSA 解密
        ///   解密失败则返回空字符串
        /// </summary>  
        /// <param name="xmlPrivateKey">XML格式的私钥</param>  
        /// <param name="encryptBytes">加密后的字节数组</param>  
        /// <returns>解密后的字符串</returns>
        public string RSADecrypt(string xmlPrivateKey, byte[] encryptBytes)
        {
            try
            {
                var rsaProvider = new RSACryptoServiceProvider();
                rsaProvider.FromXmlString(xmlPrivateKey);
                byte[] dypherTextBytes = rsaProvider.Decrypt(encryptBytes, false);
                string res = this.rsaEncoding.GetString(dypherTextBytes);
                return res;
            }
            catch (Exception) { return string.Empty; }
        }

        #endregion

        #endregion

        #region RSA数字签名

        #region MD5 Hash

        /// <summary>  
        /// 计算Hash(MD5)
        /// </summary>  
        /// <param name="sourceString">原始字符串</param>  
        /// <param name="hashString">Hash值</param>  
        /// <returns>是否成功</returns>  
        public bool ComputeMD5Hash(string sourceString, ref string hashString)
        {
            byte[] hashBytes = new byte[0];
            var res = this.ComputeMD5Hash(sourceString, ref hashBytes);
            hashString = Convert.ToBase64String(hashBytes);
            return res;
        }

        /// <summary>  
        /// 计算Hash(MD5)
        /// </summary>  
        /// <param name="srourceString">原始字符串</param>  
        /// <param name="hashBytes">Hash值</param>  
        /// <returns>是否成功</returns>  
        public bool ComputeMD5Hash(string srourceString, ref byte[] hashBytes)
        {
            try
            {
                var md5Provider = HashAlgorithm.Create("MD5");
                byte[] buffer = this.hashEncoding.GetBytes(srourceString);
                hashBytes = md5Provider.ComputeHash(buffer);
                return true;
            }
            catch (Exception) { return false; }
        }

        #endregion

        #region RSA 创建签名

        /// <summary>  
        /// 生成RSA签名
        ///   签名算法：MD5
        /// </summary>  
        /// <param name="xmlPrivateKey">XML私钥</param>  
        /// <param name="hashString">待签名Hash值</param>  
        /// <param name="signatureString">签名的值</param>  
        /// <returns>是否成功</returns>  
        public bool CreateSignature(string xmlPrivateKey, string hashString, ref string signatureString)
        {
            byte[] hashBytes = Convert.FromBase64String(hashString);
            var signatureBytes = new byte[0];
            var res = this.CreateSignature(xmlPrivateKey, hashBytes, ref signatureBytes);
            signatureString = Convert.ToBase64String(signatureBytes);
            return res;
        }

        /// <summary>  
        /// 生成RSA签名
        ///   签名算法：MD5
        /// </summary>  
        /// <param name="xmlPrivateKey">XML私钥</param>  
        /// <param name="hashBytes">待签名Hash值</param>  
        /// <param name="signatureString">签名的值</param>  
        /// <returns>是否成功</returns>  
        public bool CreateSignature(string xmlPrivateKey, byte[] hashBytes, ref string signatureString)
        {
            var signatureBytes = new byte[0];
            var res = this.CreateSignature(xmlPrivateKey, hashBytes, ref signatureBytes);
            signatureString = Convert.ToBase64String(signatureBytes);
            return res;
        }

        /// <summary>  
        /// 生成RSA签名
        ///   签名算法：MD5
        /// </summary>  
        /// <param name="xmlPrivateKey">XML私钥</param>  
        /// <param name="hashString">待签名Hash值</param>  
        /// <param name="signatureBytes">签名的值</param>
        /// <returns>是否成功</returns>  
        public bool CreateSignature(string xmlPrivateKey, string hashString, ref byte[] signatureBytes)
        {
            byte[] hashBytes = Convert.FromBase64String(hashString);
            return this.CreateSignature(xmlPrivateKey, hashBytes, ref signatureBytes);
        }

        /// <summary>  
        /// 生成RSA签名
        ///   签名算法：MD5
        /// </summary>
        /// <param name="xmlPrivateKey">XML私钥</param>  
        /// <param name="hashBytes">待验证的Hash值</param>  
        /// <param name="signatureBytes">签名的值</param>  
        /// <returns>是否成功</returns>  
        public bool CreateSignature(string xmlPrivateKey, byte[] hashBytes, ref byte[] signatureBytes)
        {
            try
            {
                var rsaProvider = new RSACryptoServiceProvider();

                rsaProvider.FromXmlString(xmlPrivateKey);
                var rsaFormatter = new RSAPKCS1SignatureFormatter(rsaProvider);
                //设置算法
                rsaFormatter.SetHashAlgorithm("MD5");
                //执行签名   
                signatureBytes = rsaFormatter.CreateSignature(hashBytes);
                return true;
            }
            catch (Exception) { return false; }
        }

        #endregion

        #region RSA 验证签名

        /// <summary>  
        /// 验证RSA签名  
        /// </summary>  
        /// <param name="xmlPublicKey">XML公钥</param>  
        /// <param name="hashString">待验证的Hash值</param>  
        /// <param name="signatureString">签名的值</param>  
        /// <returns></returns>  
        public bool VerifySignature(string xmlPublicKey, string hashString, string signatureString)
        {
            byte[] signatureBytes = Convert.FromBase64String(signatureString);
            byte[] hashBytes = Convert.FromBase64String(hashString);
            return this.VerifySignature(xmlPublicKey, hashBytes, signatureBytes);
        }

        /// <summary>  
        /// 验证RSA签名  
        /// </summary>  
        /// <param name="xmlPublicKey">XML公钥</param>  
        /// <param name="hashBytes">待验证的Hash值</param>  
        /// <param name="signatureString">签名的值</param>  
        /// <returns></returns>  
        public bool VerifySignature(string xmlPublicKey, byte[] hashBytes, string signatureString)
        {
            byte[] signatureBytes = Convert.FromBase64String(signatureString);
            return this.VerifySignature(xmlPublicKey, hashBytes, signatureBytes);
        }

        /// <summary>  
        /// 验证RSA签名  
        /// </summary>  
        /// <param name="xmlPublicKey">XML公钥</param>  
        /// <param name="hashString">待验证的Hash值</param>  
        /// <param name="signatureBytes">签名的值</param>  
        /// <returns>验签结果</returns>  
        public bool VerifySignature(string xmlPublicKey, string hashString, byte[] signatureBytes)
        {
            byte[] hashBytes = Convert.FromBase64String(hashString);
            return this.VerifySignature(xmlPublicKey, hashBytes, signatureBytes);
        }

        /// <summary>  
        /// 验证RSA签名
        /// </summary>  
        /// <param name="xmlPublicKey">XML公钥</param>  
        /// <param name="hashBytes">待验证的Hash值</param>  
        /// <param name="signatureBytes">签名的值</param>  
        /// <returns>验签结果</returns>  
        public bool VerifySignature(string xmlPublicKey, byte[] hashBytes, byte[] signatureBytes)
        {
            try
            {
                var rsaProvider = new RSACryptoServiceProvider();
                rsaProvider.FromXmlString(xmlPublicKey);
                var rsaDeformatter = new RSAPKCS1SignatureDeformatter(rsaProvider);
                //指定解密的时候HASH算法为MD5   
                rsaDeformatter.SetHashAlgorithm("MD5");
                if (rsaDeformatter.VerifySignature(hashBytes, signatureBytes))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception) { return false; }
        }

        #endregion

        #endregion

    }

•  RSA 密钥格式转换类

    /// <summary>
    /// RSA密钥格式转换
    /// </summary>
    public class RSAKeyConvert
    {

        #region 私钥转换

        /// <summary>    
        /// RSA私钥 Base64 To XML
        /// </summary>    
        /// <param name="privateKey">Base64格式的私钥</param>    
        /// <returns></returns>   
        public static string RSAPrivateKeyBase64ToXml(string privateKey)
        {
            var privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));
            return
                string.Format(
                    "<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",
                    Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()),
                    Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),
                    Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),
                    Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),
                    Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),
                    Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),
                    Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),
                    Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
        }

        /// <summary>    
        /// RSA私钥 XML To Base64
        /// </summary>    
        /// <param name="privateKey">XML格式的私钥</param>    
        /// <returns></returns>   
        public static string RSAPrivateKeyXmlToBase64(string privateKey)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(privateKey);
            BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
            BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
            BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
            BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
            BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
            BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
            BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
            BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
            RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
            PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
            byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
            return Convert.ToBase64String(serializedPrivateBytes);
        }

        #endregion

        #region 公钥转换

        /// <summary>    
        /// RSA公钥 Base64 To XML
        /// </summary>    
        /// <param name="publicKey">Base64格式的公钥</param>    
        /// <returns></returns>    
        public static string RSAPublicKeyBase64ToXml(string publicKey)
        {
            RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
            return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
                Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
                Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
        }

        /// <summary>    
        /// RSA公钥 XML To Base64
        /// </summary>    
        /// <param name="publicKey">XML格式的公钥</param>    
        /// <returns></returns>   
        public static string RSAPublicKeyXmlToBase64(string publicKey)
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(publicKey);
            BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
            BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
            RsaKeyParameters pub = new RsaKeyParameters(false, m, p);
            SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);
            byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
            return Convert.ToBase64String(serializedPublicBytes);
        }

        #endregion

    }

•  mvc 过滤器

public class APIAuthedAttribute : ActionFilterAttribute
    {
        public override void OnActionExecuting(HttpActionContext context)
        {
            base.OnActionExecuting(context);
            if (!LoginUserManager.CheckClientStatus(out Dictionary<string, string> user))
            {
                context.Response = context.Request.CreateResponse<Result>(
                    HttpStatusCode.OK,
                    new  
                    {
                        StatusCode = 1000,
                        Message = "请先登录",
                        Success = false
                    });
            }
        }
    }

     2、前台 

• 　　添加 vuex 目录结构。

• 　　安装 vuex 、js-cookie

npm install --save vuex js-cookie 

// initial state
// shape: [{ id, quantity }]
import {AuthUser} from "../../api/api";
import * as Cookies from "js-cookie"

const state = {
    loginState: {
        loginIn: false,
        user: {
            userName: ""
        }
    }
}

// getters
const getters = {
    userName: (state, getters, rootState) => {
        if (state.loginState.loginIn) {
            return state.loginState.user.userName
        }
    },
    offLine: (state, getters, rootState) => {
        return !state.loginState.loginIn;
    }
}

//actions
const actions = {
    //从服务器端校验本地登录 Cookie 有效性
    authUser({state, commit}) {
        return  AuthUser().then(res => {
            debugger;
            if (res.Success) {
                commit('loginIn', {userName: res.Data.UserName});
                return true;
            } else {
                commit('loginOut');
                return false;
            }
        });
    }
}


// mutations
const mutations = {
    //登入状态
    loginIn(state, user) {
        state.loginState.loginIn = true;
        state.loginState.user = user;
        debugger;
        Cookies.set('loginState', state.loginState, {expires: 1});
    },
    //登出状态
    loginOut(state) {
        state.loginState.loginIn = false;
        state.loginState.user = {};
        Cookies.remove('loginState');
    },
    syncLoginState(state) {
        debugger;
        let cookieState = Cookies.getJSON('loginState');
        if (cookieState) {
            state.loginState = cookieState;
        }
    }
}

export default {
    namespaced: true,
    state,
    getters,
    actions,
    mutations
}

import Vue from 'vue'
import Vuex from 'vuex'
import user from './modules/user'

Vue.use(Vuex)

const debug = process.env.NODE_ENV !== 'production'

export default new Vuex.Store({
    modules: {
        user
    },
    strict: debug,
    plugins:  []
})

• 在入口函数添加用户登陆状态判断 比如main.js

router.beforeEach((to, from, next) => {
    debugger;
    //离线用户跳转到首页
    if (to.path != '/') {
        router.app.$store.commit('user/syncLoginState');
        if (router.app.$store.getters['user/offLine']) {

            //离线用户鉴权,如果成功会自动登录
            router.app.$store.dispatch('user/authUser').then((res) => {
                if (res) {
                    next();
                }else {
                    next({path: '/'});
                }
            });
            return;
        }
    }
    next();
});

就这些了，登入，登出等操作就不贴代码了。

总结一下用到的点：

　　1、vuex 的存储源是一个自己定义的 state 对象，也就是说是脚本中一个 实例，它的作用域是当前页面，如果再开一个浏览器标签页是取不到的。同理 localstorage 、 sessionStorage 也是一样的。

　　2、vuex actions 可以执行异步方法，可以返回 promise 。比如 请求api，执行 setTimeout ，使用  dispatch 调用，上面有例子。

　　3、用新标签页请求一个路由时，代码执行顺序： router( vue 路由守护) => app .created( vue 根实例的  life hook ) => com(路由组件)。所以讲用户状态判断放到路由守卫里。

来源：

https://www.npmjs.com/package/js-cookie   

https://vuex.vuejs.org/zh/guide/actions.html