In der modernen Webentwicklung ist die sichere Authentifizierung und Autorisierung von Benutzern eine der wichtigsten Herausforderungen. Dieser Artikel zeigt Ihnen, wie Sie in Node.js-Anwendungen mit Express verschiedene Authentifizierungsmethoden implementieren können.

Die Grundlagen der Authentifizierung und Autorisierung

Was ist Authentifizierung?

Authentifizierung ist der Prozess, bei dem ein Client seine Identität gegenüber einem Server nachweist. Dies geschieht typischerweise durch die Eingabe von Anmeldeinformationen wie Benutzername und Passwort.

Was ist Autorisierung?

Die Autorisierung folgt nach erfolgreicher Authentifizierung und bestimmt, auf welche Ressourcen ein authentifizierter Benutzer zugreifen darf. Sie ist der Schlüssel zur Zugriffssteuerung in Webanwendungen.

Session-basierte Authentifizierung in Node.js

Einrichtung des Express-Servers

const express = require('express');
const session = require('express-session');
const app = express();

app.use(express.json());
app.use(
  session({
    secret: process.env.SECRET_KEY,
    resave: false,
    saveUninitialized: true,
  }),
);

Implementierung der Benutzerregistrierung

Ein sicherer Registrierungsprozess ist die Grundlage jeder Authentifizierungslösung. Hier ist ein Beispiel für eine sichere Implementierung:

const bcrypt = require('bcrypt');

app.post('/register', async (req, res) => {
  try {
    const { username, password } = req.body;
    const hashedPassword = await bcrypt.hash(password, 10);
    // Speichern des Benutzers in der Datenbank
    res.status(201).json({ message: 'Benutzer erfolgreich erstellt' });
  } catch (error) {
    res.status(500).json({ error: 'Registrierung fehlgeschlagen' });
  }
});

Login-Prozess und Session-Management

Der Login-Prozess muss sowohl sicher als auch benutzerfreundlich sein:

app.post('/login', async (req, res) => {
  try {
    const { username, password } = req.body;
    // Benutzer in der Datenbank finden
    const passwordMatch = await bcrypt.compare(password, user.password);

    if (passwordMatch) {
      req.session.regenerate((err) => {
        if (err) {
          return res
            .status(500)
            .json({ error: 'Session-Erstellung fehlgeschlagen' });
        }
        req.session.user = { username };
        res.status(200).json({ message: 'Login erfolgreich' });
      });
    }
  } catch (error) {
    res.status(401).json({ error: 'Ungültige Anmeldedaten' });
  }
});

OAuth2-Authentifizierung mit Google

Konfiguration der OAuth2-Integration

Die Integration von OAuth2 ermöglicht es Benutzern, sich mit bestehenden Konten anzumelden:

const CLIENT_ID = process.env.GOOGLE_CLIENT_ID;
const CLIENT_SECRET = process.env.GOOGLE_CLIENT_SECRET;
const REDIRECT_URI = 'http://localhost:3000/auth/callback';

app.get('/auth/google', (req, res) => {
  const state = crypto.randomBytes(16).toString('hex');
  const authUrl = `https://accounts.google.com/o/oauth2/v2/auth?
    response_type=code&
    client_id=${CLIENT_ID}&
    redirect_uri=${REDIRECT_URI}&
    scope=email&
    state=${state}`;

  res.cookie('oauth_state', state, { httpOnly: true });
  res.redirect(authUrl);
});

Verarbeitung des OAuth2-Callbacks

Nach erfolgreicher Authentifizierung bei Google muss der Callback verarbeitet werden:

app.get('/auth/callback', async (req, res) => {
  const { code, state } = req.query;
  const savedState = req.cookies.oauth_state;

  if (state !== savedState) {
    return res.status(400).json({ error: 'Ungültiger State-Parameter' });
  }

  try {
    const tokenResponse = await fetchAccessToken(code);
    const userInfo = await fetchUserInfo(tokenResponse.access_token);

    req.session.user = userInfo;
    res.redirect('/dashboard');
  } catch (error) {
    res.status(500).json({ error: 'OAuth2-Authentifizierung fehlgeschlagen' });
  }
});

Sicherheitsaspekte und Best Practices

Session-Sicherheit

Die Konfiguration der Session-Sicherheit ist entscheidend:

app.use(
  session({
    secret: process.env.SECRET_KEY,
    resave: false,
    saveUninitialized: false,
    cookie: {
      secure: true, // Nur HTTPS
      httpOnly: true,
      maxAge: 24 * 60 * 60 * 1000, // 24 Stunden
    },
  }),
);

Logout-Implementierung

Ein sicherer Logout-Prozess ist ebenso wichtig wie die Authentifizierung:

app.get('/logout', (req, res) => {
  req.session.destroy((err) => {
    if (err) {
      return res.status(500).json({ error: 'Logout fehlgeschlagen' });
    }
    res.clearCookie('connect.sid');
    res.redirect('/login');
  });
});

Fazit

Die Implementierung einer sicheren Authentifizierung in Node.js-Anwendungen erfordert sorgfältige Planung und Berücksichtigung verschiedener Sicherheitsaspekte. Durch die Kombination von Session-basierter Authentifizierung und OAuth2 können Sie eine flexible und benutzerfreundliche Lösung schaffen, die modernen Sicherheitsstandards entspricht.

Häufig gestellte Fragen (FAQ)

Warum sollte ich OAuth2 statt einer eigenen Authentifizierung verwenden?

OAuth2 bietet mehrere Vorteile: Nutzer müssen sich keine zusätzlichen Zugangsdaten merken, die Implementierung ist standardisiert und sicher, und Sie müssen keine sensiblen Passwörter speichern.

Wie lange sollten Sessions gültig sein?

Die optimale Session-Dauer hängt von Ihrer Anwendung ab. Für normale Webanwendungen sind 24 Stunden ein guter Ausgangspunkt. Bei sensiblen Anwendungen sollte die Dauer kürzer sein.

Welche Sicherheitsmaßnahmen sind bei der Passwort-Speicherung wichtig?

Passwörter sollten niemals im Klartext gespeichert werden. Verwenden Sie immer eine starke Hashing-Funktion wie bcrypt mit einem angemessenen Salt-Faktor.