Skip to main content

Lack of data validation - Session Cookie


Implementation of proper data validation for session cookies


  • Requirement of PHP 7.0 or later for running the application
  • Usage of Request for making HTTP requests in Node.js
  • Usage of response for handling HTTP responses in a Node.js application
  • Usage of cookie for handling HTTP cookies in a web application


Non compliant code

public function setCookie(Request $request) {
$value = $request->input('cookie');
$cookie = cookie('session', $value, 60);
return response('Hello World')->cookie($cookie);

In the code snippet above, we have a function setCookie that accepts a Request object as an argument. This function is responsible for setting a cookie named 'session' with a value obtained from the request input.

The vulnerability here lies in the fact that the value of the session cookie is being set directly from the request input without any form of validation or sanitization. This means that an attacker can send any value they want in the 'cookie' request parameter, and this value will be used as the session cookie.

This could lead to several security issues such as session fixation attacks, where an attacker sets a specific session ID that they know and can therefore hijack the user session. It could also lead to Cross-Site Scripting (XSS) attacks if the cookie value is used in a context that allows for JavaScript execution.

In general, the lack of validation and sanitization of user inputs before using them in security-sensitive contexts like setting session cookies is a major security vulnerability.


  • Validate the input data: Ensure that the value received from the front end is valid and safe to use. This can be done using input validation techniques such as sanitization and filtering.
  • Generate the session cookie server-side: Instead of allowing the front end to set the value of the session cookie, generate it on the server side. This way, you have full control over its value and can ensure it's secure.
  • Use secure and httpOnly flags: When setting the cookie, use the secure flag to ensure it's only sent over HTTPS, and the httpOnly flag to prevent it from being accessed through client-side scripts.
  • Implement a strong session management policy: This includes using a secure, unpredictable session ID, setting an expiration time for the session, and invalidating the session after a certain period of inactivity or when the user logs out.

Compliant code

public function setCookie(Request $request) {
// Validate the input
$value = $request->input('cookie');
$validatedValue = $this->validateInput($value);

// Generate the session cookie server-side
$sessionID = $this->generateSessionID();
$cookie = cookie('session', $sessionID, 60, null, null, false, true);

return response('Hello World')->cookie($cookie);

private function validateInput($input) {
// Implement input validation here
// This is just a placeholder and should be replaced with actual validation logic
return filter_var($input, FILTER_SANITIZE_STRING);

private function generateSessionID() {
// Generate a secure, unpredictable session ID
return bin2hex(random_bytes(32));

The updated code includes several changes to address the vulnerability:

  1. Input Validation: The validateInput function is used to sanitize the input received from the front end. This ensures that the value is safe to use. Note that the actual validation logic should be implemented based on the specific requirements of your application.

  2. Server-side Session ID Generation: The session ID is now generated on the server side using the generateSessionID function. This function uses the random_bytes function to generate a secure, unpredictable session ID.

  3. Secure and httpOnly Flags: The cookie function now includes the secure and httpOnly flags. The secure flag ensures that the cookie is only sent over HTTPS, while the httpOnly flag prevents the cookie from being accessed through client-side scripts.

  4. Session Management Policy: The session management policy should be implemented as part of the overall security strategy of your application. This includes setting an expiration time for the session, invalidating the session after a certain period of inactivity, and invalidating the session when the user logs out. This is not directly shown in the code but should be part of your application's security measures.