Rollen & Berechtigungen (RBAC)

Auris implementiert rollenbasierte Zugriffskontrolle (RBAC) mit einem Tri-State-Berechtigungsauflösungsmodell: Berechtigungen können explizit ALLOW, explizit DENY oder INHERIT (von der Rollenvorgabe übernehmen) sein. Benutzerspezifische Berechtigungsüberschreibungen haben Vorrang vor Rollenberechtigungen und ermöglichen feingranulare Ausnahmen ohne dedizierte Rollen.

Berechtigungsformat

Alle Berechtigungen in Auris folgen dem aktion:ressource-Muster:

manage:users          view:invoices         create:tickets
edit:roles            approve:expenses      delete:documents
assign:tickets        sign:interventions    export:reports

Die Komponente aktion beschreibt, was die Berechtigung ermöglicht. Gängige Aktionen: view, create, edit, delete, manage, approve, assign, export, sign, generate.

Die Komponente ressource beschreibt die Entität oder Funktion, auf die zugegriffen wird. Ressourcen entsprechen Modulen in deiner Anwendung.

Es gibt eine spezielle Berechtigung — admin:all — die uneingeschränkten Zugriff auf alle Ressourcen gewährt, wenn sie von einer Rolle gehalten wird. Sie ist der eingebauten Administrator-Rolle zugewiesen.

Rollen erstellen

Über die Console

1. Navigiere zu Console → Roles → Create Role
2. Gib einen Namen ein (z. B. Rechnungsmanager), eine optionale Beschreibung und wähle eine Farbe für das Rollen-Badge
3. Die Rolle wird ohne Berechtigungen erstellt. Konfiguriere Berechtigungen auf der Detailseite der Rolle.

Über die API

// Mit dem Auris Management Client
const management = await createManagementClient({ ... })
const role = await management.roles.create({
  name: 'Rechnungsmanager',
  description: 'Kann Rechnungen erstellen und anzeigen, aber nicht löschen',
  color: '#3b82f6',
})

Berechtigungen konfigurieren

Berechtigungskategorien

Der Console-Berechtigungseditor organisiert Berechtigungen in 10 Kategorien:

Berechtigungen für eine Rolle setzen

In der Console hat jede Berechtigung auf der Detailseite der Rolle einen Drei-Wege-Schalter:

• ALLOW — Die Berechtigung wird Benutzern mit dieser Rolle gewährt
• DENY — Die Berechtigung wird explizit verweigert und überschreibt geerbtes ALLOW aus anderen Rollen
• INHERIT — Die Rolle gewährt noch verweigert diese Berechtigung nicht (Standard)

Einem Benutzer wird eine Berechtigung gewährt, wenn eine seiner Rollen sie auf ALLOW gesetzt hat und keine seiner Rollen sie auf DENY gesetzt hat.

Über die API

Rollen Benutzern zuweisen

Rollen werden Benutzern in der Console (Users → [Benutzer] → Tab Roles) oder über die API zugewiesen:

Benutzer können mehrere Rollen haben. Berechtigungen aus allen Rollen werden zusammengeführt. Wenn eine Rolle DENY für eine Berechtigung hat, überschreibt dies ALLOW aus anderen Rollen.

Benutzerspezifische Berechtigungsüberschreibungen

Einzelnen Benutzern können direkt Berechtigungen zugewiesen werden, unabhängig von ihren Rollen. Benutzerüberschreibungen haben Vorrang vor allen Rollenberechtigungen:

• Ein benutzerspezifisches ALLOW gewährt die Berechtigung, auch wenn keine Rolle sie gewährt
• Ein benutzerspezifisches DENY blockiert die Berechtigung, auch wenn eine Rolle ALLOW gewährt

Console: Users → [Benutzer] → Tab Permissions → Add Override

Berechtigungen prüfen

Serverseitig (API-Routen)

Verwende den requirePermission()-Helfer, um Berechtigungen in API-Routen durchzusetzen:

// app/api/invoices/route.ts
import { requirePermission } from '@auris/nextjs/server'
 
const config = {
  domain: process.env.NEXT_PUBLIC_AURIS_DOMAIN!,
  clientId: process.env.NEXT_PUBLIC_AURIS_CLIENT_ID!,
}
 
export const GET = requirePermission('view:invoices', config, async (req, { session }) => {
  // Wird nur erreicht, wenn der Benutzer die Berechtigung view:invoices hat
  const invoices = await getInvoices(session.user.id)
  return Response.json(invoices)
})
 
export const POST = requirePermission('create:invoices', config, async (req, { session }) => {
  const body = await req.json()
  const invoice = await createInvoice(body, session.user.id)
  return Response.json(invoice, { status: 201 })
})

// Berechtigung in einer Server Component prüfen
import { checkPermission } from '@auris/nextjs/server'
 
export default async function AdminSection() {
  const canManageUsers = await checkPermission('manage:users')
 
  if (!canManageUsers) {
    return <p>Du hast keine Berechtigung, Benutzer zu verwalten.</p>
  }
 
  return <UserManagementPanel />
}

