Sicherheit von TypeScript-Anwendungen: Top-10 Schwachstellen und Schutz

Einleitung: Warum die Sicherheit von TypeScript-Anwendungen kritisch ist

TypeScript ist eine Erweiterung von JavaScript, die statische Typisierung und moderne Funktionen hinzufügt. Typisierung allein garantiert jedoch keine Sicherheit. Validierungsfehler, unsachgemäße Verarbeitung von Benutzereingaben und Schwachstellen in Abhängigkeiten können zu schwerwiegenden Angriffen führen. In diesem Artikel analysieren wir die Top-10 der häufigsten Schwachstellen in TypeScript-Anwendungen, geben Codebeispiele und zeigen, wie man sie vermeidet.

1. Cross-Site Scripting (XSS)

XSS-Angriffe treten auf, wenn ein Angreifer ein bösartiges Skript in eine Webseite einschleust. TypeScript schützt nicht automatisch davor.

Beispiel für anfälligen Code

function renderUserInput(input: string): string {  return `<div>${input}</div>`;}

// Angreifer übergibt: <script>alert('XSS')</script>

Lösung

Verwenden Sie HTML-Escape-Sequenzen oder Bibliotheken wie DOMPurify:

import DOMPurify from 'dompurify';

function renderUserInputSafe(input: string): string {  const sanitized = DOMPurify.sanitize(input);  return `<div>${sanitized}</div>`;}

2. SQL-Injection

Wenn Sie TypeScript mit Datenbanken verwenden, kann unkontrollierte Zeichenkettenverkettung in SQL-Abfragen zu Datenlecks führen.

Beispiel für anfälligen Code

async function getUser(id: string): Promise<User | null> {  const query = `SELECT * FROM users WHERE id = '${id}'`;  return await db.query(query);}

Lösung

Verwenden Sie parametrisierte Abfragen (prepared statements):

async function getUserSafe(id: string): Promise<User | null> {  const query = 'SELECT * FROM users WHERE id = $1';  return await db.query(query, [id]);}

3. Prototype Pollution

Diese Schwachstelle ist typisch für JavaScript/TypeScript. Ein Angreifer kann das Prototyp-Objekt verändern, was sich zur Laufzeit auf alle Objekte auswirkt.

Beispiel für anfälligen Code

function merge(target: any, source: any) {  for (const key in source) {    if (source.hasOwnProperty(key)) {      target[key] = source[key];    }  }}

const user = { name: 'Alice' };merge(user, JSON.parse('{"__proto__": {"isAdmin": true}}'));// Jetzt haben alle Objekte isAdmin: true

Lösung

Überprüfen Sie Schlüssel auf gefährliche Eigenschaften und verwenden Sie sichere Hilfsprogramme:

function safeMerge(target: Record<string, any>, source: Record<string, any>) {  for (const key in source) {    if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;    target[key] = source[key];  }}

4. Cross-Site Request Forgery (CSRF)

CSRF-Angriffe zwingen einen Benutzer, unerwünschte Aktionen auf einer Website auszuführen, bei der er authentifiziert ist.

Lösung in TypeScript

// CSRF-Token generierenimport crypto from 'crypto';

function generateCsrfToken(): string {  return crypto.randomBytes(32).toString('hex');}

// Überprüfung in Middlewarefunction csrfMiddleware(req: Request, res: Response, next: NextFunction) {  const token = req.headers['x-csrf-token'];  if (token !== req.session.csrfToken) {    return res.status(403).json({ error: 'CSRF validation failed' });  }  next();}

5. Unsichere Deserialisierung

Die Verwendung von JSON.parse() oder eval() auf ungeprüften Daten kann zur Ausführung beliebigen Codes führen.

Anfälliges Beispiel

function processData(data: string) {  const obj = eval('(' + data + ')');  // ...}

Sicherer Ansatz

function processDataSafe(data: string) {  try {    const obj = JSON.parse(data);    // Zusätzliche Typvalidierung    if (typeof obj !== 'object' || obj === null)