Zum Hauptinhalt springen

Schütze deine Gin-API mit rollenbasierter Zugangskontrolle (RBAC) und JWT-Validierung

Diese Anleitung hilft dir, Autorisierung zu implementieren, um deine Gin-APIs mit rollenbasierter Zugangskontrolle (RBAC) und JSON Web Tokens (JWTs), die von Logto ausgestellt werden, abzusichern.

Bevor du beginnst​

Deine Client-Anwendungen müssen Zugangstokens (Access tokens) von Logto erhalten. Falls du die Client-Integration noch nicht eingerichtet hast, schaue dir unsere Schnellstarts für React, Vue, Angular oder andere Client-Frameworks an oder sieh dir unseren Maschine-zu-Maschine-Leitfaden für Server-zu-Server-Zugriff an.

Dieser Leitfaden konzentriert sich auf die serverseitige Validierung dieser Tokens in deiner Gin-Anwendung.

Eine Abbildung, die den Fokus dieses Leitfadens zeigt

Was du lernen wirst​

  • JWT-Validierung: Lerne, Zugangstokens (Access tokens) zu validieren und Authentifizierungsinformationen zu extrahieren
  • Middleware-Implementierung: Erstelle wiederverwendbare Middleware zum Schutz deiner API
  • Berechtigungsmodelle: Verstehe und implementiere verschiedene Autorisierungsmuster (Authorization patterns):
    • Globale API-Ressourcen für anwendungsweite Endpunkte
    • Organisationsberechtigungen für mandantenspezifische Funktionskontrolle
    • Organisationsbezogene API-Ressourcen für Multi-Tenant-Datenzugriff
  • RBAC-Integration: Erzwinge rollenbasierte Berechtigungen (Role-based permissions) und Berechtigungen (Scopes) in deinen API-Endpunkten

Voraussetzungen​

  • Neueste stabile Version von Go installiert
  • Grundlegendes Verständnis von Gin und Web-API-Entwicklung
  • Eine konfigurierte Logto-Anwendung (siehe Schnellstarts, falls benötigt)

Überblick über Berechtigungsmodelle​

Bevor du Schutzmechanismen implementierst, wähle das Berechtigungsmodell, das zu deiner Anwendungsarchitektur passt. Dies steht im Einklang mit den drei Haupt-Autorisierungsszenarien von Logto:

Globale API-Ressourcen RBAC
  • Anwendungsfall: Schutz von API-Ressourcen, die in deiner gesamten Anwendung geteilt werden (nicht organisationsspezifisch)
  • Token-Typ: Zugangstoken (Access token) mit globaler Zielgruppe (Audience)
  • Beispiele: Öffentliche APIs, Kernproduktdienste, Admin-Endpunkte
  • Am besten geeignet für: SaaS-Produkte mit APIs, die von allen Kunden genutzt werden, Microservices ohne Mandantenisolation
  • Mehr erfahren: Globale API-Ressourcen schützen

💡 Wähle dein Modell, bevor du fortfährst – die Umsetzung in diesem Leitfaden bezieht sich durchgehend auf deinen gewählten Ansatz.

Schnelle Vorbereitungsschritte​

