Skip to main content

Lack of protection against brute force attacks - Credentials

Need​

Implementation of strong authentication mechanisms to prevent brute force attacks on promotional codes.

Context​

  • Usage of C# for developing robust and efficient applications
  • Usage of _context for managing shared state and data in the application
  • Usage of IActionResult for defining and returning action results in a web application
  • Usage of HttpPost for making HTTP POST requests
  • Usage of the Ok library for handling HTTP responses
  • Usage of BadRequest for handling and returning HTTP 400 Bad Request responses
  • Usage of CheckPromoCode for validating and applying promotional codes
  • Usage of promoCode for managing promotional codes and discounts
  • Usage of _context.PromoCodes.ToList() for retrieving a list of promo codes from the context

Description​

Non compliant code​

[HttpPost]
public IActionResult ValidatePromoCode(string promoCode)
{
    bool isValid = CheckPromoCode(promoCode);
    if(isValid)
    {
        return Ok("Promo Code is valid");
    }
    else
    {
        return BadRequest("Invalid Promo Code");
    }
}

private bool CheckPromoCode(string promoCode)
{
    // Assume we have a list of valid promo codes stored in the database
    var validPromoCodes = _context.PromoCodes.ToList();

    if(validPromoCodes.Contains(promoCode))
    {
        return true;
    }
    else
    {
        return false;
    }
}

In this code, there is an HTTP POST endpoint ValidatePromoCode which accepts a promotional code as a parameter. This code is then checked against a list of valid promotional codes stored in the database.

The vulnerability here is that there is no protection against brute force attacks. An attacker could potentially send a large number of requests with different promotional codes to this endpoint until they find a valid one. This is because the application does not implement any form of rate limiting or account lockout after a certain number of failed attempts.

Additionally, there is no form of captcha or similar mechanism in place to ensure that the requests are coming from a human and not from an automated script. This makes it easier for an attacker to perform a brute force attack.

Furthermore, the application responds with a clear message indicating whether the promotional code is valid or not. This provides an attacker with immediate feedback on whether their attempt was successful or not, making the brute force attack more efficient.

Steps​

  • Implement rate limiting to limit the number of requests per IP address or user account.
  • Implement account lockout mechanism after a certain number of failed login attempts.
  • Use a strong and secure hashing algorithm to store and compare passwords.
  • Implement CAPTCHA or reCAPTCHA to prevent automated attacks.
  • Implement a delay or exponential backoff mechanism to slow down repeated login attempts.
  • Implement multi-factor authentication to add an extra layer of security.
  • Regularly monitor and analyze logs for suspicious activity and patterns.
  • Educate users about the importance of using strong and unique passwords.

Compliant code​

[HttpPost]
[EnableCors("AllowSpecificOrigin")]
[RateLimit(Seconds = 60, Requests = 5)] // Rate limiting
public async Task<IActionResult> ValidatePromoCode(string promoCode)
{
    // Implement delay mechanism
    await Task.Delay(1000);

    bool isValid = await CheckPromoCode(promoCode);
    if(isValid)
    {
        return Ok("Promo Code is valid");
    }
    else
    {
        // Implement account lockout mechanism
        if (HttpContext.Session.GetInt32("FailedAttempts") >= 5)
        {
            return StatusCode(429, "Too Many Requests");
        }

        HttpContext.Session.SetInt32("FailedAttempts", HttpContext.Session.GetInt32("FailedAttempts") + 1);
        return BadRequest("Invalid Promo Code");
    }
}

private async Task<bool> CheckPromoCode(string promoCode)
{
    // Assume we have a list of valid promo codes stored in the database
    var validPromoCodes = await _context.PromoCodes.ToListAsync();

    if(validPromoCodes.Contains(promoCode))
    {
        return true;
    }
    else
    {
        return false;
    }
}

The updated code now includes several security measures to protect against brute force attacks:

  1. Rate Limiting: The RateLimit attribute is used to limit the number of requests per IP address within a certain time frame. In this case, a maximum of 5 requests are allowed per minute.

  2. Delay Mechanism: A delay of 1 second is introduced before checking the promo code. This slows down repeated login attempts, making brute force attacks less feasible.

  3. Account Lockout Mechanism: The application now keeps track of the number of failed attempts to validate a promo code. After 5 failed attempts, the user is locked out and receives a "Too Many Requests" response.

Please note that this is a basic implementation and might need to be adjusted based on your specific requirements. For example, you might want to implement a more sophisticated rate limiting mechanism that differentiates between different types of requests, or a more complex account lockout mechanism that includes a way for users to unlock their account.

Also, remember to regularly monitor and analyze logs for suspicious activity and patterns, and educate users about the importance of using strong and unique passwords.

References​

Last updated on