OpenRBAC 0.1 draft

Open specification · version 0.1 (draft)

Apps publish the permissions they understand.
Identity providers read them.

OpenRBAC is a small JSON format for an application to describe its actions, how they group, and the roles it suggests. Your identity provider fetches it, shows admins real checkboxes, and puts exactly the granted actions in the token.

The problem

Every application has its own idea of what users can do. Identity providers only see a handful of free-text scopes or group names. So admins guess, apps hard-code role names, and "who can reset a device?" has no answer you can audit.

Admins guess

IdP consoles show groups and scopes, not what each app can actually do. Granting the right access means reading docs or asking the developer.

Apps hard-code roles

"admin", "editor", "viewer" mean different things in every app, and changing them means a release.

Nobody can audit it

There is no single place that lists which person can perform which action in which app.

How it works

One static JSON file, served by the app. No new protocol: discovery and delivery reuse OAuth, OIDC and SAML.

1

The app publishes

Serve /.well-known/openrbac.json listing your actions, how they group, and the roles you suggest.

2

The IdP reads it

When the app is connected, the IdP fetches the manifest and shows admins real checkboxes and ready-made roles.

3

Tokens carry actions

The access token for the app carries a perm claim with exactly the granted action ids. The app checks for them.

A complete manifest

Actions are opaque ids you already use. Groups organize them for humans. Roles are suggestions, written with simple patterns like device.*, *.read or @content, and can say which kind of team they are for.

More examples JSON Schema

{
  "openrbac": "0.1",
  "app": { "id": "signage-player", "name": "Signage Player" },
  "groups": {
    "device": {
      "title": "Devices",
      "actions": {
        "device.register": "Pair a new screen",
        "device.reset": { "title": "Factory-reset a screen", "dangerous": true },
        "device.volume": "Change volume"
      }
    },
    "content": {
      "title": "Content",
      "actions": {
        "content.read": "View content",
        "content.publish": "Publish to screens"
      }
    }
  },
  "roles": {
    "operator": { "title": "Device operator", "persona": "operator",
                  "actions": ["device.*", "content.read"] },
    "viewer":   { "title": "Viewer", "persona": "viewer", "actions": ["*.read"] }
  }
}

Designed to be easy to adopt

Small

One file, a few required fields. An app can adopt it in an afternoon; an IdP can support the basics without a policy engine.

Static and cacheable

A plain HTTPS document with ETags. Apps that cannot host a file can push the manifest to the IdP instead.

Safe to change

New actions are never granted silently. Changed suggested roles are shown as a diff for an admin to accept.

Builds on standards

Discovery follows RFC 9728 protected resource metadata. Runtime checks can use OpenID AuthZEN. The catalog idea comes from UMA 2.0.

Personas

Suggested roles name the team they are for (operator, security, auditor…). Map your groups once; new apps propose matching roles.

Open

Apache 2.0. The spec, schema and examples live on GitHub, and changes happen in the open.

For application developers

Write the manifest, serve it, and check the perm claim. Ten minutes for a first version.

App quick start

For identity provider developers

Fetch and validate manifests, offer suggested roles, and issue perm for the app's audience.

IdP quick start

Status

Version 0.1 is a draft and is being implemented end to end: Gimbal publishes a manifest as an application, and Gimbal ID implements the identity provider side. Feedback and implementation reports are welcome on GitHub.