RBAC in der Praxis: Implementierung einer sicheren Autorisierung für deine Anwendung

Hast du Schwierigkeiten, ein sicheres und skalierbares Autorisierungssystem für deine Anwendung zu implementieren? Role-Based Access Control (RBAC) ist der Industriestandard zur Verwaltung von Benutzerberechtigungen, aber die korrekte Implementierung kann eine Herausforderung sein. Dieses Tutorial zeigt dir, wie du ein robustes RBAC-System anhand eines praktischen Beispiels aus einem Content-Management-System (CMS) aufbaust.

Indem du diesem Leitfaden folgst, lernst du:

• ✨ Wie du fein abgestimmte Berechtigungen entwirfst und implementierst, die dir präzise Kontrolle bieten
• 🔒 Best Practices zur Organisation von Berechtigungen in sinnvollen Rollen
• 👤 Techniken zur effektiven Verwaltung von Ressourcenbesitz
• 🚀 Möglichkeiten, dein Autorisierungssystem skalierbar und wartbar zu gestalten
• 💡 Praktische Implementierung anhand eines realen CMS-Beispiels

Der komplette Quellcode für dieses Tutorial ist auf GitHub verfügbar.

Verständnis der RBAC-Grundlagen#

Role-Based Access Control bedeutet mehr als nur das Zuweisen von Berechtigungen an Benutzer. Es geht darum, einen strukturierten Ansatz zur Autorisierung zu schaffen, der Sicherheit und Wartbarkeit in Einklang bringt.

Mehr Informationen darüber, Was ist RBAC findest du im Auth-Wiki.

Hier sind die wichtigsten Prinzipien, denen wir in unserer Implementierung folgen werden:

Fein abgestimmtes Berechtigungsdesign#

Fein abgestimmte Berechtigungen bieten dir präzise Kontrolle darüber, was Benutzer in deinem System tun können. Anstatt breiter Zugriffslevel wie "admin" oder "benutzer", definieren wir spezifische Aktionen, die Benutzer mit Ressourcen durchführen können. Zum Beispiel:

• read:articles - Alle Artikel im System ansehen
• create:articles - Neue Artikel erstellen
• update:articles - Bestehende Artikel ändern
• publish:articles - Die Veröffentlichungsstatus von Artikeln ändern

Ressourcenbesitz und Zugangskontrolle#

Ressourcenbesitz ist ein zentrales Konzept im Autorisierungsdesign unseres CMS. Während RBAC definiert, welche Aktionen verschiedene Rollen ausführen können, fügt der Besitz eine persönliche Dimension zur Zugangskontrolle hinzu:

• Autoren haben automatisch Zugriff auf die Artikel, die sie erstellt haben
• Dieses natürliche Besitzmodell bedeutet, dass Autoren immer ihre eigenen Inhalte ansehen und bearbeiten können
• Das System prüft sowohl Rollenzugriff als auch Besitz, wenn Artikeloperationen durchgeführt werden
• Zum Beispiel kann ein Autor auch ohne die Berechtigung update:articles seine eigenen Artikel bearbeiten
• Dieses Design reduziert den Bedarf an zusätzlichen Rollenberechtigungen, während es die Sicherheit aufrechterhält

Dieser zweistufige Ansatz (Rollen + Besitz) schafft ein intuitiveres und sichereres System. Verlage und Admins können weiterhin alle Inhalte über ihre Rollenberechtigungen verwalten, während Autoren die Kontrolle über ihre eigenen Arbeiten behalten.

Entwerfen von sicheren APIs#

Lass uns damit beginnen, die Kernfunktionalität unseres CMS durch seine API-Endpunkte zu entwerfen:

Zugangskontrolle für deine API implementieren#

Für jeden Endpunkt müssen wir zwei Aspekte der Zugangskontrolle berücksichtigen:

1. Ressourcenbesitz - Besitzt der Benutzer diese Ressource?
2. Rollenbasierte Berechtigungen - Erlaubt die Rolle des Benutzers diese Operation?

So werden wir den Zugang für jeden Endpunkt handhaben:

