使用ASP.NET重新創建我的身份驗證策略

Question

當前，我使用自定義的書面身份驗證代碼，用於構建在.NET上的我的網站。我沒有采用標準的Forms Auth路由，因爲我可以找到的所有示例都與WebForms緊密集成，我不使用它。對於所有意圖和目的，我擁有所有靜態HTML，並且任何邏輯都是通過Javascript和Web服務調用完成的。登錄，註銷和創建新帳戶等事情都不需要離開頁面。

下面是它的工作原理：在數據庫中，我有一個User ID，Security ID和Session ID。所有這三個都是UUID，前兩個永遠不會改變。每次用戶登錄時，我都會檢查user表中與該用戶名和散列密碼相匹配的行，並將Session ID更新爲新的UUID。然後我創建一個cookie，它是所有三個UUID的序列化表示。在任何安全的Web服務調用中，我反序列化該cookie，確保用戶表中有一行含有這3個UUID。這是一個相當簡單的系統，運行良好，但我不太喜歡這樣的事實：用戶一次只能用一個客戶端登錄。當我創建移動和平板電腦應用程序時，它會引發問題，並且如果他們有多臺計算機或Web瀏覽器，則會產生問題。出於這個原因，我正在考慮扔掉這個系統，並用新的東西去做。自從我多年前寫了這篇文章以來，我認爲可能會有更多的建議。

我一直在閱讀.NET Framework中的FormsAuthentication類，該類處理auth cookie，並作爲HttpModule運行以驗證每個請求。我想知道我是否可以在我的新設計中利用這一點。

它看起來像Cookie是無狀態的，會話不需要在數據庫中進行跟蹤。這是通過這樣一個事實來完成的，即Cookie使用服務器上的私鑰加密，也可以在一組Web服務器上共享。如果我這樣做：

FormsAuthentication.SetAuthCookie("Bob", true); 

然後在後面的請求，我可以放心鮑勃確實是一個有效的用戶作爲一個cookie是，如果不是不可能僞造非常困難。

我會明智地使用FormsAuthentication類來替換我當前的身份驗證模型？數據庫中沒有Session ID列，我依賴加密的cookie來表示有效的會話。

是否有第三方/開源的.NET認證框架可能對我的架構更好？

此認證機制是否會在移動客戶端和平板電腦客戶端（例如iPhone應用程序或Windows 8 Surface應用程序）上運行代碼時導致任何問題？我會認爲這會起作用，只要這些應用程序可以處理cookie。謝謝！

Answer 1

因爲我沒有得到任何答覆，所以我決定自己去拍一下。首先，我發現一個open source project以算法不可知的方式實現會話cookie。我以此爲出發點來實現類似的處理程序。

我在內置的ASP.NET實現中遇到的一個問題是AppHarbor實現中的類似限制，會話僅由字符串用戶名來確定。我希望能夠存儲任意數據來識別用戶，例如他們在數據庫中的UUID以及他們的登錄名。儘管我現有的許多代碼都假定這些數據在cookie中可用，但如果這些數據不再可用，則需要進行大量的重構。另外，我喜歡能夠存儲基本用戶信息而不必訪問數據庫的想法。

正如this open issue中指出的，AppHarbor項目的另一個問題是加密算法未經過驗證。這並不完全正確，因爲AppHarbor是算法不可知論者，但要求示例項目應該顯示如何使用PBKDF2。出於這個原因，我決定在我的代碼中使用這個算法（在.NET Framework中通過Rfc2898DeriveBytes class實現）。

這是我能夠想出的。這意味着有人希望實施他們自己的會話管理，所以可以隨意將其用於任何你認爲合適的目的。

using System; 
using System.IO; 
using System.Linq; 
using System.Runtime.Serialization.Formatters.Binary; 
using System.Security; 
using System.Security.Cryptography; 
using System.Security.Principal; 
using System.Web; 

