# Node/Express-Backend

Fügen Sie einer Node.js-Express-App die Anmeldung hinzu, mit der Bibliothek openid-client und dem Authorization Code Flow mit PKCE.

Diese Anleitung fügt einer Express-App die OIDC-Anmeldung hinzu, mit der Bibliothek [`openid-client`](https://www.npmjs.com/package/openid-client), die Discovery, PKCE und Token-Validierung übernimmt. Sie geht von einem **Confidential Client** aus (einem Backend, das ein Secret geheim halten kann).

Falls Sie noch keine Anwendung registriert haben, siehe [Bevor Sie beginnen](https://dts-identity.com/de/docs/quickstarts.md#before-you-start). Zum zugrunde liegenden Protokoll siehe [OpenID Connect (Authorization Code + PKCE)](https://dts-identity.com/de/docs/quickstarts/oidc-authorization-code.md).

## 1. Abhängigkeiten installieren

```bash
npm install express express-session openid-client
```

## 2. Client konfigurieren

```js
import * as client from 'openid-client';

// Your instance's login domain (issuer). openid-client reads the
// discovery document at <issuer>/.well-known/openid-configuration.
const server = new URL('https://<your-domain>');
const clientId = process.env.OIDC_CLIENT_ID;
const clientSecret = process.env.OIDC_CLIENT_SECRET;
const redirectUri = 'https://app.example.com/callback';
const scope = 'openid profile email offline_access';

// Discover endpoints and prepare the client (default: client_secret_basic).
const config = await client.discovery(server, clientId, clientSecret);
```

Halten Sie `OIDC_CLIENT_ID` und `OIDC_CLIENT_SECRET` in der Umgebung, niemals in der Versionsverwaltung.

## 3. Anmeldung starten

Bauen Sie die Autorisierungs-URL mit einer PKCE-Challenge und einem `state`, merken Sie sich beides in der Session und leiten Sie den Browser weiter.

```js
import express from 'express';
import session from 'express-session';

const app = express();
app.use(session({ secret: process.env.SESSION_SECRET, resave: false, saveUninitialized: false }));

app.get('/login', async (req, res) => {
  const codeVerifier = client.randomPKCECodeVerifier();
  const codeChallenge = await client.calculatePKCECodeChallenge(codeVerifier);
  const state = client.randomState();

  // stash for the callback
  req.session.codeVerifier = codeVerifier;
  req.session.state = state;

  const authUrl = client.buildAuthorizationUrl(config, {
    redirect_uri: redirectUri,
    scope,
    code_challenge: codeChallenge,
    code_challenge_method: 'S256',
    state,
  });

  res.redirect(authUrl.href);
});
```

## 4. Callback verarbeiten

Tauschen Sie den Code gegen Tokens. `openid-client` validiert die Antwort, den `state` und den PKCE-Verifier.

```js
app.get('/callback', async (req, res) => {
  const currentUrl = new URL(req.originalUrl, 'https://app.example.com');

  const tokens = await client.authorizationCodeGrant(config, currentUrl, {
    pkceCodeVerifier: req.session.codeVerifier,
    expectedState: req.session.state,
  });

  const claims = tokens.claims(); // validated ID-token claims
  req.session.user = { sub: claims.sub, name: claims.name, email: claims.email };
  req.session.idToken = tokens.id_token;

  // Optional: fetch additional claims from UserInfo
  // const userinfo = await client.fetchUserInfo(config, tokens.access_token, claims.sub);

  res.redirect('/');
});
```

## 5. Abmelden

Schicken Sie den Benutzer an den End-Session-Endpunkt und löschen Sie anschließend Ihre eigene Session.

```js
app.get('/logout', (req, res) => {
  const endSession = client.buildEndSessionUrl(config, {
    id_token_hint: req.session.idToken,
    post_logout_redirect_uri: 'https://app.example.com/',
  });
  req.session.destroy(() => res.redirect(endSession.href));
});
```

Registrieren Sie `https://app.example.com/` als Post-Logout-Redirect-URI an der Anwendung, auf dieselbe Weise wie eine Redirect-URI.

## Fehlerbehebung

- **Der Discovery-Aufruf schlägt fehl.** Stellen Sie sicher, dass `https://<your-domain>/.well-known/openid-configuration` von Ihrem Server aus erreichbar ist und die Domain der Login-Host Ihrer Instanz ist.
- **`state`- oder PKCE-Fehler beim Callback.** Die Session, die die Anmeldung gestartet hat, muss dieselbe sein, die den Callback verarbeitet. Stellen Sie sicher, dass Session-Cookies den Redirect überleben (korrektes `SameSite` und in Produktion `secure`-Cookies über HTTPS).
- **Es wird nie ein Refresh-Token zurückgegeben.** Nehmen Sie `offline_access` in den Scope auf und prüfen Sie, dass die Anwendung so konfiguriert ist, dass sie Refresh-Tokens erhält.

## Nächste Schritte

- [React-Single-Page-App](https://dts-identity.com/de/docs/quickstarts/react-spa.md) für einen reinen Browser-Client.
- [Anwendungen](https://dts-identity.com/de/docs/integrations/applications.md), um Token-Laufzeiten und weitere Client-Einstellungen zu prüfen.