Ein Berechtigungssystem erstellen, das skaliert#

Basierend auf unseren API-Zugriffsanforderungen können wir diese Berechtigungen definieren:

Beachte, dass diese Berechtigungen nur benötigt werden, wenn auf Ressourcen zugegriffen wird, die du nicht besitzt. Artikelbesitzer können automatisch:

• Ihre eigenen Artikel ansehen (keine read:articles benötigt)
• Ihre eigenen Artikel bearbeiten (keine update:articles benötigt)
• Ihre eigenen Artikel löschen (keine delete:articles benötigt)

Effektive Rollen erstellen#

Nun, da wir unsere API und Berechtigungen definiert haben, können wir Rollen erstellen, die diese Berechtigungen logisch gruppieren:

Hinweis: Autoren haben automatisch Lese-/Aktualisierungs-/Löschberechtigungen für ihre eigenen Artikel, unabhängig von den Rollenberechtigungen.

Jede Rolle ist mit spezifischen Verantwortlichkeiten entworfen:

• Admin: Hat die vollständige Kontrolle über das CMS, einschließlich aller Artikeloperationen
• Publisher: Konzentriert sich auf Inhaltsbewertung und Veröffentlichungsmanagement
• Autor: Spezialisiert auf Inhaltserstellung

Diese Rollenstruktur schafft eine klare Trennung der Zuständigkeiten:

• Autoren konzentrieren sich auf das Erstellen von Inhalten
• Publisher verwalten die Inhaltsqualität und Sichtbarkeit
• Admins behalten die Kontrolle über das gesamte System

RBAC in Logto konfigurieren#

Bevor du beginnst, musst du ein Konto in Logto Cloud erstellen, oder du kannst auch eine selbst gehostete Logto-Instanz verwenden, indem du die Logto OSS-Version nutzst.

Aber für dieses Tutorial werden wir Logto Cloud verwenden, um der Einfachheit willen.

Deine Anwendung einrichten#

1. Gehe zu „Anwendungen“ in der Logto-Konsole, um eine neue React-Anwendung zu erstellen
   • Anwendungsname: Content Management System
   • Anwendungstyp: Traditionelle Webanwendung
   • Umleitungs-URIs: http://localhost:5173/callback

API-Ressourcen und Berechtigungen konfigurieren#

1. Gehe zu „API-Ressourcen“ in der Logto-Konsole, um eine neue API-Ressource zu erstellen
   • API-Name: CMS API
   • API-Bezeichner: https://api.cms.com
   • Berechtigungen zur API-Ressource hinzufügen
     • list:articles
     • read:articles
     • create:articles
     • update:articles
     • publish:articles
     • delete:articles

Rollen erstellen#

Gehe zu Rollen in der Logto-Konsole, um die folgenden Rollen für das CMS zu erstellen

• Admin
  • mit allen Berechtigungen
• Publisher
  • mit read:articles, list:articles, publish:articles
• Autor
  • mit create:articles

Rollen Benutzern zuweisen#

Gehe zum Bereich „Benutzerverwaltung“ in der Logto-Konsole, um Benutzer zu erstellen.

Im „Rollen“-Tab der Benutzerdetails kannst du dem Benutzer Rollen zuweisen.

In unserem Beispiel erstellen wir 3 Benutzer mit den folgenden Rollen:

• Alex: Admin
• Bob: Publisher
• Charlie: Autor

Deinen Frontend mit Logto RBAC integrieren#

Nun, da wir RBAC in Logto eingerichtet haben, können wir anfangen, es in unser Frontend zu integrieren.

Folge zuerst den Logto Quick Starts, um Logto in deine Anwendung zu integrieren.

In unserem Beispiel verwenden wir React zur Demonstration.

Nachdem du Logto in deiner Anwendung eingerichtet hast, müssen wir die RBAC-Konfigurationen hinzufügen, damit Logto funktioniert.

Denke daran, dich abzumelden und erneut anzumelden, damit diese Änderung wirksam wird, falls du bereits angemeldet bist.

