So erstellen Sie ein Authentifizierungssystem mit Claude Code (JWT und OAuth)

Vorteile von Claude Code für die Authentifizierungssystem-Entwicklung

Authentifizierung ist eine sicherheitskritische Funktion, und Implementierungsfehler führen zu schwerwiegenden Sicherheitslücken. Claude Code generiert Implementierungen nach Sicherheits-Best-Practices und schlägt auch Gegenmaßnahmen für oft übersehene Angriffsvektoren vor.

JWT-Authentifizierung implementieren

> Implementiere JWT-Authentifizierung mit Express + TypeScript.
> Verwende ein 2-Token-System mit Access Token (15 Min.) und Refresh Token (7 Tage).
> Verwalte den Refresh Token als httpOnly-Cookie.

Authentifizierungsservice

import jwt from 'jsonwebtoken';
import bcrypt from 'bcrypt';
import { prisma } from './db';

const ACCESS_TOKEN_SECRET = process.env.ACCESS_TOKEN_SECRET!;
const REFRESH_TOKEN_SECRET = process.env.REFRESH_TOKEN_SECRET!;

interface TokenPayload {
  userId: string;
  email: string;
}

export class AuthService {
  async register(email: string, password: string, name: string) {
    const existing = await prisma.user.findUnique({ where: { email } });
    if (existing) throw new Error('E-Mail bereits registriert');

    const hashedPassword = await bcrypt.hash(password, 12);
    const user = await prisma.user.create({
      data: { email, password: hashedPassword, name },
    });

    return this.generateTokens({ userId: user.id, email: user.email });
  }

  async login(email: string, password: string) {
    const user = await prisma.user.findUnique({ where: { email } });
    if (!user) throw new Error('Ungültige Anmeldedaten');

    const valid = await bcrypt.compare(password, user.password);
    if (!valid) throw new Error('Ungültige Anmeldedaten');

    return this.generateTokens({ userId: user.id, email: user.email });
  }

  async refreshToken(token: string) {
    const payload = jwt.verify(token, REFRESH_TOKEN_SECRET) as TokenPayload;

    // Gültigkeit des Refresh Tokens in der DB prüfen
    const stored = await prisma.refreshToken.findFirst({
      where: { token, userId: payload.userId, revoked: false },
    });
    if (!stored) throw new Error('Ungültiges Refresh Token');

    // Altes Token ungültig machen (Token-Rotation)
    await prisma.refreshToken.update({
      where: { id: stored.id },
      data: { revoked: true },
    });

    return this.generateTokens(payload);
  }

  private async generateTokens(payload: TokenPayload) {
    const accessToken = jwt.sign(payload, ACCESS_TOKEN_SECRET, {
      expiresIn: '15m',
    });
    const refreshToken = jwt.sign(payload, REFRESH_TOKEN_SECRET, {
      expiresIn: '7d',
    });

    await prisma.refreshToken.create({
      data: { token: refreshToken, userId: payload.userId },
    });

    return { accessToken, refreshToken };
  }
}

Authentifizierungs-Middleware

import { Request, Response, NextFunction } from 'express';
import jwt from 'jsonwebtoken';

export function authMiddleware(req: Request, res: Response, next: NextFunction) {
  const header = req.headers.authorization;
  if (!header?.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'Kein Token bereitgestellt' });
  }

  const token = header.slice(7);

  try {
    const payload = jwt.verify(token, process.env.ACCESS_TOKEN_SECRET!);
    req.user = payload as TokenPayload;
    next();
  } catch (err) {
    return res.status(401).json({ error: 'Ungültiges oder abgelaufenes Token' });
  }
}

Router-Konfiguration

import { Router } from 'express';
import { AuthService } from './auth-service';

const router = Router();
const auth = new AuthService();

router.post('/register', async (req, res) => {
  try {
    const { accessToken, refreshToken } = await auth.register(
      req.body.email, req.body.password, req.body.name
    );
    res.cookie('refreshToken', refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });
    res.json({ accessToken });
  } catch (err) {
    res.status(400).json({ error: (err as Error).message });
  }
});

router.post('/login', async (req, res) => {
  try {
    const { accessToken, refreshToken } = await auth.login(
      req.body.email, req.body.password
    );
    res.cookie('refreshToken', refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });
    res.json({ accessToken });
  } catch (err) {
    res.status(401).json({ error: 'Ungültige Anmeldedaten' });
  }
});

router.post('/refresh', async (req, res) => {
  try {
    const token = req.cookies.refreshToken;
    const { accessToken, refreshToken } = await auth.refreshToken(token);
    res.cookie('refreshToken', refreshToken, {
      httpOnly: true,
      secure: true,
      sameSite: 'strict',
      maxAge: 7 * 24 * 60 * 60 * 1000,
    });
    res.json({ accessToken });
  } catch (err) {
    res.status(401).json({ error: 'Ungültiges Refresh Token' });
  }
});

export default router;

OAuth-Integration (Google)

> Füge Google-Login mit PassportJS hinzu. Integriere es mit der bestehenden JWT-Authentifizierung.

import passport from 'passport';
import { Strategy as GoogleStrategy } from 'passport-google-oauth20';

passport.use(new GoogleStrategy({
  clientID: process.env.GOOGLE_CLIENT_ID!,
  clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
  callbackURL: '/auth/google/callback',
}, async (accessToken, refreshToken, profile, done) => {
  let user = await prisma.user.findFirst({
    where: { providerId: profile.id, provider: 'google' },
  });

  if (!user) {
    user = await prisma.user.create({
      data: {
        email: profile.emails![0].value,
        name: profile.displayName,
        provider: 'google',
        providerId: profile.id,
      },
    });
  }

  done(null, user);
}));

Sicherheits-Checkliste

Sie können Claude Code mit folgendem Prompt um ein Sicherheitsaudit bitten.

> Überprüfe den Authentifizierungscode aus Sicherheitssicht.
> Prüfe anhand der OWASP Top 10.

Die wichtigsten Prüfpunkte sind:

• Wird bcrypt für das Passwort-Hashing verwendet?
• Ist der JWT-Secret-Key ausreichend lang?
• Ist Token-Rotation für Refresh Tokens implementiert?
• Sind CSRF-Gegenmaßnahmen vorhanden?
• Ist Rate Limiting konfiguriert?

Für die Aufrechterhaltung der Codequalität einschließlich Sicherheit ist auch die Refactoring-Automatisierung effektiv. Wenn Sie die Authentifizierungsrichtlinien in CLAUDE.md dokumentieren, generiert Claude Code konsistenten Code.

Zusammenfassung

Mit Claude Code können Sie ein robustes Authentifizierungssystem einschließlich JWT-Authentifizierung und OAuth-Integration effizient aufbauen. Da Code nach Sicherheits-Best-Practices generiert wird, lassen sich auch oft übersehene Sicherheitslücken leichter beheben. Stellen Sie in der Produktionsumgebung unbedingt die sichere Verwaltung von Secret Keys und HTTPS-Kommunikation sicher.

Weitere Informationen finden Sie in der offiziellen Anthropic-Dokumentation.