Skip to main content

Lack of data validation - Input Length

Need​

Implementation of proper input length validation

Context​

  • Usage of PHP for server-side scripting and web development
  • Usage of Request for making HTTP requests
  • Usage of Post for interacting with a database or making HTTP POST requests

Description​

Non compliant code​

public function store(Request $request)
{
    $data = $request->all();

    $post = new Post();
    $post->title = $data['title'];
    $post->content = $data['content'];
    $post->save();

    return response()->json($post);
}

The above code is a typical Laravel controller method that handles POST requests to create a new "Post" in the application. The problem with this code is that it does not validate the length of the input data it receives.

In detail, the store method gets all the input data from the request without checking if the length of the data is within a certain limit. The title and content fields of the Post are directly assigned from the input data and then saved into the database.

This lack of input length validation makes it possible for an attacker to send a POST request with massive amounts of characters in the title or content fields. This could potentially lead to several issues such as exhausting system resources, causing the application to crash, or opening up other attack vectors like buffer overflow attacks.

Steps​

  • Implement input validation to check the length of the data received in the request.
  • Use Laravel's validation rules to set a maximum length for the 'title' and 'content' fields.
  • Return an error response if the validation fails, informing the user that their input is too long.

Compliant code​

public function store(Request $request)
{
    $validatedData = $request->validate([
        'title' => 'required|max:255',
        'content' => 'required|max:5000',
    ]);

    $post = new Post();
    $post->title = $validatedData['title'];
    $post->content = $validatedData['content'];
    $post->save();

    return response()->json($post);
}

The above code fixes the vulnerability by adding input validation to the store method. This is done using Laravel's built-in validation rules.

The $request->validate() method is used to validate the incoming request data. It takes an array of validation rules as its argument. In this case, two rules are applied to both the 'title' and 'content' fields:

  • required: This rule ensures that the field is present in the request data. If it's not, a validation error will be thrown.
  • max:255 and max:5000: These rules set a maximum length for the 'title' and 'content' fields respectively. If the length of the data exceeds these limits, a validation error will be thrown.

If the validation fails, Laravel will automatically redirect the user back to their previous location and flash the error messages in the session. In the case of an AJAX request, a JSON response will be returned with a 422 HTTP status code and the validation error messages.

If the validation passes, the validated data will be returned by the $request->validate() method and can be used to create the new post.

This way, the application is protected against attempts to send massive amounts of characters and expand attack vectors.

References​

Last updated on