Skip to main content

User enumeration

Need

Prevention of user enumeration

Context

  • Usage of C# for building robust and scalable applications
  • Usage of _userManager for managing user authentication and authorization
  • Usage of _signInManager for managing user sign-in functionality

Description

Non compliant code

[HttpPost]
public async Task<IActionResult> Login(string username, string password)
{
var user = await _userManager.FindByNameAsync(username);
if(user == null)
{
return NotFound("User not found");
}

var result = await _signInManager.PasswordSignInAsync(user, password, false, false);
if(result.Succeeded)
{
return Ok("Login successful");
}
else
{
return BadRequest("Invalid password");
}
}

This piece of code is an endpoint for user login in an ASP.NET Core application. It receives a username and password as parameters, and it uses the UserManager service provided by ASP.NET Core Identity to find a user by the username.

The vulnerability lies in the way this code handles non-existent users. If the UserManager service cannot find a user with the provided username, it returns a NotFound result with a message "User not found". If the user exists but the password is incorrect, it returns a BadRequest result with a message "Invalid password".

This difference in response allows an attacker to enumerate valid users: if they receive a "User not found" message, they know the username is not valid; if they receive an "Invalid password" message, they know the username is valid. This information can be used to carry out further attacks.

Also, the use of async/await might lead to a difference in response times for existent and non-existent users, providing another way for attackers to enumerate valid usernames.

This vulnerability can be mitigated by returning the same response for both existent and non-existent users, and by ensuring that the response time is the same regardless of whether the user exists.

Steps

  • Implement a consistent error response for both existent and non-existent users to avoid providing information that can be used for user enumeration.
  • Use a constant time comparison algorithm when comparing passwords to avoid timing attacks.
  • Consider implementing rate limiting or CAPTCHA to prevent brute force attacks on the login endpoint.
  • Ensure that the login endpoint does not leak information about the existence of user accounts through differences in response times or error messages.

Compliant code

[HttpPost]
public async Task<IActionResult> Login(string username, string password)
{
var user = await _userManager.FindByNameAsync(username);
var result = await _signInManager.PasswordSignInAsync(user, password, false, false);

if(user == null || !result.Succeeded)
{
// Delay to prevent timing attacks
await Task.Delay(1000);
return BadRequest("Invalid username or password");
}

return Ok("Login successful");
}

The updated code now returns a consistent error message for both existent and non-existent users, which is "Invalid username or password". This prevents an attacker from being able to enumerate valid users via error messages.

The PasswordSignInAsync method is called regardless of whether the user exists or not. This ensures that the response time is consistent for both existent and non-existent users, preventing timing attacks.

A delay has been added to the response when the login attempt fails. This delay can help to mitigate brute force attacks by slowing down the rate at which an attacker can make login attempts.

Please note that this code does not implement rate limiting or CAPTCHA. These are additional measures that can be implemented to further secure the login endpoint. Rate limiting would limit the number of login attempts that can be made from a single IP address in a given time period. CAPTCHA would require the user to complete a challenge to prove they are human before allowing the login attempt.

It's also important to ensure that the application does not leak information about the existence of user accounts through other means, such as differences in response times or error messages in other parts of the application.

References