Skip to main content

Improper type assignation

Need​

Enforce proper type assignment in the source code

Context​

  • Usage of TypeScript for type-checking and compiling JavaScript code
  • Usage of Express for building web applications and APIs

Description​

Non compliant code​

import express from 'express';

const app = express();

let data: any;

app.get('/api/data', (req, res) => {
  // Fetch data from a database or external API
  data = fetchData();

  res.send(data);
});

app.post('/api/data', (req, res) => {
  // Modify the data based on user input
  const newData = req.body;

  // Improper type assignation
  data = newData;

  res.send('Data updated successfully');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

function fetchData(): any {
  // Fetch data from a database or external API
  return { id: 1, name: 'John Doe' };
}

The vulnerability in this code is improper type assignation. The variable data is declared with the type any, which means it can hold any type of value. In the POST route handler, the data is being assigned a new value from the user input without any type checking or validation.

This can lead to potential security issues. If the user input contains malicious data or unexpected data types, it can result in unintended behavior or even compromise the integrity of the data. For example, an attacker could send a request with a different data type that the code does not expect, causing potential data corruption or manipulation.

To mitigate this vulnerability, it is recommended to explicitly define the type of the data variable based on the expected data structure. This will ensure that only valid data types can be assigned to the variable, reducing the risk of unintended modifications or security breaches.

Steps​

  • Declare a specific type for the 'data' variable instead of using 'any'
  • Update the 'fetchData' function to return data of the same type as the 'data' variable
  • Update the 'data' variable assignment in the '/api/data' route handler to properly assign the type of 'newData'
  • Consider adding input validation and sanitization to ensure the user input is safe

Compliant code​

import express, { Request, Response } from 'express';

interface Data {
  id: number;
  name: string;
}

const app = express();

let data: Data;

app.get('/api/data', (req: Request, res: Response) => {
  data = fetchData();

  res.send(data);
});

app.post('/api/data', (req: Request, res: Response) => {
  const newData: Data = req.body;

  data = newData;

  res.send('Data updated successfully');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

function fetchData(): Data {
  return { id: 1, name: 'John Doe' };
}

The fixed code addresses the vulnerability by explicitly declaring the types of variables and parameters using TypeScript.

First, the code imports the necessary modules from the Express framework, including the Request and Response types.

Next, an interface named "Data" is defined, which specifies the structure of the data object. It has two properties: "id" of type number and "name" of type string.

The Express application is created using the "express()" function and assigned to the "app" variable.

A variable named "data" is declared with the type "Data". This ensures that the variable can only hold values that conform to the structure defined by the "Data" interface.

The code defines two routes: a GET route and a POST route.

In the GET route, when a request is made to "/api/data", the code calls the "fetchData" function to retrieve the data and assigns it to the "data" variable. Then, the data is sent as the response using the "res.send" method.

In the POST route, when a request is made to "/api/data", the code expects the request body to contain data that matches the "Data" interface. The received data is assigned to a new variable named "newData" with the type "Data". Then, the "data" variable is updated with the new data. Finally, a success message is sent as the response.

The Express application listens on port 3000 using the "app.listen" method, and a message is logged to the console to indicate that the server is running.

The code also includes a function named "fetchData" that returns a hardcoded data object that matches the "Data" interface.

By explicitly specifying the types of variables and parameters, the code ensures that only valid data is assigned to them, reducing the risk of improper type assignation vulnerabilities.

References​

Last updated on