Skip to main content

Lack of data validation - Non Sanitized Variables


Implementation of proper data validation and sanitization


  • Usage of Ruby for building dynamic and object-oriented applications
  • Usage of system for low-level operating system interactions


Non compliant code

def execute_command(user_input)
system("echo #{user_input}")

In the above code snippet, a function execute_command is defined which accepts a user input and uses it to construct a system command. This command is then executed using Ruby's system method.

The vulnerability in this code is that the user input is directly embedded into the system command without any sanitization or validation. This means that if a user provides a malicious input, it could potentially modify the system command and execute unintended actions. This is a typical example of a command injection vulnerability.

For instance, if a user provides an input of ; rm -rf /, the system command would become echo ; rm -rf /, which when executed, would delete all files in the root directory.

This vulnerability can be exploited by an attacker to execute arbitrary commands on the system with the privileges of the user running the Ruby application. This could lead to a variety of negative outcomes, such as data loss, data theft, or even a full system compromise.


  • Implement input validation to ensure that user input is properly sanitized.
  • Use a secure method to construct system commands, such as using parameterized queries or prepared statements.
  • Avoid directly interpolating user input into system commands.
  • Consider using a whitelist approach to validate and sanitize user input.
  • Regularly update and patch the Ruby on Rails framework to benefit from security fixes and improvements.

Compliant code

def execute_command(user_input)
sanitized_input = sanitize(user_input)
system("echo #{sanitized_input}")

def sanitize(input)
# Remove any non-alphanumeric characters
input.gsub(/[^0-9a-z ]/i, '')

The original code was vulnerable to command injection attacks because it directly interpolated user input into a system command without any form of sanitization or validation. This means that a malicious user could potentially manipulate the user_input to execute arbitrary commands on the system.

The fixed code introduces a new sanitize method that removes any non-alphanumeric characters from the user input. This is a simple form of sanitization that can effectively prevent command injection attacks in this specific case. However, it's important to note that this might not be sufficient in all cases, especially if the application needs to support special characters in the user input.

The sanitize method uses the gsub method to replace any non-alphanumeric characters with an empty string. The regular expression /[^0-9a-z ]/i matches any character that is not a number, a lowercase letter, an uppercase letter, or a space. The i flag makes the regular expression case-insensitive.

After the user input is sanitized, it's then interpolated into the system command. This ensures that the system command can't be manipulated by the user input.

In addition to this code fix, it's also recommended to regularly update and patch the Ruby on Rails framework to benefit from security fixes and improvements.