Logto-Ressourcen & Berechtigungen konfigurieren​

  1. API-Ressource erstellen: Gehe zu Konsole → API-Ressourcen und registriere deine API (z. B. https://api.yourapp.com)
  2. Berechtigungen definieren: Füge Berechtigungen wie read:products, write:orders hinzu – siehe API-Ressourcen mit Berechtigungen definieren
  3. Globale Rollen erstellen: Gehe zu Konsole → Rollen und erstelle Rollen, die deine API-Berechtigungen enthalten – siehe Globale Rollen konfigurieren
  4. Rollen zuweisen: Weisen Sie Benutzern oder M2M-Anwendungen, die API-Zugriff benötigen, Rollen zu
Neu bei RBAC?:

Beginne mit unserem Leitfaden zur rollenbasierten Zugangskontrolle (RBAC) für eine Schritt-für-Schritt-Anleitung.

Aktualisiere deine Client-Anwendung​

Fordere die passenden Berechtigungen in deinem Client an:

Der Prozess beinhaltet in der Regel die Aktualisierung deiner Client-Konfiguration, um eines oder mehrere der folgenden Elemente einzuschließen:

  • scope-Parameter in OAuth-Flows
  • resource-Parameter für den Zugriff auf API-Ressourcen
  • organization_id für den Organisationskontext
Bevor du mit dem Code beginnst:

Stelle sicher, dass der Benutzer oder die M2M-App, die du testest, die entsprechenden Rollen oder Organisationsrollen zugewiesen bekommen hat, die die notwendigen Berechtigungen für deine API enthalten.

Initialisiere dein API-Projekt​

Um ein neues Go-Projekt mit Gin zu initialisieren, kannst du folgende Schritte ausführen:

go mod init your-api-name
go get github.com/gin-gonic/gin

Erstelle dann ein grundlegendes Gin-Server-Setup:

main.go
package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    r.Run(":3000") // hören und bedienen auf 0.0.0.0:3000
}
hinweis:

Siehe die Gin-Dokumentation für weitere Details zur Einrichtung von Routen, Middleware und anderen Funktionen.

Initialisiere Konstanten und Hilfsfunktionen​

Definiere die notwendigen Konstanten und Hilfsfunktionen in deinem Code, um die Extraktion und Validierung von Tokens zu handhaben. Eine gültige Anfrage muss einen Authorization-Header in der Form Bearer <Zugangstoken (Access token)> enthalten.

auth_middleware.go
package main

import (
    "fmt"
    "net/http"
    "strings"
)

const (
    JWKS_URI = "https://your-tenant.logto.app/oidc/jwks"
    ISSUER   = "https://your-tenant.logto.app/oidc"
)

type AuthorizationError struct {
    Message string
    Status  int
}

func (e *AuthorizationError) Error() string {
    return e.Message
}

func NewAuthorizationError(message string, status ...int) *AuthorizationError {
    statusCode := http.StatusForbidden // Standardmäßig 403 Verboten
    if len(status) > 0 {
        statusCode = status[0]
    }
    return &AuthorizationError{
        Message: message,
        Status:  statusCode,
    }
}

func extractBearerTokenFromHeaders(r *http.Request) (string, error) {
    const bearerPrefix = "Bearer "

    authorization := r.Header.Get("Authorization")
    if authorization == "" {
        return "", NewAuthorizationError("Authorization-Header fehlt", http.StatusUnauthorized)
    }

    if !strings.HasPrefix(authorization, bearerPrefix) {
        return "", NewAuthorizationError(fmt.Sprintf("Authorization-Header muss mit \"%s\" beginnen", bearerPrefix), http.StatusUnauthorized)
    }

    return strings.TrimPrefix(authorization, bearerPrefix), nil
}

Informationen über deinen Logto-Mandanten abrufen​

Du benötigst die folgenden Werte, um von Logto ausgestellte Tokens zu validieren:

  • JSON Web Key Set (JWKS) URI: Die URL zu den öffentlichen Schlüsseln von Logto, die zur Überprüfung von JWT-Signaturen verwendet wird.
  • Aussteller (Issuer): Der erwartete Ausstellerwert (die OIDC-URL von Logto).

Zuerst finde den Endpunkt deines Logto-Tenants. Du findest ihn an verschiedenen Stellen:

  • In der Logto-Konsole unter Einstellungen → Domains.
  • In den Anwendungseinstellungen, die du in Logto konfiguriert hast, unter Einstellungen → Endpoints & Credentials.

Abrufen vom OpenID Connect Discovery-Endpunkt​

Diese Werte können vom OpenID Connect Discovery-Endpunkt von Logto abgerufen werden:

https://<your-logto-endpoint>/oidc/.well-known/openid-configuration

Hier ist ein Beispiel für eine Antwort (andere Felder wurden zur Übersichtlichkeit weggelassen):

