Skip to main content

Lack of data validation - Non Sanitized Variables

Need​

Implementation of proper data validation and sanitization techniques

Context​

  • Usage of C# for developing robust and scalable applications
  • Usage of System.Diagnostics for performance monitoring and debugging in .NET development

Description​

Non compliant code​

public void ExecuteCommand(string command)
{
    System.Diagnostics.Process process = new System.Diagnostics.Process();
    System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
    startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
    startInfo.FileName = "cmd.exe";
    startInfo.Arguments = "/C " + command;
    process.StartInfo = startInfo;
    process.Start();
}

The above C# code is vulnerable due to lack of data validation or sanitization. The function ExecuteCommand takes a string command as an argument and directly uses it to execute a system command via cmd.exe.

The problem here is that the command string can be manipulated externally, meaning an attacker could potentially input malicious commands. Since the system does not sanitize or validate the input, it will execute whatever command it receives.

This is a serious security vulnerability known as "Command Injection". An attacker could potentially execute any command they want, which could lead to unauthorized access, data loss, or even a complete system takeover.

For example, an attacker could pass a command string like "; format C: /s /q". This would result in the system executing a command to format the C drive, which would delete all data on the drive.

Therefore, it is crucial to always validate and sanitize user inputs, especially when they are used to construct system commands.

Steps​

  • Implement input validation to ensure that only safe and expected values are accepted as input.
  • Use parameterized queries or prepared statements to prevent SQL injection attacks.
  • Sanitize user input by removing or escaping any special characters that could modify the system command.
  • Avoid using user input directly in system commands. Instead, validate and sanitize the input before constructing the command.
  • Consider using a whitelist approach to validate input, allowing only specific characters or patterns.
  • Implement proper error handling to handle any unexpected input or errors that may occur during command execution.

Compliant code​

public void ExecuteCommand(string command)
{
    // Validate the command input
    if (string.IsNullOrWhiteSpace(command) || !IsValidCommand(command))
    {
        throw new ArgumentException("Invalid command");
    }

    // Sanitize the command input
    command = SanitizeCommand(command);

    System.Diagnostics.Process process = new System.Diagnostics.Process();
    System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
    startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
    startInfo.FileName = "cmd.exe";
    startInfo.Arguments = "/C " + command;
    process.StartInfo = startInfo;
    process.Start();
}

private bool IsValidCommand(string command)
{
    // Implement your command validation logic here
    // For example, you can check if the command matches a whitelist of allowed commands
    return true;
}

private string SanitizeCommand(string command)
{
    // Implement your command sanitization logic here
    // For example, you can remove or escape any special characters that could modify the system command
    return command;
}

The original code was vulnerable because it directly used user input in a system command without any validation or sanitization. This could allow an attacker to execute arbitrary system commands by providing specially crafted input.

The fixed code adds validation and sanitization steps before using the user input in a system command.

The IsValidCommand method should be implemented to check if the command matches a whitelist of allowed commands. This is a proactive measure to ensure that only safe and expected commands are executed.

The SanitizeCommand method should be implemented to remove or escape any special characters that could modify the system command. This is a reactive measure to neutralize any potentially harmful input.

By combining these validation and sanitization steps, the fixed code significantly reduces the risk of command injection attacks.

References​

Last updated on