Wenn sich der Benutzer mit Logto anmeldet und ein Zugriffstoken für die oben angegebenen API-Ressourcen anfordert, fügt Logto dem Zugriffstoken Bereiche (Berechtigungen) hinzu, die mit der Rolle des Benutzers zusammenhängen.

Du kannst getAccessTokenClaims vom useLogto-Hook verwenden, um die Bereiche aus dem Zugriffstoken zu erhalten.

Und du kannst die userScopes verwenden, um zu überprüfen, ob der Benutzer die Erlaubnis hat, auf die Ressource zuzugreifen.

Deinen Backend mit Logto RBAC integrieren#

Jetzt ist es an der Zeit, Logto RBAC in dein Backend zu integrieren.

Backend-Autorisierungsmiddleware#

Zuerst müssen wir eine Middleware im Backend hinzufügen, um Benutzerberechtigungen zu überprüfen, zu verifizieren, ob der Benutzer angemeldet ist, und festzustellen, ob er die notwendigen Berechtigungen hat, um auf bestimmte APIs zuzugreifen.

Wie du sehen kannst, überprüfen wir in dieser Middleware, ob die Frontend-Anfrage ein gültiges Zugriffstoken enthält und ob die Audience des Zugriffstokens mit der API-Ressource übereinstimmt, die wir in der Logto-Konsole erstellt haben.

Der Grund für die Überprüfung der API-Ressource ist, dass unsere API-Ressource tatsächlich die Ressourcen unseres CMS-Backends darstellt und alle unsere CMS-Berechtigungen mit dieser API-Ressource verbunden sind.

Da diese API-Ressource die CMS-Ressourcen in Logto darstellt, schließen wir in unserem Frontend-Code das entsprechende Zugriffstoken bei API-Anfragen an das Backend ein:

Jetzt können wir die requireAuth-Middleware verwenden, um unsere API-Endpunkte zu schützen.

API-Endpunkte schützen#

Für APIs, die nur für Benutzer mit bestimmten Berechtigungen zugänglich sein sollten, können wir die Einschränkungen direkt in der Middleware hinzufügen. Zum Beispiel sollte die Artikel-Erstellungs-API nur für Benutzer mit der Berechtigung create:articles zugänglich sein:

Für APIs, die sowohl Berechtigungen als auch Ressourcenbesitz überprüfen müssen, können wir die hasScopes-Funktion verwenden. Zum Beispiel können Benutzer mit der list:articles-Berechtigung im Artikelauflistungs-API auf alle Artikel zugreifen, während Autoren auf ihre eigenen erstellten Artikel zugreifen können:

An diesem Punkt haben wir die RBAC-Implementierung abgeschlossen. Du kannst den kompletten Quellcode ansehen, um die vollständige Implementierung zu sehen.

Die CMS RBAC-Implementierung testen#

Lass uns nun unsere CMS RBAC-Implementierung mit den drei von uns erstellten Benutzern testen.

Erst einmal, lass uns als Alex und Charlie einloggen und einige Artikel erstellen.

Da Alex die Admin-Rolle hat, kann er Artikel erstellen, löschen, aktualisieren, veröffentlichen und alle Artikel einsehen.

Charlie, mit der Autoren-Rolle, kann nur die eigenen Artikel erstellen und nur die Artikel sehen, aktualisieren und löschen, die er besitzt.

Bob, mit der Publisher-Rolle, kann alle Artikel sehen und veröffentlichen, jedoch nicht erstellen, aktualisieren oder löschen.

Fazit#

Herzlichen Glückwunsch! Du hast gelernt, wie du ein robustes RBAC-System in deiner Anwendung implementierst.

Für komplexere Szenarien, wie den Aufbau von Multi-Tenant-Anwendungen, bietet Logto umfassende Organisationsunterstützung. Sieh dir unseren Leitfaden Multi-Tenant-SaaS-Anwendung erstellen: Ein kompletter Leitfaden vom Design bis zur Implementierung an, um mehr über die Implementierung einer organisationsweiten Zugriffskontrolle zu erfahren.

Viel Spaß beim Codieren! 🚀