{
  "jwks_uri": "https://your-tenant.logto.app/oidc/jwks",
  "issuer": "https://your-tenant.logto.app/oidc"
}

Da Logto keine Anpassung der JWKS-URI oder des Ausstellers (Issuer) erlaubt, kannst du diese Werte fest in deinem Code hinterlegen. Dies wird jedoch für Produktionsanwendungen nicht empfohlen, da dies den Wartungsaufwand erhöhen kann, falls sich zukünftig Konfigurationen ändern.

  • JWKS URI: https://<your-logto-endpoint>/oidc/jwks
  • Aussteller (Issuer): https://<your-logto-endpoint>/oidc

Token und Berechtigungen validieren​

Nach dem Extrahieren des Tokens und dem Abrufen der OIDC-Konfiguration überprüfe Folgendes:

  • Signatur: JWT muss gültig und von Logto (über JWKS) signiert sein.
  • Aussteller (Issuer): Muss mit dem Aussteller deines Logto-Tenants übereinstimmen.
  • Zielgruppe (Audience): Muss mit dem in Logto registrierten Ressourcenindikator der API oder dem Organisationskontext (falls zutreffend) übereinstimmen.
  • Ablauf (Expiration): Token darf nicht abgelaufen sein.
  • Berechtigungen (Scopes): Token muss die erforderlichen Berechtigungen für deine API / Aktion enthalten. Berechtigungen sind durch Leerzeichen getrennte Zeichenfolgen im scope-Anspruch.
  • Organisationskontext: Wenn du API-Ressourcen auf Organisationsebene schützt, überprüfe den organization_id-Anspruch.

Siehe JSON Web Token, um mehr über die Struktur und Ansprüche von JWT zu erfahren.

Was bei jedem Berechtigungsmodell zu prüfen ist​

  • Audience-Anspruch (aud): API-Ressourcenindikator
  • Organisations-Anspruch (organization_id): Nicht vorhanden
  • Zu prüfende Berechtigungen (scope): API-Ressourcen-Berechtigungen

Für nicht-API-Organisationsberechtigungen wird der Organisationskontext durch den aud-Anspruch dargestellt (z. B. urn:logto:organization:abc123). Der organization_id-Anspruch ist nur für Tokens von API-Ressourcen auf Organisationsebene vorhanden.
tipp:

Validiere immer sowohl Berechtigungen (Scopes) als auch Kontext (Audience, Organisation) für sichere Multi-Tenant-APIs.

Validierungslogik hinzufügen​

Wir verwenden github.com/lestrrat-go/jwx, um JWTs zu validieren. Installiere es, falls du es noch nicht getan hast:

go mod init your-project
go get github.com/lestrrat-go/jwx/v3

Füge zunächst diese gemeinsamen Komponenten zu deiner Datei auth_middleware.go hinzu:

auth_middleware.go
import (
    "context"
    "strings"
    "time"

    "github.com/lestrrat-go/jwx/v3/jwk"
    "github.com/lestrrat-go/jwx/v3/jwt"
)

var jwkSet jwk.Set

func init() {
    // JWKS-Cache initialisieren
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    var err error
    jwkSet, err = jwk.Fetch(ctx, JWKS_URI)
    if err != nil {
        panic("Fehler beim Abrufen von JWKS: " + err.Error())
    }
}

// validateJWT validiert das JWT und gibt das geparste Token zurück
func validateJWT(tokenString string) (jwt.Token, error) {
    token, err := jwt.Parse([]byte(tokenString), jwt.WithKeySet(jwkSet))
    if err != nil {
        return nil, NewAuthorizationError("Ungültiges Token: "+err.Error(), http.StatusUnauthorized)
    }

    // Aussteller überprüfen
    if token.Issuer() != ISSUER {
        return nil, NewAuthorizationError("Ungültiger Aussteller", http.StatusUnauthorized)
    }

    if err := verifyPayload(token); err != nil {
        return nil, err
    }

    return token, nil
}

