Sicherheit & Zugriffskontrolle

Verwalten Sie Authentifizierungs-Actors, Autorisierungs-Scopes und Zugriffsrichtlinien.

Laden

local security = require("security")

actor

Gibt den aktuellen Sicherheits-Actor aus dem Ausführungskontext zurück.

local actor = security.actor()
if actor then
    local id = actor:id()
    local meta = actor:meta()

    logger:info("Request from", {
        user_id = id,
        role = meta.role
    })
end

Gibt zurück: Actor|nil

scope

Gibt den aktuellen Sicherheits-Scope aus dem Ausführungskontext zurück.

local scope = security.scope()
if scope then
    local policies = scope:policies()
    for _, policy in ipairs(policies) do
        print("Active policy:", policy:id())
    end
end

Gibt zurück: Scope|nil

can

Prüft, ob der aktuelle Kontext eine Aktion auf einer Ressource erlaubt.

-- Leseberechtigung prüfen
if not security.can("read", "user:" .. user_id) then
    return nil, errors.new("PERMISSION_DENIED", "Cannot read user data")
end

-- Schreibberechtigung prüfen
if not security.can("write", "order:" .. order_id) then
    return nil, errors.new("PERMISSION_DENIED", "Cannot modify order")
end

-- Mit Metadaten prüfen
local allowed = security.can("delete", "document:" .. doc_id, {
    owner_id = doc.owner_id,
    department = doc.department
})

Gibt zurück: boolean

new_actor

Erstellt einen neuen Actor mit ID und Metadaten.

-- Benutzer-Actor erstellen
local actor = security.new_actor("user:" .. user.id, {
    role = user.role,
    department = user.department,
    email = user.email
})

-- Service-Actor erstellen
local service_actor = security.new_actor("service:payment-processor", {
    type = "service",
    version = "1.0.0"
})

Gibt zurück: Actor

new_scope

Erstellt einen neuen benutzerdefinierten Scope.

-- Leerer Scope
local scope = security.new_scope()

-- Scope mit Richtlinien
local read_policy = security.policy("app:read-only")
local scope = security.new_scope({read_policy})

-- Scope inkrementell aufbauen
local scope = security.new_scope()
local policy1 = security.policy("app:read")
local policy2 = security.policy("app:write")
scope = scope:with(policy1):with(policy2)

Gibt zurück: Scope

policy

Ruft eine Richtlinie aus der Registry ab.

local policy, err = security.policy("app:admin-access")
if err then
    return nil, err
end

-- Richtlinie auswerten
local result = policy:evaluate(actor, "delete", "user:123")
if result == "allow" then
    -- erlaubt
elseif result == "deny" then
    -- verboten
else
    -- undefiniert, andere Richtlinien prüfen
end

Gibt zurück: Policy, error

named_scope

Ruft eine vordefinierte Richtliniengruppe ab.

-- Admin-Scope holen
local admin_scope, err = security.named_scope("app:admin")
if err then
    return nil, err
end

-- Für erhöhte Operationen verwenden
local result = admin_scope:evaluate(actor, "delete", "user:123")

Gibt zurück: Scope, error

token_store

Beschafft einen Token-Store zur Verwaltung von Authentifizierungstokens.

local store, err = security.token_store("app:tokens")
if err then
    return nil, err
end

-- Store verwenden...
store:close()

Gibt zurück: TokenStore, error

Actor-Methoden

Scope-Methoden

with / without

Richtlinien zum Scope hinzufügen oder entfernen.

local scope = security.new_scope()

-- Richtlinie hinzufügen
local write_policy = security.policy("app:write")
scope = scope:with(write_policy)

-- Richtlinie entfernen
scope = scope:without("app:read-only")

evaluate

Alle Richtlinien im Scope auswerten.

local result = scope:evaluate(actor, "read", "document:123")
-- "allow", "deny" oder "undefined"

if result ~= "allow" then
    return nil, errors.new("PERMISSION_DENIED", "Access denied")
end

contains

Prüfen, ob Scope eine Richtlinie enthält.

if scope:contains("app:admin") then
    show_admin_features()
end

policies

Gibt alle Richtlinien im Scope zurück.

local policies = scope:policies()
for _, policy in ipairs(policies) do
    print(policy:id())
end

Gibt zurück: Policy[]

Policy-Methoden

TokenStore-Methoden

create

Authentifizierungstoken erstellen.

local actor = security.new_actor("user:123", {role = "user"})
local scope = security.named_scope("app:default")

local token, err = store:create(actor, scope, {
    expiration = "24h",  -- oder Millisekunden
    meta = {
        login_ip = request_ip,
        user_agent = user_agent
    }
})

Gibt zurück: string, error

validate

Token validieren und Actor/Scope holen.

local actor, scope, err = store:validate(token)
if err then
    return nil, errors.new("UNAUTHENTICATED", "Invalid token")
end

Gibt zurück: Actor, Scope, error

revoke

Token ungültig machen.

local ok, err = store:revoke(token)

Gibt zurück: boolean, error

close

Token-Store-Ressource freigeben.

store:close()

Gibt zurück: boolean

Berechtigungen

Sicherheitsoperationen unterliegen der Sicherheitsrichtlinienauswertung.

Sicherheitsaktionen

Siehe Sicherheitsmodell für Richtlinienkonfiguration.

Fehler

local store, err = security.token_store("app:tokens")
if err then
    if errors.is(err, errors.INVALID) then
        print("Invalid request:", err:message())
    end
    return nil, err
end

Siehe Fehlerbehandlung für die Arbeit mit Fehlern.

Siehe auch

• Sicherheitsmodell - Actors, Richtlinien, Scopes-Konfiguration
• HTTP-Middleware - Endpoint- und Ressourcen-Firewall