Einführung:

JSON Web Tokens (JWT) werden häufig zur Sicherung der API-Authentifizierung und des Datenaustauschs verwendet. Durch unsachgemäße Implementierung und Handhabung können jedoch Schwachstellen aufgedeckt werden, die zu Token-Fälschung und Datenmanipulation führen können. In diesem Blog untersuchen wir häufige JWT-Schwächen, Beispiele für Angriffe aus der Praxis und Best Practices zur Minderung dieser Risiken.

Was ist JWT?

JWT ist ein kompaktes, URL-sicheres Mittel zur Darstellung von Ansprüchen, die zwischen zwei Parteien übertragen werden sollen. Es besteht aus drei Teilen: Header, Payload und Signatur, codiert in Base64.

JWT-Struktur:

{
  "header": {
    "alg": "HS256",
    "typ": "JWT"
  },
  "payload": {
    "sub": "1234567890",
    "name": "John Doe",
    "iat": 1516239022
  },
  "signature": "SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
}

Häufige JWT-Schwachstellen:

1. Algorithmus-Verwirrungsangriff:
Angreifer können schwache Algorithmen ausnutzen oder den Algorithmus im Token-Header auf „Keine“ ändern, was zu einer Token-Fälschung führt.

Beispiel:

{
  "alg": "none",
  "typ": "JWT"
}

Abhilfe:
Validieren Sie immer den Parameter alg auf der Serverseite und lehnen Sie Token mit „keine“ oder schwachen Algorithmen ab.

Sichere Implementierung:

const jwt = require('jsonwebtoken');
const payload = {
  sub: "1234567890",
  name: "John Doe"
};
const secret = 'your-256-bit-secret';
const token = jwt.sign(payload, secret, { algorithm: 'HS256' });

jwt.verify(token, secret, { algorithms: ['HS256'] }, function(err, decoded) {
  if (err) throw new Error('Token verification failed');
  console.log(decoded);
});

2. Key-Injection-Angriff:
Angreifer könnten die Nutzlast so manipulieren, dass sie einen neuen Schlüssel einfügt, was zu unbefugtem Zugriff führt.

Beispiel:

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

Abhilfe:
Stellen Sie sicher, dass Ansprüche ordnungsgemäß validiert werden und vertrauliche Informationen nicht in der Nutzlast gespeichert werden.

Sichere Implementierung:

const payload = {
  sub: "1234567890",
  name: "John Doe"
};

const token = jwt.sign(payload, secret, { algorithm: 'HS256' });

jwt.verify(token, secret, function(err, decoded) {
  if (err) throw new Error('Token verification failed');
  if (decoded.admin) throw new Error('Unauthorized access');
  console.log(decoded);
});

3. Schwacher Geheimschlüssel:
Die Verwendung schwacher oder vorhersehbarer geheimer Schlüssel kann zu Brute-Force-Angriffen führen.

Abhilfe:
Verwenden Sie starke, zufällig generierte geheime Schlüssel und wechseln Sie diese regelmäßig.

Sichere Implementierung:

const crypto = require('crypto');
const secret = crypto.randomBytes(64).toString('hex');

const token = jwt.sign(payload, secret, { algorithm: 'HS256' });

jwt.verify(token, secret, function(err, decoded) {
  if (err) throw new Error('Token verification failed');
  console.log(decoded);
});

Vollständiges sicheres JWT-Implementierungsbeispiel:

Hier ist ein vollständiges Beispiel für die sichere Implementierung von JWT in einer Node.js-Anwendung:

Schritt 1: Abhängigkeiten installieren

npm install jsonwebtoken express body-parser

Schritt 2: Erstellen Sie einen einfachen Server

const express = require('express');
const bodyParser = require('body-parser');
const jwt = require('jsonwebtoken');
const crypto = require('crypto');

const app = express();
app.use(bodyParser.json());

const secret = crypto.randomBytes(64).toString('hex');

app.post('/login', (req, res) => {
  const { username, password } = req.body;

  // Authenticate user (dummy check for example)
  if (username === 'user' && password === 'pass') {
    const payload = { username };
    const token = jwt.sign(payload, secret, { algorithm: 'HS256', expiresIn: '1h' });
    res.json({ token });
  } else {
    res.status(401).json({ message: 'Invalid credentials' });
  }
});

app.get('/protected', (req, res) => {
  const token = req.headers['authorization'];

  if (!token) return res.status(403).json({ message: 'No token provided' });

  jwt.verify(token, secret, { algorithms: ['HS256'] }, (err, decoded) => {
    if (err) return res.status(500).json({ message: 'Failed to authenticate token' });

    res.json({ message: 'Access granted', user: decoded });
  });
});

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

Best Practices für eine sichere JWT-Implementierung:

• Verwenden Sie starke Algorithmen: Für mehr Sicherheit bevorzugen Sie RS256 oder ES256 gegenüber HS256.
• Token-Ablauf validieren: Überprüfen Sie immer den Exp-Anspruch, um sicherzustellen, dass der Token nicht abgelaufen ist.
• Geheimnisse sicher speichern: Bewahren Sie geheime Schlüssel an einem sicheren Ort auf, z. B. in Umgebungsvariablen oder sicheren Tresoren.
• Implementieren Sie die richtige Fehlerbehandlung: Vermeiden Sie die Offenlegung vertraulicher Fehlermeldungen, die Angreifern helfen können.
• HTTPS verwenden: Stellen Sie sicher, dass die gesamte Kommunikation über HTTPS erfolgt, um das Abfangen von Token zu verhindern.

Abschluss:

Das Verständnis und die Behebung von JWT-Schwachstellen ist entscheidend für die Aufrechterhaltung der Sicherheit Ihrer Anwendungen. Durch die Befolgung von Best Practices und den ordnungsgemäßen Umgang mit JWTs können Sie Token-Fälschung und Datenmanipulation verhindern und so eine robuste API-Sicherheit gewährleisten.

Sichern Sie jetzt Ihre APIs, indem Sie diese Best Practices zum Schutz vor JWT-Schwachstellen implementieren!