asp.net MVC 通用登录验证模块

namespace MVCCommonAuth
{
[Serializable]
public class LoginUser
{
private const string DESKEY = "12345678";
public int ID { get; set; }

public string UserName { get; set; }
public string Roles { get; set; }

public DateTime Expires { get; set; }

public readonly static string CookieNamePrefix = "authcookie";

public void Login(string userType, string domain = null, string path = null)
{
var keyName = CookieNamePrefix + userType;
var json = JsonConvert.SerializeObject(this);
var value = EncryptString(json, DESKEY);

HttpCookie cookie = new HttpCookie(keyName, value);
cookie.Expires = Expires;
if (!string.IsNullOrWhiteSpace(domain))
{
cookie.Domain = domain;
}
if (path != null)
{
cookie.Path = path;
}
HttpContext.Current.Items[keyName] = this;
HttpContext.Current.Response.Cookies.Add(cookie);
}

/// <summary>
/// 从cookie读取用户信息
/// </summary>
/// <param name="cookieName"></param>
private static LoginUser BuildUser(string keyName)
{
var cookie = HttpContext.Current.Request.Cookies[keyName];
if (cookie != null && !string.IsNullOrEmpty(cookie.Value))
{
try
{
var json = DecryptString(cookie.Value, DESKEY);
var loginuser = JsonConvert.DeserializeObject<LoginUser>(json);
if (loginuser != null)
{
if (loginuser.Expires >= DateTime.Now)
{
return loginuser;
}
}
}
catch
{
//do nothing
}
}
return null;
}

public static LoginUser GetUser(string userType)
{
var keyName = CookieNamePrefix + userType;
if (!HttpContext.Current.Items.Contains(keyName))
{
var user = BuildUser(keyName);
HttpContext.Current.Items[keyName] = user;
return user;
}
else
{
return HttpContext.Current.Items[keyName] as LoginUser;
}
}

public static int GetUserID(string userType)
{
var user = GetUser(userType);
if (user != null)
return user.ID;
return 0;
}

/// <summary>
/// 退出cookie登录
/// </summary>
public static void Logout(string userType)
{
var keyName = CookieNamePrefix + userType;

HttpCookie cookie = new HttpCookie(keyName, string.Empty);
cookie.Expires = DateTime.Now.AddMonths(-1);
HttpContext.Current.Response.Cookies.Add(cookie);
}

#region 字符串加密

/// <summary>
/// 利用DES加密算法加密字符串（可解密）
/// </summary>
/// <param name="plaintext">被加密的字符串</param>
/// <param name="key">密钥（只支持8个字节的密钥）</param>
/// <returns>加密后的字符串</returns>
private static string EncryptString(string plaintext, string key)
{
//访问数据加密标准(DES)算法的加密服务提供程序 (CSP) 版本的包装对象
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Key = ASCIIEncoding.ASCII.GetBytes(key);　//建立加密对象的密钥和偏移量
des.IV = ASCIIEncoding.ASCII.GetBytes(key);　 //原文使用ASCIIEncoding.ASCII方法的GetBytes方法

byte[] inputByteArray = Encoding.Default.GetBytes(plaintext);//把字符串放到byte数组中

MemoryStream ms = new MemoryStream();//创建其支持存储区为内存的流　
//定义将数据流链接到加密转换的流
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
//上面已经完成了把加密后的结果放到内存中去
StringBuilder ret = new StringBuilder();
foreach (byte b in ms.ToArray())
{
ret.AppendFormat("{0:X2}", b);
}
ret.ToString();
return ret.ToString();
}
/// <summary>
/// 利用DES解密算法解密密文（可解密）
/// </summary>
/// <param name="ciphertext">被解密的字符串</param>
/// <param name="key">密钥（只支持8个字节的密钥，同前面的加密密钥相同）</param>
/// <returns>返回被解密的字符串</returns>
private static string DecryptString(string ciphertext, string key)
{
try
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();

byte[] inputByteArray = new byte[ciphertext.Length / 2];
for (int x = 0; x < ciphertext.Length / 2; x++)
{
int i = (Convert.ToInt32(ciphertext.Substring(x * 2, 2), 16));
inputByteArray[x] = (byte)i;
}

des.Key = ASCIIEncoding.ASCII.GetBytes(key);　//建立加密对象的密钥和偏移量，此值重要，不能修改
des.IV = ASCIIEncoding.ASCII.GetBytes(key);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);

cs.Write(inputByteArray, 0, inputByteArray.Length);

cs.FlushFinalBlock();

//建立StringBuild对象，createDecrypt使用的是流对象，必须把解密后的文本变成流对象
StringBuilder ret = new StringBuilder();

return System.Text.Encoding.Default.GetString(ms.ToArray());
}
catch (Exception)
{
return "error";
}
}

#endregion
}

}

namespace MVCCommonAuth
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
public class AuthFilterAttribute : ActionFilterAttribute
{
public AuthFilterAttribute() { }
public AuthFilterAttribute(string roles,string userType) {
this.Roles = roles;
this.UserType = userType;
}
public bool Allowanonymous { get; set; }
public string Roles { get; set; }

public string Users { get; set; }

public string UserType { get; set; }

public sealed override void OnActionExecuting(ActionExecutingContext filterContext)
{
if (Allowanonymous) return;
if (IsAuth()) return;
UnauthorizedRequest(filterContext);
}

public sealed override void OnActionExecuted(ActionExecutedContext filterContext)
{
base.OnActionExecuted(filterContext);
}
public sealed override void OnResultExecuting(ResultExecutingContext filterContext)
{
base.OnResultExecuting(filterContext);
}
public sealed override void OnResultExecuted(ResultExecutedContext filterContext)
{
base.OnResultExecuted(filterContext);
}

private bool IsAuth()
{
var user = LoginUser.GetUser(UserType);
if (user != null)
{
return AuthorizeCore(user.UserName, user.Roles);
}
else
{
return false;
}
}

private void UnauthorizedRequest(ActionExecutingContext filterContext)
{
if (filterContext.HttpContext.Request.IsAjaxRequest())
UnauthorizedAjaxRequest(filterContext);
else
UnauthorizedGenericRequest(filterContext);
}

protected virtual bool AuthorizeCore(string userName, string userRoles)
{
var separator = new char[] { ',' };
var options = StringSplitOptions.RemoveEmptyEntries;
if (!string.IsNullOrWhiteSpace(Users))
{
return Users.Split(separator, options).Contains(userName);
}
if (!string.IsNullOrWhiteSpace(Roles))
{
var allowRoles = Roles.Split(separator, options);
var hasRoles = userRoles.Split(separator, options);
foreach (var role in hasRoles)
{
if (allowRoles.Contains(role))
{
return true;
}
}
return false;
}
return true;
}

protected virtual void UnauthorizedGenericRequest(ActionExecutingContext filterContext)
{
//根据Roles、Users、UserType信息分别跳转
filterContext.Result = new RedirectResult("/Account/login?returnurl=" + filterContext.HttpContext.Request.Url.PathAndQuery);
}
protected virtual void UnauthorizedAjaxRequest(ActionExecutingContext filterContext)
{
var acceptTypes = filterContext.HttpContext.Request.AcceptTypes;
if (acceptTypes.Contains("*/*") || acceptTypes.Contains("application/json"))
{
filterContext.Result = new JsonResult { Data = new { code = 0, msg = "nologin" }, JsonRequestBehavior = JsonRequestBehavior.AllowGet };
}
else
{
filterContext.Result = new ContentResult { Content = "nologin" };
}

}

}
}