Mass-Assignment-Schwachstellen in Node.js vermeiden

Mass Assignment ist eine Schwachstelle, durch die Angreifer vorhersehbare Datensatzmuster ausnutzen und unzulässige Aktionen ausführen können. Mass Assignment tritt häufig auf, wenn Eigenschaften beim Binden von clientseitig bereitgestellten Daten an Datenmodelle nicht gefiltert werden. Schwachstellen dieser Art ermöglichen es Angreifern, zusätzliche Objekte in POST-Anfrage-Payloads einzufügen und so Eigenschaften zu ändern, die unveränderlich sein sollten.

Node.js ist eine Open-Source-Serverumgebung, die plattformübergreifend für die Entwicklung von Webanwendungen eingesetzt werden kann. Damit können Entwickler leistungsstarke, skalierbare Anwendungen schnell erstellen. Node.js ist eine bewährte und produktionsreife Plattform – Herausforderungen bei der Anwendungssicherheit ergeben sich durch die Supply-Chain-Sicherheit von Drittanbieterpaketen, die bei der Entwicklung von Anwendungen installiert werden. Für eine Node.js-Anwendung kommen mitunter Tausende Open-Source-npm-Pakete aus der npm-Registry zum Einsatz, wodurch zahlreiche Angriffsvektoren entstehen.

Mass-Assignment-Schwachstellen treten häufig in Node.js-Anwendungen auf, die Payloads in POST-Anfragen an die Datenbank senden. Angreifer können diese Schwachstellen für SQL-Injection-Angriffe oder andere Angriffe auf in Datenbanken gespeicherte Daten nutzen. Mit einer Mass-Assignment-Schwachstelle können Angreifer ein System vollständig übernehmen oder vertrauliche Daten stehlen. Daher ist es entscheidend, sich gegen diese Art von Angriff zu schützen.

Dieser Artikel zeigt anhand eines Node.js-Projekts, wie eine Mass-Assignment-Schwachstelle entsteht, wie Angreifer sie ausnutzen können und wie Sie eine Webanwendung davor schützen.

Mass-Assignment-Schwachstellen in Node.js beseitigen

In diesem Beispiel verwenden wir Mongoose, eine Object-Data-Modelling-Bibliothek (ODM) für Node.js und MongoDB. Sie verknüpft Objekte im Code mit Objekten in MongoDB, validiert Schemas und erleichtert die Verwaltung von Datenbeziehungen.

Wie oben beschrieben, müssen Sie den Schutz vor Mass Assignment in einer Node.js-MongoDB-Anwendung in Mongoose umsetzen. Im Folgenden sehen Sie ein Beispiel dafür, wie eine Mass-Assignment-Schwachstelle in einer Node.js-Anwendung ausgenutzt werden kann.

Voraussetzungen

Für dieses Projekt benötigen Sie:

• Node.js installiert

• Zugriff auf eine MongoDB-Datenbank und einen gültigen Verbindungsstring. Dieses Tutorial verwendet eine MongoDB-Atlas-Cloudumgebung. Sie können aber auch einen lokalen MongoDB-Server einrichten und den Verbindungsstring entsprechend anpassen.

Mass Assignment in Node.js

Öffnen Sie zunächst Ihr Terminal und führen Sie diesen Befehl aus:

1npm init

Installieren Sie anschließend die Abhängigkeiten:

1npm i mongoose
2npm i express

Um die Daten aus dem obigen Formular zu verarbeiten, benötigen wir im Ordner models eine Datei namens newUser.js, die das Benutzerschema verwaltet.

1const mongoose = require('mongoose');
2
3const Schema = mongoose.Schema;
4
5const userSchema = new Schema({
6
7    first_name: String,
8    last_name: String,
9    email: String,
10    password: String,
11    isAdmin: {
12        type: Boolean,
13        protect: true,
14        default: false
15    }
16
17});
18
19const User = mongoose.model("User", userSchema);
20
21module.exports = User;
22

Dieses Modell umfasst alle Felder des Registrierungsformulars. Das zusätzliche Feld isAdmin vom Typ Boolean legt die Rolle eines Benutzers fest. Wenn Sie dieses Feld auf true setzen, erstellen Sie einen Benutzer mit Administratorrechten. Bei false wird ein Benutzer ohne Administratorrechte erstellt.

Erstellen Sie ein neues Verzeichnis namens routes und fügen Sie die Datei routes.js hinzu, um Benutzerdetails zu verarbeiten:

