Skip to main content

Weak credential policy - Password Change Limit

Need​

Enforcement of password change limits

Context​

  • Usage of C# 7.1 for developing applications with advanced language features and improvements
  • Usage of Microsoft.AspNetCore.Mvc for building web applications using the ASP.NET Core MVC framework
  • Usage of Microsoft.AspNetCore.Identity for managing user authentication and authorization in ASP.NET Core applications

Description​

Non compliant code​

// Controller for user management
public class UserController : Controller
{
    private readonly UserManager<ApplicationUser> _userManager;

    public UserController(UserManager<ApplicationUser> userManager)
    {
        _userManager = userManager;
    }

    // Action for password change
    [HttpPost]
    public async Task<IActionResult> ChangePassword(string userId, string newPassword)
    {
        var user = await _userManager.FindByIdAsync(userId);
        if (user == null)
        {
            return NotFound();
        }

        var result = await _userManager.ChangePasswordAsync(user, user.PasswordHash, newPassword);

        if (!result.Succeeded)
        {
            return BadRequest(result.Errors);
        }

        return Ok();
    }
}

The above code is an example of a weak credential policy vulnerability due to unlimited password change requests. The ChangePassword method in the UserController class is responsible for changing the user's password.

It first finds the user by ID using the FindByIdAsync method of the _userManager object. If the user is not found, it returns a NotFound response. If the user is found, it proceeds to change the password using the ChangePasswordAsync method of the _userManager object.

The vulnerability lies in the fact that there is no limit to the number of times a password can be changed in a given time period. This can be exploited by an attacker to flood the system with password change requests, potentially causing a denial of service (DoS) attack. Additionally, if an attacker gains access to a user's account, they can continually change the password, effectively locking out the legitimate user.

Steps​

  • Implement a password change limit policy.
  • Add a configuration setting to specify the maximum number of password changes allowed per day.
  • Track the number of password change requests made by a user within a day.
  • Check the number of password change requests made by a user before allowing a password change.
  • If the user has reached the maximum number of password changes, reject the password change request.
  • Consider implementing additional security measures such as account lockout after multiple failed password change attempts.

Compliant code​

public class UserController : Controller
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly IConfiguration _configuration;
    private readonly Dictionary<string, int> _passwordChangeTracker;

    public UserController(UserManager<ApplicationUser> userManager, IConfiguration configuration)
    {
        _userManager = userManager;
        _configuration = configuration;
        _passwordChangeTracker = new Dictionary<string, int>();
    }

    // Action for password change
    [HttpPost]
    public async Task<IActionResult> ChangePassword(string userId, string newPassword)
    {
        var user = await _userManager.FindByIdAsync(userId);
        if (user == null)
        {
            return NotFound();
        }

        // Check if the user has reached the maximum number of password changes for the day
        if (_passwordChangeTracker.ContainsKey(userId) && _passwordChangeTracker[userId] >= _configuration.GetValue<int>("MaxPasswordChangesPerDay"))
        {
            return BadRequest("You have reached the maximum number of password changes allowed for today.");
        }

        var result = await _userManager.ChangePasswordAsync(user, user.PasswordHash, newPassword);

        if (!result.Succeeded)
        {
            return BadRequest(result.Errors);
        }

        // Increment the password change count for the user
        if (_passwordChangeTracker.ContainsKey(userId))
        {
            _passwordChangeTracker[userId]++;
        }
        else
        {
            _passwordChangeTracker[userId] = 1;
        }

        return Ok();
    }
}

The updated code now includes a password change limit policy. This policy is enforced by tracking the number of password change requests made by each user within a day.

The UserController now takes an additional IConfiguration parameter in its constructor, which is used to access configuration settings. A new configuration setting, MaxPasswordChangesPerDay, is used to specify the maximum number of password changes allowed per day.

A Dictionary&lt;string, int> named _passwordChangeTracker is used to track the number of password change requests made by each user. The user's ID is used as the key, and the value is the number of password change requests made by the user.

Before a password change is allowed, the code checks if the user has already reached the maximum number of password changes for the day. If the user has reached the limit, the password change request is rejected and a "Bad Request" response is returned with a message indicating that the user has reached the maximum number of password changes allowed for the day.

If the password change is successful, the code increments the password change count for the user in the _passwordChangeTracker dictionary. If the user is not already in the dictionary, they are added with a count of 1.

This approach helps to mitigate the risk of attacks that attempt to change a user's password multiple times in a short period.

References​

Last updated on