Modelo de Seguridad

Wippy implementa control de acceso basado en atributos. Cada solicitud lleva un actor (quién) y un scope (qué políticas aplican). Las políticas evalúan el acceso basado en la acción, recurso, y metadatos tanto del actor como del recurso.

flowchart LR
    A[Actor + Scope] --> PE[Evaluación de Política] --> AD[Permitir/Denegar]
    A -.->|Identidad
Metadatos| PE
    PE -.->|Condiciones
actor, recurso, acción| AD

Tipos de Entrada

Actores

Un actor representa quién está realizando una acción.

local security = require("security")

-- Crear actor con metadatos
local actor = security.new_actor("user:123", {
    role = "admin",
    team = "backend",
    department = "engineering",
    clearance = 3
})

-- Acceder propiedades del actor
local id = actor:id()        -- "user:123"
local meta = actor:meta()    -- {role="admin", ...}

Actor en Contexto

-- Obtener actor actual del contexto
local actor = security.actor()
if not actor then
    return nil, errors.new("UNAUTHORIZED", "Sin actor en contexto")
end

Políticas

Las políticas definen reglas de acceso con acciones, recursos, condiciones y efectos.

Política Declarativa

# src/security/_index.yaml
version: "1.0"
namespace: app.security

entries:
  # Acceso completo admin
  - name: admin_policy
    kind: security.policy
    policy:
      actions: "*"
      resources: "*"
      effect: allow
      conditions:
        - field: actor.meta.role
          operator: eq
          value: admin
    groups:
      - admin

  # Acceso de solo lectura
  - name: readonly_policy
    kind: security.policy
    policy:
      actions:
        - "*.read"
        - "*.get"
        - "*.list"
      resources: "*"
      effect: allow
    groups:
      - default

  # Acceso de propietario de recurso
  - name: owner_policy
    kind: security.policy
    policy:
      actions:
        - read
        - write
        - delete
      resources: "document:*"
      effect: allow
      conditions:
        - field: meta.owner
          operator: eq
          value_from: actor.id
    groups:
      - default

  # Denegar confidencial sin autorización
  - name: deny_confidential
    kind: security.policy
    policy:
      actions: "*"
      resources: "document:*"
      effect: deny
      conditions:
        - field: meta.classification
          operator: eq
          value: confidential
        - field: actor.meta.clearance
          operator: lt
          value: 3
    groups:
      - security

Estructura de Política

policy:
  actions: "*" | "accion" | ["accion1", "accion2"]
  resources: "*" | "recurso" | ["res1", "res2"]
  effect: allow | deny
  conditions:  # Opcional
    - field: "ruta.campo"
      operator: "eq"
      value: "valor_estatico"
      # O
      value_from: "otra.ruta.campo"

Política Basada en Expresiones

Para lógica compleja, use políticas de expresiones:

- name: flexible_access
  kind: security.policy.expr
  policy:
    actions:
      - read
      - write
    resources: "file:*"
    effect: allow
    expression: |
      (actor.meta.role == "editor" && action == "write") ||
      (action == "read" && meta.public == true) ||
      actor.id == meta.owner      
  groups:
    - editors

Condiciones

Las condiciones permiten evaluación dinámica de políticas basada en actor, acción, recurso y metadatos.

Rutas de Campo

Operadores

Scopes

Los scopes combinan múltiples políticas en un contexto de seguridad.

local security = require("security")

-- Obtener políticas
local admin_policy = security.policy("app.security:admin_policy")
local readonly_policy = security.policy("app.security:readonly_policy")

-- Crear scope con políticas
local scope = security.new_scope()
scope = scope:with(admin_policy)
scope = scope:with(readonly_policy)

-- Los scopes son inmutables - :with() retorna nuevo scope

Scopes Nombrados (Grupos de Políticas)

Cargar todas las políticas de un grupo:

-- Cargar scope con todas las políticas del grupo
local scope, err = security.named_scope("app.security:admin")

Evaluación de Políticas

Flujo de Evaluación

1. Verificar cada política en scope
2. Si ALGUNA política retorna Deny -> Resultado es Deny
3. Si al menos un Allow y ningún Deny -> Resultado es Allow
4. Sin políticas aplicables -> Resultado es Undefined

Resultados de Evaluación

Almacenes de Tokens

Los almacenes de tokens proporcionan creación, validación y revocación segura de tokens.

Configuración

# src/auth/_index.yaml
version: "1.0"
namespace: app.auth

entries:
  # Registrar variable de entorno
  - name: os_env
    kind: env.storage.os

  - name: AUTH_SECRET_KEY
    kind: env.variable
    variable: AUTH_SECRET_KEY
    storage: app.auth:os_env

  # Almacén respaldo para tokens
  - name: token_data
    kind: store.memory
    lifecycle:
      auto_start: true

  # Almacén de tokens
  - name: tokens
    kind: security.token_store
    store: app.auth:token_data
    token_length: 32
    default_expiration: "24h"
    token_key_env: "AUTH_SECRET_KEY"

Opciones del Almacén de Tokens

Use token_key_env en producción para evitar embeber secretos en entradas.

Verificación Rápida de Permisos

-- Verificar contra actor y scope del contexto actual
local allowed = security.can("read", "document:123", {
    owner = "user:456"
})

if not allowed then
    return nil, errors.new("FORBIDDEN", "Acceso denegado")
end

Flujo de Contexto

El contexto de seguridad se propaga a través de llamadas de funciones.

Estableciendo Contexto

local funcs = require("funcs")

-- Llamar función con contexto de seguridad
local result, err = funcs.new()
    :with_actor(actor)
    :with_scope(scope)
    :call("app.api:protected_endpoint", data)

Seguridad a Nivel de Servicio

Configure seguridad por defecto para servicios:

- name: worker_service
  kind: process.lua
  source: file://worker.lua
  lifecycle:
    auto_start: true
    security:
      actor:
        id: "service:worker"
        meta:
          role: worker
          service: true
      policies:
        - app.security:worker_policy
      groups:
        - workers

Modo Estricto

Habilite modo estricto para denegar acceso cuando el contexto de seguridad está ausente:

# wippy.yaml
security:
  strict_mode: true

Ver También

• Módulo Security - API de seguridad en Lua