Skip to main content

Lack of data validation - Non Sanitized Variables

Need​

Implementation of proper data validation and sanitization mechanisms

Context​

  • Usage of Go 1.16 for developing scalable and efficient applications
  • Usage of gin-gonic/gin for building web applications in Go
  • Usage of os/exec for executing external commands in the operating system

Description​

Non compliant code​

package main

import (
	"os/exec"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/cmd/:command", func(c *gin.Context) {
		command := c.Param("command")
		cmd := exec.Command(command)
		output, err := cmd.Output()

		if err != nil {
			c.JSON(500, gin.H{
				"message": err.Error(),
			})
			return
		}

		c.JSON(200, gin.H{
			"message": string(output),
		})
	})

	r.Run()
}

The above Go code is a simple web server that uses the Gin framework. In the main function, it sets up a GET route handler for "/cmd/:command". The handler function takes a command as a parameter from the URL, executes it using os/exec package's Command function, and sends the output back as a response.

This code is vulnerable because it directly uses the command from the URL to construct a system command without any validation or sanitization. This means an attacker could manipulate the input to execute arbitrary commands on the system where the server is running. This is a classic example of a command injection vulnerability.

For instance, if an attacker sends a GET request to /cmd/;rm -rf /, it would delete all files in the system's root directory.

This vulnerability could lead to serious consequences, including data loss, system damage, or unauthorized access. Therefore, it is crucial to validate and sanitize all inputs that are used to construct system commands.

Steps​

  • Implement input validation to ensure that the 'command' parameter only contains allowed characters.
  • Use a whitelist approach to validate the 'command' parameter, allowing only specific commands or characters.
  • Sanitize the 'command' parameter by removing any special characters or escape sequences.
  • Implement proper error handling to handle any potential errors during command execution.
  • Consider using a secure alternative to executing system commands, such as using a library or framework function specifically designed for command execution.
  • Regularly update and patch the dependencies used in the application to ensure any security vulnerabilities are addressed.

Compliant code​

package main

import (
	"os/exec"
	"github.com/gin-gonic/gin"
	"regexp"
)

func main() {
	r := gin.Default()

	r.GET("/cmd/:command", func(c *gin.Context) {
		command := c.Param("command")

		// Validate the 'command' parameter using a whitelist approach
		matched, err := regexp.MatchString(`^[a-zA-Z0-9\\s]*$`, command)
		if err != nil || !matched {
			c.JSON(400, gin.H{
				"message": "Invalid command",
			})
			return
		}

		cmd := exec.Command(command)
		output, err := cmd.Output()

		if err != nil {
			c.JSON(500, gin.H{
				"message": err.Error(),
			})
			return
		}

		c.JSON(200, gin.H{
			"message": string(output),
		})
	})

	r.Run()
}

The updated code includes input validation for the 'command' parameter. This is done using a whitelist approach, where only specific characters are allowed in the command. The allowed characters are alphanumeric characters and spaces. This is achieved using a regular expression (^[a-zA-Z0-9\\s]*$), which matches any string that only contains these characters.

If the 'command' parameter contains any other characters, the server responds with a 400 status code and an "Invalid command" message. This prevents the execution of potentially harmful system commands.

The code also includes proper error handling. If there is an error during the execution of the command, the server responds with a 500 status code and the error message.

This approach significantly reduces the risk of command injection attacks. However, it is still recommended to use a secure alternative to executing system commands whenever possible. Regularly updating and patching the dependencies used in the application can also help ensure any security vulnerabilities are addressed.

References​

Last updated on