Skip to main content

Remote command execution

Need​

Prevention of unauthorized remote command execution

Context​

  • Usage of Java 8 for developing applications with enhanced features and performance improvements.
  • Usage of javax.servlet-api for developing Java web applications with Servlets

Description​

Non compliant code​

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class VulnerableServlet extends HttpServlet {

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String data = request.getParameter("data");
        Process p = Runtime.getRuntime().exec("cmd /C " + data);
    }
}

The above code is a Java Servlet that takes in a POST request and extracts a parameter named "data" from the request. This parameter is then directly used in the exec method of Runtime class, which is used to execute operating system commands.

The vulnerability in this code lies in the fact that the "data" parameter is directly used without any sanitization or validation. This means that an attacker can manipulate the "data" parameter to execute arbitrary commands on the operating system, leading to a Remote Command Execution vulnerability.

For example, an attacker can send a POST request with "data" parameter as "; rm -rf /". This would result in the operating system command cmd /C ; rm -rf / being executed, which can delete all files in the server's filesystem.

This is a severe security vulnerability as it allows an attacker to execute arbitrary commands on the server, leading to complete system compromise.

Steps​

  • Validate and sanitize user input: Before using the input to build OS commands, ensure that it is properly validated and sanitized. This includes checking for any special characters or malicious inputs that could modify the command.
  • Use parameterized queries or prepared statements: Instead of directly concatenating user input into the command, use parameterized queries or prepared statements to build the command. This helps to separate the command from the user input and prevents any unintended command execution.
  • Implement input validation and whitelisting: Implement strict input validation and whitelisting to only allow specific characters or patterns in the user input. This can help to filter out any potentially malicious inputs.
  • Limit privileges and access: Ensure that the code is running with the least privileges necessary to execute the required commands. This helps to minimize the potential impact of any command execution vulnerabilities.
  • Implement strong access controls: Implement strong access controls to restrict access to the vulnerable code. This can help to prevent unauthorized users from exploiting the vulnerability.
  • Regularly update and patch dependencies: Keep all dependencies and libraries up to date with the latest security patches. This helps to mitigate any known vulnerabilities in the underlying components.
  • Perform security testing and code reviews: Regularly perform security testing and code reviews to identify and fix any vulnerabilities in the code. This includes both manual code reviews and automated vulnerability scanning tools.
  • Follow secure coding practices: Follow secure coding practices such as input validation, output encoding, and proper error handling to prevent common vulnerabilities like remote command execution.

Compliant code​

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class SecureServlet extends HttpServlet {

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String data = request.getParameter("data");

        // Validate and sanitize the input
        if (isValid(data)) {
            String[] command = {"cmd", "/C", data};
            ProcessBuilder pb = new ProcessBuilder(command);
            Process p = pb.start();
        }
    }

    // Implement input validation and whitelisting
    private boolean isValid(String data) {
        // Define a whitelist of allowed characters
        String whitelist = "^[a-zA-Z0-9]*$";

        // Check if the input matches the whitelist
        if (data.matches(whitelist)) {
            return true;
        } else {
            return false;
        }
    }
}

The updated code includes a method isValid() to validate and sanitize the user input. This method uses a whitelist of allowed characters (in this case, alphanumeric characters) and checks if the user input matches this whitelist. If the input does not match the whitelist, the method returns false and the command is not executed.

The command execution is also updated to use a ProcessBuilder instead of Runtime.exec(). This separates the command from the user input and prevents any unintended command execution. The user input is passed as a separate argument to the command, which helps to prevent command injection vulnerabilities.

Please note that this is a basic example and the whitelist should be adjusted according to your specific requirements. For example, you might need to allow certain special characters or disallow certain alphanumeric characters.

In addition to these code changes, it's also important to follow the other steps mentioned earlier, such as limiting privileges and access, implementing strong access controls, regularly updating and patching dependencies, performing security testing and code reviews, and following secure coding practices.

References​

Last updated on