JWT: Token-basierte Authentifizierung

JSON Web Tokens (JWT) sind ein offener Standard für sichere Datenübertragung. Sie werden häufig für API-Authentifizierung verwendet - stateless und skalierbar.

JWT-Aufbau

Ein JWT besteht aus drei Teilen, getrennt durch Punkte:

xxxxx.yyyyy.zzzzz
Header.Payload.Signature

Header

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

Payload (Claims)

{
  "sub": "1234567890",
  "name": "Max Mustermann",
  "email": "max@example.com",
  "role": "admin",
  "iat": 1704974400,
  "exp": 1705060800
}

Signature

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

JWT in PHP

// composer require firebase/php-jwt
use Firebase\JWT\JWT;
use Firebase\JWT\Key;

$secret = 'mein_geheimer_schluessel';

// Token erstellen
$payload = [
    'iss' => 'example.com',
    'sub' => '1234',
    'name' => 'Max',
    'role' => 'admin',
    'iat' => time(),
    'exp' => time() + 3600  // 1 Stunde
];

$token = JWT::encode($payload, $secret, 'HS256');

// Token verifizieren
try {
    $decoded = JWT::decode($token, new Key($secret, 'HS256'));
    echo "User: " . $decoded->name;
} catch (Exception $e) {
    echo "Token ungültig: " . $e->getMessage();
}

JWT in Node.js

// npm install jsonwebtoken
const jwt = require('jsonwebtoken');

const secret = 'mein_geheimer_schluessel';

// Token erstellen
const payload = {
    sub: '1234',
    name: 'Max',
    role: 'admin'
};

const token = jwt.sign(payload, secret, { expiresIn: '1h' });

// Token verifizieren
try {
    const decoded = jwt.verify(token, secret);
    console.log('User:', decoded.name);
} catch (err) {
    console.log('Token ungültig');
}

API-Authentifizierung

// Login-Route
app.post('/login', (req, res) => {
    const { email, password } = req.body;
    
    // User prüfen (Beispiel)
    const user = findUser(email, password);
    
    if (!user) {
        return res.status(401).json({ error: 'Invalid credentials' });
    }
    
    const token = jwt.sign(
        { sub: user.id, role: user.role },
        secret,
        { expiresIn: '24h' }
    );
    
    res.json({ token });
});

// Middleware
function authMiddleware(req, res, next) {
    const authHeader = req.headers.authorization;
    
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
        return res.status(401).json({ error: 'No token' });
    }
    
    const token = authHeader.split(' ')[1];
    
    try {
        const decoded = jwt.verify(token, secret);
        req.user = decoded;
        next();
    } catch (err) {
        res.status(401).json({ error: 'Invalid token' });
    }
}

// Geschützte Route
app.get('/profile', authMiddleware, (req, res) => {
    res.json({ user: req.user });
});

Client-Seitig

// Login
async function login(email, password) {
    const res = await fetch('/login', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ email, password })
    });
    
    const data = await res.json();
    localStorage.setItem('token', data.token);
}

// API-Request mit Token
async function getProfile() {
    const token = localStorage.getItem('token');
    
    const res = await fetch('/profile', {
        headers: {
            'Authorization': `Bearer ${token}`
        }
    });
    
    return res.json();
}

Best Practices

• Kurze Ablaufzeiten (1h für Access Token)
• Starken Secret Key verwenden
• HTTPS verwenden
• Keine sensiblen Daten im Payload
• Refresh Tokens für längere Sessions

Weitere Hilfe

• 📖 JWT.io - Debugger
• 📧 E-Mail: support@enjyn.de