WebAPI接口调用身份验证

Common

 public interface ICacheWriter
    {
        void AddCache(string key, object value, DateTime expDate);
        void AddCache(string key, object value);
        object GetCache(string key);
        T GetCache<T>(string key);
        void SetCache(string key, object value, DateTime extDate);
        void SetCache(string key, object value);
    }

public class CacheHelper
    {
        public static ICacheWriter CacheWriter { get; set; }

        static CacheHelper()
        {
            CacheWriter = new MemcacheWriter();
        }
        public static void AddCache(string key, object value, DateTime expDate)
        {
            CacheWriter.AddCache(key, value, expDate);
        }
        public static void AddCache(string key, object value)
        {
            CacheWriter.AddCache(key, value);
        }

        public static object GetCache(string key)
        {
            return CacheWriter.GetCache(key);
        }

        public static void SetCache(string key, object value, DateTime extTime)
        {
            CacheWriter.SetCache(key, value, extTime);
        }

        public static void SetCache(string key, object value)
        {
            CacheWriter.SetCache(key, value);
        }
    }

 public class MemcacheWriter : ICacheWriter
    {
        private MemcachedClient memcachedClient;
        public MemcacheWriter()
        {
            string strAppMemcachedServer = System.Configuration.ConfigurationManager.AppSettings["MemcachedServerList"];
            string[] servers = strAppMemcachedServer.Split(',');

            //初始化池
            SockIOPool pool = SockIOPool.GetInstance();
            pool.SetServers(servers);
            pool.InitConnections = 3;
            pool.MinConnections = 3;
            pool.MaxConnections = 5;
            pool.SocketConnectTimeout = 1000;
            pool.SocketTimeout = 3000;
            pool.MaintenanceSleep = 30;
            pool.Failover = true;
            pool.Nagle = false;
            pool.Initialize();

            MemcachedClient mc = new Memcached.ClientLibrary.MemcachedClient();
            mc.EnableCompression = false;

            memcachedClient = mc;
        }


        public void AddCache(string key, object value, DateTime expDate)
        {
            memcachedClient.Add(key, value, expDate);
        }

        public void AddCache(string key, object value)
        {
            memcachedClient.Add(key, value);
        }

        public object GetCache(string key)
        {
            return memcachedClient.Get(key);
        }

        public T GetCache<T>(string key)
        {
            return (T)memcachedClient.Get(key);
        }
        public void SetCache(string key, object value, DateTime extDate)
        {
            memcachedClient.Set(key, value, extDate);
        }

        public void SetCache(string key, object value)
        {
            memcachedClient.Set(key, value);
        }
    }

  public static class Utils
    {
        #region GetSHA1(string str) #
        public static string GetSHA1(string str)
        {
            byte[] cleanBytes = Encoding.Default.GetBytes(str);
            byte[] hashedBytes = System.Security.Cryptography.SHA1.Create().ComputeHash(cleanBytes);
            return BitConverter.ToString(hashedBytes).Replace("-", "").ToLower();
        }
        #endregion
    }

