Skip to main content

Lack of data validation

Need​

Implementation of robust data validation mechanisms

Context​

  • Requirement of Ruby 2.0 or higher for running the application
  • Usage of Ruby on Rails for building web applications

Description​

Non compliant code​

class UsersController < ApplicationController
  def update
    @user = User.find(params[:id])
    @user.update(params[:user])
    redirect_to @user
  end
end

The above code shows an example of a lack of data validation in a Ruby on Rails application. The update action in the UsersController is directly taking the params[:id] and params[:user] input from the user without validating them.

The User.find(params[:id]) is used to find the user in the database with the given ID. Since there is no validation, an attacker could potentially use an invalid ID, for instance, an ID composed of only letters, which could lead to unexpected behavior or errors.

The @user.update(params[:user]) is used to update the user's data with the given parameters. Again, since there is no validation, an attacker could potentially provide invalid data for fields that should have certain restrictions. For instance, they could provide a string for a field that should only contain numbers.

This lack of data validation could potentially lead to a variety of security issues, including data integrity issues, application crashes, and even potential data breaches if the invalid data is used in a harmful way.

Steps​

  • Implement server-side data validation to ensure that only valid data is accepted.
  • Validate the input data against a set of predefined rules or constraints.
  • Use appropriate validation techniques such as regular expressions, data type checks, and length checks.
  • Sanitize the input data to prevent any potential security vulnerabilities.
  • Handle validation errors gracefully and provide meaningful error messages to the user.
  • Consider implementing client-side validation as an additional layer of defense, but remember that it should not be relied upon as the sole means of validation.

Compliant code​

class UsersController < ApplicationController
  def update
    @user = User.find(params[:id])
    if @user.update(user_params)
      redirect_to @user
    else
      render :edit, status: :unprocessable_entity
    end
  end

  private

  def user_params
    params.require(:user).permit(:name, :email)
  end
end

The updated code now includes a private method user_params that uses Rails' strong parameters feature to whitelist the :name and :email fields. This means that only these fields will be allowed to be updated when the update action is called.

In the update action, we now check if the update is successful with @user.update(user_params). If it is, we redirect to the user's page as before. If it's not, we render the edit page again and send a :unprocessable_entity status. This status indicates that the server understands the content type of the request entity, and the syntax of the request entity is correct, but it was unable to process the contained instructions.

This way, we ensure that only valid data is accepted and any invalid data is handled gracefully with meaningful error messages. This is a crucial step in preventing potential security vulnerabilities related to lack of data validation.

References​

Last updated on