Skip to main content

Lack of data validation - OTP

Need​

Implementation of proper data validation for OTP tokenCode parameter

Context​

  • Usage of Ruby 2.7.0 for Ruby programming and development
  • Usage of Ruby for building dynamic and object-oriented applications
  • Usage of Rails framework for building web applications

Description​

Non compliant code​

class AuthController < ApplicationController
  def verify_otp
    token_code = params[:tokenCode]
    user = User.find_by(token_code: token_code)

    if user
      user.update(verified: true)
      render json: { message: 'User verified successfully' }, status: :ok
    else
      render json: { error: 'Invalid token' }, status: :unauthorized
    end
  end
end

The above code is a Ruby on Rails controller action that verifies a One Time Password (OTP). It takes a tokenCode parameter from the request parameters, and then looks for a user with that token code. If it finds a user, it marks that user as verified and returns a success message. If it doesn't find a user, it returns an error message.

The vulnerability here is that there is no validation of the tokenCode parameter. An attacker could potentially send multiple requests with random values for the tokenCode parameter in an attempt to find a valid token code. This is known as a brute force attack.

There are no measures in place to limit the number of attempts an attacker can make. There is also no measure to ensure the tokenCode parameter is in a valid format before attempting to find a user with it. This lack of data validation and rate limiting makes this code vulnerable to brute force attacks.

Steps​

  • Implement input validation for the tokenCode parameter.
  • Validate the format and length of the tokenCode value.
  • Consider using regular expressions or specific validation methods to ensure the tokenCode follows the expected format.
  • Limit the number of attempts a user can make to enter the tokenCode.
  • Implement rate limiting or lockout mechanisms to prevent brute-force attacks.
  • Consider using a time-based one-time password (TOTP) instead of a static tokenCode.
  • Use a secure and reliable OTP generation library or service.
  • Ensure that the OTP is unique and not easily guessable.
  • Consider implementing additional security measures such as multi-factor authentication (MFA) to enhance the overall security of the authentication process.

Compliant code​

class AuthController < ApplicationController
  MAX_ATTEMPTS = 5

  def verify_otp
    token_code = params[:tokenCode]
    user = User.find_by(token_code: token_code)

    if user && valid_token?(token_code) && !max_attempts_reached?(user)
      user.update(verified: true)
      render json: { message: 'User verified successfully' }, status: :ok
    else
      increment_failed_attempts(user)
      render json: { error: 'Invalid token' }, status: :unauthorized
    end
  end

  private

  def valid_token?(token_code)
    # Add your own validation logic here
    # For example, a simple length check:
    token_code.length == 6
  end

  def max_attempts_reached?(user)
    user.failed_attempts >= MAX_ATTEMPTS
  end

  def increment_failed_attempts(user)
    user.update(failed_attempts: user.failed_attempts + 1)
  end
end

The updated code includes several measures to validate the OTP and prevent brute-force attacks:

  1. OTP Validation: The valid_token? method checks if the OTP is valid. In this example, it checks if the OTP is 6 characters long. You should replace this with your own validation logic, such as a regular expression check or a call to a validation service.

  2. Attempt Limit: The max_attempts_reached? method checks if the user has reached the maximum number of attempts to enter the OTP. If the user has reached the limit, the method returns true and the OTP is not verified.

  3. Failed Attempt Counter: The increment_failed_attempts method increments the user's failed attempt counter each time they enter an invalid OTP.

  4. Rate Limiting: The MAX_ATTEMPTS constant sets the maximum number of attempts a user can make to enter the OTP. This is a simple form of rate limiting to prevent brute-force attacks.

These measures help ensure that the OTP is valid and that the user is not attempting to guess the OTP through brute force. They also help protect the user's account from unauthorized access.

References​

Last updated on