WebAPIService

   #region 获取授权的TOKEN
        /// <summary>
        /// 获取授权的TOKEN
        /// </summary>
        /// <param name="userId">当前用户ID</param>
        /// <returns></returns>
        [AcceptVerbs("GET")]
        public IHttpActionResult GetTokenResult()
        {
            long timeStamp = DateTime.Now.ConvertTimestamp();
            try
            {
                string token = Guid.NewGuid().ToString("N");
                _msg = new Message()
                 {
                     retcode = 200,
                     resTime = timeStamp,
                     toKen = token,
                     retmsg = "成功"
                 };
                //缓存到memcached 用户的TOKEN    失效时间是一分钟
                CacheHelper.SetCache(token, token, DateTime.Now.AddMinutes(1));
                var toek = CacheHelper.GetCache(token);
            }
            catch
            {
                _msg = new Message() { retcode = -1, resTime = timeStamp, retmsg = "获取TOKEN失败！" };
            }
            return Json(_msg);
        }
        #endregion

 private bool IsValideLogin(UserLoginInfo userLoginInfo, out Message msg)
        {
            msg = null;
            bool result = false;
            long timeStamp = DateTime.Now.ConvertTimestamp();
            try
            {
                //采用DES+KEY 对数据加密

                //从memcached 获取用户的授权令牌进行匹配，如果匹配上说明身份已经验证过,无需要二次验证损耗性能
                var _sign = CacheHelper.GetCache(userLoginInfo.userId.ToString(CultureInfo.InvariantCulture));
                if (_sign != null && !string.IsNullOrEmpty(_sign.ToString()))
                {
                    if (!string.IsNullOrEmpty(userLoginInfo.SIGN) &&
                            userLoginInfo.SIGN.Equals(_sign.ToString(), StringComparison.OrdinalIgnoreCase))
                    {
                        result = true;
                    }
                }

                //1.从memcached 读取用户的token 检查token 是否授权
                var _token = CacheHelper.GetCache(userLoginInfo.TOKEN);
                if (_token != null && !string.IsNullOrEmpty(_token.ToString()))
                {
                    //模拟读取数据库已配置的key密钥
                    string key = "cvuUldfieEULqfjdi92k1-lsdf#*ksdf2jd@ld0";

                    string userId = userLoginInfo.userId.ToString();
                    string timeStamps = userLoginInfo.timeStamp.ToString();

                    //3.SHA1加密匹配参数是否正确
                    string[] temps = { userId, timeStamps, key, _token.ToString() };
                    Array.Sort(temps);
                    string sign = Utils.GetSHA1(string.Join("", temps));
                    if (!string.IsNullOrEmpty(userLoginInfo.SIGN) &&
                        sign.Equals(userLoginInfo.SIGN, StringComparison.OrdinalIgnoreCase))
                    {
                        result = true;
                        //设置到memcache 设置有效期为1天时间 授权的临时令牌 分发给用户
                        //这里可以使用DES加密过的串分发给用户 DES+KEY
                        CacheHelper.SetCache(userLoginInfo.userId.ToString(CultureInfo.InvariantCulture), sign, DateTime.Now.AddDays(1));
                    }
                    else
                    {
                        msg = new Message() { resTime = timeStamp, retcode = -2000, retmsg = "身份验证失败，非法请求！" };
                        return result = false;
                    }
                }
                else
                {
                    msg = new Message() { resTime = timeStamp, retcode = -3000, retmsg = "非法请求，未授权的TOKEN" };
                    return result = false;
                }
            }
            catch
            {
                msg = new Message() { resTime = timeStamp, retcode = 500, retmsg = "身份验证服务出错！" };
                return result = false;
            }
            return result;
        }

WebAPIClient

   RestClient client = new RestClient("http://192.168.64.231:32768");

            UserLoginInfo User = new UserLoginInfo();

            #region Get 方式请求列表
            string str = client.Get("api/values");
            Message msg = JsonConvert.DeserializeObject<Message>(str);

            string userId = "10000";
            string timeStamp = msg.resTime.ToString();
            string key = "cvuUldfieEULqfjdi92k1-lsdf#*ksdf2jd@ld0";
            string[] temps = { userId, timeStamp, key, msg.toKen };
            Array.Sort(temps);
            string sign = Utils.GetSHA1(string.Join("", temps));

            //1.获取授权的TOKEN
            User.userId = userId;
            User.TOKEN = msg.toKen;
            User.SIGN = sign;
            User.timeStamp = msg.resTime.ToString();

            Console.WriteLine(str);
            #endregion


            #region Post 方式 添加数据

            string postUri = "api/values/1";

            //string userJson = @"{""Id"":123,""Age"":12,""UserInfo"":""111""}";
            string userJson = JsonConvert.SerializeObject(User);
            string postResponse = client.Post(userJson, postUri);

            Console.WriteLine(postResponse);
            #endregion


            Console.ReadKey();