Motor de papel

1) Modelos de autorização

RBAC (Role-Based Access Control): o sujeito recebe papéis, os papéis estão relacionados com permissões. Apenas controlar, bom para tarefas típicas.
ABAC: a solução depende dos atributos do sujeito, do recurso, da ação e do ambiente (tempo, IP, região, risco). Flexível e escala em regras complexas.
Híbrido RBAC + ABAC: Os papéis oferecem capacidade básica e os atributos estreitam-na.
(Opcional) ReBAC/Relationship-based: Gráfico de relacionamento (proprietário, membro da equipe, delegado), útil para documentários e estruturas org.

2) Arquitetura: PDP/PEP e fluxos

PEP (Policy Enforcement Point): local de aplicação da solução (entrada API, método backend, camada SQL, UI).
PDP (Policy Decision Point): serviço/biblioteca que calcula 'ALLOW/DENY' por políticas e atributos.
PIP (Policy Information Point): fontes de atributos (IDP/perfil, metadados do recurso, screen de risco, geo).
IP (Policy Management Point): interface administrativa/repositório de políticas (versões, rascunhos, publicação).

Fluxo: A consulta PEP cria um contexto o PDP puxa os atributos que faltam (via PIP) calcula a solução o PEP aplica (permitir/proibir/cortar campos) a uma auditoria .

3) Modelo de dados

• `subject` (user/service) с атрибутами: `tenant_id`, `roles`, `departments`, `risk_level`, `mfa_verified`, `scopes`, `claims`.
• 'resource' com o tipo e os atributos: 'tipo', 'owner _ id', 'tenant _ id', 'classification' (público/confidential), 'region', 'tags'.
• `action`: `read`, `write`, `delete`, `export`, `approve`, `impersonate` и т. п.
• `environment`: `time`, `ip`, `device`, `geo`, `auth_strength`, `business_context` (канал, тариф).

• 'roles (id, tenant _ id, name, inherits [])' - suporte hierarquias e modelos.
• `permissions(id, resource_type, action, constraint?)`.
• `role_permissions(role_id, permission_id)`.
• 'assignments (subject _ id, role _ id, scope)' - scope: global/por projeto/por objeto.

• `policy(id, effect=allow|deny, target: {subject, resource, action}, condition: expr, priority, version, status)`.

4) Princípios decisórios

Deny-overrides: proibições explícitas são mais prioritárias do que permissões.
Least Privilege (PoLP): Execute o mínimo de acesso necessário, amplie através das condições.
Separation of Duties (SoD): impede combinações de papéis/ações (por exemplo, «criou um pagamento» ≠ «apareceu»).
Context-aware: Reforce as exigências para risco elevado (sem MFA, IP suspeito).
Determinism: contexto idêntico → resposta idêntica; registar a versão da política.

5) Pattern de implementação

5. 1 Híbrido RBAC→ABAC (ar condicionado)

yaml
Declarative Policy Example
- id: doc_read_own effect: allow target: { action: read, resource. type: document, subject. roles: ["editor","owner"] }
condition: resource. owner_id == subject. id

- id: doc_read_team effect: allow target: { action: read, resource. type: document, subject. roles: ["editor","viewer"] }
condition: subject. team_id in resource. shared_team_ids

- id: doc_read_confidential_external effect: deny target: { action: read, resource. type: document }
condition: resource. classification == "confidential" and subject. tenant_id!= resource. tenant_id priority: 100 # deny high priority

5. 2 Row/Field-Level Security

Nível BD: políticas RLS (por 'tenant _ id', 'owner _ id').
Nível de API: filtre as coleções e disfarce os campos se não houver 'allow: read _ sensitivo _ fields'.

5. 3 Soluções «step-up»

allow if action == "export" and subject. mfa_verified == true else deny

5. 4 Permissões temporárias

Bolsas com TTL: 'assignment. expires _ at ', «janelas» de acesso (durante o horário de trabalho da região do recurso).

6) Desempenho e armazenamento em dinheiro

A chave «(subject _ hash, resource _ key, action, policy _ version)» é uma TTL curta.
Atributos do item Edge-dinheiro (claims no token) + lazy-fetch atributos do recurso.
Incorporental invalidation: deficiência por evento (mudança de papel, alteração de política, tradução do recurso para «confidential»).
Verificações batch: para listas - Avalie com «filtro» (policy-predicate pushdown) para não puxar PDP de propósito.

7) Multiplicidade (Multi-tenant)

Cada tabela tem «tenant _ id»; políticas padrão restringem o acesso dentro do aluguel.
Os administradores de aluguel administram apenas os papéis/direitos de renda.
Acesso de aluguel cruzado - exclusivamente através de convites explícitos/shering com deny-override explícito.

