Skip to main content

Inappropriate coding practices - Eval function

Need​

Elimination of the use of eval function with unvalidated user input

Context​

  • Usage of Scala for building scalable and high-performance applications
  • Usage of play.api.mvc for handling HTTP requests and responses in Play Framework
  • Usage of scala.util.control.Exception for handling exceptions in Scala
  • Usage of scala.tools.nsc.interpreter.IMain for interactive Scala code execution

Description​

Non compliant code​

import play.api.mvc._
import scala.util.control.Exception._

class HomeController @Inject()(val controllerComponents: ControllerComponents) extends BaseController {

  def index() = Action { implicit request: Request[AnyContent] =>
    val param = request.getQueryString("param")
    val result = catching(classOf[Exception]) opt {
      val func = new scala.tools.nsc.interpreter.IMain().interpret(param.getOrElse(""))
      func.toString
    }
    Ok(result.getOrElse("Invalid input"))
  }
}

The above Scala code is a basic Play Framework controller that has a single index action. This action takes a URL parameter, "param", and uses it as input for the Scala interpret function, which is similar to the eval function in other languages.

The interpret function evaluates a string of Scala code and executes it, returning the result. The use of this function in the above code is what makes it vulnerable. It takes the "param" directly from the request without any validation or sanitizing, thus allowing for arbitrary code execution.

The catching(classOf[Exception]) opt block is used to catch any exceptions that might occur during the execution of the interpret function. However, this does not prevent the execution of potentially harmful code, it merely prevents the application from crashing if such code is executed.

An attacker could exploit this vulnerability by sending a request with a "param" that contains malicious Scala code. This code would then be executed on the server, potentially leading to data leakage, data manipulation, or even full control over the server. This is a severe security vulnerability and should be addressed immediately.

Steps​

  • Avoid using the eval function altogether.
  • Validate and sanitize user input before using it in any code execution.
  • Use a whitelist approach to only allow specific inputs and reject everything else.
  • Implement proper input validation and sanitization techniques, such as input validation libraries or regular expressions.
  • Use parameterized queries or prepared statements when interacting with databases to prevent SQL injection.
  • Implement a strict content security policy (CSP) to prevent the execution of any injected scripts.
  • Regularly update and patch the application framework and dependencies to ensure the latest security fixes are applied.
  • Educate developers about secure coding practices and provide training on identifying and mitigating code injection vulnerabilities.

Compliant code​

import play.api.mvc._
import scala.util.control.Exception._

class HomeController @Inject()(val controllerComponents: ControllerComponents) extends BaseController {

  def index() = Action { implicit request: Request[AnyContent] =>
    val param = request.getQueryString("param")
    param match {
      case Some(p) if isValidInput(p) => 
        // Process the valid input
        Ok("Valid input")
      case _ => 
        Ok("Invalid input")
    }
  }

  // Implement a function to validate the input
  def isValidInput(input: String): Boolean = {
    // Add your validation logic here
    // For example, check if the input matches a whitelist of allowed inputs
    true
  }
}

The original code was vulnerable because it used the eval function to execute code based on user input. This could allow an attacker to inject malicious code and execute it on the server.

The fixed code removes the use of the eval function and instead validates the user input before processing it. The isValidInput function is used to check if the input is valid. This function should contain the logic to validate the input, for example by checking if it matches a whitelist of allowed inputs.

By validating the input before processing it, we can prevent code injection attacks. This is a much safer approach than using the eval function.

In addition to this, it's important to regularly update and patch the application framework and dependencies to ensure the latest security fixes are applied. Developers should also be educated about secure coding practices and trained to identify and mitigate code injection vulnerabilities.

References​

Last updated on