// Hilfsfunktionen zum Extrahieren von Token-Daten
func getStringClaim(token jwt.Token, key string) string {
    if val, ok := token.Get(key); ok {
        if str, ok := val.(string); ok {
            return str
        }
    }
    return ""
}

func getScopesFromToken(token jwt.Token) []string {
    if val, ok := token.Get("scope"); ok {
        if scope, ok := val.(string); ok && scope != "" {
            return strings.Split(scope, " ")
        }
    }
    return []string{}
}

func getAudienceFromToken(token jwt.Token) []string {
    return token.Audience()
}

Implementiere anschließend das Middleware, um das Zugangstoken zu überprüfen:

auth_middleware.go
import "github.com/gin-gonic/gin"

func VerifyAccessToken() gin.HandlerFunc {
    return func(c *gin.Context) {
        tokenString, err := extractBearerTokenFromHeaders(c.Request)
        if err != nil {
            authErr := err.(*AuthorizationError)
            c.JSON(authErr.Status, gin.H{"error": authErr.Message})
            c.Abort()
            return
        }

        token, err := validateJWT(tokenString)
        if err != nil {
            authErr := err.(*AuthorizationError)
            c.JSON(authErr.Status, gin.H{"error": authErr.Message})
            c.Abort()
            return
        }

        // Token im Kontext für generische Nutzung speichern
        c.Set("auth", token)
        c.Next()
    }
}

Je nach deinem Berechtigungsmodell musst du möglicherweise unterschiedliche verifyPayload-Logik anwenden:

auth_middleware.go
func verifyPayload(token jwt.Token) error {
    // Überprüfe, ob der Audience-Anspruch mit deinem API-Ressourcenindikator übereinstimmt
    if !hasAudience(token, "https://your-api-resource-indicator") {
        return NewAuthorizationError("Ungültige Zielgruppe")
    }

    // Überprüfe erforderliche Berechtigungen für globale API-Ressourcen
    requiredScopes := []string{"api:read", "api:write"} // Ersetze durch deine tatsächlichen erforderlichen Berechtigungen
    if !hasRequiredScopes(token, requiredScopes) {
        return NewAuthorizationError("Unzureichende Berechtigung")
    }

    return nil
}

Füge diese Hilfsfunktionen zur Payload-Überprüfung hinzu:

auth_middleware.go
// hasAudience prüft, ob das Token die angegebene Zielgruppe enthält
func hasAudience(token jwt.Token, expectedAud string) bool {
    audiences := token.Audience()
    for _, aud := range audiences {
        if aud == expectedAud {
            return true
        }
    }
    return false
}

// hasOrganizationAudience prüft, ob das Token eine Zielgruppe im Organisationsformat enthält
func hasOrganizationAudience(token jwt.Token) bool {
    audiences := token.Audience()
    for _, aud := range audiences {
        if strings.HasPrefix(aud, "urn:logto:organization:") {
            return true
        }
    }
    return false
}

// hasRequiredScopes prüft, ob das Token alle erforderlichen Berechtigungen enthält
func hasRequiredScopes(token jwt.Token, requiredScopes []string) bool {
    scopes := getScopesFromToken(token)
    for _, required := range requiredScopes {
        found := false
        for _, scope := range scopes {
            if scope == required {
                found = true
                break
            }
        }
        if !found {
            return false
        }
    }
    return true
}

// hasMatchingOrganization prüft, ob die Token-Zielgruppe mit der erwarteten Organisation übereinstimmt
func hasMatchingOrganization(token jwt.Token, expectedOrgID string) bool {
    expectedAud := fmt.Sprintf("urn:logto:organization:%s", expectedOrgID)
    return hasAudience(token, expectedAud)
}

// hasMatchingOrganizationID prüft, ob die organization_id des Tokens mit der erwarteten übereinstimmt
func hasMatchingOrganizationID(token jwt.Token, expectedOrgID string) bool {
    orgID := getStringClaim(token, "organization_id")
    return orgID == expectedOrgID
}

Middleware auf deine API anwenden​

Wende nun die Middleware auf deine geschützten API-Routen an.

