Sicherheit von TypeScript-Anwendungen: Top-10-Schwachstellen für Anfänger

Einleitung: Warum die Sicherheit von TypeScript-Anwendungen von Anfang an wichtig ist

TypeScript ist eine Erweiterung von JavaScript, die statische Typisierung hinzufügt. Viele Anfänger gehen fälschlicherweise davon aus, dass Typisierung automatisch alle Sicherheitsprobleme löst. Tatsächlich wird TypeScript in normales JavaScript kompiliert, und alle Schwachstellen, die JS eigen sind, bleiben relevant. In diesem Artikel analysieren wir die Top-10 Schwachstellen, auf die Anfänger stoßen, und zeigen, wie man sie vermeidet.

1. XSS (Cross-Site-Scripting)

XSS ist einer der häufigsten Angriffe. Ein Angreifer schleust ein schädliches Skript in eine Seite ein, das im Browser des Benutzers ausgeführt wird.

Beispiel für anfälligen Code:

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

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

Wie man es behebt:

Maskieren Sie immer Benutzereingaben. Verwenden Sie Bibliotheken wie DOMPurify oder integrierte Escape-Methoden:

import DOMPurify from 'dompurify';

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

2. SQL-Injection

Wenn Sie SQL-Abfragen durch Verkettung von Zeichenketten mit Benutzereingaben erstellen, öffnen Sie die Tür für SQL-Injection.

Anfälliger Code:

function getUser(username: string): Promise<User> {    const query = `SELECT * FROM users WHERE username = '${username}'`;    return db.execute(query);}

Sichere Variante:

function getUserSafe(username: string): Promise<User> {    const query = 'SELECT * FROM users WHERE username = $1';    return db.execute(query, [username]); // parametrisierte Abfrage}

3. Unsichere Speicherung von Passwörtern

Speichern Sie Passwörter niemals im Klartext. Verwenden Sie bcrypt oder argon2 zum Hashen.

import bcrypt from 'bcrypt';

async function hashPassword(password: string): Promise<string> {    const saltRounds = 12;    return bcrypt.hash(password, saltRounds);}

async function verifyPassword(password: string, hash: string): Promise<boolean> {    return bcrypt.compare(password, hash);}

4. Unsichere direkte Objektreferenzen (IDOR)

Wenn ein Benutzer auf fremde Daten zugreifen kann, indem er einfach die ID in der URL ändert.

Beispiel:

// Anfällig: Jeder Benutzer kann jede Bestellung abrufenapp.get('/api/order/:id', (req, res) => {    const order = getOrderById(req.params.id);    res.json(order);});

// Sicher: Überprüfung der Zugehörigkeitapp.get('/api/order/:id', (req, res) => {    const order = getOrderById(req.params.id);    if (order.userId !== req.user.id) {        return res.status(403).json({ error: 'Forbidden' });    }    res.json(order);});

5. Verwendung veralteter Abhängigkeiten

TypeScript-Projekte verwenden oft npm-Pakete. Veraltete Versionen können bekannte Schwachstellen enthalten.

• Führen Sie regelmäßig npm audit aus
• Verwenden Sie npm update zum Aktualisieren von Paketen
• Richten Sie automatische Überprüfungen in CI/CD ein

6. Unzureichende Validierung von Eingabedaten

TypeScript-Typen werden zur Laufzeit nicht überprüft. Validieren Sie Daten immer auf dem Server.

interface UserInput {    email: string;    age: number;}

// Nicht ausreichend: TypeScript-Typen schützen nicht zur Laufzeitfunction processUser(input: UserInput) {    // ...}

// Richtig: Verwenden Sie Zod oder Joi zur Validierungimport { z } from 'zod';

const UserSchema = z.object({    email: z.string().email(),    age: z.number().min(18).max(120)});

function processUserSafe(input: unknown) {    const validate