Clientseitig (React-Komponenten)

import { useCheckPermission, usePermissions } from '@auris/react'
 
// Eine einzelne Berechtigung prüfen
function InvoiceActions() {
  const { allowed: canCreate, isLoading } = useCheckPermission('create:invoices')
  const { allowed: canDelete } = useCheckPermission('delete:invoices')
 
  if (isLoading) return null
 
  return (
    <div>
      {canCreate && <button>Neue Rechnung</button>}
      {canDelete && <button>Auswahl löschen</button>}
    </div>
  )
}
 
// Mehrere Berechtigungen gleichzeitig prüfen
function DashboardNav() {
  const { has, hasAll, hasAny } = usePermissions([
    'view:invoices',
    'view:quotes',
    'manage:users',
    'view:billing',
  ])
 
  return (
    <nav>
      {has('view:invoices') && <a href="/invoices">Rechnungen</a>}
      {has('view:quotes') && <a href="/quotes">Angebote</a>}
      {has('manage:users') && <a href="/users">Benutzer</a>}
      {has('view:billing') && <a href="/billing">Abrechnung</a>}
      {hasAll(['view:invoices', 'view:quotes']) && <a href="/documents">Alle Dokumente</a>}
      {hasAny(['manage:users', 'manage:roles']) && <a href="/de/admin">Admin</a>}
    </nav>
  )
}

import { PermissionGate } from '@auris/react'
 
// UI bedingt basierend auf Berechtigung rendern
function InvoicePage() {
  return (
    <div>
      <h1>Rechnungen</h1>
 
      {/* Wird nur gerendert, wenn Benutzer create:invoices hat */}
      <PermissionGate permission="create:invoices">
        <button>Neue Rechnung</button>
      </PermissionGate>
 
      {/* Fallback für nicht autorisierte Benutzer */}
      <PermissionGate
        permission="delete:invoices"
        fallback={<span>Nur-Lesen-Zugriff</span>}
      >
        <button>Auswahl löschen</button>
      </PermissionGate>
    </div>
  )
}

import { AurisClient } from '@auris/js'
 
const auris = new AurisClient({ domain: 'auth.yourdomain.com', clientId: 'your-client-id' })
 
// Eine einzelne Berechtigung prüfen
const result = await auris.permissions.checkOne('manage:users')
console.log(result.allowed) // boolean
 
// Mehrere Berechtigungen gleichzeitig prüfen
const results = await auris.permissions.check([
  'view:invoices',
  'create:invoices',
  'delete:invoices',
])
 
results.forEach((result) => {
  console.log(`${result.permission}: ${result.allowed}`)
})
 
// Alle Berechtigungen des aktuellen Benutzers abrufen
const allPermissions = await auris.permissions.listUserPermissions()
console.log(allPermissions) // string[] — z. B. ['view:invoices', 'create:quotes', ...]

Berechtigungs-API

Berechtigungsauflösungsreihenfolge

Bei der Auflösung, ob ein Benutzer eine bestimmte Berechtigung hat, folgt Auris dieser Priorität:

1. Benutzerspezifisches DENY-Override — Falls vorhanden, wird die Berechtigung verweigert. Keine weitere Auswertung.
2. Benutzerspezifisches ALLOW-Override — Falls vorhanden (und kein DENY), wird die Berechtigung gewährt.
3. Rollenberechtigungen — Wenn eine Rolle ALLOW hat und keine Rolle DENY hat, wird die Berechtigung gewährt.
4. Implizite Verweigerung — Wenn keine Regel die Berechtigung gewährt, wird sie verweigert.

Benutzer-Override DENY  →  VERWEIGERT (hört hier auf)
Benutzer-Override ALLOW →  GEWÄHRT (hört hier auf)
Jede Rolle DENY         →  VERWEIGERT (hört hier auf)
Jede Rolle ALLOW        →  GEWÄHRT
Keine Übereinstimmung   →  VERWEIGERT

Anwendungsspezifische Berechtigungen

Berechtigungen können optional auf eine bestimmte Anwendung beschränkt werden. Wenn eine applicationId in einer Berechtigungsprüfung enthalten ist, wertet Auris Berechtigungen im Kontext dieser Anwendung aus — nützlich für Multi-Anwendungs-Tenants, bei denen Rollen pro Anwendung unterschiedlich sein können.

const result = await fetch('/api/roles/check', {
  method: 'POST',
  headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    permissions: ['view:invoices', 'create:invoices'],
    applicationId: 'app-id-for-billing-app',
  }),
})

Verwandte Anleitungen

• Fine-Grained Authorization — Objekt-Level-Zugriffskontrolle jenseits von Rollen
• Benutzerdefinierte JWT-Claims — Rollen- oder Berechtigungsdaten in Access Tokens einbetten
• M2M Client Credentials — Autorisierung für Server-zu-Server-Aufrufe