1    const express = require("express");
2    const userModel = require("../models/newUser");
3
4    const app = express();
5
6    app.post("/add_user", async (request, response) => {
7        const user = new userModel(request.body);
8
9        try {
10          await user.save();
11          response.send(user);
12        } catch (error) {
13          response.status(500).send(error);
14        }
15    });
16
17module.exports = app;

Der obige Code erfasst die Formulardaten und strukturiert sie anschließend mithilfe des Modells newUSer.

Dieser Code weist zwei Schwachstellen auf, die eine Mass-Assignment-Schwachstelle verursachen. Erstens verwendet er für ein vertrauliches Feld einen gängigen Namen und Typ: isAdmin. Zweitens enthält das Benutzermodell ein vertrauliches, ungenutztes Feld. Um die Schwachstelle auszunutzen, starten wir zunächst einen Server.

Erstellen Sie im Stammverzeichnis des Projekts eine Datei namens server.js und fügen Sie den folgenden Code ein. Ersetzen Sie dabei <APP_ID> durch den Wert aus Ihrem Verbindungsstring:

1const express = require("express");
2const mongoose = require("mongoose");
3const Router = require("./routes/routes")
4
5const app = express();
6
7app.use(express.json());
8
9const username = "<USER>";
10const password = "<USER_PASSWORD>";
11const cluster = "<CLUSTER>";
12const dbname = "<DATABSE_NAME>";
13
14mongoose.connect(
15  `mongodb+srv://${username}:${password}@${cluster}.<APP_ID>.mongodb.net/${dbname}?retryWrites=true&w=majority`,
16  {
17    useNewUrlParser: true,
18    useUnifiedTopology: true
19  }
20);
21
22const db = mongoose.connection;
23db.on("error", console.error.bind(console, "connection error: "));
24db.once("open", function () {
25  console.log("Connected successfully");
26});
27
28app.use(Router);
29
30app.listen(3000, () => {
31  console.log("Server is running at port 3000");
32});
33

Starten Sie den Server mit node server.js.

Ein Angreifer kann diese Schwachstelle ausnutzen, indem er eine curl POST-Anfrage mit dem Feld isAdmin erstellt und dessen Wert auf true setzt, wie im folgenden Code gezeigt:

1curl --location --request POST 'http://localhost:3000/add_user' \
2--header 'Content-Type: application/json' \
3--data-raw '{
4    "first_name": "Mike",
5    "last_name": "Jones",
6    "email": "mikejones@hmail.com",
7    "isAdmin":"true"
8}'

Mit der obigen Anfrage wird ein Benutzer namens Mike mit Administratorrechten erstellt. Dieser Benutzer kann sich nun mit seinen Zugangsdaten am System anmelden und alles tun, was auch ein Administrator tun kann.

Schutz vor Mass Assignment

Mit drei Anpassungen können wir die Anwendung besser vor Mass-Assignment-Angriffen schützen.

Schlanke Modelle erstellen

Schlanke Modelle enthalten nur die Eingaben, die ein Benutzer voraussichtlich hinzufügen soll, und schließen vertrauliche Felder aus.

Wie im obigen Beispiel besteht der erste und wichtigste Schritt darin, das vertrauliche Feld aus dem Modell newUser zu entfernen, wie unten gezeigt:

1const mongoose = require("mongoose");
2
3// create a schema
4var userSchema = new mongoose.Schema({
5	first_name: String,
6	last_name: String,
7	email: String,
8	password: String
9
10	//NB: there is no isAdmin field
11
12});
13
14const User = mongoose.model("User", userSchema);
15
16module.exports = User;

Wenn Angreifer Zugriff auf den Quellcode erhalten, können sie das vertrauliche Feld dann nicht sehen und für einen Angriff nutzen. Vermeiden Sie außerdem vorhersehbare Begriffe in der Datenbank, mit denen die Rolle eines Benutzers festgelegt wird – etwa isAdmin, admin und role –, da Angreifer sie erraten und einen Angriff starten könnten.

Benutzereingaben mit Schema-Validierung prüfen

Validierung mit underscore

Eine weitere Möglichkeit, Ihre Anwendung zu schützen, besteht darin, die Felder festzulegen und einzuschränken, die eine POST-Anfrage verarbeiten darf. Dieses Verfahren wird Allowlisting genannt und verwendet die Bibliothek underscore. Installieren Sie zunächst die Bibliothek:

1npm install underscore

Wechseln Sie in den Ordner routes und ersetzen Sie den Code in route.js durch diesen:

