Using cookies to control return page after login on asp.net mvc 3

Default behavior and the scenario

On asp.net in general, when an user tries to access a page that requires the user to login first, it is fairly common to use the built in support to return to that page after the user logins.

When an user tries to access the page and an authorization made by the code determines the user doesn’t have access, a 401 is returned by that code. When that happens the FormsAuthenticationModule intercepts it and instead redirects the user to the login page configured in the asp.net config.

When the redirect to the login page is sent,  it includes a returnUrl query string parameter. On a successful the user is sent back to that url. If no return url is indicated, the user is sent to a default url after authentication.

The above works fine, if the scenario fits well with the site.

One consideration is with the use of register and forgot password options, in which case extra code needs to be put in place if you want the user to be redirected to the url visited when the process started. A similar case is if the user visits any other page linked there, like a faq or about page and then hitting the login option you almost certainly have in your master page/layout.

Another consideration comes with the user of ajax based login forms accessible anywhere on the site. Depending on the site, the user might be on a page where you don’t want it redirect to. You still might want it redirected to a page the user visited before doing some action, like in a client’s scenario, a specific deal page.

The cookie based approach

One way to handle the above scenario is by storing the returnUrl in a cookie. By doing so the user can visit other pages (like the register/forgot password options), and the redirect will go to the last relevant page. Additionally you can control which actions are considered relevant pages, in case the user uses the login option in your master page/layout in any random page they happen to be at.

To set the cookie in an unauthorized access scenario, one could use a module based approach just like the FormsAuthenticationModule. In our case, we instead introduced an AuthorizeWithReturnCookieAttribute, and replaced the use of [Authorize] with [AuthorizeWithReturnCookie].

5. public class AuthorizeWithReturnCookieAttribute : AuthorizeAttribute
6. {
7.     protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
8.     {
9.         var ctx = filterContext.HttpContext;
10.         NavigationCookies.SetReturnAfterAuthenticationUrl(ctx, ctx.Request.RawUrl);
11.         base.HandleUnauthorizedRequest(filterContext);
12.     }
13. }

To set the cookie when a relevant page was visisted, we introduced a separate attribute ReturnAfterAuthenticationAttribute. Unlike the authorize attribute, this one is used on public pages, we want the user redirected back to if the login option in the master page/layout is used.

17. public class ReturnAfterAuthenticationAttribute : ActionFilterAttribute
18. {
19.     public const string ViewDataIgnoreKey = "IgnoreReturnAfterAuthentication";
20.     public override void OnActionExecuted(ActionExecutedContext filterContext)
21.     {
22.         var ctx = filterContext.HttpContext;
23.         if ((bool?)filterContext.Controller.ViewData[ViewDataIgnoreKey] == true) return;
24.         if (ctx.User.Identity.IsAuthenticated) return;
25.         if (filterContext.HttpContext.Request.HttpMethod != "GET") return;
26.         NavigationCookies.SetReturnAfterAuthenticationUrl(ctx, ctx.Request.RawUrl);
27.     }
28. }

There are a few more things going on in the above attribute.

• We can avoid it being set based on logic executed in the action method, by setting true on the corresponding value in ViewData. In retrospective ctx.Items is probably the right place for it.
• No point in setting the cookie if the user is already authenticated.
• Post requests are not tracked.

For a more complete sample, the modified logon and register methods of the asp.net mvc template below. It still supports the returnUrl and gives it precendence (not what we did in our case, as we only use the cookie one).

23. [HttpPost]
24. public ActionResult LogOn(LogOnModel model, string returnUrl)
25. {
26.     if (ModelState.IsValid)
27.     {
28.         if (Membership.ValidateUser(model.UserName, model.Password))
29.             return SetAuthCookieAndRedirect(model.UserName, model.RememberMe, returnUrl);
30.         ModelState.AddModelError("", "The user name or password provided is incorrect.");
31.     }
32.     // If we got this far, something failed, redisplay form
33.     return View(model);
34. }

57. [HttpPost]
58. public ActionResult Register(RegisterModel model)
59. {
60.     if (ModelState.IsValid)
61.     {
62.         // Attempt to register the user
63.         MembershipCreateStatus createStatus;
64.         Membership.CreateUser(model.UserName, model.Password, model.Email, null, null, true, null, out createStatus);
65.  
66.         if (createStatus == MembershipCreateStatus.Success)
67.             return SetAuthCookieAndRedirect(model.UserName);
68.         ModelState.AddModelError("", ErrorCodeToString(createStatus));
69.     }
70.     // If we got this far, something failed, redisplay form
71.     return View(model);
72. }

127. ActionResult SetAuthCookieAndRedirect(string userName, bool createPersistentCookie=false, string returnUrl=null)
128. {
129.     FormsAuthentication.SetAuthCookie(userName, createPersistentCookie);
130.     var url = IsValidReturnUrl(returnUrl) ?
131.         returnUrl :
132.         NavigationCookies.GetReturnAfterAuthenticationUrl(Request);
133.     if (string.IsNullOrEmpty(url)) return RedirectToAction("Index", "Home");
134.     return new RedirectResult(url);
135. }
136. private bool IsValidReturnUrl(string returnUrl)
137. {
138.     return Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
139.            && !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\");
140. }

The NavigationCookies class just sets/gets the cookie:

6. public class NavigationCookies
7. {
8.     private const string ReturnAfterAuthenticationKey = "ReturnAfterAuthentication";
9.     public static void SetReturnAfterAuthenticationUrl(HttpContextBase context, string url)
10.     {
11.         url = VirtualPathUtility.ToAbsolute(url, context.Request.ApplicationPath);
12.         var cookie = context.Response.Cookies[ReturnAfterAuthenticationKey];
13.         cookie.Expires = DateTime.Now.AddDays(1);
14.         cookie.Value = url;
15.     }
16.     public static string GetReturnAfterAuthenticationUrl(HttpRequestBase request)
17.     {
18.         var cookie = request.Cookies["ReturnAfterAuthentication"];
19.         if (cookie == null || cookie.Expires > DateTime.Now) return String.Empty;
20.         return cookie.Value;
21.     }
22. }

I added a full sample that uses the asp.net mvc 3 template to the following github repository: https://github.com/eglasius/Cookie-Based-ReturnUrl-After-Authentication-Sample. You can download a zip file of it directly at: https://github.com/eglasius/Cookie-Based-ReturnUrl-After-Authentication-Sample/zipball/master.