namespace AuthTest 
{ 
    [Serializable] 
    public class AuthIdentity : IIdentity 
    { 
     public Guid Id { get; private set; } 
     public string Name { get; private set; } 

     public AuthIdentity() { } 

     public AuthIdentity(Guid id, string name) 
     { 
     Id = id; 
     Name = name; 
     } 

     public string AuthenticationType 
     { 
     get { return "CookieAuth"; } 
     } 

     public bool IsAuthenticated 
     { 
     get { return Id != Guid.Empty; } 
     } 
    } 

    [Serializable] 
    public class AuthToken : IPrincipal 
    { 
     public IIdentity Identity { get; set; } 

     public bool IsInRole(string role) 
     { 
     return false; 
     } 
    } 

    public class AuthModule : IHttpModule 
    { 
     static string COOKIE_NAME = "AuthCookie"; 

     //Note: Change these two keys to something else (VALIDATION_KEY is 72 bytes, ENCRYPTION_KEY is 64 bytes) 
     static string VALIDATION_KEY = @"MkMvk1JL/ghytaERtl6A25iTf/ABC2MgPsFlEbASJ5SX4DiqnDN3CjV7HXQI0GBOGyA8nHjSVaAJXNEqrKmOMg=="; 
     static string ENCRYPTION_KEY = @"QQJYW8ditkzaUFppCJj+DcCTc/H9TpnSRQrLGBQkhy/jnYjqF8iR6do9NvI8PL8MmniFvdc21sTuKkw94jxID4cDYoqr7JDj"; 

     static byte[] key; 
     static byte[] iv; 
     static byte[] valKey; 

     public void Dispose() 
     { 
     } 

     public void Init(HttpApplication context) 
     { 
     context.AuthenticateRequest += OnAuthenticateRequest; 
     context.EndRequest += OnEndRequest; 

     byte[] bytes = Convert.FromBase64String(ENCRYPTION_KEY); //72 bytes (8 for salt, 64 for key) 
     byte[] salt = bytes.Take(8).ToArray(); 
     byte[] pw = bytes.Skip(8).ToArray(); 

     Rfc2898DeriveBytes k1 = new Rfc2898DeriveBytes(pw, salt, 1000); 
     key = k1.GetBytes(16); 
     iv = k1.GetBytes(8); 

     valKey = Convert.FromBase64String(VALIDATION_KEY); //64 byte validation key to prevent tampering 
     } 

     public static void SetCookie(AuthIdentity token, bool rememberMe = false) 
     { 
     //Base64 encode token 
     var formatter = new BinaryFormatter(); 
     MemoryStream stream = new MemoryStream(); 
     formatter.Serialize(stream, token); 
     byte[] buffer = stream.GetBuffer(); 
     byte[] encryptedBytes = EncryptCookie(buffer); 

     string str = Convert.ToBase64String(encryptedBytes); 

     var cookie = new HttpCookie(COOKIE_NAME, str); 
     cookie.HttpOnly = true; 

     if (rememberMe) 
     { 
      cookie.Expires = DateTime.Today.AddDays(100); 
     } 

     HttpContext.Current.Response.Cookies.Add(cookie); 
     } 

     public static void Logout() 
     { 
     HttpContext.Current.Response.Cookies.Remove(COOKIE_NAME); 
     HttpContext.Current.Response.Cookies.Add(new HttpCookie(COOKIE_NAME, "") 
      { 
       Expires = DateTime.Today.AddDays(-1) 
      }); 
     } 