8) Administração e ciclo de vida de políticas

Versioning: 'policy. versão 'na resposta PDP, guarde na auditoria.
Ambientes: draft → canary (partes de tráfego/shadow) → prod.
Teste matrix: tabelas de verdade para papéis/atributos essenciais (testes contratuais).
Mudança de gestão: recordações de políticas com revisão de segurança/complacência.

9) Auditoria e observação

Журнал решений: `decision_id`, `subject`, `action`, `resource_ref`, `result`, `matched_policies`, `policy_version`, `attributes_digest`.
Métricas: QPS PDP, Latidão p95, hit-rate em dinheiro, proporção deny, taxa de step-up, incidentes de SoD.
Traçados: span para chamada PDP; correlação com a solicitação de API.
Réplicas: possibilidade de «redesenhar» soluções históricas em uma nova versão da política (safety check).

10) Integração com autenticação e tokens

A identidade é de IdP (OIDC/SAML). Os tokens carregam um mínimo de atributos: «sub», «tenant», «roles», «auth _ time», «amr», «scopes».
Para ABAC, estique os sinais pesados do lado do servidor (PIP) para não inflar o token.
Resource tocens (capability/convites) assinados - para delegações estritamente restritas.

11) Pseudocode PDP (simplificado)

python def decide(subject, resource, action, env, policies):
matched = []
effect = "deny"
Explicit DENYs with priority for p in sorted (policies, key = lambda x: x.priority, reverse = True):
if target_matches(p. target, subject, resource, action):
if eval_condition(p. condition, subject, resource, env):
matched. append(p. id)
if p. effect == "deny":
return Decision("deny", matched, p. version)
Looking for ALLOW for p in policies:
if target_matches(p. target, subject, resource, action):
if eval_condition(p. condition, subject, resource, env):
matched. append(p. id)
effect = "allow"
break return Decision(effect, matched, max_version(matched, policies))

12) Anti-pattern

«Papel = página» (centenas de pequenos papéis sem modelo de objeto).
Armazenamento de políticas somente em código sem versão/auditoria.
Falta de deny-override e SoD → aumentar o risco de fraude.
Listas rígidas de 'user _ id' nas regras (em vez de atributos/relacionamentos).
Não há filtragem no nível de dados (RLS) se o filtro estiver disponível apenas na UI.
Sincronizar os papéis através de script manuais sem eventos ou deficiência de dinheiro.

13) Malas e receitas

13. 1 Camuflagem de nível:

allow read invoice when subject. roles includes "support"
mask fields ["card_last4", "billing_email"] unless subject. role == "finance"

13. 2 Exportar dados apenas com MFA:

allow export if subject. mfa_verified and env. ip in cidr("203. 0. 113. 0/24")

13. 3 SoD:

deny approve_payment if subject. performed_actions includes ("create_payment" within last 24h)

13. 4 Delegação (token limitado):

Capability-token contém 'resource _ id', 'action = [' read ']', 'expires _ at', 'aud'. O PEP verifica a assinatura e o prazo.

14) Testes

Os testes unit de políticas são tabelas de verdade por combinações básicas.
Property-based: geração de atributos aleatórios para encontrar «buracos».
Golden-testes: fixação de um conjunto de soluções para endpoentos críticos.
Canady/Shadow: Avaliação paralela das versões antigas e novas de políticas com o loging de divergências.

15) Capacidades associadas da seção Arquitetura e Protocolos

Autenticação e autorização (OIDC/OAuth2)

Gerenciamento de concordâncias

Tocando e gerenciando chaves

Observabilidade: logs, métricas, traçáveis

Gerenciamento e localização de geo

Criptografia At Rest/In Transit

16) Folha de cheque do arquiteto

1. Os papéis e hierarquias são definidos?
2. Há algum modelo híbrido: papéis + condições em atributos?
3. Implementado PDP com deny-overrides, SoD e step-up?
4. Onde está o PEP? (portaria, backand, BD, UI) - Há uniformidade em todo o lado?
5. As caixas de solução e a deficiência de eventos estão configuradas?
6. As políticas são versionizadas, testadas, divulgadas?
7. Está incluída a auditoria de soluções, métricas e traçados?
8. Suporta multi-arending e RLS/field-masking?
9. Há um runbook sobre incidentes e regressão político?

Conclusão

O RBAC fornece governabilidade, o ABAC, contexto e precisão. Ao combinar papéis com condições de atributo, separar PDP/PEP, implementar a sala de armazenamento, auditoria e teste de políticas, você constrói a permissão como uma capacidade de plataforma, previsível, verificável e escalável para requisitos alimentares e regulatórios.