JWT-Sicherheit: 5 kritische Fehler, die dein API-Backend gefährden

import jwt
import datetime

SECRET_KEY = "your-super-secret-key-that-is-strong-and-random-in-production"

def create_jwt(user_id: str) -> str:
    payload = {
        "user_id": user_id,
        "exp": datetime.datetime.utcnow() + datetime.timedelta(minutes=30), # Ablauf in 30 Min
        "iat": datetime.datetime.utcnow(),
        "iss": "your-backend-service", # Aussteller
        "aud": "your-client-application" # Empfänger
    }
    return jwt.encode(payload, SECRET_KEY, algorithm="HS256")

def decode_jwt(token: str) -> dict | None:
    try:
        # Strikte Validierung von issuer und audience ist hier integriert
        decoded_payload = jwt.decode(
            token,
            SECRET_KEY,
            algorithms=["HS256"], # Erlaubte Algorithmen
            audience="your-client-application",
            issuer="your-backend-service"
        )
        return decoded_payload
    except (jwt.ExpiredSignatureError, jwt.InvalidTokenError, jwt.exceptions.InvalidAudienceError, jwt.exceptions.InvalidIssuerError) as e:
        print(f"JWT Fehler: {e}")
        return None

# Beispielnutzung:
token = create_jwt("user123")
print(f"Erzeugtes Token: {token}")

decoded_data = decode_jwt(token)
print(f"Dekodiertes Payload: {decoded_data}")

# Beispiel eines abgelaufenen Tokens (simuliert durch Manipulation des exp-Werts oder Wartezeit)
# decoded_data_expired = jwt.decode(token, SECRET_KEY, algorithms=["HS256"], audience="your-client-application", issuer="your-backend-service", options={"verify_exp": False})
# decoded_data_expired["exp"] = datetime.datetime.utcnow() - datetime.timedelta(minutes=1)
# expired_token = jwt.encode(decoded_data_expired, SECRET_KEY, algorithm="HS256") # Das ist KEIN sicherer Weg!
# print(f"Versuch dekodiert abgelaufen: {decode_jwt(expired_token)}")

async function callAuthenticatedApi(url: string, jwtToken: string) {
  try {
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${jwtToken}`, // JWT im Authorization-Header
        'Content-Type': 'application/json'
      }
    });
    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
    return await response.json();
  } catch (error) {
    console.error('Fehler beim API-Aufruf:', error);
    throw error;
  }
}

// Client-seitige Dekodierung (NUR zur Anzeige, NICHT zur Validierung!)
// Diese Funktion sollte niemals für Sicherheitsprüfungen verwendet werden.
// Die Validierung gehört IMMER ins Backend.
function decodeJwtPayload(token: string): any | null {
  try {
    const base64Url = token.split('.')[1];
    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
    const jsonPayload = decodeURIComponent(atob(base64).split('').map(function(c) {
      return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
    }).join(''));
    return JSON.parse(jsonPayload);
  } catch (e) {
    console.error('Fehler beim Dekodieren des JWT-Payloads:', e);
    return null;
  }
}

// Beispielaufruf (angenommen, das JWT kommt aus einem HttpOnly-Cookie oder In-Memory)
// const myJwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoidXNlcjEyMyIsImV4cCI6MTY3ODkwNTY3OCwiaWF0IjoxNjc4OTAyMDc4LCJpc3MiOiJ5b3VyLWJhY2tlbmQtc2VydmljZSIsImF1ZCI6InlvdXItY2xpZW50LWFwcGxpY2F0aW9uIn0.SIGNATUR_HIER";
// callAuthenticatedApi('https://api.example.com/data', myJwt)
//   .then(data => console.log('API-Antwort:', data))
//   .catch(err => console.error(err));

// const decodedClientInfo = decodeJwtPayload(myJwt);
// console.log('Client-seitig dekodierte Infos (nur Anzeige):', decodedClientInfo);

YOUR_JWT_TOKEN="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"

echo "HEADER:"
echo "$YOUR_JWT_TOKEN" | awk -F'.' '{print $1}' | base64 --decode | jq '.'

echo "\nPAYLOAD:"
echo "$YOUR_JWT_TOKEN" | awk -F'.' '{print $2}' | base64 --decode | jq '.'

# Hinweis: Für die Signaturprüfung ist ein dediziertes Tool oder Code erforderlich.
# jq muss installiert sein (apt install jq / brew install jq)

# Dockerfile Auszug für einen Backend-Dienst
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

# Umgebungsvariablen für Entwicklung. In Produktion NIE so setzen!
ENV JWT_SECRET="mySuperSecureDevelopmentSecret"
ENV JWT_ALGORITHM="HS256"
ENV JWT_EXPIRATION_MINUTES="30"

CMD ["python", "app.py"]

# docker-compose.yml Auszug für Dev-Umgebung
services:
  backend:
    build: .
    ports:
      - "8000:8000"
    environment:
      JWT_SECRET: "mySuperSecureDevelopmentSecret"
      JWT_ALGORITHM: "HS256"
      JWT_EXPIRATION_MINUTES: "30"
    # In Produktion: secrets verwenden! z.B. Docker Secrets, Kubernetes Secrets oder HashiCorp Vault.