Re-inventing my authentication strategy with ASP.NET

Question

Currently, I use custom written authentication code for my site, which is built on .NET. I didn't take the standard Forms Auth route, as all the examples I could find were tightly integrated with WebForms, which I do not use. For all intents and purposes, I have all static HTML, and any logic is done through Javascript and web service calls. Things like logging in, logging off, and creating a new account are done without even leaving the page.

Here's how it works now: In the database, I have a User ID, a Security ID, and a Session ID. All three are UUIDs, and the first two never change. Each time the user logs on, I check the user table for a row that matches that username and hashed password, and I update the Session ID to a new UUID. I then create a cookie that's a serialized representation of all three UUIDs. In any secure web service calls, I deserialize that cookie that make sure there's a row in the users table with those 3 UUIDs. It's a fairly simple system and works well, however I don't really like the fact that a user can only be logged on with one client at a time. It's going to cause issues when I create mobile and tablet apps, and already creates issues if they have multiple computers or web browsers. For this reason, I'm thinking about throwing away this system and going with something new. Since I wrote it years ago, I figure there might be something much more recommended.

I've been reading up on the FormsAuthentication class in the .NET Framework, which handles auth cookies, and runs as an HttpModule to validate each request. I'm wondering if I can take advantage of this in my new design.

It looks like cookies are stateless, and sessions don't have to be tracked within the database. This is done through the fact that cookies are encrypted with a private key on the server, that can also be shared across a cluster of web servers. If I do something like:

FormsAuthentication.SetAuthCookie("Bob", true);

Then in later requests, I can be assured that Bob is indeed a valid user as a cookie would be very difficult if not impossible to forge.

Would I be wise to use the FormsAuthentication class to replace my current authentication model with? Rather than have a Session ID column in the database, I'd rely on encrypted cookies to represent valid sessions.

Are there third party/open source .NET authentication frameworks that might work better for my architecture?

Will this authentication mechanism cause any grief with code running on mobile and tablet clients, such as an iPhone app or Windows 8 Surface app? I would assume this would work, as long as these apps could handle cookies. Thanks!

Answer 1

Since I didn't get any responses, I decided to take a shot at this myself. First, I found an open source project that implements session cookies in an algorithm agnostic way. I used this as a starting point to implement a similar handler.

One issue I had with the built in ASP.NET implementation, which is a similar restriction in the AppHarbor implementation, is sessions are only keyed by a string username. I wanted to be able to store arbitrary data to identify a user, such as their UUID in the database as well as their logon name. As much of my existing code assumes this data is available in the cookie, it would take a lot of refactoring if this data were no longer available. Plus, I like the idea of being able to store basic user information without having to hit the database.

Another issue with the AppHarbor project, as pointed out in the this open issue, is the encryption algorithm isn't verified. This is not exactly true, as AppHarbor is algorithm agnostic, however it was requested that the sample project should show how to use PBKDF2. For that reason, I decided to use this algorithm (implemented in the .NET Framework through the Rfc2898DeriveBytes class) in my code.

Here's what I was able to come up with. It's meant as a starting point for someone looking to implement their own session management, so feel free to use it for whatever purpose you see fit.

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");
         }
      }
   }
}

Also, be sure to include the following module in your web.config file:

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

In your code, you can lookup the currently logged on user with:

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

And set the auth cookie like so:

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