Skip to main content

Session Fixation

Need​

Prevention of session hijacking

Context​

  • Usage of C# 7.1 for developing applications with advanced language features and improvements.
  • Usage of _signInManager for managing user sign-in functionality
  • Usage of LoginViewModel for managing login functionality in a view
  • Usage of IActionResult for defining and returning action results in a web application
  • Usage of Controller for managing and handling application logic and routes
  • Usage of RedirectToActionResult for redirecting to a specific action or controller in a web application.
  • Usage of ViewResult for rendering views in a web application

Description​

Non compliant code​

public class AccountController : Controller
{
    [HttpPost]
    public async Task<IActionResult> Login(LoginViewModel model)
    {
        if (ModelState.IsValid)
        {
            var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
            if (result.Succeeded)
            {
                return RedirectToAction("Index", "Home");
            }
        }
        return View(model);
    }
}

In the above code, the Login method is responsible for handling user login. It takes in a LoginViewModel object which contains the user's email and password. If the model state is valid, it will attempt to sign in the user using the _signInManager.PasswordSignInAsync method.

The vulnerability lies in the fact that the session cookie is not being regenerated upon successful login. This means that if an attacker is able to obtain a user's session cookie prior to login, they will be able to hijack the user's session after the user logs in. This is because the session cookie remains the same before and after login, allowing the attacker to impersonate the user.

This is a session fixation vulnerability, as the attacker fixes the session ID known to them, thereby enabling unauthorized access to the user's account.

Steps​

  • Generate a new session identifier for the user after a successful login.
  • Invalidate the old session identifier to prevent session fixation attacks.
  • Ensure that the session identifier is securely stored and transmitted.
  • Implement secure session management practices, such as using secure cookies and enforcing HTTPS.
  • Regularly review and update session management code to address any new vulnerabilities or best practices.

Compliant code​

public class AccountController : Controller
{
    private readonly SignInManager<ApplicationUser> _signInManager;
    private readonly IHttpContextAccessor _httpContextAccessor;

    public AccountController(SignInManager<ApplicationUser> signInManager, IHttpContextAccessor httpContextAccessor)
    {
        _signInManager = signInManager;
        _httpContextAccessor = httpContextAccessor;
    }

    [HttpPost]
    public async Task<IActionResult> Login(LoginViewModel model)
    {
        if (ModelState.IsValid)
        {
            var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
            if (result.Succeeded)
            {
                await _signInManager.SignOutAsync(); // Invalidate the old session
                await _signInManager.SignInAsync(await _signInManager.UserManager.FindByEmailAsync(model.Email), isPersistent: false); // Generate a new session

                var cookieOptions = new CookieOptions
                {
                    HttpOnly = true, // The cookie is accessible only by the web server
                    Secure = true, // Transmit the cookie over HTTPS only
                    SameSite = SameSiteMode.Strict, // Prevents the browser from sending this cookie along with cross-site requests
                };

                _httpContextAccessor.HttpContext.Response.Cookies.Append(".AspNetCore.Cookies", _httpContextAccessor.HttpContext.Request.Cookies[".AspNetCore.Cookies"], cookieOptions);

                return RedirectToAction("Index", "Home");
            }
        }
        return View(model);
    }
}

The updated code fixes the session fixation vulnerability by generating a new session identifier for the user after a successful login and invalidating the old session identifier. This prevents an attacker from hijacking the user's session by setting the user's cookie to one known by the attacker.

The SignInManager.SignOutAsync method is called to invalidate the old session, and the SignInManager.SignInAsync method is called to generate a new session.

The session identifier is securely stored and transmitted by setting the HttpOnly, Secure, and SameSite properties of the CookieOptions object to true, true, and SameSiteMode.Strict, respectively. This ensures that the cookie is accessible only by the web server, is transmitted over HTTPS only, and is not sent along with cross-site requests.

By implementing these secure session management practices, the application is better protected against session fixation attacks. It is important to regularly review and update session management code to address any new vulnerabilities or best practices.

References​

Last updated on