1const express = require("express");
2const userModel = require("../models/newUser");
3var _ = require('underscore');
4
5const app = express();
6
7app.post("/add_user", async (request, response) => {
8    const user = new userModel( _.pick(request.body, 'first_name', 'last_name', 'email', 'password'));
9
10    try {
11      await user.save();
12      response.send(user);
13    } catch (error) {
14      response.status(500).send(error);
15    }
16});
17
18module.exports = app;

Im obigen Code verwenden wir die Funktion pick, um die Variablen festzulegen, die aus einer POST-Anfrage extrahiert werden. So verhindern wir, dass Angreifer das vertrauliche Feld isAdmin verwenden.

Die Herausforderung bei underscore besteht darin, dass die Anwendung die Daten erst verarbeiten muss, um festzustellen, ob sie gültig sind. Anders gesagt: Fehler werden nicht früh genug erkannt.

Validierung mit Zod

Für eine robuste Schema-Validierung sollten Sie Zod verwenden. Zod validiert das Schema und stellt sicher, dass die Daten genau der vorgegebenen Struktur, dem Muster und Datentyp entsprechen. Unvollständige oder fehlerhafte Daten erkennt Zod frühzeitig, sodass Anwendungsfehler vermieden werden. Außerdem können Sie einfach eine Fehlermeldung erstellen, die Benutzer über die fehlerhaften Eingaben und die Art des Fehlers informiert.

Der Codeausschnitt veranschaulicht die Funktionsweise von Zod. Beachten Sie, dass der folgende Ausschnitt in TypeScript geschrieben ist und daher eine zusätzliche Konfiguration erfordert.

1import { z, AnyZodObject } from "zod";
2import express, { Request, Response, NextFunction } from 'express';
3
4const app = express();
5
6app.use(express.json());
7
8const dataSchema = z.object({
9    body: z.object({
10        first_name: z.string({
11            required_error: "First name is required",
12            invalid_type_error: "First name must be a string",
13        }),
14        last_name: z.string({
15            required_error: "Last name is required",
16            invalid_type_error: "Last name must be a string",
17        }),
18        password: z.string({
19            required_error: "Password is required",
20        }),
21        email: z
22            .string({
23                required_error: "Email is required",
24            })
25            .email("Not a valid email"),
26    }),
27});
28
29const validate =
30    (schema: AnyZodObject) =>
31    async (req: Request, res: Response, next: NextFunction) => {
32        try {
33            await schema.parseAsync({
34                body: req.body,
35                query: req.query,
36                params: req.params,
37            });
38            return next();
39        } catch (error) {
40            return res.status(400).json(error);
41        }
42    };
43
44app.post("/create",
45    validate(dataSchema),
46    (req: Request, res: Response): Response => {
47        return res.json({
48            ...req.body
49        });
50    }
51);

Wenn ein Benutzer Daten eingibt, die nicht dem Schema entsprechen, wird der Fehler invalid_type_error ausgegeben. Lässt der Benutzer ein Feld leer, wird der Fehler required_error ausgegeben.

Weitere Beispiele für Mass-Assignment-Schwachstellen in ORMs

Sehen wir uns drei weitere Beispiele für Mass-Assignment-Schwachstellen in gängigen ORM-Lösungen an.

Mass-Assignment-Schwachstelle in Sequelize-Code

Sehen wir uns ein Beispiel für anfälligen Sequelize-Code an. Dieser Code definiert ein Benutzermodell, erstellt einen Benutzer und speichert die Benutzerdetails in der Datenbank:

1const { Sequelize } = require("sequelize");
2
3const User = sequelize.define("users", {
4    username: {
5        type: DataTypes.STRING,
6        allowNull: false
7    },
8
9    email: {
10        type: DataTypes.STRING,
11        allowNull: false
12    },
13
14    password: {
15        type: DataTypes.STRING,
16        allowNull: false
17    },
18
19    is_verified: {
20        type: DataTypes.BOOLEAN,
21        allowNull: false,
22        default: false
23    },
24
25 });

Beim Erstellen eines neuen Benutzers ruft der Controller das obige Modell auf, wie unten gezeigt:

1// Create a User
2const user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password,
6    is_verified: false
7  };
8
9//Save User in the database
10User.create(user)
11.then(data => {
12    res.send(data);
13})
14.catch(err => {
15    res.status(500).send({
16    message:
17        err.message || "Error occurred. User not created!"
18    });
19});

Der obige Code ist anfällig, weil er das vertrauliche Feld is_verified offenlegt. Angreifer können eine POST-Anfrage mit dem Feld is_verified und dem Wert true erstellen und so den Verifizierungsschritt umgehen.

