# V5616. OWASP. Possible command injection. Potentially tainted data is used to create OS command.

The analyzer has detected the creation of the OS-level command from unverified data. The data was received from an external source. This may cause the command injection vulnerability.

The OWASP Top 10 Application Security Risks puts command injections in the following categories:

- A1:2017-Injection in the 2017 list;
- A3:2021-Injection in the 2021 list.

Look at the example:

    HttpRequest _request;
    string _pathToExecutor;

    private void ExecuteOperation()
    {
      ....
      String operationNumber = _request.Form["operationNumber"];

      Process.Start("cmd", $"/c {_pathToExecutor} {operationNumber}");
      ....
    }

In this code fragment the application reads the number of operation that the called process should execute. Thus, the number of operations is strictly limited. An attacker may pass a string as the "operationNumber" parameter's value. This string allows executing unauthorized actions. As a result, "operationNumber" may contain the following string:

    0 & del /q /f /s *.*

Let's assume that the 'executor.exe' path is written to '_pathToExecutor'. As a result of calling 'Process.Start' the system performs the following command:

    cmd /c executor.exe 0 & del /q /f /s *.*

The '&' character is interpreted as a command separator. The 'del' instruction with such arguments deletes all files in the current and nested directories (if the application has the sufficient file access rights). Thus, the correctly selected value in the "operationNumber" parameter performs malicious actions.

In order to avoid this vulnerability, you should always check the input data. The specific implementation of this check depends on the situation. In the code fragment above it is enough to make sure that a number is written to the 'operationNumber' variable:

    private void ExecuteOperation()
    {
      String operationNumber = _request.Form["operationNumber"];

      if (uint.TryParse(operationNumber, out uint number))
        Process.Start("cmd", $"/c {_pathToExecutor} {number}");
    }

The method parameters available from other builds are also source of insecure data. Although, the analyzer issues low-level warnings for such sources. You can read the explanation of this position in the "Why you should check values of public methods' parameters" note.

Let's take the following code fragment as an example:

    private string _userCreatorPath;

    public void CreateUser(string userName, bool createAdmin)
    {
      string args = $"--name {userName}";

      if (createAdmin)
        args += " --roles ADMIN";

      RunCreatorProcess(args);           // <=
    }

    private void RunCreatorProcess(string arguments)
    {
      Process.Start(_userCreatorPath, arguments).WaitForExit();
    }

In this code fragment, the 'RunCreatorProcess' method creates a process. This process, in turn, creates a user. This user obtains the administrator permissions only if the 'createAdmin' flag has the 'true' value.

The code from the library that depends on the current one may call the 'CreateUser' method to create a user. The developer may pass, for example, a query parameter to the 'userName' parameter. There's a high probability that there would be no checks in the caller code. The developer would expect them to be in the 'CreateUser' method. Thus, both the library and the code that uses it, don't have the 'userName' validation.

As a result, the correctly selected name allows an attacker to create a user with the administrator permissions. This would not depend on the 'createAdmin' flag value (it will be 'false' in most cases). Let's assume that the following string is written to the 'userName' parameter:

    superHacker --roles ADMIN

After substitution, the argument string will look the same as if 'createAdmin' was set to 'true':

    --name superHacker --roles ADMIN

Thus, even without the administrator permissions, an attacker can create a user with such permissions and use it for their own purposes.

In this case, you should check the username for forbidden characters. For example, you can allow using only Latin letters and numbers:

     public void CreateUser(string userName, bool createAdmin)
    {
      if (!Regex.IsMatch(userName, @"^[a-zA-Z0-9]+$"))
      {
        // error handling
        return;
      }

      string args = $"--name {userName}";

      if (createAdmin)
        args += " --roles ADMIN";

      RunCreatorProcess(args);
    }

This diagnostic is classified as:

CWE-77 CWE-78 CWE-88 OWASP-5.3.8