     private static byte[] EncryptCookie(byte[] rawBytes) 
     { 
     TripleDES des = TripleDES.Create(); 
     des.Key = key; 
     des.IV = iv; 

     MemoryStream encryptionStream = new MemoryStream(); 
     CryptoStream encrypt = new CryptoStream(encryptionStream, des.CreateEncryptor(), CryptoStreamMode.Write); 

     encrypt.Write(rawBytes, 0, rawBytes.Length); 
     encrypt.FlushFinalBlock(); 
     encrypt.Close(); 
     byte[] encBytes = encryptionStream.ToArray(); 

     //Add validation hash (compute hash on unencrypted data) 
     HMACSHA256 hmac = new HMACSHA256(valKey); 
     byte[] hash = hmac.ComputeHash(rawBytes); 

     //Combine encrypted bytes and validation hash 
     byte[] ret = encBytes.Concat<byte>(hash).ToArray(); 

     return ret; 
     } 

     private static byte[] DecryptCookie(byte[] encBytes) 
     { 
     TripleDES des = TripleDES.Create(); 
     des.Key = key; 
     des.IV = iv; 

     HMACSHA256 hmac = new HMACSHA256(valKey); 
     int valSize = hmac.HashSize/8; 
     int msgLength = encBytes.Length - valSize; 
     byte[] message = new byte[msgLength]; 
     byte[] valBytes = new byte[valSize]; 
     Buffer.BlockCopy(encBytes, 0, message, 0, msgLength); 
     Buffer.BlockCopy(encBytes, msgLength, valBytes, 0, valSize); 

     MemoryStream decryptionStreamBacking = new MemoryStream(); 
     CryptoStream decrypt = new CryptoStream(decryptionStreamBacking, des.CreateDecryptor(), CryptoStreamMode.Write); 
     decrypt.Write(message, 0, msgLength); 
     decrypt.Flush(); 

     byte[] decMessage = decryptionStreamBacking.ToArray(); 

     //Verify key matches 
     byte[] hash = hmac.ComputeHash(decMessage); 
     if (valBytes.SequenceEqual(hash)) 
     { 
      return decMessage; 
     } 

     throw new SecurityException("Auth Cookie appears to have been tampered with!"); 
     } 

     private void OnAuthenticateRequest(object sender, EventArgs e) 
     { 
      var context = ((HttpApplication)sender).Context; 
     var cookie = context.Request.Cookies[COOKIE_NAME]; 
     if (cookie != null && cookie.Value.Length > 0) 
     { 
      try 
      { 
       var formatter = new BinaryFormatter(); 
       MemoryStream stream = new MemoryStream(); 
       var bytes = Convert.FromBase64String(cookie.Value); 
       var decBytes = DecryptCookie(bytes); 
       stream.Write(decBytes, 0, decBytes.Length); 
       stream.Seek(0, SeekOrigin.Begin); 
       AuthIdentity auth = formatter.Deserialize(stream) as AuthIdentity; 
       AuthToken token = new AuthToken() { Identity = auth }; 
       context.User = token; 

       //Renew the cookie for another 100 days (TODO: Should only renew if cookie was originally set to persist) 
       context.Response.Cookies[COOKIE_NAME].Value = cookie.Value; 
       context.Response.Cookies[COOKIE_NAME].Expires = DateTime.Today.AddDays(100); 
      } 
      catch { } //Ignore any errors with bad cookies 
     } 
     } 

     private void OnEndRequest(object sender, EventArgs e) 
     { 
     var context = ((HttpApplication)sender).Context; 
     var response = context.Response; 
     if (response.Cookies.Keys.Cast<string>().Contains(COOKIE_NAME)) 
     { 
      response.Cache.SetCacheability(HttpCacheability.NoCache, "Set-Cookie"); 
     } 
     } 
    } 
} 

此外，一定要包括以下模塊中的web.config文件：

<httpModules> 
    <add name="AuthModule" type="AuthTest.AuthModule" /> 
</httpModules> 

在你的代碼，你可以查找當前登錄的用戶有：

var id = HttpContext.Current.User.Identity as AuthIdentity; 

而且設置auth cookie像這樣：

AuthIdentity token = new AuthIdentity(Guid.NewGuid(), "Mike"); 
AuthModule.SetCookie(token, false);