Skip to main content

Inappropriate coding practices - relative path command


Enforcement of secure coding practices and absolute path definitions


  • Usage of Ruby for building dynamic and object-oriented applications
  • Usage of a custom command "some_command" in the bin directory


Non compliant code

def execute_command
command = '../bin/some_command'
result = `#{command}`
return result

The function execute_command is vulnerable to a relative path command exploit. The string command is defined as a relative path to an executable file, ../bin/some_command.

In Ruby, using backticks (`) around a string is a way of executing shell commands. When the execute_command function is called, the command defined by the string command is executed in the shell.

This is problematic because it relies on the PATH environment variable to find the executable file. If an attacker is able to manipulate the PATH environment variable, they could potentially redirect the command to execute a malicious script instead of the intended file, thereby compromising the system.

This type of vulnerability is common in applications that do not properly sanitize user input or that use relative paths to execute system commands. It can be mitigated by using absolute paths and by validating and sanitizing user input.


  • Avoid using relative paths when referencing executables
  • Use absolute paths instead to ensure the correct location of the executable
  • Validate and sanitize user input to prevent any manipulation of the command
  • Implement proper input validation and filtering to prevent command injection attacks
  • Consider using a secure library or framework function to execute commands safely

Compliant code

def execute_command
absolute_path = '/usr/local/bin/some_command'
result = `#{absolute_path}`
return result

The original code was vulnerable due to the use of a relative path to execute a command. This could allow an attacker to manipulate the PATH environment variable and execute arbitrary commands.

The fixed code now uses an absolute path to reference the executable. This ensures that the correct executable is always called, regardless of the current PATH setting.

Please note that the absolute path /usr/local/bin/some_command is just an example. You should replace it with the actual absolute path of your executable.

In addition, it's important to validate and sanitize any user input that might be included in the command. This can help prevent command injection attacks.

Consider using a secure library or framework function to execute commands. For example, in Ruby on Rails, you can use methods like system or exec which are designed to safely execute commands.

Remember, security is a multi-layered approach. Using absolute paths is just one layer of protection. Always validate and sanitize user input, and use secure methods to execute commands.