main.go
package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/lestrrat-go/jwx/v3/jwt"
)

func main() {
    r := gin.Default()

    // Middleware auf geschützte Routen anwenden
    r.GET("/api/protected", VerifyAccessToken(), func(c *gin.Context) {
        // Zugangstoken (Access token) Informationen direkt aus dem Kontext abrufen
        tokenInterface, exists := c.Get("auth")
        if !exists {
            c.JSON(http.StatusInternalServerError, gin.H{"error": "Token nicht gefunden"})
            return
        }

        token := tokenInterface.(jwt.Token)

        c.JSON(http.StatusOK, gin.H{
            "sub":             token.Subject(),
            "client_id":       getStringClaim(token, "client_id"),
            "organization_id": getStringClaim(token, "organization_id"),
            "scopes":          getScopesFromToken(token),
            "audience":        getAudienceFromToken(token),
        })
    })

    r.Run(":8080")
}

Teste deine geschützte API​

Zugangstokens erhalten​

Von deiner Client-Anwendung: Wenn du eine Client-Integration eingerichtet hast, kann deine App Tokens automatisch erhalten. Extrahiere das Zugangstoken und verwende es in API-Anfragen.

Zum Testen mit curl / Postman:

  1. Benutzertokens: Verwende die Entwicklertools deiner Client-App, um das Zugangstoken aus dem localStorage oder dem Netzwerk-Tab zu kopieren.

  2. Maschine-zu-Maschine-Tokens: Verwende den Client-Credentials-Flow. Hier ein nicht-normatives Beispiel mit curl:

    curl -X POST https://your-tenant.logto.app/oidc/token \
      -H "Content-Type: application/x-www-form-urlencoded" \
      -d "grant_type=client_credentials" \
      -d "client_id=your-m2m-client-id" \
      -d "client_secret=your-m2m-client-secret" \
      -d "resource=https://your-api-resource-indicator" \
      -d "scope=api:read api:write"

    Möglicherweise musst du die Parameter resource und scope entsprechend deiner API-Ressource und Berechtigungen anpassen; ein organization_id-Parameter kann ebenfalls erforderlich sein, wenn deine API organisationsgebunden ist.

tipp:

Möchtest du den Inhalt des Tokens inspizieren? Verwende unseren JWT Decoder, um deine JWTs zu dekodieren und zu überprüfen.

Geschützte Endpunkte testen​

Gültige Token-Anfrage
curl -H "Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9..." \
  http://localhost:3000/api/protected

Erwartete Antwort:

{
  "auth": {
    "sub": "user123",
    "clientId": "app456",
    "organizationId": "org789",
    "scopes": ["api:read", "api:write"],
    "audience": ["https://your-api-resource-indicator"]
  }
}
Fehlendes Token
curl http://localhost:3000/api/protected

Erwartete Antwort (401):

{
  "error": "Authorization header is missing"
}
Ungültiges Token
curl -H "Authorization: Bearer invalid-token" \
  http://localhost:3000/api/protected

Erwartete Antwort (401):

{
  "error": "Invalid token"
}

Berechtigungsmodell-spezifisches Testen​

Testszenarien für APIs, die mit globalen Berechtigungen geschützt sind:

  • Gültige Berechtigungen: Teste mit Tokens, die deine erforderlichen API-Berechtigungen enthalten (z. B. api:read, api:write)
  • Fehlende Berechtigungen: Erwarte 403 Verboten, wenn das Token die erforderlichen Berechtigungen nicht enthält
  • Falsche Zielgruppe: Erwarte 403 Verboten, wenn die Zielgruppe nicht mit der API-Ressource übereinstimmt
# Token mit fehlenden Berechtigungen - erwarte 403
curl -H "Authorization: Bearer token-without-required-scopes" \
  http://localhost:3000/api/protected

Weiterführende Literatur​

RBAC in der Praxis: Sichere Autorisierung für deine Anwendung implementieren

Entwicklung einer Multi-Tenant-SaaS-Anwendung: Ein vollständiger Leitfaden von Design bis Implementierung