Sicherheit von TypeScript-Anwendungen: Top-10 Schwachstellen

Sicherheit von TypeScript-Anwendungen: Top-10 Schwachstellen

TypeScript erbt als Erweiterung von JavaScript viele seiner Schwachstellen und fügt spezifische Risiken hinzu, die mit dem Typsystem und der Kompilierung zusammenhängen. Selbst strenge Typisierung garantiert keine Sicherheit – Logikfehler und unsichere Praktiken können schwerwiegende Folgen haben. In diesem Artikel analysieren wir die Top-10 Schwachstellen von TypeScript-Anwendungen, geben Codebeispiele und Empfehlungen zum Schutz.

1. Cross-Site Scripting (XSS) durch dangerouslySetInnerHTML

Eine der häufigsten Schwachstellen in React/TypeScript-Anwendungen ist das Einfügen von nicht maskiertem HTML über dangerouslySetInnerHTML.

// ❌ Angreifbarer Codefunction UserComment({ comment }: { comment: string }) {  return <div dangerouslySetInnerHTML={{ __html: comment }} />;}

// ✅ Sichere Varianteimport DOMPurify from 'dompurify';

function SafeComment({ comment }: { comment: string }) {  const sanitized = DOMPurify.sanitize(comment);  return <div dangerouslySetInnerHTML={{ __html: sanitized }} />;}

2. SQL-Injection durch nicht maskierte Abfragen

Die Verwendung von Template-Strings in SQL-Abfragen mit Benutzereingaben ist ein direkter Weg zur Injection.

// ❌ Angreifbarer Codeasync function getUser(id: string) {  const query = `SELECT * FROM users WHERE id = '${id}'`;  return db.execute(query);}

// ✅ Sichere Variante (Verwendung parametrisierter Abfragen)async function safeGetUser(id: string) {  const query = 'SELECT * FROM users WHERE id = $1';  return db.execute(query, [id]);}

3. Prototype Pollution durch tiefes Zusammenführen von Objekten

TypeScript ermöglicht das einfache Kopieren von Objekten, überprüft jedoch nicht die Prototypenkette.

// ❌ Angreifbarer Codefunction merge(target: any, source: any) {  for (const key in source) {    if (typeof source[key] === 'object') {      target[key] = merge(target[key] || {}, source[key]);    } else {      target[key] = source[key];    }  }  return target;}

// ✅ Sichere Variantefunction safeMerge(target: Record<string, any>, source: Record<string, any>) {  const result = { ...target };  for (const key of Object.keys(source)) {    if (key === '__proto__' || key === 'constructor') continue;    if (typeof source[key] === 'object' && !Array.isArray(source[key])) {      result[key] = safeMerge(result[key] || {}, source[key]);    } else {      result[key] = source[key];    }  }  return result;}

4. NoSQL-Injection (MongoDB)

Bei der Arbeit mit MongoDB kann die direkte Übergabe eines Objekts aus der Anfrage zu einer Injection von $where- oder $regex-Operatoren führen.

// ❌ Angreifbarer Codeapp.post('/login', async (req, res) => {  const { username, password } = req.body;  const user = await User.findOne({ username, password });  // Bei Übergabe von { "$gt": "" } kann die Prüfung umgangen werden});

// ✅ Sichere Varianteimport { sanitize } from 'mongo-sanitize';

app.post('/login', async (req, res) => {  const cleanBody = sanitize(req.body);  const user = await User.findOne({    username: cleanBody.username,    password: cleanBody.password  });});

5. OS-Befehle durch child_process

Die Ausführung von Benutzereingaben über exec ohne Maskierung ist eine kritische Schwachstelle.

// ❌ Angreifbarer Codeimport { exec } from 'child_process';

function runCommand(input: string) {  exec(`echo ${input}`, (err, stdout) => {    console.log(stdout);  });}

// ✅ Sichere Varianteimport { execFile } from 'child_process';

function safeCommand(input: string) {  // Verwendung von execFile mit einem Argument-Array  execFile('echo', [input], (err, stdout) => {    console.log(stdout);  });}

6. Path Traversal bei der Dateiarbeit