Emre Demir

Posted on Mar 26 • Originally published at apidog.com

OpenID Connect Tutorial: Schritt-für-Schritt Anleitung

OpenID Connect ist der Industriestandard für sichere, moderne Authentifizierung und Single Sign-On (SSO). Wenn du ein praxisorientiertes und umfassendes OpenID Connect-Tutorial suchst, bist du hier richtig. In diesem Leitfaden lernst du, wie OpenID Connect funktioniert, warum es wichtig ist, die zentralen Konzepte, den Authentifizierungsablauf, die technische Umsetzung und erhältst sofort umsetzbare Beispiele für reale Szenarien.

Probiere Apidog noch heute aus

Was ist OpenID Connect? (Grundlagen)

OpenID Connect ist ein Authentifizierungsprotokoll auf Basis von OAuth 2.0. Während OAuth 2.0 den Zugriff auf Ressourcen (Autorisierung) regelt, dient OpenID Connect der Authentifizierung – der sicheren Überprüfung der Identität eines Benutzers sowie der Bereitstellung von Profilinformationen.

Warum OpenID Connect einsetzen?

Sichere Authentifizierung: Vermeide proprietäre, unsichere Login-Lösungen.
Single Sign-On (SSO): Ein Login für mehrere Anwendungen.
Interoperabilität: Funktioniert für Web, Mobile und APIs.
Standardisierte Profildaten: Liefert Identitätsdaten im JWT-Format.

Schlüsselkonzepte

Bevor du implementierst, solltest du diese Begriffe kennen:

Identity Provider (IdP): Authentifiziert den Nutzer (z.B. Google, Auth0, Okta).
Client (Relying Party): Deine Anwendung, die Authentifizierung anfordert.
Endbenutzer: Die Person, die sich einloggt.
Autorisierungsserver: Meist identisch mit dem IdP; stellt Tokens aus.
ID-Token: JWT mit Identitätsdaten des Nutzers.
Access Token: Von OAuth 2.0; für API-Zugriff nach Authentifizierung.
Discovery Document: Endpunkt mit Metadaten und URLs für OpenID Connect-Abläufe.

OpenID Connect: Authentifizierungsablauf Schritt für Schritt

Folge diesen Schritten für eine robuste OpenID Connect-Integration:

1. Benutzer startet den Login-Prozess

Der Nutzer klickt auf „Mit OpenID Connect anmelden“ in deiner Anwendung.

2. Weiterleitung zum Autorisierungsserver

Deine App leitet den Nutzer-Browser zum Autorisierungsendpunkt des IdP um. Notwendige Parameter:

client_id
redirect_uri
scope (z.B. openid profile email)
state
response_type (meist code)

Beispiel-URL:

https://idp.example.com/authorize?
  client_id=YOUR_CLIENT_ID
  &redirect_uri=https://yourapp.com/callback
  &scope=openid%20profile%20email
  &response_type=code
  &state=randomState123

3. Benutzer authentifiziert sich

Der IdP präsentiert einen Login-Screen. Der Nutzer meldet sich an und gibt ggf. Zustimmungen.

4. Rückleitung mit Autorisierungscode

Nach erfolgreichem Login leitet der IdP mit einem Authorization Code an deine redirect_uri zurück.

Beispiel:

https://yourapp.com/callback?code=AUTH_CODE&state=randomState123

5. Backend tauscht Code gegen Tokens

Dein Backend sendet einen POST-Request an den Token-Endpunkt des IdP, um Tokens zu erhalten.

Beispiel (HTTP POST):

POST /token
Host: idp.example.com
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code
&code=AUTH_CODE
&redirect_uri=https://yourapp.com/callback
&client_id=YOUR_CLIENT_ID
&client_secret=YOUR_CLIENT_SECRET

6. Empfang der Tokens

Der IdP liefert:

id_token (JWT mit Benutzerinformationen)
access_token (für APIs)
(optional) refresh_token

Beispiel-Antwort:

{
  "access_token": "eyJ...abc",
  "id_token": "eyJ...xyz",
  "expires_in": 3600,
  "token_type": "Bearer"
}

7. Tokens validieren und verwenden

Deine Anwendung validiert das id_token (Signatur, Audience, Ablaufzeit) und meldet den Nutzer an. Das access_token nutzt du für API-Aufrufe.

OpenID Connect: Geeigneter Ablauf

Für Webanwendungen empfiehlt sich der Authorization Code Flow:

Bietet maximale Sicherheit (Tokens gelangen nicht in den Browser)
Unterstützt serverseitige Token-Validierung
Für "confidential clients" (z.B. Apps mit Backend)

