Skip to main content

Insecure object reference - Data

Need​

Enforcement of proper authorization and access control mechanisms

Context​

  • Usage of Scala for building scalable and high-performance applications
  • Usage of javax.inject for Dependency Injection in Java applications
  • Usage of Play Framework for building web applications
  • Usage of play.api.mvc for handling HTTP requests and building web applications in Play Framework
  • Usage of models.Store for managing and accessing data in a store
  • Usage of scala.concurrent.ExecutionContext for managing asynchronous execution in Scala

Description​

Non compliant code​

package controllers

import javax.inject._
import play.api._
import play.api.mvc._
import models.Store
import scala.concurrent.ExecutionContext

class StoreController @Inject()(cc: ControllerComponents)(implicit ec: ExecutionContext) extends AbstractController(cc) {

  def getStore(id: Long) = Action.async { implicit request: Request[AnyContent] =>
    Store.find(id).map { store =>
      Ok(views.html.store(store))
    }.getOrElse(NotFound)
  }

  def updateStore(id: Long) = Action.async { implicit request: Request[AnyContent] =>
    val form = Form("name" -> nonEmptyText)
    form.bindFromRequest.fold(
      errorForm => {
        Future.successful(BadRequest(views.html.errorPage(errorForm.errors)))
      },
      data => {
        Store.update(id, data).map { _ =>
          Redirect(routes.StoreController.getStore(id))
        }
      }
    )
  }
}

The above code represents a Scala-based Play framework application where a controller named StoreController is defined which handles the HTTP requests for a particular store.

The getStore function accepts an id as a parameter and returns the corresponding store from the database. It does not check if the logged-in user has the necessary permissions to access the store. Hence, any user who knows the id of a store can access its information.

Similarly, the updateStore function updates the information of a store based on the provided id. It also does not check if the user has the necessary permissions to update the store information. Therefore, any user who knows the id of a store can update its information.

This is a clear example of Insecure Direct Object Reference (IDOR) vulnerability, where the application exposes a reference to an internal implementation object, like a file, directory, or database key without any access control checks or other protection. As a result, attackers can manipulate these references to access unauthorized data.

Steps​

  • Implement proper authorization and authentication mechanisms to ensure that only authorized users can access and modify store information.
  • Validate the user's permissions before allowing access to sensitive data or performing any modifications.
  • Use session management or tokens to track and verify user identity and permissions.
  • Implement access control checks at the server-side to prevent unauthorized access to store information.
  • Ensure that the user can only access and modify stores that they are assigned to.
  • Regularly review and update the authorization and authentication mechanisms to address any new vulnerabilities or security risks.

Compliant code​

package controllers

import javax.inject._
import play.api._
import play.api.mvc._
import models.Store
import scala.concurrent.ExecutionContext

class StoreController @Inject()(cc: ControllerComponents, authService: AuthService)(implicit ec: ExecutionContext) extends AbstractController(cc) {

  def getStore(id: Long) = Action.async { implicit request: Request[AnyContent] =>
    authService.authorize(request, id).flatMap { isAuthorized =>
      if (isAuthorized) {
        Store.find(id).map { store =>
          Ok(views.html.store(store))
        }.getOrElse(NotFound)
      } else {
        Future.successful(Forbidden)
      }
    }
  }

  def updateStore(id: Long) = Action.async { implicit request: Request[AnyContent] =>
    authService.authorize(request, id).flatMap { isAuthorized =>
      if (isAuthorized) {
        val form = Form("name" -> nonEmptyText)
        form.bindFromRequest.fold(
          errorForm => {
            Future.successful(BadRequest(views.html.errorPage(errorForm.errors)))
          },
          data => {
            Store.update(id, data).map { _ =>
              Redirect(routes.StoreController.getStore(id))
            }
          }
        )
      } else {
        Future.successful(Forbidden)
      }
    }
  }
}

The updated code now includes an AuthService that is used to authorize the user before they can access or modify a store. The authorize method of AuthService takes the current request and the id of the store as parameters and returns a Future[Boolean] indicating whether the user is authorized to access or modify the store.

In both getStore and updateStore methods, we first call authService.authorize(request, id). If the user is authorized (isAuthorized is true), we proceed as before. If the user is not authorized (isAuthorized is false), we immediately return a Forbidden response.

This ensures that only users who are authorized to access or modify a store can do so. Unauthorized users are prevented from accessing or modifying store information, thereby fixing the insecure object reference vulnerability.

References​

Last updated on