Skip to main content

Automatic information enumeration - Personal Information

Need​

Prevention of unauthorized access to personal information

Context​

  • Requirement of Ruby 2.0 or later for executing the code
  • Usage of Rails for building web applications in Ruby

Description​

Non compliant code​

class UsersController < ApplicationController
  def index
    @users = User.all
    render json: @users
  end

  def show
    @user = User.find(params[:id])
    render json: @user
  end
end

The above code is a simple Ruby on Rails controller for handling user data. The index method retrieves all users from the database and the show method retrieves a single user by their ID. These methods then render the data as JSON, making it accessible to whoever makes a request to these endpoints.

This code is vulnerable to automatic information enumeration, as it indiscriminately shares user data with anyone who makes a request. No authentication or authorization checks are performed to ensure that the requester has the right to access the data. This means that an attacker could potentially access and enumerate all user information stored in the database.

In the index method, all user data is retrieved with User.all and then sent as a response. This allows an attacker to easily list all users of the platform.

In the show method, a user is retrieved by their ID with User.find(params[:id]). This allows an attacker to potentially iterate over all possible IDs and retrieve information for each user.

The lack of a token-based authentication system allows any client to make requests to these endpoints and retrieve user data. This can lead to unauthorized access to personal information, which is a serious security concern.

Steps​

  • Implement authentication and authorization mechanisms to ensure that only authorized users can access user information.
  • Use a token-based authentication system to authenticate users and restrict access to user information based on the token.
  • Ensure that the token is securely generated, stored, and validated to prevent unauthorized access.
  • Implement proper access controls to restrict access to user information based on the user's role or permissions.
  • Regularly review and update the access controls to ensure they are effective and up-to-date.
  • Consider implementing additional security measures such as rate limiting, IP whitelisting, and logging to detect and prevent unauthorized access attempts.

Compliant code​

class UsersController < ApplicationController
  before_action :authenticate_user!
  before_action :set_user, only: [:show]
  before_action :authorize_user, only: [:show]

  def index
    @users = User.all
    render json: @users
  end

  def show
    render json: @user
  end

  private

  def set_user
    @user = User.find(params[:id])
  end

  def authorize_user
    unless current_user == @user || current_user.admin?
      render json: { error: 'Not Authorized' }, status: 403
    end
  end
end

The updated code now includes authentication and authorization checks before accessing user information.

  • before_action :authenticate_user! is a Rails method that checks if a user is logged in before executing any action in the controller. If the user is not logged in, they will be redirected to the login page.

  • before_action :set_user, only: [:show] is a custom method that finds the user based on the id parameter. This method is only run before the show action.

  • before_action :authorize_user, only: [:show] is another custom method that checks if the current user is the same as the user whose information they are trying to access or if the current user is an admin. If neither condition is met, the server will respond with a 'Not Authorized' error message and a 403 status code.

This way, the application ensures that only authorized users can access user information, thus fixing the vulnerability.

References​

Last updated on