Skip to main content

Traceability loss

Need​

Enhancement of traceability and logging capabilities

Context​

  • Usage of Scala for building scalable and high-performance applications
  • Usage of play.api.mvc for handling HTTP requests and building web applications in Play Framework

Description​

Non compliant code​

import play.api.mvc._

class ApplicationController extends Controller {
  def index = Action {
    try {
      // Some critical action here which might throw exception
    } catch {
      case e: Exception => 
        // Exception is caught but not logged or tracked
        BadRequest("An error occurred")
    }
  }
}

The above Scala code shows a controller action in a Play Framework application. Inside the index action, there is a try-catch block. The try block is supposed to execute some critical action which might throw an exception.

The vulnerability lies in the catch block. When an exception is thrown, it is caught but not logged or tracked anywhere. This results in a loss of traceability, as we will not have any information about the error or exceptional event that occurred.

This is a serious issue because without proper logging or tracking, it becomes difficult to monitor the system, detect possible security events, or debug issues. Additionally, it can also hinder audits and compliance checks because there is no record of the exceptions or errors that have occurred.

In the context of security, it's important to have a complete and accurate record of all activities, especially those that result in errors or exceptions, so that we can detect and respond to potential security threats.

Steps​

  • Implement proper error handling and logging mechanism
  • Use a centralized logging system to track errors and exceptional events
  • Ensure that critical actions are properly tracked and logged
  • Consider using a dedicated error tracking tool or library
  • Regularly review and analyze the logged errors to detect security events

Compliant code​

import play.api.mvc._
import play.api.Logger

class ApplicationController extends Controller {
  def index = Action {
    try {
      // Some critical action here which might throw exception
    } catch {
      case e: Exception => 
        // Exception is caught and logged
        Logger.error("An error occurred", e)
        BadRequest("An error occurred")
    }
  }
}

The updated code now includes a logging mechanism to track errors and exceptional events. The Logger.error method is used to log the exception details whenever an error occurs. This method takes two parameters: a string message and the exception object. The string message provides a brief description of the error, and the exception object contains the details of the error.

This way, whenever an exception is thrown during the execution of the critical action, the error details are logged using the Logger.error method. This ensures that all errors and exceptional events are properly tracked and logged, which aids in the detection of possible security events.

In addition to this, it is recommended to use a centralized logging system to manage and analyze the logged errors. Regular review and analysis of the logged errors can help in early detection of security events and taking appropriate actions.

Also, consider using a dedicated error tracking tool or library for more advanced error tracking and analysis. These tools can provide more detailed insights into the errors and help in identifying the root cause of the errors.

References​

Last updated on