Skip to main content

Lack of data validation - Reflected Parameters

Need​

Implementation of proper input validation and sanitization

Context​

  • Usage of Ruby for building web applications and scripting
  • Usage of params for handling request parameters in a web application
  • Usage of render for rendering views or templates in a web application

Description​

Non compliant code​

def show_error
  error_message = params[:error_message]
  render html: "An error occurred: #{error_message}".html_safe
end

The above code is a method in a Ruby on Rails controller which takes an error message from the URL parameters and directly includes it in the HTML response sent back to the client.

This is a case of unvalidated user input as the 'error_message' parameter is taken directly from the user's request and included in the server's response without any form of sanitization or validation.

The vulnerability lies in the fact that the user could supply a string containing malicious JavaScript code as the 'error_message' parameter. This JavaScript code would then be included in the server's response and executed by the client's browser. This is a type of Cross-Site Scripting (XSS) attack.

For example, an attacker could send a request with the following URL:

http://example.com/?error_message=<script>malicious_code_here</script>

And the server would respond with:

An error occurred: <script>malicious_code_here</script>

The client's browser would then execute the malicious JavaScript code. This could lead to a variety of attacks, such as stealing the user's cookies or performing actions on their behalf.

Steps​

  • Implement input validation to ensure that the error_message parameter does not contain any special characters.
  • Use a whitelist approach to validate the input, allowing only specific characters or patterns.
  • Sanitize the error_message parameter before rendering it in the HTML response to prevent XSS attacks.
  • Consider using a library or framework-provided validation mechanism to simplify the input validation process.
  • Regularly update the application and its dependencies to ensure that any security patches or fixes are applied.

Compliant code​

def show_error
  error_message = params[:error_message]
  sanitized_error_message = ActionController::Base.helpers.sanitize(error_message)
  render html: "An error occurred: #{sanitized_error_message}".html_safe
end

The original code was vulnerable to Cross-Site Scripting (XSS) attacks because it directly included user input in the server error responses without any validation or sanitization. This could allow an attacker to inject malicious scripts by including special characters in the error_message parameter.

The fixed code mitigates this vulnerability by sanitizing the error_message parameter before including it in the HTML response. The ActionController::Base.helpers.sanitize method from the Ruby on Rails framework is used for this purpose. This method removes any dangerous HTML tags and attributes from the input, preventing the possibility of script injection.

In addition to this, it's recommended to implement input validation to ensure that the error_message parameter does not contain any unexpected characters or patterns. This could be done using a whitelist approach, where only specific characters or patterns are allowed. Also, regularly updating the application and its dependencies can help to ensure that any security patches or fixes are applied.

References​

Last updated on