Skip to main content

Insecure exceptions - Empty or no catch

Need​

Proper exception handling and error management

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

Description​

Non compliant code​

import play.api.mvc._

def index = Action {
  try {
    val result = riskyOperation()
    Ok("Operation successful")
  } catch {
    case _ => 
  }
}

def riskyOperation() = {
  // Code that may throw an exception
}

In the above Scala code, we have a function index that uses the try-catch block to handle any exceptions that might be thrown during the execution of riskyOperation().

The vulnerability lies in the catch clause case _ =>. This is an empty catch block. It means that it catches all types of exceptions but doesn't do anything to handle them. When an exception is caught here, the program will simply continue running as if nothing happened. This is a bad practice because it can hide potential issues that might occur during the execution of riskyOperation(), and we will have no idea what went wrong or how to fix it.

Moreover, if riskyOperation() throws an exception, the user will receive a success message "Operation successful", which is misleading because the operation has actually failed.

This kind of error handling is insecure and can lead to unexpected behavior of the application, making it temporarily or permanently unavailable. It may also make debugging difficult because exceptions are swallowed and not logged anywhere.

Steps​

  • Identify the specific exception that can be thrown by the risky operation.
  • Add a catch block to the try-catch statement to handle the specific exception.
  • Handle the exception appropriately, either by logging the error, returning an error response, or taking any other necessary action.
  • Ensure that the catch block does not leave the exception unhandled or empty.
  • Consider adding a finally block if there are any cleanup tasks that need to be performed regardless of whether an exception occurs or not.

Compliant code​

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

def index = Action {
  try {
    val result = riskyOperation()
    Ok("Operation successful")
  } catch {
    case e: Exception => 
      Logger.error("An error occurred: ", e)
      InternalServerError("An error occurred while performing the operation")
  } finally {
    // Any cleanup tasks go here
  }
}

def riskyOperation() = {
  // Code that may throw an exception
}

The updated code now includes proper exception handling. The try block contains the code that might throw an exception, which is the riskyOperation() method.

In the catch block, we now catch a generic Exception (you should replace this with the specific exception(s) that riskyOperation() might throw). When an exception is caught, we log the error using Play's Logger and return a 500 Internal Server Error response with a message indicating that an error occurred. This way, we're not leaving the catch block empty and we're providing feedback to the user about what went wrong.

The finally block is optional and can be used to perform any cleanup tasks that need to be done regardless of whether an exception was thrown or not. For example, if riskyOperation() opens a database connection, you might want to close that connection in the finally block to make sure it gets closed even if an error occurs.

Remember, it's important to handle exceptions appropriately to prevent your application from becoming temporarily or permanently unavailable. By handling exceptions, you can control what happens when an error occurs and provide a better user experience.

References​

Last updated on