Achtung: Der Implicit Flow ist unsicher (Tokens in der URL) und wird nicht mehr empfohlen. Für SPAs immer Authorization Code Flow mit PKCE nutzen.

Das ID-Token dekodieren

Das id_token ist ein JWT, das Nutzerinformationen enthält. Du kannst es dekodieren, um Claims wie E-Mail oder Name zu extrahieren.

Beispiel-Payload:

{
  "iss": "https://idp.example.com",
  "sub": "1234567890",
  "aud": "YOUR_CLIENT_ID",
  "exp": 1712345678,
  "iat": 1712341678,
  "email": "user@example.com",
  "name": "Jane Doe"
}

iss: Aussteller (IdP)
sub: Nutzer-ID (beim IdP)
aud: Zielgruppe (deine App)
exp: Ablaufzeit
email, name: Standard-Claims

Tipp: Überprüfe immer die Signatur & Claims im ID-Token!

Praxisbeispiel: Python

So implementierst du OpenID Connect in Python (ohne externe SDKs):

1. Autorisierungs-URL bauen

import urllib.parse

params = {
    "client_id": "YOUR_CLIENT_ID",
    "redirect_uri": "https://yourapp.com/callback",
    "response_type": "code",
    "scope": "openid profile email",
    "state": "randomState123"
}
auth_url = "https://idp.example.com/authorize?" + urllib.parse.urlencode(params)
print(auth_url)

2. Authorization Code gegen Tokens tauschen

import requests

token_data = {
    "grant_type": "authorization_code",
    "code": "AUTH_CODE",
    "redirect_uri": "https://yourapp.com/callback",
    "client_id": "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET"
}
resp = requests.post("https://idp.example.com/token", data=token_data)
tokens = resp.json()
print(tokens)

3. ID-Token dekodieren und validieren

import jwt

id_token = tokens['id_token']
decoded = jwt.decode(id_token, options={"verify_signature": False})
print(decoded)

Wichtig: In der Produktion immer die Signatur mit dem öffentlichen Schlüssel des IdP prüfen!

Praktische Anwendungsszenarien

1. Single Sign-On (SSO)

Einmaliges Login (z.B. Google) für Zugriff auf alle Unternehmensanwendungen. So realisierst du SSO mit OpenID Connect.

2. Sichere API-Authentifizierung

Authentifiziere API-Clients mit OpenID Connect. Überprüfe das ID-Token im Backend für jede Anfrage. Tools wie Apidog unterstützen schnelles Design und Testing sicherer APIs.

3. Social Logins

Mit OpenID Connect kannst du „Mit Google anmelden“ oder „Mit Microsoft anmelden“ einfach integrieren.

4. Mobile App Authentifizierung

Verwende denselben Flow für mobile Apps – über Deep Links oder In-App-Browser.

Testen und Debuggen mit Apidog

Für OpenID Connect-Integrationen ist ein effizientes API-Testing entscheidend. Apidog ist eine API-Entwicklungsplattform, die API-Design, Mocking und das Testen vereinfacht:

API-Requests testen: Simuliere Token-Anfragen und prüfe Antworten visuell.
Endpunkte mocken: Erstelle Mock-IdP-Endpunkte, um Auth-Flows ohne Live-Anbieter zu testen.
API-Dokumentation: Dokumentiere OpenID-gesicherte APIs für Zusammenarbeit mit Frontend- und Security-Teams.

Durch Apidog im Entwicklungsprozess beschleunigst du die Integration, reduzierst Fehlerquellen und erhältst stabile Authentifizierungsabläufe.

OpenID Connect: Best Practices

ID-Tokens validieren: Immer Signatur, Aussteller, Zielgruppe und Ablauf prüfen.
HTTPS überall: Tokens nie unverschlüsselt senden.
Secrets sicher speichern: client_secret und Tokens nie offen ablegen.
Fehlerbehandlung umsetzen: Logins, abgelaufene Tokens und Session-Revocation elegant behandeln.
Aktuell bleiben: OpenID Connect entwickelt sich – halte Libraries und Know-how up-to-date.

Fazit & Nächste Schritte

Mit diesem OpenID Connect-Tutorial hast du alles für eine sichere, standardkonforme Authentifizierung:

Deine nächsten Schritte:

Registriere deine App bei einem IdP (Google, Auth0, Okta etc.).
Implementiere den Authorization Code Flow nach dieser Anleitung.
Teste deine Abläufe mit Apidog.
Vertiefe dein Wissen zu Themen wie Discovery, dynamische Client-Registrierung und Föderation.

Integriere OpenID Connect in deine Anwendungen für maximale Sicherheit und Nutzerkomfort. Happy Coding!

DEV Community