Wir können die Mass-Assignment-Schwachstelle in diesem Code beseitigen, indem wir das Feld is_verified beim Erstellen des Benutzers weglassen. Der sichere Code sieht so aus:

1// Create a User
2const user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password
6  };

Dadurch werden die zulässigen Variablen einer POST-Anfrage auf Benutzername, E-Mail-Adresse und Passwort beschränkt.

Mass-Assignment-Schwachstelle in Prisma-Code

Im Folgenden sehen Sie ein Beispiel für anfälligen Prisma-Code, der das vertrauliche Feld Role offenlegt.

1model User {
2    id      		Int    @id @default(autoincrement())
3    username        String
4    email       	String
5    Role    		Boolean    @default(USER)
6  }
7
8enum Role {
9    USER
10    ADMIN
11}

Um einen Benutzer hinzuzufügen, erstellen wir eine Route namens add_user.

1const { PrismaClient } = require("@prisma/client");
2const express = require("express");
3const prisma = new PrismaClient();
4
5const app = express();
6
7app.use(express.json());
8
9app.post('/add_user', async (req, res) => {
10    const user = await prisma.user.create({ data: req.body });
11    res.json(user);
12  });

Diese POST-Anfrage erwartet im Body ein Benutzerobjekt. Der obige Code ist anfällig für Mass-Assignment-Angriffe, da Hacker das Feld role auf ADMIN setzen können, um Administratorrechte zu erlangen.

Wir können die Schwachstelle im obigen Code beseitigen, indem wir das vertrauliche Feld Role aus dem Modell ausschließen.

1model User {
2    id      		Int    @id @default(autoincrement())
3    username        String
4    email       	String
5  }

Mass-Assignment-Schwachstelle in MySQL-Code

Hier sehen Sie ein Beispiel für anfälligen MySQL-Code mit Mass Assignment, der das vertrauliche Feld isAdmin offenlegt:

1// Defining the user data
2let user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password,
6    isAdmin: req.body.role
7};

Mit diesem Code wird der oben definierte Benutzer hinzugefügt:

1// Saving user details
2app.post('/add_user',(req, res) => {
3
4let myQuery = "INSERT INTO users SET ?";
5
6    let query = connection.query(myQuery, user,(err, results) => {
7        if(err) throw err;
8        res.send(apiResponse(results));
9    });
10
11});

Der obige Code weist eine Mass-Assignment-Schwachstelle auf, weil er das vertrauliche Feld isAdmin offenlegt und erlaubt, es in eine POST-Anfrage aufzunehmen. Angreifer können eine POST-Anfrage erstellen, die das Feld isAdmin auf true setzt und so einen Administratorbenutzer erstellt.

Wir können diese Schwachstelle beheben, indem wir das vertrauliche Feld beim Erstellen des Objekts user weglassen. Der sichere Code sieht so aus:

1// Defining the user data
2let user = {
3    username: req.body.username,
4    email: req.body.email,
5    password: req.body.password
6};

Der Standardwert false für das Feld isAdmin kann festgelegt werden, indem Sie die Tabelle mit dem folgenden Befehl ändern:

1ALTER TABLE users ALTER isAdmin SET DEFAULT ‘false’;

Ihren Node.js-Code sicher halten

Node.js ist sicher, doch die für die Entwicklung einer Webanwendung benötigten Pakete sind es mitunter nicht. Bei Node.js-Anwendungen, die Anfragen an eine Datenbank senden, zählt Mass Assignment zu den häufigsten Angriffsvektoren. Dadurch können böswillige Benutzer SQL-Injection-Angriffe ausführen, bei denen sie schädliche Anfragen an eine Datenbank senden.

Eingaben lassen sich jedoch einfach bereinigen, um Mass Assignment in Node.js zu verhindern. Sie können vertrauliche Felder nicht offenlegen, zulässige Felder einschränken oder die Bearbeitung bestimmter Felder blockieren.

Wenn Sie Eingaben von Benutzern nicht robust validieren, ist Ihr System Angriffen wie Prototype Pollution ausgesetzt. Solche Angriffe können schwache Validierungsmechanismen wie underscore umgehen. Achten Sie daher darauf, stets robuste Lösungen wie Zod einzusetzen.

Sehen Sie sich das vollständige Quellcodebeispiel in unserem GitHub-Repository an und führen Sie eigene lokale Sicherheitsexperimente durch, um zu erfahren, wie Sie Mass-Assignment-Schwachstellen in Node.js vermeiden.

Befolgen Sie Snyks Top 10 der Best Practices für Node.js-Sicherheit, um die Sicherheit Ihrer Node.js-Anwendung zu optimieren.