| Internet-Draft | Mission AuthZEN | November 2026 |
| McGuinness | Expires 8 May 2027 | [Page] |
Mission-Bound Runtime Enforcement defines a substrate-independent decision contract: before each consequential action runs, a Policy Enforcement Point (PEP) obtains a permit from a Policy Decision Point (PDP) that evaluates the action against the established Mission. This specification defines the OpenID AuthZEN profile of that contract. Its Decision Base maps the decision inputs onto the AuthZEN Authorization API request, shapes permit and denial responses, and binds every runtime failure condition to a wire-visible identifier, so two implementations interoperate on decisions with the base alone. Six optional feature profiles compose on the base: Transaction Assurance, Runtime Evidence, Obligations, the Access Request and Approval Profile (ARAP), History, and Batch.¶
This note is to be removed before publishing as an RFC.¶
The latest revision of this draft can be found at https://mcguinness.github.io/mission-bound-authorization/draft-mcguinness-mission-authzen.html. Status information for this document may be found at https://datatracker.ietf.org/doc/draft-mcguinness-mission-authzen/.¶
Source for this draft and an issue tracker can be found at https://github.com/mcguinness/mission-bound-authorization.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 8 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
Mission-Bound Runtime Enforcement [I-D.draft-mcguinness-mission-runtime] (the "runtime profile") defines the decision contract for Mission-bound authorization: action classification, PEP placement, parameter binding and the time-of-check to time-of-use gap, the consumption-bound failure posture, failure modes, runtime evidence, and conformance scope. It leaves the decision API wire format to the deployment.¶
This document defines that wire format for the OpenID AuthZEN Authorization API [AUTHZEN]: which AuthZEN members carry each decision input, how permits and denials are shaped, and which identifier surfaces each failure condition. It carries only the AuthZEN deltas. It does not redefine which actions are consequential, where the PEP sits, the semantics of parameter binding, the failure modes, or the runtime conformance scope; the runtime profile defines them normatively.¶
This profile inherits the runtime profile's substrate requirements.
The decision contract is defined against the Mission model, not
against OAuth 2.0 mechanics: OAuth enters only through the
credential-derived decision inputs (the token's sub, client_id,
cnf, authorization_details, and mission claim), which the
substrate's Mission-bound credential supplies. The examples use the
OAuth binding, Mission-Bound Authorization for OAuth 2.0
[I-D.draft-mcguinness-oauth-mission]. A deployment on another Mission
substrate maps that substrate's credential to the same inputs and uses
this profile unchanged.¶
The Decision Base is sufficient for two implementations to interoperate on decisions alone. It defines:¶
how the materialized policy view is referenced on the wire through
its policy_view_id (Section 4);¶
how the decision inputs map onto the AuthZEN
subject/resource/action/context envelope, with worked
requests and the PDP-side consistency checks (Section 5);¶
the permit and denial responses, and the rules that keep a permit bound to the PEP, channel, and inputs it was issued for (Section 6);¶
the denial classification and the complete mapping of the runtime profile's failure conditions onto wire-visible identifiers (Section 6.5, Section 6.8).¶
Six optional feature profiles compose on the base (Section 2):¶
Transaction Assurance: the parameter-digest and idempotency-key
members, and the high-consequence permit's use_limit condition
(Section 5.7, Section 6.1.1);¶
Runtime Evidence: emission of the runtime evidence companion's Decision Evidence, Execution Evidence, and Refusal Record, and the response members this profile echoes into them (Section 7);¶
Obligations: mandatory PEP work under an existing decision (Section 6.2);¶
ARAP: requestable denials through the AuthZEN Access Request and Approval Profile [ARAP] (Section 6.6);¶
History: policy-selected predicates over prior Decision and Execution Evidence (Section 5.17);¶
Batch: evaluations over the AuthZEN evaluations endpoint (Section 5.22).¶
Two companions extend the request without changing the base. Mission Capability Binding ([I-D.draft-mcguinness-mission-capability-binding]) adds capability-source context and establishes the action identity this profile consumes. The experimental metering companion ([I-D.draft-mcguinness-mission-metering]) defines the AuthZEN representation of cumulative consumption metering, including the settlement exchange and duration-lease renewal.¶
The end-to-end flow is:¶
Agent PEP PDP Access Request Service | | | | |- action ->| | | | | validate token | | | |- evaluation -->| | | | request | decide vs Mission | | |<- permit ------| | | | (+ context) | | | | execute | | | |- Execution --->| | | | Evidence | commit / release | |<- result -| | | | | | | | |<- deny --------| | | | (+ access_request) | | |- submit access request ------------->| | |<--------------- approval ------------| | |- re-evaluate ->| |¶
This profile is a Decision Base plus six feature profiles. Each feature profile depends on the Decision Base alone; none depends on another:¶
Decision Base +-- Transaction Assurance +-- Runtime Evidence +-- Obligations +-- ARAP +-- History +-- Batch¶
Feature profile selection is issuer or deployment policy plus authenticated capability discovery, never a requester's own choice (Section 8.1). A PDP or PEP that does not support a profile a policy or action class requires denies rather than falling back to the base, and a requester cannot omit a required profile to downgrade enforcement.¶
A feature profile never widens what the runtime profile's own rules already require for a class. Where the runtime profile makes a property mandatory for a class, the corresponding feature profile is the wire vehicle for that requirement, not a free election ([I-D.draft-mcguinness-mission-runtime]).¶
Each feature profile states its prerequisites, roles, required members, the behavior when it is absent, and the assurance it enables.¶
Prerequisites: the Decision Base.¶
Roles: the PEP supplies parameter_digest and, where the Operation
Profile requires one, idempotency_key; the PDP binds and claims
them; the executing PEP reverifies.¶
Required members: action.properties.parameter_digest and,
conditionally, action.properties.idempotency_key
(Section 5.7); the response conditions.parameter_digest
and, for the high-consequence classes, conditions.use_limit: 1
(Section 6.1.1).¶
Absence: for the parameter-bound and high-consequence classes, the runtime profile makes exact parameter binding and single use mandatory, so a PEP and a PDP MUST support this feature profile for those classes and the PDP MUST advertise its capability URN (Section 8.1). The Decision Base alone does not conform for those classes, and a PEP whose PDP does not advertise the URN fails closed. The Decision Base checklist repeats the conditional enforcement duties these members carry (Section 8); the capability URN declares support for this feature profile's complete applicable contract. Outside those classes, it is optional.¶
Assurance: exact operation and parameter binding with replay and duplicate-execution protection (the runtime profile's transaction-assurance tier).¶
Prerequisites: the Decision Base.¶
Roles: the PDP and PEP are producers of Decision Evidence, Execution Evidence, and Refusal Records; an auditor or relying party is the verifier ([I-D.draft-mcguinness-mission-runtime-evidence]).¶
Required members: none beyond what the Decision Base carries on the wire; the records are populated from the base's request and response members (Section 7).¶
Absence: the runtime profile's baseline still requires an evidence record for every decision ([I-D.draft-mcguinness-mission-runtime]). A Decision-Base-only deployment may satisfy that with its own internal record, never with this feature profile's portable schema, and MUST NOT represent an internal record as the portable schema. A deployment composes this feature profile when it needs decision or execution evidence portable to a verifier it does not operate.¶
Assurance: portable, independently verifiable Decision, Execution, and Refusal evidence (the evidence requirement of the Runtime-Enforced Mission Assurance Level, [I-D.draft-mcguinness-mission-architecture]).¶
Prerequisites: the Decision Base.¶
Roles: the PDP attaches an obligation; the PEP fulfills it or fails closed (Section 6.2).¶
Required members: the response obligations array.¶
Absence: a PDP that never attaches an obligation composes nothing.
Fail-closed handling of an obligation the PEP does not recognize or
cannot fulfill is a Decision-Base rule regardless. This feature
profile adds specific obligation types (the step-up obligation) and
the supported_obligations advertisement.¶
Assurance: mandatory PEP-side work under an existing decision, with no second grant and no governance adjudication.¶
Prerequisites: the Decision Base; an Access Request Service in the trusted base (Section 9.2).¶
Roles: the PDP marks a denial requestable; the PEP submits the access request and re-evaluates; the Access Request Service adjudicates (Section 6.6).¶
Required members: the response access_request, next_action, and
retry_after; the request context.approval on a fresh
evaluation.¶
Absence: a deployment that does not compose ARAP never marks a denial requestable; the denial is terminal for the attempted action, as under the Decision Base.¶
Assurance: demand-driven, runtime-initiated authority requests without a standing grant.¶
Prerequisites: the Decision Base; the runtime profile's
runtime.history-input capability
([I-D.draft-mcguinness-mission-runtime]).¶
Roles: the PDP evaluates a policy-selected predicate against its
evidence store; the PEP optionally supplies evidence_reference or
attribute_values in context.mission_history (Section 5.17).¶
Required members: the optional request object
context.mission_history and the Decision Evidence
mission_history extension, which the PDP computes.¶
Absence: a deployment that does not declare history evaluation in its Enforcement Scope Statement never receives a history-dependent denial. Where deployment or Resource policy requires a history predicate, the PDP still fails closed under the runtime profile's rule when this feature profile is absent.¶
Assurance: sequence-aware decisions, where an action's authorization depends on where the undertaking stands, not only on the request in isolation.¶
Prerequisites: the Decision Base.¶
Roles: the PEP submits a boxcar; the PDP evaluates every item under
execute_all semantics (Section 5.22).¶
Required members: the AuthZEN evaluations array; this feature
profile defines no member of its own.¶
Absence: a deployment that never batches submits one evaluation per action, at the same enforcement strength.¶
Assurance: transport amortization only, never a change in per-item enforcement semantics.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
Two member-presence conventions extend that vocabulary:¶
The member is present when the stated condition holds and absent otherwise. The condition accompanies each member so marked.¶
The sender includes the member when it holds the member's value. A receiver MUST NOT infer meaning from the member's absence.¶
JSON [RFC8259] is the data model for all PDP requests, responses, and
evidence objects. Where this document computes an integrity hash, it
uses JCS [RFC8785] under the canonicalization rules of
[I-D.draft-mcguinness-oauth-mission] and defines no second
canonicalization. "SHA-256" refers to [RFC6234]. A digest is encoded
in the integrity-anchor encoded form of
[I-D.draft-mcguinness-oauth-mission]: sha-256: followed by the
base64url, no-padding encoding of the digest. The canonical projections
of Section 5.18 are canonical-object digests under the substrate's
default commitment construction, which this document imports
normatively ([I-D.draft-mcguinness-mission-substrate]).¶
This document uses the following terms as defined in [I-D.draft-mcguinness-mission-runtime]: Policy Enforcement Point (PEP), Policy Decision Point (PDP), consequential action, Resource policy, decision, Mission state source, enforcement scope, high-consequence classes, parameter-bound, Operation Profile, Enforcement Scope Statement, materialized policy view, trusted compiler, and the action-class names (consequential read, consequential write, irreversible action, external commitment, and privileged administration). It also uses:¶
Mission reference (id, issuer): a binding's Mission Reference
identifier and Controller namespace, in the representation that
binding defines. The OAuth realization is the Mission claim of
[I-D.draft-mcguinness-oauth-mission].¶
Authority Set, Approver, and the authority_hash integrity anchor,
as defined in [I-D.draft-mcguinness-oauth-mission].¶
mission_resource_access: the authorization_details type of the
Mission Resource Access Profile
([I-D.draft-mcguinness-oauth-mission-resource-access]).¶
Effective Authority Set: as defined in [I-D.draft-mcguinness-oauth-mission-status].¶
Decision Evidence, Execution Evidence, and Refusal Record: the records the PDP and PEP emit for a decision, an execution outcome, or a pre-decision refusal, as defined in [I-D.draft-mcguinness-mission-runtime-evidence].¶
HTTP message examples follow [AUTHZEN] for the decision request and response, and [RFC9457] for problem-details error bodies where a deployment carries them outside the AuthZEN envelope.¶
Where the PDP evaluates a Mission against an action through a
materialized policy view, the runtime profile defines the view, its
trusted-compiler and reproducibility rules, its bounded-fidelity
property, and the content-addressed policy_view_id with its
mission-policy-view integrity envelope
([I-D.draft-mcguinness-mission-runtime]). A PDP that evaluates the
Mission's recorded authority directly meets that profile's authority
input (its Section "Authority") without a view, and its requests omit
policy_view_id.¶
The trusted compiler computes the view's envelope, and the
authority_hash it binds, from its own held Mission record. The OAuth
binding's baseline mission claim does not carry authority_hash
([I-D.draft-mcguinness-oauth-mission]), so the consistency check
between a decision request and the loaded view is an equality test on
mission_id and issuer alone, with policy_view_id as the optional,
stronger content check where the requesting PEP holds it
(Section 5.20).¶
This profile carries policy_view_id only in the request, at
context.mission.policy_view_id (Section 5.4). The PDP does not
echo it on the response. Where the PDP evaluates through a view, it
records that view in Decision Evidence
([I-D.draft-mcguinness-mission-runtime-evidence]); evaluation_id
(Section 6.1), not a view identifier, correlates a permit or a
denial with its evidence.¶
The PDP need not be remote. A PDP embedded in or colocated with its PEP, evaluating against a loaded materialized policy view, is a conforming deployment; the decision's network cost is then paid per freshness window rather than per action.¶
This profile does not define a policy-language wire form for the materialized view. Implementations MAY use canonical input bundles the AuthZEN PDP consumes directly, or an engine-native artifact. Compiling a Mission into an engine-native policy artifact and standardizing a policy-view carriage format are out of scope ([I-D.draft-mcguinness-mission-runtime]).¶
The PDP request carries the runtime profile's decision inputs in the
OpenID AuthZEN Authorization API envelope [AUTHZEN], per the AuthZEN
request model: action-scoped members in action.properties,
resource-scoped members in resource.properties, and evaluation-wide
members in context. This profile does not change which inputs the
PDP evaluates; the runtime profile defines them.¶
This profile is used after ordinary access-token validation under [I-D.draft-mcguinness-mission-runtime]: the PEP MUST NOT ask a PDP to authorize an action from unverified token claims, and the PEP-PDP channel MUST be integrity-protected and mutually authenticated as that profile requires.¶
| AuthZEN member | Mission-bound content |
|---|---|
subject
|
The principal the decision is requested for. |
resource
|
type/id carry the fine-grained object identity the action names (for example, a specific journal entry), for Resource-policy evaluation; properties carries resource-scoped members, including operation_target (Section 5.2), audience (Section 5.11), and, where a resource contract applies, resource_contract (Section 5.3). Only operation_target is matched against an entry's resource. |
action
|
name is the requested action identifier (for example, journal-entries.write), which the PDP evaluates against the approved actions per [I-D.draft-mcguinness-oauth-mission]; properties carries action-scoped members (Section 5.7). |
context
|
Carries the Mission-bound, evaluation-wide members defined below. |
The runtime profile's Authority Set check matches the action's resource
and action identity against an entry's resource and actions
([I-D.draft-mcguinness-mission-runtime]). For a
mission_resource_access entry, the action's resource is the operation
target in resource.properties.operation_target
(Section 5.2).¶
A PDP MUST match each such entry's
resource against that target under
[I-D.draft-mcguinness-oauth-mission-resource-access], Section
"Resource Matching", in the credential's authority
(Section 5.6), in the current effective authority
([I-D.draft-mcguinness-mission-runtime]), and in any other
mission_resource_access authority bound it applies. A PDP MUST NOT
match an entry against resource.properties.audience, resource.type
or resource.id, or substitute any of them for the operation target.¶
Audience validation (Section 5.11) and
Resource-policy evaluation of type and id remain separate checks,
and the action, constraint and delegation checks remain independent of
the target match.¶
The AuthZEN subject is the Subject the Mission's authority is
exercised for. It does not change under delegation: the acting agent's
client_id and any act delegation chain are carried in
context.actor (Section 5.5), never in subject. The PDP binds
the permit to subject together with the actor context, and the
confused-deputy check ([I-D.draft-mcguinness-mission-runtime])
re-verifies that the action is for the same Subject it was authorized
for.¶
subject.type is user unless the deployment profiles another value.
subject.id is the credential's authenticated subject identifier (the
OAuth realization is the token's sub claim). subject.properties.iss
is REQUIRED when known (Section 3), carrying the
issuer that authenticated the Subject, so a sub is disambiguated
across issuers; a PEP that cannot establish the Subject's issuer omits
it.¶
operation_target:REQUIRED for an action evaluated against mission_resource_access
authority. A string, carried at
resource.properties.operation_target, holding one absolute URI
(Section 4.3 of [RFC3986]): the operation target of
[I-D.draft-mcguinness-oauth-mission-resource-access], Section
"Resource Matching", which identifies the resource the operation
acts on.¶
The authenticated PEP establishes the target from the trusted operation contract of the resource it enforces for and from the operation's validated arguments, as that section requires of a resource server. The PEP MUST NOT derive the target from the credential's entries, the Mission's entries, or a target value the caller asserts. A PEP that cannot establish one unambiguous target MUST refuse the operation before requesting a decision (Section 6.8).¶
The PDP checks the target's syntax (Section 5.20) and
passes the received string to the matcher unchanged: an exact match
compares that string, never a parsed and reserialized form, and a
prefix match applies only the comparison normalization of
[I-D.draft-mcguinness-oauth-mission-resource-access].¶
The operation target is part of the operation identity, the
authorization binding and the cache key (Section 5.18). A permit is
therefore never reused for another target, even when the audience,
the action, resource.type and resource.id are equal, and the PEP
executes the operation only on the target the permit was evaluated
for (Section 6.9).¶
resource_contract:CONDITIONAL. An object, carried at
resource.properties.resource_contract: the id, version, and
digest of the resource contract under which the PEP will perform the
operation. REQUIRED when a resource contract applies to the action
([I-D.draft-mcguinness-mission-runtime], Section "Resource
Contract").¶
The PEP establishes the reference from the applicable entry's
reference, resolved against its own trusted contract declarations, and
never from a value the caller asserts. The PDP MUST deny the action
with resource_contract_drift unless the reference resolves under the
PDP's own trusted declarations and equals, member for member, the
reference of an applicable entry that authorizes the action. An absent
member where a contract applies is denied the same way.¶
The reference is part of the authorization binding and the cache key
(Section 5.18), so a permit is never reused under another contract.
Because it is a member of the resource object, it is also part of
the approved Resource an ARAP approval binds (Section 5.16).¶
The mission member identifies the governance record and its current
materialized view. It carries authority identity only: current Mission
state and its freshness are carried separately, in
context.mission_state_observation (Section 5.11),
so a change in state never mints a new policy_view_id
(Section 4).¶
id:REQUIRED. A string. The Mission Reference identifier, in its
binding's representation (the OAuth realization is the Mission's
id).¶
issuer:REQUIRED. A string containing a URI. The Mission Reference's
Controller namespace, in its binding's representation (the OAuth
realization is the Mission's issuer). It is not the credential's
issuer, which context.credential.issuer carries
(Section 5.6).¶
authority_hash:OPTIONAL. A string. The Authority Set integrity anchor, in the
integrity-anchor encoded form ([I-D.draft-mcguinness-oauth-mission]).
The OAuth binding's baseline mission claim and default
introspection projection do not carry it. A PEP includes it only
where it holds it under the Local Approved-Set Verification profile
([I-D.draft-mcguinness-oauth-mission-approved-set-verification],
Section "Local Approved-Set Verification") or introspection's
disclosure privilege ([I-D.draft-mcguinness-oauth-mission]). The
mandatory identity check (Section 5.20) does not depend
on it; a PDP that receives it and independently verifies it MAY use
it as a further audit correlator, never as a substitute for that
check.¶
policy_version:REQUIRED when known. A string. The policy_version recorded at the
approval event. It is a Mission-record field
([I-D.draft-mcguinness-oauth-mission]) not carried on the mission
claim or the introspection projection, so a PEP that is not
co-located with the Mission record may not have it; such a PEP omits
it and relies on policy_view_id for view correlation.¶
policy_view_id:OPTIONAL. A string. The materialized view identifier (Section 4). The PDP is authoritative for the current view, so a PEP need not supply it; a PEP that has the value supplies it, and the PDP checks it as Section 5.20 specifies.¶
subject:OPTIONAL. A closed object with exactly iss and sub: the
Mission's origin principal, value-unchanged from the Mission
record, per the cross-domain profile's Origin Principal rules
([I-D.draft-mcguinness-oauth-mission-cross-domain]). REQUIRED for
a request claiming that profile. The PEP populates it only from a
verified token or delegation chain, or from trusted local token
metadata, never from an unverified request value. The PDP relates it
to the request subject only through the origin-principal mapping
check (Section 5.20), never by direct comparison. The
AuthZEN subject (the authenticated local token subject), this
member (the origin principal), and context.actor (the acting
lineage) remain distinct roles even when two identifiers are equal.¶
id and issuer anchor the Mission's approved Authority Set, resolved
against the materialized policy view the PDP loads for that Mission
(Section 4); authority_hash, where a PEP
carries it, is an audit correlator, not the anchor. Where a Mission
runs a narrowing mechanism, the PDP evaluates the request against the
Effective Authority Set ([I-D.draft-mcguinness-oauth-mission-status]),
not the approved set alone, per the runtime profile's Authority
decision input ([I-D.draft-mcguinness-mission-runtime]). The
Containment profile is one such mechanism
([I-D.draft-mcguinness-oauth-mission-containment]). This document
defines no member carrying the Effective Authority Set's evaluated
state.¶
A companion profile MAY extend the mission context with the member it
needs, by specification. An extension member name MUST be a
collision-resistant name or a name coordinated within this document
family, as for denial reasons (Section 6.5), and
a PDP that does not recognize an extension member does not apply the
subtraction carried only by that member.¶
A denial produced against the Effective Authority Set carries its
narrowing mechanism's own denial reason, not out_of_authority. For
example, the Containment profile's authority_contained denies
capability the Approver granted and the issuer later removed, a
distinct history from capability never approved
([I-D.draft-mcguinness-oauth-mission-containment]).¶
The actor member carries the authenticated actor context when
delegation is in effect, reconstructed from the credential's
actor-delegation chain and authenticated client identity (the OAuth
realization is the access token's act claim and its authenticated
client identity, [I-D.draft-mcguinness-oauth-mission]):¶
client_id:REQUIRED when known. A string. The authenticated client identity.¶
client_instance_id:OPTIONAL. A string. A deployment-defined client-instance correlator when the PEP can establish one.¶
act:OPTIONAL. An array of objects. The delegation chain projection, ordered root to leaf. For a single actor, the array has one member.¶
The actor member carries the delegation chain only. Provenance beyond
the delegation chain (the tool a request invoked, a named workflow
step, a human approver) MUST NOT be encoded inside the act chain;
the PDP evaluates the act chain as defined by the runtime profile,
and provenance is recorded in dedicated evidence fields where the
deployment captures it.¶
Where tokens carry Instance Context
([I-D.draft-mcguinness-oauth-client-instance-id]), the PEP can set
client_instance_id from it once it has validated that context as a
Context Consumer
(Section 7.5 of [I-D.draft-mcguinness-oauth-client-instance-id])
and established its association with the current presenter.
The PEP MUST NOT populate context.actor.client_instance_id from
context that establishes only upstream instance participation.¶
The correlator represents the pair (iss, id) without collisions
across the Instance Context Authorities accepted by the PDP and its
evidence consumers, including when separate PEPs each accept only one
authority. Attributing the presentation requires the association with
the presenter that
Section 7.5 of [I-D.draft-mcguinness-oauth-client-instance-id]
establishes: a sender-constraint key
unique to the instance
(Section 7.3 of [I-D.draft-mcguinness-oauth-client-instance-id])
where the token issuer conveys context only from direct Client
Attestation validation, and authenticated provenance where it may
preserve context from an input token. Decision Evidence then records
which instance acted, and Execution Evidence does through the
evaluation_id link, without new members.¶
The credential member carries credential-derived facts the PEP has
already validated and that the PDP needs to enforce the runtime
decision's time, issuer, sender-constraint, and credential authority
checks:¶
issuer:REQUIRED when known. A string containing a URI. The credential issuer.¶
expires_at:REQUIRED when the credential carries an expiry. An RFC 3339
[RFC3339] timestamp corresponding to the credential's expiry (the
OAuth realization is the token's exp claim,
[I-D.draft-mcguinness-mission-runtime-oauth]).¶
confirmation:OPTIONAL. An object. A sender-constraint confirmation value or digest of that value, included only after the PEP has verified the proof-of-possession check for the presented credential.¶
authority:REQUIRED. An array of authorization_details entries: the
authority the verified credential itself carries, the credential
authority of [I-D.draft-mcguinness-mission-runtime]. For a
Mission-bound token it is the token's own entries; for an ordinary
token joined to a Mission it is the authority that token carries as
issued, as the join profile establishes it
([I-D.draft-mcguinness-mission-runtime-oauth]).¶
The PEP MUST NOT include unverified credential claims in this member.¶
The PDP evaluates the action against authority independently of the
Mission entry it matches:¶
The action MUST fall within one entry of authority as a whole: its
resource, its actions, and every constraint it carries.¶
The PDP MUST NOT substitute the Mission's Authority Set, or any other
record of Mission authority, for authority.¶
A condition on that entry that the PDP cannot establish from its own state does not permit, and an action-approval requirement on it applies as one on the matched Mission entry does (Section 5.16).¶
An action that no entry of authority names by resource and action
is denied out_of_authority. An action that entries name, but whose
parameters violate a constraint on each of them, is denied
parameter_violation, as on the matched Mission entry
(Section 6.5). Decision Evidence's
authority_bound names which bound decided either deny
(Section 7).¶
A request whose authority is absent, or carries an entry the PDP
cannot evaluate in full, is denied credential_invalid, and the PDP
MUST NOT fall back to the Mission's authority. This profile
deliberately requires the credential's entire authority description
to be evaluable, so an unevaluable credential entry invalidates the
request even when another entry could authorize it under Resource
Access's alternative-entry rule
([I-D.draft-mcguinness-oauth-mission-resource-access]). That is this
profile's credential validation policy; the prohibition on falling
back to the Mission's authority does not by itself require it. An
entry the PDP evaluates and finds unsatisfied invalidates nothing:
another complete entry of authority still authorizes the action.
The policy has an interoperability cost: adding an entry a PDP cannot
evaluate makes the credential unusable at that PDP.¶
When parameter binding is required for the requested action's class
under [I-D.draft-mcguinness-mission-runtime], the PEP supplies, in
the AuthZEN action object's properties (action.properties), the
following action-scoped members:¶
parameters:CONDITIONAL. An object. When present, it MUST be the
operation-profile-normalized parameter object
([I-D.draft-mcguinness-mission-runtime]): the same bytes the
parameter_digest is computed over, so the PDP's recomputation
matches. The shape is action-specific.¶
The PEP MAY omit parameters and supply only parameter_digest
where the raw values are sensitive
([I-D.draft-mcguinness-mission-runtime-evidence]), but only when
the PDP can still enforce the applicable parameter policy from the
digest, the supplied parameter_attributes, or local state. If the
PDP needs raw parameter values to evaluate an applicable constraint
and they are supplied through neither parameters nor the
equivalent privacy-preserving parameter_attributes, it MUST deny
with parameter_violation.¶
parameter_digest:REQUIRED for parameter-bound classes. A string. The
parameter_digest defined by [I-D.draft-mcguinness-mission-runtime],
carried on the wire with no second digest or canonicalization. The
PDP recomputes it over any supplied parameters, and the executing
PEP recomputes and reverifies it immediately before acting, both as
the runtime profile requires.¶
idempotency_key:CONDITIONAL. A string, distinct from parameters and
parameter_digest. REQUIRED where the Operation Profile defines one
for the action: the idempotency key the Operation Profile requires
for a non-idempotent action in the high-consequence classes
([I-D.draft-mcguinness-mission-runtime]). It identifies one
intended execution of one normalized request, so a legitimate
re-execution mints a new key. The PDP processes it as
Section 5.7.1 specifies.¶
parameter_attributes:OPTIONAL. An object. Privacy-preserving attributes derived from the
action parameters that the PEP supplies for constraint evaluation
when it withholds raw parameters
([I-D.draft-mcguinness-mission-runtime-evidence]). It is the wire
carriage of the derived attributes the runtime profile's privacy
carve-out relies on ([I-D.draft-mcguinness-mission-runtime]); each
member is a deployment-defined attribute the applicable constraints
evaluate against. A constraint the PDP cannot evaluate from
parameter_digest, parameter_attributes, or local state MUST fail
closed.¶
The PDP handles an idempotency_key by action class:¶
For a key in the irreversible-action, external-commitment, or
privileged-administration classes, the PDP atomically claims the
pair (idempotency scope, idempotency_key) together with the
request's operation identity (Section 5.18) before issuing a
permit ([I-D.draft-mcguinness-mission-runtime]).¶
For a reversible consequential write's key, the PDP makes no claim, and the enforcing PEP or resource deduplicates instead ([I-D.draft-mcguinness-mission-runtime]).¶
A claim resolves per the runtime profile's idempotency claim-state table:¶
While the claim is unresolved, a matching key and operation identity
is a transient duplicate_suppressed
(Section 6.5), carrying next_action: retry
with the reconciliation window as its retry_after guidance
(Section 6.1).¶
Once the operation completes, a matching key and operation identity
is a terminal duplicate_suppressed, carrying next_action: none.
The prior result is available from the resource under the Operation
Profile, never re-executed and never replayed by a fresh PDP
decision.¶
When the same key instead matches a prior claim under a different
operation identity, the reuse is a conflict, never a new execution:
the PDP MUST deny with idempotency_conflict
(Section 6.5), terminal in every claim state.¶
Reuse of an idempotency_key never yields a second execution within
the deployment's declared idempotency horizon, which for the
high-consequence classes is backed by a durable consumed-key tombstone
([I-D.draft-mcguinness-mission-runtime]). An intentional re-execution
is a new operation under a new key, which an action-bound approval MAY
authorize as such, never as re-execution under the consumed key.¶
context.action_phase is CONDITIONAL: REQUIRED when the PEP's trusted
Operation Profile identifies the operation as a phase of a compound
action ([I-D.draft-mcguinness-mission-runtime]). Its value is a string
from the closed set preflight, prepare, commit, or compensate.
The PEP MUST derive the value from that profile, never from an
agent-supplied argument. The PDP MUST refuse, before evaluation, a
request whose action_phase is outside this set, or is absent where
its trusted operation declaration requires a phase
(Section 6.8), and MUST return the validated phase
as conditions.action_phase on a permit. Decision Evidence records the validated phase and omits
malformed input ([I-D.draft-mcguinness-mission-runtime-evidence]).¶
The request member communicates the phase being evaluated; it is not a
permit binding, and neither it nor Decision Evidence's action_phase
substitutes for the permit condition (Section 6.1.1). If the
PEP cannot establish the phase before requesting a decision, it MUST
refuse locally without requesting or using a permit;
Section 6.8 defines the carrier.¶
context.compensates_evaluation_id is CONDITIONAL: REQUIRED on a
request whose action_phase is compensate. Its value is a string
with the syntax of evaluation_id (Section 6.1): the
evaluation identifier of the Decision whose committed effect the
operation offsets ([I-D.draft-mcguinness-mission-runtime]).¶
The PEP MUST establish the value from retained, verified evidence of
that committed effect and of the Decision it executed under, taking
that Decision's evaluation_id, and MUST NOT take it from an
agent-supplied argument. An agent MAY identify the effect it asks to
offset; the PEP resolves that identification against its own evidence.
A PEP that cannot establish the link MUST refuse before requesting a
decision (Section 6.8).¶
The PDP checks the member (Section 5.20) and records the
validated value as Decision Evidence's compensates_evaluation_id, on
a permit or a denial, omitting malformed input
([I-D.draft-mcguinness-mission-runtime-evidence]). The member is not
a permit condition and confers no authority: the compensation is
evaluated as its own action, and the compensated action's permit never
authorizes it ([I-D.draft-mcguinness-mission-runtime]).¶
For an operation covered by the runtime profile's optional
Evaluation-Context Binding extension, the PEP MUST supply
context.evaluation_context_digest and
context.evaluation_context_binding.¶
evaluation_context_digest is the prefixed canonical-object digest
of the captured context. It is an observation the PDP echoes, not
one it can recompute without the PEP's secret salt and authoritative
resolved facts.¶
evaluation_context_binding is the versioned descriptor reference
{id, version, digest} defined by
[I-D.draft-mcguinness-mission-runtime], committed inside the
context digest. Granularity belongs to the referenced descriptor's
individual facts, not a scalar wire mode.¶
These inputs come from the authenticated PEP authorized for the enforcement scope, never from agent arguments. The PDP MUST validate their shape and applicability against the declared operation binding, and MUST NOT issue a covered permit when either is missing, malformed or incompatible with that declaration; it refuses such a request before evaluation (Section 6.8). Policy-evaluable values still travel in the existing parameter or attribute inputs.¶
The extension is claimed per class: neither input becomes mandatory for an operation outside its declared scope, and existing permit lifetime, single-use, phase, and parameter bindings are unchanged.¶
audience:REQUIRED. A string. Carried at resource.properties.audience
(Section 5.1). The boundary identifier of the enforcement
boundary the PEP established for the request, byte for byte
([I-D.draft-mcguinness-mission-runtime], Section "Enforcement
Boundary Identifier"); on OAuth, the protected resource's
identifier, never an aud value or alias
([I-D.draft-mcguinness-mission-runtime-oauth]). Entries are matched
against operation_target, never this member (Section 5.1).¶
mission_state_observation:CONDITIONAL. An object, carried at context.mission_state_observation.
REQUIRED where the deployment's declared state-source placement has
the PEP supply state; absent where state establishment is placed
with the PDP, whose obligation the PDP-side consistency checks state
(Section 5.20). It consolidates the PEP's Mission-state
observation and its freshness into one snapshot, conveying the
runtime profile's state and freshness inputs on the wire. It is the
carrier for a PEP-supplied observation, never a substitute for a
state source the PDP can itself consult (Section 5.20).
Members:¶
state:REQUIRED. A string. The current Mission lifecycle state the PEP established from its Mission state source ([I-D.draft-mcguinness-mission-runtime]).¶
termination:OPTIONAL. An object. The Mission's termination
([I-D.draft-mcguinness-oauth-mission], Section "Mission
Termination") when state is terminated; absent otherwise.¶
version:OPTIONAL. An integer. The Mission's state version as the status profile defines it ([I-D.draft-mcguinness-oauth-mission-status]), populated where the PEP holds it. The PDP compares it with its own tracked state version (Section 5.20).¶
mode:REQUIRED. A string. One of fresh, cached, or event_driven
(Section 5.11.1).¶
freshness_at:REQUIRED in every mode. An RFC 3339 [RFC3339] timestamp. When the PEP's view of the Mission state was current.¶
mission_status_issued_at:REQUIRED for cached and event_driven, OPTIONAL for fresh. An
RFC 3339 timestamp. When the relied-on Mission state was issued:
for a signed Mission Status Response, the RFC 3339 representation
of its iat, a NumericDate
([I-D.draft-mcguinness-oauth-mission-status]). freshness_at
can precede this value by no more than the published maximum
clock skew (Section 5.21).¶
mission_status_expires_at:REQUIRED for cached and event_driven, OPTIONAL for fresh. An
RFC 3339 timestamp. When reliance on the observed Mission state
ends: for a signed Mission Status Response, its
mission.fresh_until, never its exp, or an earlier end
deployment policy sets; for a lease, the lease's end.¶
assertion:OPTIONAL. A string. The signed Mission Status Response
[I-D.draft-mcguinness-oauth-mission-status] the PEP obtained
state and version from, when the PEP holds one, so the PDP
can verify the snapshot instead of trusting an unsigned PEP
assertion.¶
The runtime profile defines the Mission state source, the deployment's
maximum staleness bound, and the rule that a consequential action fails
closed when the Mission cannot be established as active within that
bound ([I-D.draft-mcguinness-mission-runtime]);
mission_state_observation is only their wire representation. Its
mode member records how the PEP obtained the state:¶
fresh:The PEP consulted the Mission state source synchronously before the action.¶
cached:The PEP used cached Mission state within the deployment's staleness bound.¶
event_driven:The PEP relies on event-channel invalidation, but the cached state
remains bounded by the deployment's staleness bound, or the lease
the state carries, exactly as for cached; it is not valid
indefinitely. A missed or delayed invalidation event does not extend
validity, and when the bound elapses without a confirming event the
PEP MUST refresh from a Mission state source rather than continue on
the cache.¶
When freshness cannot be established within the bound, the PDP fails
closed for consequential actions as the runtime profile requires, with
a stale_state denial (Section 6.5).¶
external_communication:CONDITIONAL. A boolean, carried at
action.properties.external_communication alongside the other
action-scoped members (Section 5.7). A registered extension
point owned by the harness profile
([I-D.draft-mcguinness-mission-harness]), which defines the
predicate and how the PEP computes it. REQUIRED for every action to
which a class applies for which the deployment declares PDP-enforced
taint; OPTIONAL otherwise.¶
taint:OPTIONAL, carried at context.taint. A registered extension point
owned by the harness profile
([I-D.draft-mcguinness-mission-harness]), which defines the
member shape (tainted, granularity, source_class) and the
taint-state trust rules. Where the deployment's Enforcement Scope
Statement declares PDP-enforced taint for a class that applies to
the action ([I-D.draft-mcguinness-mission-runtime], Section
"Action Classification"), the fail-closed default applies: the PDP
MUST deny with taint_context_missing
(Section 6.5) when context.taint is absent
from an in-scope decision.¶
protected_data:OPTIONAL, carried at context.protected_data. A registered
extension point owned by the harness profile
([I-D.draft-mcguinness-mission-harness]), which defines the member
shape (exposed, established_by), the establishing layer's
attachment the PEP populates it from, its reading when absent, and
the exposure qualification it can satisfy. It never relaxes the
fail-closed default of context.taint (Section 5.13).¶
work_item:OPTIONAL, carried at context.work_item. A registered extension
point owned by the harness profile
([I-D.draft-mcguinness-mission-harness]), which defines the
qualified work-item identifier and its attacher. An object with
exactly two members, both strings: issuer, the URI of the harness
that issued the identifier, and id, that harness's identifier for
the work item.¶
The PEP populates context.work_item only from the harness's
authenticated attachment: the work item a verified Mission reference
carries, for the attacher the Enforcement Scope Statement declares for
the authenticated client ([I-D.draft-mcguinness-mission-harness]).
A reference that verifies does not by itself establish that
attachment, and the PEP never takes a work item from tool arguments or
another value the agent supplies.¶
The PDP MUST refuse, before evaluation, a request whose
context.work_item is present but not of that shape: an unusable
input, recorded as the Refusal Record work_item_invalid
(Section 6.8), never an evaluated denial. Where
the deployment's Enforcement Scope Statement claims work-item
attribution for a class that applies to the action, the PDP MUST deny
with work_item_context_missing
(Section 6.5) a decision from which
context.work_item is absent. Elsewhere its absence relaxes nothing,
and the deployment claims Mission-level attribution only.¶
The member is part of the authorization binding and the cache key
(Section 5.18), so no cached decision or resumed execution crosses
work items, and a permit for a decision that carried it binds it as
the work_item condition (Section 6.1.1).¶
The OPTIONAL approval member is carried at context.approval on a
fresh evaluation after an access request is approved. The PEP returns
here exactly the approval object the Access Request Service issued:
ARAP's approval object [ARAP] unchanged, with all of ARAP's
members. ARAP makes approved_at OPTIONAL and approved_until
REQUIRED; this profile does not subset or rename either.¶
On top of ARAP's own requirements, before treating context.approval
as satisfying approval_required, the PDP MUST additionally
establish the Mission checks: that the approval binds to the
request's parameter_digest (a mismatch means the approval does not
cover these parameters), that its grant time is within the
deployment's maximum approval age
([I-D.draft-mcguinness-mission-runtime]), and that approved_until
has not passed.¶
This profile requires a verifiable completion time for an action-bound
approval: approved_at when present, otherwise the PDP MUST establish
the grant time from the approval record it resolves by id or from
verified signed state. An approval whose completion time cannot be
established is treated as unverifiable. An approval that fails a
Mission check, or whose completion time cannot be established, does
not satisfy the denial.¶
Where a resource contract applies to the action
(Section 5.3), the approval binds its reference
through the approved Resource, which ARAP requires the approval record
or its binding material to contain or let the PDP determine
([ARAP], Section 12.3.1). The Mission checks then also establish
that the approved Resource's properties.resource_contract equals the
request's, member for member. An approval given under one reference does
not cover an action under another, even when both references resolve:
the PDP MUST deny that re-evaluation with ARAP's out_of_scope, which
ARAP defines for a valid approval whose scope the current evaluation
falls outside ([ARAP], Section 8.2).¶
The PDP MUST record the presented approval id in Decision Evidence.
The approval is an input attribute, never a bearer grant: the PDP
evaluates current policy and current state.¶
When policy requires an action-bound approval and no context.approval
is presented, the PDP MUST deny with approval_required
(Section 6.5). When a re-evaluation that
presented context.approval fails a Mission or ARAP check, the PDP
instead returns one of ARAP's five registered re-evaluation reasons in
context.reason, with ARAP's default next_action for each:¶
approval_expired (request);¶
out_of_scope (request);¶
grant_pending (retry);¶
policy_denied (none);¶
approval_unverifiable (none), which also covers an approval
whose completion time cannot be established.¶
These are ARAP-owned values carried under its extensibility rule [ARAP], not values this profile defines.¶
Which history predicates a decision requires is a policy decision: the materialized policy view, or the PDP's own policy, names the predicates it evaluates for the action. The request does not select them; a requester able to choose which history a decision turns on could pick predicates favorable to it.¶
This document defines one predicate type that policy MAY name,
action_class_completed. It is satisfied when the PDP's evidence store
holds, for the established Mission, at least one Decision Evidence
record with decision permit to which the named class applied, and
every such permit has a completion witness: a linked Execution
Evidence record ([I-D.draft-mcguinness-mission-runtime-evidence])
whose outcome is completed and in which each authorized digest
present (authorized_parameter_digest,
authorized_evaluation_context_digest) has an equal effective
counterpart (effective_parameter_digest,
effective_evaluation_context_digest). The named class applied to a record when its
action_classes member lists that class or, in a record without
action_classes, its action_class is that class, so an execution
the class applied to counts whichever class was assigned. The
predicate carries an action_class: a runtime action
class name, from the same value space as the Decision Evidence
action_class member
([I-D.draft-mcguinness-mission-runtime-evidence]). For a migration
Mission whose copy steps are consequential writes, policy names the
delete step's precondition this way:¶
{
"predicate": "action_class_completed",
"action_class": "consequential_write"
}
¶
The predicate is per permit: a permit has a completion witness when
any of its executions is one, so a failed use of a multi-use permit,
or a replay suppressed as permit_consumed, does not remove it. A
predicate that requires every use of a permit to complete is a
different predicate type.¶
A single-use permit has one authorized completion
([I-D.draft-mcguinness-mission-runtime-evidence]): only the
completion that took its single use can be its witness, and any other
completed record under it creates none, whatever its digests. The
order in which records reach the evidence store does not establish
which completion took the use, nor do the records' sequence or
timestamps. Where no trusted source, such as the PEP's
consumed-identifier store, establishes it, a single-use permit with
more than one completed record has a witness only when each of them
would be one on its own, and its completion is undetermined when only
some would.¶
A completed record whose effective digest differs from its
authorized digest records an unauthorized execution
([I-D.draft-mcguinness-mission-runtime-evidence]): it remains valid
evidence, and it is not a completion witness. A completed record
that carries an authorized digest without its effective counterpart is
not a completion witness either, and a permit with such a record and
no witness has an undetermined completion. The predicate is not
satisfied when some permit has neither a witness nor an undetermined
completion, and is otherwise not establishable while any permit's
completion is undetermined. The evaluation relies on the evidence
store returning the complete, current Mission history; sequence checks
detect gaps only within the records returned
([I-D.draft-mcguinness-mission-runtime-evidence], Section "History
Completeness").¶
An extension predicate type MUST be either a collision-resistant name
or a name coordinated within this document family, under the same rule
as denial reasons (Section 6.5). The harness
profile defines the coordinated type work_item_prerequisite_completed
([I-D.draft-mcguinness-mission-harness]).¶
The OPTIONAL context.mission_history request object carries only what
the PEP can supply in support of the policy-selected predicates, never
a selection of which predicates apply. Members:¶
evidence_reference:OPTIONAL. A string. A reference to the evidence or state source the PEP consulted, when that source is not the PDP's own evidence store, so the PDP can resolve the same history the PEP saw.¶
attribute_values:OPTIONAL. An object. Precomputed values for the policy-selected predicates, supplied where the deployment permits the PEP to compute them directly, mirroring the privacy-preserving carve-out for action parameters (Section 5.7); each member is a deployment-defined attribute the applicable predicate evaluates against.¶
The PDP evaluates each policy-selected predicate against its own
evidence store, or, where the deployment's policy permits a
non-default evidence source, against the supplied
evidence_reference or attribute_values. A caller-supplied
context.mission_history value is never itself evidence of a
predicate's outcome, and carries no result member; the PDP MUST NOT
accept a predicate outcome asserted through any context member. The
request object is distinct from the Decision Evidence
mission_history member, which the PDP computes (Section 7): request
input neither chooses the required predicates nor asserts their
outcomes.¶
The PDP MUST refuse the evaluation of a policy-selected predicate it
does not recognize, treating the predicate as not establishable,
consistent with this profile's unknown-value conventions
(Section 6.5). Where deployment or Resource
policy requires a history predicate that is unsatisfied or cannot be
established, the PDP MUST deny with
history_not_satisfied (Section 6.5); the
runtime profile fixes the fail-closed posture and the evidence
store's freshness discipline
([I-D.draft-mcguinness-mission-runtime]). The PDP MUST record the
evaluated predicates and their outcomes in Decision Evidence
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
The idempotency claim (Section 5.7.1), permit retransmission and
reuse, and this profile's permit-binding rules each turn on a different
relation over the normalized evaluation request, so this section defines
three internal canonical projections. Each is sha-256: followed by the
base64url, no-padding SHA-256 [RFC6234] digest of the JCS [RFC8785]
serialization of its defined subset of the normalized request. None is a
wire parameter: an implementation computes each internally from the
request and response members it already carries.¶
The action, the resource, including its operation target (Section 5.2), and the normalized effectful parameters. This is what an idempotency key identifies one execution of.¶
The subject, the actor, the audience
(Section 5.11), the operation target, the resource
contract reference (Section 5.3),
credential-derived facts, the Mission reference, the authority and
view identity, the approval, and every policy-relevant context
input, including taint, protected_data, work_item, the
Mission history reference, the capability source, and any extension
member a companion profile adds. This is what a permit is bound to.
A new companion context member is part of the authorization binding
by default; a companion narrows it only by amending this enumeration.
It excludes only the request's volatile machinery: the
supported_obligations declaration and transport metadata.¶
The authorization binding plus the explicit state generation the
decision consulted (the PDP's tracked mission_state_version, or
an equivalent status-issuance generation marker where the
deployment does not track one), excluding observation telemetry:
freshness_at, retrieval or issuance timestamps, and other
volatile machinery.¶
State generation is cache-relevant; observation telemetry is not. A decision computed against an unchanged authorization binding and an unchanged state generation is the same decision regardless of when either side observed it, so permit retransmission and permit reuse test the cache key for equality (Section 6.9). The idempotency claim identifies one execution rather than one decision, so it tests operation identity instead ([I-D.draft-mcguinness-mission-runtime]). What a permit is bound to, and what a re-presented request must match to rely on that binding, is the authorization binding.¶
Each projection includes the operation target, so two requests that
differ only in their target differ in all three, including cacheable
reads that carry no parameter_digest.¶
In this document's ERP examples, the operation contract identifies
https://erp.example.com as the operation target
([I-D.draft-mcguinness-oauth-mission-resource-access]); actions and
constraints determine the permitted operations within that service.
The AuthZEN resource object's type and id name the object for
Resource-policy evaluation, not the operation target. The examples'
policy_view_id (sha-256:kP3xR9sQ...) differs from the runtime
profile's worked value (sha-256:RBI8j_YN...) because the two
manifests name different compilers; both are valid views of the same
Mission. In these examples, journal-entries.write is a reversible
consequential write whose deployment chooses single-use permits; that
choice, not a high-consequence class, is why its permits carry
use_limit: 1 (Section 6.1.1).¶
The following is an example of a PDP request for the ERP reconciliation Mission:¶
For an agent acting for its own workload principal, subject names
the workload principal and context.actor names the agent's client.
The token carries no act, so that client is the immediate actor
([I-D.draft-mcguinness-mission-runtime]). The subject.type value
workload is deployment-profiled. The following example shows the
ledger-reconciler agent reading an invoice:¶
A PDP that also serves non-Mission AuthZEN traffic MUST NOT downgrade:
for an action within a runtime enforcement scope it mediates, a request
whose context lacks the mission member (Section 5.4) is
malformed under this profile, and the PDP MUST refuse it rather than
evaluate it against non-Mission policy alone, and MUST record the
refusal as a Refusal Record with denial_reason
mission_context_missing
([I-D.draft-mcguinness-mission-runtime-evidence]), populating the
members the PDP itself can attest. A permit issued to an in-scope
consequential action without Mission evaluation is an enforcement
bypass, not a decision ([I-D.draft-mcguinness-mission-runtime]).¶
Likewise, where the runtime Enforcement Scope Statement declares
action classes, a mediated request that reaches the PDP with no
action class established, neither carried from the PEP's Operation
Profile nor assigned by the PDP's own trusted declaration, or carried
with a class other than the one that declaration assigns its
operation and phase, is malformed: the PDP MUST refuse it before
evaluation, MUST NOT evaluate it under a default class or record a
class in Decision Evidence, and MUST record the refusal as a Refusal
Record with denial_reason action_class_missing
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
In addition to evaluating the decision inputs the runtime profile requires, the PDP MUST verify that the AuthZEN-carried envelope is self-consistent:¶
When present, the Mission state conveyed in
context.mission_state_observation.state is exactly active; every
other value, recognized or not, is non-active per the OAuth
binding's forward-compatibility rule
([I-D.draft-mcguinness-oauth-mission]) and the PDP returns
mission_inactive (Section 6.5).¶
Where state establishment is placed with the PDP and the member is
absent (Section 5.11), the PDP MUST establish state
from its own source or deny with stale_state. A PDP with direct
access to a Mission state source MUST prefer its own fresher view
over context.mission_state_observation.state, and MUST return
mission_inactive when its view disagrees with the PEP-supplied
state. PEP-supplied state is a floor, never a substitute for a state
source the PDP can itself consult.¶
The id and issuer in context.mission equal the mission_id
and issuer committed in the materialized policy view the PDP has
loaded for this Mission, or, for a PDP that evaluates the Mission's
recorded authority directly, those of the trusted Mission record it
evaluates ([I-D.draft-mcguinness-mission-runtime]); the PDP
returns view_inconsistent on any inequality. When
context.mission.authority_hash is also present, it MUST equal
the authority_hash that view or record commits, with the same
view_inconsistent result on inequality (its omission is covered
by rule 5 below).¶
Where the PDP evaluates through a view and
context.mission.policy_view_id is present, it MUST equal
the loaded view's policy_view_id, and the PDP returns
view_inconsistent on inequality.¶
When context.mission_state_observation.version is present, the
PDP compares it against its own tracked Mission state version,
recorded in Decision Evidence rather than echoed on the response
([I-D.draft-mcguinness-mission-runtime-evidence]), never against
policy_view_id, which commits to authority only
(Section 4), and treats a mismatch as
staleness (stale_state): one side has missed a committed change.¶
A PDP MUST NOT fail a decision solely because the optional
policy_view_id, policy_version, or authority_hash was
omitted; the view the PDP loaded, or the Mission record it
evaluates directly, is authoritative.¶
When context.credential.expires_at is present, it has not passed;
otherwise the PDP returns credential_invalid.¶
The freshness the PEP supplied in context.mission_state_observation
is within the deployment's staleness bound; otherwise
the PDP returns stale_state, with the freshness-window violation
in the denial reason.¶
For an action whose class requires parameter binding
([I-D.draft-mcguinness-mission-runtime]),
action.properties.parameter_digest MUST be present; if it is absent
the PDP returns parameter_violation. When
action.properties.parameters is also present, the PDP-recomputed
digest MUST match action.properties.parameter_digest, otherwise
parameter_violation. When parameters is omitted under the privacy
carve-out, the PDP returns parameter_violation if it cannot
evaluate an applicable parameter constraint (Section 5.7). A
parameter-bound action MUST NOT be permitted without a verified
parameter_digest.¶
A deployment adopting Mission Capability Binding applies that
companion's source checks and its capability_drift extension
reason ([I-D.draft-mcguinness-mission-capability-binding]); this
profile consumes an already established action identity.¶
For a request claiming the cross-domain Origin Principal profile ([I-D.draft-mcguinness-oauth-mission-cross-domain]), the PDP establishes the mapped local principal and requires it to equal the authenticated request subject before entitlement lookup:¶
mapped_subject = map(context.mission.subject, audience, tenant, mapping_policy) require mapped_subject == (subject.properties.iss, subject.id) entitlement = lookup_current_entitlement(mapped_subject)¶
The PDP never compares context.mission.subject with the request
subject directly: the two occupy different namespaces, and only the
mapping's output is comparable. The PDP is authoritative for the
mapping in the default placement. A
deployment that instead places mapping at the PEP MUST convey it
as a structured, integrity-protected mapping observation carrying
its source, the mapping-policy identifier and version, the
issuer-qualified input, the local output, the observation time,
and a validity bound; the PDP verifies it as it verifies
context.mission_state_observation.¶
A failed, missing,
ambiguous, or stale result at either step denies with the
profile's principal_mapping_failed extension reason
([I-D.draft-mcguinness-oauth-mission-cross-domain],
Section 6.5); entitlement staleness beyond
the declared bound denies likewise. The permit and its evidence
bind to both the origin and the mapped local identity through the
principal_mapping evidence object
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
For an action evaluated against mission_resource_access
authority, resource.properties.operation_target is present, is a
string holding one absolute URI, and names a resource within the
declared enforcement scope for which the requesting PEP is
authorized ([I-D.draft-mcguinness-mission-runtime], Section
"Remote Decision Channel"). Otherwise the PDP MUST refuse the
request before evaluation, with no fallback to
resource.properties.audience, resource.type or resource.id,
and MUST record the refusal as a Refusal Record with
denial_reason operation_target_invalid
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
context.compensates_evaluation_id, when present, is a string with
the syntax of evaluation_id (Section 6.1), and it is
present when context.action_phase is compensate
(Section 5.9). Otherwise the PDP MUST refuse the
request before evaluation and MUST record the refusal as a Refusal
Record with denial_reason compensation_link_invalid
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
The following time comparisons MAY allow a small leeway to absorb
clock skew between the components: the permit's valid_until at the
PEP (Section 6.1.1); the context.mission_state_observation
freshness window and context.credential.expires_at at the PDP; and
the approval maximum age (Section 5.16).¶
Any leeway MUST NOT exceed the deployment's maximum clock skew, and the deployment MUST publish that maximum-skew assumption in its Enforcement Scope Statement ([I-D.draft-mcguinness-mission-runtime]). A value outside its window by more than the published maximum skew MUST fail closed: an expired permit, a stale freshness window, or an expired credential is refused, and the leeway never extends a permit lease or freshness lease beyond its bound plus the published skew.¶
The AuthZEN evaluations (boxcar) endpoint MAY be used to submit several Mission-bound decisions in one request. Batching is a transport optimization and changes none of the per-item enforcement semantics:¶
Each item yields its own Decision Evidence Object
([I-D.draft-mcguinness-mission-runtime-evidence]) with its own
evidence_id and sequence, assigned in request order.¶
Any metered bounds apply per item in request order ([I-D.draft-mcguinness-mission-metering]).¶
Permits are per item, so a boxcar MAY return a mix of permits and denials.¶
This profile requires execute_all semantics: every item MUST be
evaluated independently, on the same terms as a single request,
regardless of an earlier item's decision. A PDP MUST reject, as an
AuthZEN request error rather than a silent downgrade, a request
whose recognized options ask for deny_on_first_deny,
permit_on_first_permit, or any other recognized short-circuit or
fail-fast semantics. An options member the PDP does not recognize
follows AuthZEN's own rules for unrecognized options.¶
The following example is a batch request for two journal-entry writes
under the ERP reconciliation Mission, where the second exceeds the
entry's max_amount ceiling of 500.00 USD. The shared subject is
hoisted to the request's default members per [AUTHZEN]; each item
carries its complete context:¶
The response returns one decision per item, in request order; the
first is a permit and the second a parameter_violation deny, whose
failing max_amount key is listed in that item's Decision
Evidence contributing_constraints:¶
{
"evaluations": [
{
"decision": true,
"context": {
"evaluation_id": "dec_2FpQ8kV5nR1tX7mB4sJ9eL6wYc",
"conditions": {
"parameter_digest":
"sha-256:WPVi6EnQ7H9Fh-qk9ADxmTg8zruOdVUX1esl-v3TfCI",
"valid_until": "2026-11-02T08:15:00Z",
"use_limit": 1
}
}
},
{
"decision": false,
"context": {
"evaluation_id": "dec_6JwN3xT9rQ4mV8kP1sB5eZ2yLd",
"reason": "parameter_violation"
}
}
]
}
¶
An evaluation exchange carries metered and single-use consequences. Its transport behavior is as follows:¶
A PEP MUST bound each evaluation call with a timeout inside the
action class's staleness budget and treat expiry as
pdp_unreachable
([I-D.draft-mcguinness-mission-runtime-evidence]): fail closed,
never a permit.¶
A PEP MAY retry an evaluation whose response was lost, carrying the same normalized parameters and idempotency key. The runtime profile's retransmission rule then returns the prior decision where its permit is unexpired and unconsumed ([I-D.draft-mcguinness-mission-runtime]). Whether the retried request consumes a metered bound is the metering companion's rule ([I-D.draft-mcguinness-mission-metering]).¶
A PDP under overload sheds load explicitly with HTTP 429 and
Retry-After. This is transport backpressure, not an authorization
result: the PEP MUST NOT retry before Retry-After elapses, and
when no decision is obtainable within its policy window it fails
closed as pdp_unreachable under the runtime profile. A successful
evaluation that denies transiently is expressed with
context.next_action: retry (Section 6.1), never as an
HTTP error.¶
A PDP MAY publish a maximum batch size and refuse an oversized boxcar with HTTP 413; the PEP splits the batch rather than dropping items.¶
The PDP returns its permit or denial in the AuthZEN response
[AUTHZEN]: a boolean decision and an optional context object.
Runtime denials are successful evaluations, represented as
decision: false with the context members below, not as transport
errors.¶
This profile defines the following AuthZEN response context members:¶
evaluation_id:REQUIRED. A string. The correlation identifier for this evaluation,
ARAP's evaluation_id [ARAP]. ABNF:
1*64( ALPHA / DIGIT / "-" / "_" ). At least 128 bits of entropy.
Decision Evidence records this same value as its own evaluation_id
member, alongside the evidence record's distinct evidence_id
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
evaluated_at:OPTIONAL. An RFC 3339 [RFC3339] timestamp of the evaluation,
ARAP's evaluated_at member [ARAP]. RECOMMENDED on a denial that
carries access_request or next_action.¶
reason:REQUIRED when decision is false. A string: ARAP's reason
member [ARAP], with a value from Section 6.5,
including approval_required, which this profile defines, and any
specification-defined
extension under that section's extensibility rule, which also governs
an unrecognized value. A constraint violation uses
parameter_violation; the specific failing constraints keys are
carried in the Decision Evidence contributing_constraints, not
here.¶
obligations:OPTIONAL. An array of obligation objects ([AUTHZEN-OBL]), present when the decision carries a genuine attached obligation, on either a permit or a denial. The PEP processes them as Section 6.2 specifies; an obligation on a denial confers nothing and does not make the denial a permit.¶
conditions:REQUIRED when decision is true for a consequential action. An
object carrying the permit's decision conditions
(Section 6.1.1).¶
access_request:OPTIONAL. An object: ARAP's requestable-denial context object,
imported as ARAP defines it; this profile adds no members and no
additional required members. Present on an out_of_authority or
approval_required denial when the deployment exposes it as
requestable (Section 6.6). The access request the PEP
submits references the denied evaluation by the top-level
context.evaluation_id, as [ARAP] specifies. Its presence does not
change the decision: false result and does not grant access.¶
next_action:OPTIONAL on a denial. A string: request, retry, or none
([ARAP]). request MUST be accompanied by a fresh
context.access_request. retry marks the denial transient: the
same request is expected to succeed on re-evaluation after a delay.
none marks it terminal for policy and local action alike. ARAP
defines next_action for the denial of a re-evaluation that
presented an approval; this profile extends it, with identical
semantics, to any denial.¶
retry_after:OPTIONAL, only with next_action: retry. An integer: seconds the
PEP waits before re-evaluating ([ARAP]).¶
decision_evidence:OPTIONAL. An object: the complete signed Decision Evidence Object the PDP emitted for this evaluation, envelope included ([I-D.draft-mcguinness-mission-runtime-evidence]). The PDP constructs and signs it on its own emission path; a requesting PEP verifies it and retains it as received, byte for byte. Carrying it on the response does not change its treatment: it is retrospective evidence of what the PDP decided, never authorization to act (Section 6.9). The permit is the decision itself.¶
The conditions object carries the permit's decision conditions
([I-D.draft-mcguinness-mission-runtime]): declarative constraints on
relying on the permit, each evaluated at every use. Members:¶
parameter_digest:CONDITIONAL. A string. The parameter binding the permit is
bound to; REQUIRED, and equal to the request's
action.properties.parameter_digest, when the action was
parameter-bound. The PEP MUST enforce the exact request
binding. This is the response's only carriage of the digest.¶
valid_until:REQUIRED. An RFC 3339 [RFC3339] timestamp. The permit's
validity bound, past which the permit MUST NOT be used.
valid_until MUST NOT exceed the earliest of:¶
the presented credential's expiry, context.credential.expires_at
(Section 5.6), when present;¶
the approval's approved_until, where the permit satisfies
approval_required (Section 5.16);¶
the state valid-through; and¶
any policy-defined maximum permit lifetime for the action's class.¶
The state valid-through is defined by source: a signed Mission
Status Response's mission.fresh_until (not its exp), or a
lease's end, both carried in a supplied
context.mission_state_observation.mission_status_expires_at; or,
for a polled observation reporting neither, freshness_at plus the
deployment's published maximum staleness bound for the action's
class. In fresh mode with no supplied mission_status_expires_at,
the PDP derives the state valid-through from its own state view
under the same rule. The observation timestamp (freshness_at)
alone is never the state valid-through, so no mode leaves this
window unbounded.¶
use_limit:OPTIONAL. An integer. A consumption bound on evaluation_id.
The PDP MUST set use_limit: 1 for a permit in the
high-consequence classes
([I-D.draft-mcguinness-mission-runtime]), and the PEP MUST
treat a high-consequence permit lacking it as invalid. Absent
otherwise, the permit carries no PDP-enforced use limit.¶
The PEP applies its own deployment classification floor to this
duty, independent of any class the PDP applied internally: for an
action the PEP's own deployment classification or a resource floor
places in the high-consequence classes, the PEP MUST refuse a permit
lacking use_limit: 1, whatever class the PDP recorded for itself
in Decision Evidence
([I-D.draft-mcguinness-mission-runtime-evidence]). No class label
is echoed on this response for the PEP to compare.¶
The PDP is stateless with respect to consumption: it declares
use_limit on the decision, and the PEP owns the consumed-identifier
store and refuses a re-presented consumed evaluation_id.¶
evaluation_context_digest:CONDITIONAL. A string. REQUIRED on a permit for an operation
covered by Section 5.10; MUST equal the
validated request's context digest. The executing PEP MUST
recompute it under the descriptor the binding committed, from
authoritative facts, and MUST refuse before an effect on a missing or
unequal binding, a descriptor the operation's declaration no longer
names, an unrecoverable descriptor, or an unavailable fact. A mismatch
or inability to re-resolve after a permit is Execution Evidence
suppressed, not a PDP denial reason, with the error the runtime
evidence profile's classification names
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
action_phase:CONDITIONAL. A string from preflight, prepare, commit, or
compensate; REQUIRED on a permit for an operation that is a
phase of a compound action. It MUST equal the validated request
phase (Section 5.8). At every use, the PEP MUST
compare this condition with the phase from its own trusted
Operation Profile and MUST NOT release an effect on inequality,
a missing or malformed condition where a phase is required, or a
phase it cannot establish. A phase condition on a crossing whose
profile declares no phase is invalid there. The request context
and the retrospective evidence phase never substitute for this
condition.¶
resource_contract:CONDITIONAL. An object; REQUIRED on a permit for an action to
which a resource contract applies, and equal to the validated
request's resource.properties.resource_contract
(Section 5.3). At every use, the executing PEP
MUST resolve this reference against its own current contract
declarations and MUST NOT release an effect unless it resolves
and equals the reference of the contract the PEP is about to
perform the operation under. A missing condition where a
contract applies, an unresolvable reference, or an unequal one
is Execution Evidence suppressed /
resource_contract_unresolvable, not a PDP denial.¶
work_item:CONDITIONAL. An object; REQUIRED on a permit for a decision whose
request carried context.work_item (Section 5.15), and
equal to it. At every use, the executing PEP MUST compare it with
the work item it attributes to the request it is executing, and
MUST NOT release an effect when they differ or when either is
present without the other. Such a refusal is Execution Evidence
suppressed / work_item_mismatch, not a PDP denial.¶
The PEP MUST honor every condition present, at every use of the permit. A permit carrying a condition member the PEP does not recognize is invalid: the PEP MUST NOT release the action's effect under it. New conditions are coordinated extensions under this document's extensibility rule (Section 6.5). If AuthZEN standardizes decision conditions or must-understand response semantics, that mechanism governs and this profile aligns with it.¶
This profile defines no must-understand marker, because a marker inside
the response cannot bootstrap itself: a component that predates the
marker ignores it too. The guarantee is deployment-established instead:
a PDP MUST NOT return a permit carrying conditions to a PEP it has not
established, through deployment configuration and the mutually
authenticated channel, as conforming to this profile.¶
An obligation is mandatory PEP work under the existing decision, whichever it is. It confers no authority, has no approver, and creates no governance state: unlike the governance lane (Section 6.7), it involves no adjudication, no new authority, no approval record, and no task handle. An obligation MAY involve subject interaction or an external side effect (a step-up challenge to the subject, a notification to another system); it never acquires authority from an adjudicator.¶
An obligation MAY accompany a permit or a denial (Section 6.1): on a permit the PEP MUST fulfill each obligation before releasing the action's effect; on a denial the PEP MUST still deny the action and MUST additionally execute every returned obligation. The PEP MUST treat an obligation it does not recognize, or cannot fulfill, as an effective deny and MUST release no protected effect; it still executes every obligation it understands and can perform, as on any denial.¶
Fail-closed processing does not depend on prior negotiation: a PDP MAY attach an obligation the PEP has not declared support for, and a PEP that cannot perform an attached obligation treats it as unfulfillable. This profile mandates correct obligation processing, not any particular obligation type.¶
On a permit, obligation processing is recorded in Execution Evidence's
obligation_outcomes
([I-D.draft-mcguinness-mission-runtime-evidence]), one entry per
attached obligation, including a failure that suppresses an
already-permitted action before release. A denial-side obligation is
executed but not separately evidenced: it inherits the AuthZEN
Obligations Profile's no-proof-of-execution posture [AUTHZEN-OBL], and
a deployment that needs proof of its execution composes its own audit
mechanism.¶
A PDP claiming the Obligations feature profile
(Section 2) MUST publish in its metadata
supported_obligations array each obligation type it supports, the
step-up obligation included, as the AuthZEN Obligations Profile
requires [AUTHZEN-OBL]. A PEP MAY declare supported_obligations in
the request context, as that profile defines. The declaration is
advisory, a usability optimization on the fail-closed baseline: a PDP
MAY use it to avoid attaching an obligation that is guaranteed to fail,
sparing a round trip. A PEP that omits the declaration has an unknown
capability, not support for no obligation type, and the omission never
relaxes obligation processing.¶
The PDP MAY attach the [AUTHZEN-OBL] step-up obligation
(authentication-context properties such as acr_value and
amr_values, per that profile) when Resource policy requires a
stronger authentication context than the actor presents. It has two
fulfillment shapes, both in the obligations lane:¶
The obligation is carried on a permit only when the PEP can establish the stronger authentication context without changing any credential-bound authorization input, for example a session re-verification or a local challenge. The PEP MUST achieve the required context before releasing the action's effect, and the original permit continues.¶
Obtaining a new access token changes credential-derived inputs, so
this shape cannot fulfill an obligation attached to a permit. The PDP
denies the original request with reason resource_policy and the
step-up obligation carrying the challenge parameters, under the
deny-side processing of Section 6.2.1. The PEP challenges
the actor, obtains a new access token through RFC 9470 step-up
authentication [RFC9470] at the protected resource, and a fresh
evaluation follows under the new credential. The original permit is
never continued across an RFC 9470 step-up. Denial does not turn
step-up into governance: no access request is submitted and no
approval record is created (Section 6.7).¶
The requirement is Resource policy, never a Mission constraint. The
OAuth binding's approval-time acr_values/max_age carriage is a
requirement on the Approver at the approval event, a distinct fact
from this per-action, token-associated requirement: it is neither
carried on derived tokens nor evaluated per action, and the OAuth
binding defines no per-action amr constraint
([I-D.draft-mcguinness-oauth-mission]). The resource server's own
challenge for a weak or stale token-associated authentication is the
RFC 9470 insufficient_user_authentication challenge
([I-D.draft-mcguinness-oauth-mission]); it composes with either
shape but is not a Mission-defined denial reason.¶
A deployment MAY define further obligation types for genuine attached
PEP actions, for example watermark (apply a provenance watermark to
output before release), under the AuthZEN Obligations Profile's
registration and extensibility rule [AUTHZEN-OBL]. An obligation MUST NOT carry human approval, role or relationship creation, Mission
expansion, a task handle, residual policy, or retry instructions;
evaluation_id and evaluation timestamps are decision facts outside it.
Obligation-array ordering is not normative.¶
This profile defines no advice collection. A future context.advice
carrying safely-ignorable instructions is reserved; an obligation MUST NOT be marked optional or downgraded to advice, and permit request
binding, permit expiry, use limits, evidence emission, step-up, and
mandatory notification are never advice.¶
When the PDP permits an action, it returns AuthZEN decision: true
and the context the PEP needs to enforce the permit. The
evaluation_id binds the response to the Decision Evidence.
conditions carries the permit's decision conditions, including the
parameter_digest that binds the permit to the request inputs the
PDP evaluated; obligations is present only when a genuine
obligation applies. The following is an example of a permit:¶
{
"decision": true,
"context": {
"evaluation_id": "dec_8K2nP4qV9rL3tY6sB1zN0eF7jB",
"conditions": {
"parameter_digest":
"sha-256:WPVi6EnQ7H9Fh-qk9ADxmTg8zruOdVUX1esl-v3TfCI",
"valid_until": "2026-11-02T08:15:00Z",
"use_limit": 1
}
}
}
¶
A runtime denial is returned as decision: false with the context
members of Section 6.1. The following is an example of a
denial:¶
{
"decision": false,
"context": {
"evaluation_id": "dec_5WcR2mT8xN4qV7kB1sJ6eL9yPd",
"reason": "stale_state"
}
}
¶
Alternatively, the PDP marks the same denial transient:¶
{
"decision": false,
"context": {
"evaluation_id": "dec_5WcR2mT8xN4qV7kB1sJ6eL9yPd",
"reason": "stale_state",
"next_action": "retry",
"retry_after": 10
}
}
¶
Malformed requests, authentication failures, or PDP processing errors that prevent evaluation MAY be returned as AuthZEN or transport-level errors; so is an in-scope request refused for missing Mission context (Section 5.20). A deployment MAY additionally carry [RFC9457] problem details for structured error information when the PDP is consumed over HTTP outside the AuthZEN envelope.¶
When the PDP denies a consequential action, the failure condition is
one the runtime profile defines. This section gives the denial-reason
identifier for each condition, carried in context.reason and in
Decision Evidence's denial_reason:¶
out_of_authority: the action is not within the Authority Set, or
not within the presented credential's authority
(Section 5.6); Decision Evidence's authority_bound
records which (Section 7).¶
approval_required: deployment or Resource policy requires an
action-bound approval for this action
([I-D.draft-mcguinness-mission-runtime]) and no context.approval
is presented. This is the first-evaluation reason. The runtime
profile owns the approval artifact; the PEP carries a presented
approval in context.approval (Section 5.16). This profile
defines the value; [ARAP] uses the same spelling only in
non-normative examples. The value alone does not make a denial
requestable (Section 6.6).¶
approval_expired, out_of_scope, grant_pending, policy_denied,
approval_unverifiable: ARAP's five registered re-evaluation
reasons [ARAP], returned when a re-evaluation that presented
context.approval fails a Mission or ARAP check, with the default
next_action values Section 5.16 lists.¶
taint_context_missing: the deployment declares PDP-enforced taint
for a class that applies to the action, as the harness profile
defines ([I-D.draft-mcguinness-mission-harness]), and the decision
request carries no context.taint (Section 5.13).¶
work_item_context_missing: the deployment claims work-item
attribution for a class that applies to the action and the decision
request carries no context.work_item (Section 5.15). A
malformed one is the pre-evaluation refusal work_item_invalid
instead.¶
stale_state: the Mission state the decision relies on is not
current: the PEP-supplied freshness is outside the deployment's
staleness bound (a freshness-bound violation), the PDP cannot
establish the state it is required to establish, or the request's
state version differs from the PDP's (Section 5.20). A
Mission the PDP knows is not active is mission_inactive instead.
Where a fresh read or reconciliation is expected to resolve the
condition, the PDP SHOULD mark the denial transient with
next_action: retry (Section 6.1); otherwise it does not
recommend a retry.¶
view_inconsistent: the request's Mission id or issuer, or (when
carried) authority_hash or policy_view_id, does not equal the
committed values in the materialized policy view the PDP loaded, or
in the Mission record it evaluates directly, so the request and the
PDP disagree on which Mission or view is in force. This is a view
inconsistency, not staleness.¶
mission_inactive: the Mission state is not active.¶
mission_binding_failed: in externally-established Mission binding
mode ([I-D.draft-mcguinness-mission-runtime]), the PDP could not
verify the supplied Mission reference against the acting credential
under the binding's join, so no Mission is established.¶
actor_invalid: the required act chain is missing or malformed, so
the PDP cannot establish the runtime actor context
([I-D.draft-mcguinness-mission-runtime]).¶
credential_invalid: token-derived credential facts supplied by the
PEP are expired, inconsistent, or otherwise not usable for a runtime
decision.¶
parameter_violation: parameters violate a constraint the PDP
evaluated, the recomputed digest does not match, or a required
parameter_digest is absent for a parameter-bound action.¶
duplicate_suppressed: the request's idempotency_key and
operation identity (Section 5.18) match a prior claim whose
outcome is unresolved (transient) or completed (terminal), so the
PDP suppresses a duplicate execution of the same normalized action
rather than issue a second permit (Section 5.7.1).¶
idempotency_conflict: the request reused an idempotency_key with
a different operation identity (Section 5.18) than the prior
claim it was made under (Section 5.7.1). This condition is
terminal in every claim state, carries next_action: none
(Section 6.1), and is never marked requestable
(Section 6.6).¶
resource_policy: Resource policy refuses the action independently
of Mission authority.¶
quota_exceeded: a metered runtime bound is exhausted. The runtime
profile fixes the fail-closed posture for consumption bounds
([I-D.draft-mcguinness-mission-runtime]); the metering semantics
and settlement exchange are defined by the experimental metering
companion ([I-D.draft-mcguinness-mission-metering]).¶
unsupported_authorization_type: the action targets an
authorization_details type the PDP does not understand or cannot
enforce, so it refuses rather than guess the type's semantics
([I-D.draft-mcguinness-mission-runtime]).¶
constraint_unsupported: an applicable constraint or consumption
bound on the entry is unrecognized or unmetered, so the PDP cannot
enforce it and refuses ([I-D.draft-mcguinness-mission-runtime]).
This is distinct from parameter_violation, which is a constraint the
PDP evaluated and found violated.¶
resource_contract_drift: a resource contract applies to the action
and the applicable entry's reference is missing or does not resolve
under the resource's declared contract states
([I-D.draft-mcguinness-mission-runtime]), or the request's
resource.properties.resource_contract is absent or differs from it
(Section 5.3). The entry names the action, but
the contract it was approved under no longer holds, so this is
distinct from out_of_authority, and from capability_drift, which
compares one capability's extracted definition.¶
history_not_satisfied: a deployment- or Resource-policy-required
history predicate (Section 5.17) is not satisfied: the PDP
established it false, could not establish it, could not consult
its evidence store within the declared staleness bound, or does
not recognize the presented predicate value. The per-predicate
outcomes are in Decision Evidence
([I-D.draft-mcguinness-mission-runtime-evidence]), so the
unsatisfied and unavailable cases stay distinguishable after the
fact.¶
Authentication step-up has no dedicated denial-reason value
(Section 6.2.2): an in-process step-up carries the obligation on a
permit, and an RFC 9470 step-up carries it on a resource_policy
denial. That
denial carries no next_action value: the step-up obligation is the
actionable instruction, and the fresh evaluation that follows depends
on the PEP obtaining a new token, not on a timed retry or a
requestable workflow. A Resource-policy refusal with no step-up path
is also resource_policy.¶
A terminal policy refusal SHOULD carry next_action: none, except a
denial carrying the step-up obligation, which carries no
next_action; a denial the deployment exposes as
requestable carries next_action: request with
context.access_request (Section 6.1).¶
This document defines no other denial-reason values. ARAP's five re-evaluation reasons are values ARAP owns and registers under its own extensibility rule [ARAP], carried here rather than redefined, and this profile does not require them to satisfy the naming rule below.¶
A companion profile MAY extend the set by specification; an extension value MUST be either a collision-resistant name (following the Collision-Resistant Name guidance of Section 4.2 of [RFC7519]) or a name coordinated within this document family, so values cannot collide.¶
A consumer of a denial reason, wherever it is carried (the Decision
Evidence denial_reason,
[I-D.draft-mcguinness-mission-runtime-evidence], or the response
context.reason, Section 6.1), MUST treat an unrecognized
value as a deny and MUST NOT attach any other semantics to it, mirroring
the OAuth binding's open lifecycle state space
([I-D.draft-mcguinness-oauth-mission]).¶
A deny is terminal for the attempted action: the agent does not proceed
on a denial. A deny need not end the task, however. For an
out_of_authority or approval_required denial, the PDP MAY mark the
denial requestable by including a context.access_request object,
composing this profile with ARAP [ARAP]. The PEP then submits an ARAP
access request bound to the denied evaluation; an independent approver
or policy adjudicates it, synchronously when policy auto-approves and
otherwise asynchronously through ARAP's task handle; and on approval
the PEP re-evaluates.¶
This is the demand-driven counterpart to the pre-consented drawdown of the experimental progressive authorization companion ([I-D.draft-mcguinness-oauth-mission-progressive]): the agent starts narrow and requests the authority it discovers it needs, instead of holding it up front.¶
Auto-approval is bounded the same way in-ceiling drawdown is
([I-D.draft-mcguinness-oauth-mission-progressive]): a deployment SHOULD
rate-limit and anomaly-check synchronous auto-approval, and MUST NOT
auto-approve a request for an approval_required denial in the
irreversible, external-commitment, or privileged-administration classes
without an independent approver, so a compromised agent cannot drive the
request loop to escalate itself unattended.¶
An ARAP approval is input context, not a bearer grant: the PDP remains
authoritative at enforcement, so the PEP MUST obtain a fresh decision,
and any resulting permit and evidence remain subject to this profile.
The action-bound approval an approval_required denial calls for
([I-D.draft-mcguinness-mission-runtime]) is exactly such an approval,
and ARAP's approval.id or signed approval.state is its carrier.¶
An ARAP completion realizes one of two outcomes:¶
In-authority approval gate: the action is within the Authority Set, but policy requires a fresh approval. The approval attribute alone satisfies the re-evaluation; no Mission change occurs.¶
Missing authority (out_of_authority, or a subject lacking a role or
relationship): the governance realization MAY be a Mission expansion
([I-D.draft-mcguinness-oauth-mission-expansion]), a
policy-adjudicated in-ceiling expansion where the progressive
companion is deployed
([I-D.draft-mcguinness-oauth-mission-progressive]), a role or
relationship grant, or another authority-state change. The fresh
evaluation observes that new state. Expansion is one realization,
not ARAP's completion model.¶
The following example shows a requestable denial: deployment policy requires an action-bound approval for the journal-entry write, no valid fresh approval is present, and the PDP marks the denial requestable:¶
{
"decision": false,
"context": {
"evaluation_id": "dec_7YbK4nQ9tR2xV6mL1sP8eJ3wZc",
"evaluated_at": "2026-11-02T08:14:00Z",
"reason": "approval_required",
"next_action": "request",
"access_request": {
"endpoint": "https://requests.example.com/access-requests",
"expires_at": "2026-11-02T09:14:00Z",
"binding_token": "eyJhbGciOiJFUzI1NiIsInR5cCI6InBkcC1k..."
}
}
}
¶
The example uses ARAP's PDP-signed binding_token form. The PEP
refuses the action, submits the access request referencing the
top-level context.evaluation_id, and re-evaluates only after
approval.¶
Three lanes and three non-lanes classify a response by one governing test: what changes before access can proceed.¶
PEP work under the existing decision, whichever it is (Section 6.2). An obligation is mandatory and fail-closed (Section 6.2.1). Advice (reserved, Section 6.2.3) is safely ignorable and fail-open: a PEP that does not act on it proceeds unaffected. Neither confers authority, has an approver, or creates governance state.¶
A governance process creates approval, authority, role, or
relationship state: context.access_request outbound,
context.approval on return, and a portable task handle tracking
the workflow in between (Section 6.6).¶
Residual policy, with no workflow and nothing conferred. Partial
evaluation is a non-goal: this profile returns decisions and
instructions, never executable residual policy. parameter_attributes
(Section 5.7), context.mission_history (Section 5.17),
materialized policy views (Section 4), and
embedded PDPs are inputs or deployment shapes, not residual
evaluation. Composition with a future AuthZEN partial-evaluation
profile is reserved, and a PDP MUST NOT return residual policy under
this profile.¶
insufficient_authorization and authorization_remediation of
[I-D.draft-ietf-oauth-rar-metadata-remediation], as the OAuth
binding adopts them into the family's remediation
([I-D.draft-mcguinness-oauth-mission]). The grain is payload: it
describes authority that could be requested, MAY travel as payload
within an ARAP request, and confers nothing by itself. A deployment
MAY expose both grains on the same denial. The RAR-details grain
names what authority to request, as actionable
authorization_details routed per the OAuth binding's remediation
routing ([I-D.draft-mcguinness-oauth-mission]); the AuthZEN grain
names how the denial is escalated, into a governed access request
that an independent approver or policy adjudicates before the PEP
re-evaluates.¶
An outcome carrying retry guidance (next_action: retry,
retry_after), not a remediation path: nothing is remediated, and
the condition is expected to clear with time.¶
Constraints of the decision itself (conditions,
Section 6.1.1): declarative bounds on relying on it,
evaluated at every use. They are not work the PEP performs; a
condition the PEP does not recognize makes the permit invalid,
where an unrecognized obligation makes the result an effective
deny.¶
Lanes coexist on one response: a requestable denial can carry a notification obligation under Lane 1's deny-obligation rule (Section 6.2.1), and an approval-satisfied permit can carry a watermarking obligation, without either changing the other's semantics.¶
Every runtime failure condition, whether named in the runtime profile's
failure-mode table or in its other normative requirements
([I-D.draft-mcguinness-mission-runtime]), surfaces through exactly
one of four carriers in this profile: a Refusal Record for a PEP or
PDP refusal before any PDP decision
([I-D.draft-mcguinness-mission-runtime-evidence]), a PDP
denial (reason in the decision context, denial_reason in Decision
Evidence), a permit obligation (Section 6.2), or an Execution
Evidence error for a failure after a permit
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
A PDP denial MAY additionally carry an obligation; the OAuth step-up composition of Section 6.2.2 is the one case this document defines, and its row still names a single condition surfaced by one denial. The following table is the normative mapping for the conditions it names; extension identifiers remain governed by each carrier's extensibility rule.¶
| Runtime failure condition | Carrier | Identifier |
|---|---|---|
| Token validation fails | Refusal Record |
token_invalid
|
Required mission claim absent |
Refusal Record |
mission_claim_missing
|
| PEP-PDP channel authentication or integrity fails | Refusal Record |
channel_failure
|
| PDP unreachable | Refusal Record |
pdp_unreachable
|
| Mission state not establishable at the PEP | Refusal Record |
state_unavailable
|
| Required phase not establishable at the PEP before the decision request | Refusal Record |
phase_unavailable
|
| Committed effect a compensation offsets, or the Decision it executed under, not establishable at the PEP from retained, verified evidence before the decision request | Refusal Record |
compensation_link_unavailable
|
| Authoritative evaluation context of a covered operation not capturable at the PEP before the decision request | Refusal Record |
evaluation_context_unresolvable
|
| Presented credential's own authority does not cover the request, established before any decision request | Refusal Record |
credential_authority_insufficient
|
| Enforcement surface implements no such action | Refusal Record |
request_unsupported
|
| Supplied arguments fail the PEP-established action's required input schema | Refusal Record |
request_invalid
|
| Named target object not resolvable at the enforcement surface | Refusal Record |
target_unresolvable
|
| Operation target not establishable as one unambiguous target at the PEP | Refusal Record |
target_unresolvable
|
| Capability definition the PEP must present not resolvable before the decision request | Refusal Record |
capability_source_unresolvable
|
| Resource contract the operation requires not resolvable before the decision request | Refusal Record |
resource_contract_unresolvable
|
| Decision Evidence for a permit absent or not verifiable, so no relied-upon decision was obtained | Refusal Record |
decision_evidence_unverifiable
|
| In-scope request reaches the PDP without the Mission decision context | Refusal Record |
mission_context_missing
|
| Operation target absent, malformed, or outside the requesting PEP's enforcement scope at the PDP | Refusal Record |
operation_target_invalid
|
| No action class established for a mediated request where the Enforcement Scope Statement declares action classes, or a carried class other than the one the PDP's declaration assigns, at the PDP | Refusal Record |
action_class_missing
|
action_phase outside the closed set, or absent where the trusted operation declaration requires a phase, at the PDP |
Refusal Record |
phase_invalid
|
compensates_evaluation_id absent where action_phase is compensate, or malformed, at the PDP |
Refusal Record |
compensation_link_invalid
|
| Evaluation-context binding inputs missing, malformed, or incompatible with the declared operation binding, for a covered operation, at the PDP | Refusal Record |
evaluation_context_invalid
|
context.work_item present but not an object with exactly the string members issuer and id, at the PDP |
Refusal Record |
work_item_invalid
|
| Action outside the Authority Set (including an invoked identity outside the approved set with no recorded source binding), or the request would broaden it | PDP denial |
out_of_authority
|
| Duration-lease renewal names no lease the PDP issued or an ended activity, or fails continuity with the evaluation it renews | PDP denial |
out_of_authority
|
| Resource policy requires a stronger authentication context, satisfiable by in-process step-up with no change to credential-bound inputs | Obligation on permit | step-up obligation ([AUTHZEN-OBL]) |
| Resource policy requires a stronger authentication context satisfiable only by a new access token (RFC 9470) | PDP denial (with obligation) |
resource_policy with the step-up obligation ([AUTHZEN-OBL]) |
| Resource policy requires a stronger authentication context and refuses outright, no step-up path available | PDP denial |
resource_policy
|
| Required action-bound approval absent (first evaluation) | PDP denial |
approval_required
|
| Re-evaluation's presented approval fails a Mission or ARAP check | PDP denial | ARAP's approval_expired, out_of_scope, grant_pending, policy_denied, or approval_unverifiable ([ARAP]) |
| Mission state not current: a freshness-bound violation, required state not establishable at the PDP, or a state-version mismatch | PDP denial |
stale_state
|
Request Mission id or issuer, or (when carried) authority_hash or policy_view_id, inconsistent with the loaded view or the directly evaluated Mission record |
PDP denial |
view_inconsistent
|
Mission not active, including a passed expires_at
|
PDP denial |
mission_inactive
|
| External Mission-binding join verification fails | PDP denial |
mission_binding_failed
|
| Work-item context absent where work-item attribution is claimed for a class that applies to the action | PDP denial |
work_item_context_missing
|
Required act chain missing or malformed |
PDP denial |
actor_invalid
|
| Credential facts expired or inconsistent | PDP denial |
credential_invalid
|
| Credential authority absent, or carrying an entry the PDP cannot evaluate in full | PDP denial |
credential_invalid
|
| No entry of the presented credential's own authority names the action's resource and action, established by the PDP | PDP denial |
out_of_authority
|
| Entries of the presented credential's own authority name the action, but its parameters violate a constraint on each | PDP denial |
parameter_violation
|
| Parameter constraint violated, PDP digest mismatch, or required digest absent | PDP denial |
parameter_violation
|
| Idempotency key and operation identity match a prior unresolved or completed claim, except a retransmitted settled duration-lease renewal, which receives its permit while valid | PDP denial |
duplicate_suppressed
|
| Idempotency key reused with a different operation identity | PDP denial |
idempotency_conflict
|
| Resource policy refuses the action | PDP denial |
resource_policy
|
| Consumption bound exhausted | PDP denial |
quota_exceeded
|
Unsupported authorization_details type |
PDP denial |
unsupported_authorization_type
|
| Unrecognized or unmetered constraint | PDP denial |
constraint_unsupported
|
| Resource contract reference missing where required, or not resolvable, established by the PDP | PDP denial |
resource_contract_drift
|
| Presented approval bound to a resource contract reference other than the request's | PDP denial | ARAP's out_of_scope ([ARAP]) |
| Policy-required history predicate unsatisfied or not establishable | PDP denial |
history_not_satisfied
|
| Effective parameters differ at the executing PEP in a parameter no claimed evaluation-context binding declares as a fact | Execution Evidence |
parameter_mismatch
|
| Permit's bound phase differs from the crossing, is missing or malformed where a phase is required, or cannot be established at use | Execution Evidence |
phase_mismatch
|
| A claimed evaluation-context binding differs or cannot be established at use | Execution Evidence |
target_drift
|
Operation target at use differs from the request's operation_target, or cannot be established at use |
Execution Evidence |
target_drift
|
| Named target object the permit was evaluated for, or the effective parameters it determines, not establishable at use | Execution Evidence |
target_drift
|
| Permit validity window passed at execution | Execution Evidence |
permit_expired
|
| Consumed single-use identifier presented again | Execution Evidence |
permit_consumed
|
| Different evaluation identifier presented for an operation identity already claimed | Execution Evidence |
operation_already_claimed
|
| Single-use authorization identifier turned to a different operation identity | Execution Evidence |
operation_identity_conflict
|
| Permit carries a decision condition the executing PEP does not recognize | Execution Evidence |
condition_unrecognized
|
| Store the executing PEP takes single use in is unreachable | Execution Evidence |
consumption_unavailable
|
| Capability definition the permit was decided against not re-resolvable at use | Execution Evidence |
capability_source_unresolvable
|
| Resource contract the permit was decided under not re-resolvable at use, or unequal to the contract the operation would be performed under | Execution Evidence |
resource_contract_unresolvable
|
| Obligation attached to a permit could not be fulfilled | Execution Evidence |
obligation_unfulfilled
|
| Operator or safety control suppressed execution | Execution Evidence |
kill_switch
|
| Permit's work-item condition differs from the work item attributed to the executing request, or one is present without the other | Execution Evidence |
work_item_mismatch
|
The following rules separate conditions that share a carrier or an identifier:¶
Phase: An at-use phase failure is recorded as Execution Evidence
with outcome suppressed and error phase_mismatch, with no
effect released. A phase unestablishable before the decision request
is instead a local configuration failure at the PEP, refused before
any decision request and recorded as a Refusal Record with
phase_unavailable
([I-D.draft-mcguinness-mission-runtime-evidence]); it does not
invent a PDP denial or an Execution Evidence record for a permit
never obtained.¶
Compensation: A PEP that cannot establish the committed effect a
compensation offsets refuses before any decision request, with
compensation_link_unavailable. The compensated action's permit
presented at a compensating crossing is a post-permit failure of its
phase binding, phase_mismatch as Execution Evidence, never a Refusal
Record.¶
Unusable inputs: phase_invalid, compensation_link_invalid,
evaluation_context_invalid, work_item_invalid, and
action_class_missing are PDP refusals before evaluation. They
describe decision inputs the PDP cannot use, not an evaluated policy
denial, and a PDP claiming only the Decision Base records them in its
own internal form (Section 2).¶
Target: A target-determining argument that changed under a
parameter-bound permit is a parameter deviation, parameter_mismatch;
target_drift records an operation target that differs while the
bound parameters do not.¶
Context: under a claimed Evaluation-Context Binding a moved declared
fact can change the parameter digest too. The recorded error is
target_drift unless the context is established and an agent-supplied
parameter changed, and every observable digest pair is kept
([I-D.draft-mcguinness-mission-runtime-evidence]).
evaluation_context_unresolvable is the PEP's capture failure before
the decision request, and evaluation_context_invalid the PDP's
refusal of the inputs it received.¶
Duplicates: The duplicate_suppressed and idempotency_conflict rows
key on the same (idempotency scope, idempotency_key) claim
(Section 5.7.1), and whether the new request's operation
identity (Section 5.18) equals the claim's decides between them.
Both are PDP denials, refused before a permit exists. Their
post-permit counterparts, reached at use under a permit the PEP
already holds, are operation_already_claimed and
operation_identity_conflict, decided by the same equality. A
duplicate detected at use is never carried as a PDP denial reason, and
a duplicate refused before a decision is never carried as an Execution
Evidence error. Both post-permit errors remain distinct from
permit_consumed, the same evaluation identifier presented twice.¶
Capability source: capability_source_unresolvable appears
on two carriers, and the carrier records whether the resolution
failure happened before the decision request or at use; a resolution
failure is never reported as parameter_violation or
parameter_mismatch.¶
Resource contract: resource_contract_unresolvable likewise appears
on two carriers, the carrier recording whether the PEP found the
contract unresolvable before the decision request or at use;
resource_contract_drift is the PDP's denial between them. A contract
failure is never reported as a parameter deviation or as
target_drift, even when the parameters and the target are unchanged.¶
The requesting component and the executing PEP MUST be the same enforcement identity, on the same mutually authenticated channel that requested the permit. A permit is valid only on that channel and identity, and MUST NOT be relayed to another component as a bearer grant. Signed Decision Evidence ([I-D.draft-mcguinness-mission-runtime-evidence]) MUST NOT be accepted as authorization to act: it is retrospective evidence of what the PDP decided, never a live credential a distinct component presents to execute.¶
A deployment whose requesting component and executing component differ is out of scope for this profile. That split is reserved for a future split-execution profile, which would define an execution authorization artifact distinct from evidence: audience-bound to the executor, short-lived, and one-use.¶
The single enforcement identity owns the consumed-identifier store and
honors the permit's valid_until and use_limit
(Section 6.1.1) under the runtime profile's
consumed-identifier rules ([I-D.draft-mcguinness-mission-runtime]),
so a permit cannot be executed twice or after its lease.¶
A PEP permit cache MUST key on the request's cache key
(Section 5.18), which already excludes observation telemetry by
definition, so a per-request timestamp cannot prevent a cache hit.
The materialized view identifier is not echoed on the response
(Section 4), so a cache cannot key on it;
the permit's own valid_until and use_limit bound reuse instead, so
a permit issued against a view the PDP has since retired cannot
outlive its lease. A cached permit cannot be reused for a request
whose cache key differs.¶
At each use of a permit, cached or not, the executing PEP establishes
the operation target again from its operation contract and the
arguments it executes with. It MUST NOT release an effect on a target
other than the request's operation_target, and requests a new
decision for the changed operation instead
(Section 6.8). For a parameter-bound action, the
arguments that determine the target are effectful parameters, so the
digest reverification also covers them
([I-D.draft-mcguinness-mission-runtime]).¶
A parameter-bound class keys on parameter_digest, and a
high-consequence permit is single-use, so a permit cache amortizes
only repeat-identical, non-single-use actions: reads and idempotent
re-checks. Consequential writes take one evaluation per action, and a
deployment sizes PDP capacity and placement to that rate, not to a
cache hit ratio ([I-D.draft-mcguinness-mission-runtime]).¶
The resource request a permit authorizes is commonly served by a
resource server that did not see the PDP exchange. The PEP SHOULD
propagate the permit's evaluation_id to the resource request in the
Mission-Decision request header field (Section 11); the field value is
the evaluation_id, whose ABNF (Section 6.1) is
field-value-safe. A PEP that propagates the field MUST send the
resource request carrying it over TLS 1.2 or later; the TLS this
profile requires of the PDP endpoint (Section 9)
does not cover that hop. Where the deployment signs resource requests,
the signature MUST cover the field.¶
A resource server that logs the received evaluation_id with the
access it serves joins that access to the decision that permitted it:
Decision Evidence, Execution Evidence, and the access log share one
identifier, with no timestamp correlation. This adds the evaluation
identifier to the OAuth binding's recommendation that a resource server
log the mission claim's id and the token jti with each decision
([I-D.draft-mcguinness-oauth-mission]).¶
The field is a correlation aid, not an authorization. Its presence or value grants nothing, the resource server's token validation and PEP obligations are unchanged, and a resource server MUST NOT treat it as a permit; the permit-binding rules (Section 6.9) govern.¶
This section defines the Runtime Evidence feature profile (Section 2). A PDP and PEP that claim it emit the Decision Evidence, Execution Evidence, and Refusal Records of the runtime evidence companion ([I-D.draft-mcguinness-mission-runtime-evidence]) for every decision, execution outcome, and pre-decision refusal this profile produces. A PEP/PDP pair claiming only the Decision Base satisfies the runtime profile's baseline evidence duty in its own internal form instead ([I-D.draft-mcguinness-mission-runtime]).¶
The response's evaluation_id (Section 6.1) is the
correlation key; each record carries its own record identifier
(evidence_id, execution_id, or refusal_id). The runtime evidence
companion defines every core Decision Evidence and Execution Evidence
member. Under that companion's coordinated-extension rule, this
profile defines two Decision Evidence extension members:
mission_history, the policy-selected history predicates and their
outcomes (Section 5.17), and authority_bound (below). It also
carries coordinated extension members owned elsewhere, for example
taint, protected_data and work_item (owned by the harness profile,
[I-D.draft-mcguinness-mission-harness]) and capability_source
(owned by Mission Capability Binding,
[I-D.draft-mcguinness-mission-capability-binding]).¶
authority_bound:A string, recorded at the top level of Decision Evidence:
credential when the presented credential's own authority
(Section 5.6) decided the deny, mission when the
Mission's own authority did. It is REQUIRED on an out_of_authority
or parameter_violation deny that one of those two bounds decided,
and absent on every other decision, including a permit and a deny by
Resource policy. When both bounds exclude the action, the PDP records
the one it evaluated first.¶
This profile maps its wire members into Decision Evidence as follows, in addition to the members other sections require the PDP to record:¶
mission, subject, resource, action, audience,
credential, parameter_digest, obligations, taint,
protected_data, and work_item are populated from the
correspondingly named members of
the PDP request and response (Section 5, Section 6).¶
mission_history records the predicates the PDP evaluated and their
outcomes (Section 5.17); the PDP computes it, never copying it
from context.mission_history.¶
conditions is populated from the response context.conditions
(Section 6.1.1).¶
denial_reason carries the value returned in context.reason
(Section 6.5).¶
action_class, action_classes, class_source, and
mission_state_version are not on this profile's wire: the PDP
computes them and records them directly.¶
The runtime evidence companion's integrity envelope is this profile's
one signing convention for evidence objects: the default envelope
format is jws-compact, the protected typ is the one value that
envelope fixes, and the protected cty names the record's own
registered media type
([I-D.draft-mcguinness-mission-runtime-evidence]).¶
Under this profile, the input to evaluation_request_digest
([I-D.draft-mcguinness-mission-runtime-evidence]) is the complete
JSON request body the PEP submitted to the evaluation or evaluations
endpoint: every member it carried, extension members included, before
the PDP applies any default or enrichment. HTTP header fields and
transport framing are not part of it.¶
The digest is sha-256:
followed by the base64url, unpadded, encoding of the SHA-256 of the
body's JCS [RFC8785] canonical bytes, so member order and whitespace
do not change it, while an omitted member and a member set to null
yield different digests.¶
For a batch (Section 5.22), the input is the batch request body as submitted, before its default members are merged into the items; each item's Decision Evidence carries that one digest.¶
The digest commits to its input; it does not hide an input a party
can guess. For example, for this abbreviated consequential-read
request, submitted without a parameter_digest:¶
{
"subject": {
"type": "user",
"id": "user_3p2q8mN1a0kV7tR"
},
"resource": {
"type": "journal-entry",
"id": "je_2026Q3_inv_8421",
"properties": {
"audience": "https://erp.example.com"
}
},
"action": {
"name": "journal-entries.read"
},
"context": {
"mission": {
"id": "msn_8RfX2Lqv9TqMv4z7sA2bN1k0YpEdHc9-",
"issuer": "https://as.example.com"
}
}
}
¶
the value is:¶
evaluation_request_digest = sha-256:v_QKMU8dffVDdoAnQkBenjWgtp5U_ffH5ORwT39iaoo¶
Independent of anything the PDP
returns, a PEP that claims Runtime Evidence MUST emit one Execution
Evidence Object ([I-D.draft-mcguinness-mission-runtime-evidence]) for
the final disposition of every consequential permit: completed,
failed, or suppressed before release. This is a profile-level PEP
requirement, not an obligation. A PEP claiming only the Decision Base
satisfies the runtime profile's baseline execution-evidence duty in its
own internal form instead, as it does for Decision Evidence and Refusal
Records (Section 7).¶
The runtime evidence companion defines the record's delivery contract,
keyed on its stable execution_id. A permit whose action is never
released still ends in Execution Evidence with outcome suppressed;
only a refusal before any PDP decision is a Refusal Record.¶
If evidence emission fails after an irreversible effect, the effect stands: nothing retroactively permits or denies it. The PEP MUST record the emission failure durably and surface it on its operational alarm path, and the deployment's audit posture treats the execution as unevidenced. Where the deployment's transaction assurance depends on that later evidence ([I-D.draft-mcguinness-mission-runtime]), the PEP MUST durably reserve evidence capacity for the execution, an evidence reservation, before acting, and MUST fail closed when the reservation cannot be made.¶
This profile adds AuthZEN-specific requirements to the runtime profile's enforcement contract. An implementation conforms to this profile only for the resources, action classes, and PDPs in the runtime enforcement scope it documents ([I-D.draft-mcguinness-mission-runtime]). Each requirement is normative in its owning section; the checklists below cite them without restating their mechanics.¶
Mission Capability Binding ([I-D.draft-mcguinness-mission-capability-binding]) and the harness profile ([I-D.draft-mcguinness-mission-harness]) are normative references. The requirements that cite them bind only a deployment that adopts Capability Binding, or the harness capability the requirement names (PDP-enforced taint, for the taint members; exposure qualification, for the protected-data member; and work-item attribution, for the work-item member).¶
A PEP conforming to the Decision Base MUST:¶
carry the Mission and actor decision inputs from validated token
claims only (Section 5), and carry in
resource.properties.operation_target the operation target it
establishes from its trusted operation contract, refusing an
operation for which it cannot establish one
(Section 5.2);¶
supply action.properties.parameter_digest where required
(Section 5.7), and, where the deployment adopts Mission
Capability Binding, context.capability_source as that companion
requires ([I-D.draft-mcguinness-mission-capability-binding]);¶
process obligations as Section 6.2.1 requires;¶
honor every decision condition present (parameter_digest,
valid_until, use_limit, action_phase,
evaluation_context_digest, resource_contract, work_item) at
every use of
the permit, applying its own deployment classification floor to that
duty independent of any class the PDP applied internally
(Section 6.1.1);¶
be the same enforcement identity as the requesting component, on the same mutually authenticated channel, and never relay a permit or treat signed Decision Evidence as authorization to act (Section 6.9); and¶
key permit caches on the request's cache key, and release an effect only on the operation target a permit was evaluated for (Section 6.9).¶
A PEP additionally claiming the Runtime Evidence profile
(Section 2) MUST emit a Refusal Record
([I-D.draft-mcguinness-mission-runtime-evidence]) for a pre-decision
refusal, and an Execution Evidence Object for the final disposition of
every consequential permit (completed, failed, or suppressed
before release, Section 7.2). A PEP claiming
only the Decision Base records a refusal or an execution outcome in
its own internal form, never represented as this profile's portable
schema (Section 2).¶
A PDP conforming to the Decision Base MUST:¶
refuse an in-scope consequential request that lacks the Mission decision context, and perform the PDP-side consistency checks (Section 5.20);¶
match mission_resource_access entries against
resource.properties.operation_target, never against audience,
type or id (Section 5.1);¶
classify every denial per Section 6.5;¶
return the decision context of Section 6.1, including a
conditions object on every consequential permit and an obligations
array only when a genuine obligation applies (Section 6.2); and¶
advertise the urn:ietf:params:authzen:mission-runtime capability
URN in its metadata capabilities array (Section 8.1).¶
A PDP additionally claiming the Runtime Evidence profile (Section 2) MUST emit the records of [I-D.draft-mcguinness-mission-runtime-evidence] for every decision, and a Refusal Record for an in-scope request it refuses before evaluation (Section 5.20). A PDP claiming only the Decision Base records a decision or refusal in its own internal form, sufficient to satisfy the runtime profile's baseline evidence duty ([I-D.draft-mcguinness-mission-runtime]) without this profile's portable schema.¶
A PDP claiming the Obligations feature profile publishes its supported obligation types in metadata as Section 6.2.1 requires.¶
A deployment whose requesting component and executing component differ is out of scope for conformance to this profile (Section 6.9). Record producer and consumer conformance, including evidence signing-key verification and the classification of orphaned Decision Evidence, is defined by the runtime evidence companion ([I-D.draft-mcguinness-mission-runtime-evidence]).¶
A PDP conforming to the Decision Base MUST advertise the full URN
urn:ietf:params:authzen:mission-runtime, never the bare capability
name. A PDP that additionally conforms to a feature profile MUST
advertise that profile's own capability URN as well; a PDP MUST NOT
advertise a feature-profile URN it does not conform to.
Section 11.1 registers the URNs.¶
A PEP MUST NOT
rely on a feature profile whose URN the PDP's advertised
capabilities does not include: an unadvertised profile fails closed
exactly as an absent one does elsewhere in this document
(Section 2). This in-band discovery complements,
and does not replace, the deployment-established conformance gating
this profile otherwise requires (Section 6.1.1).¶
Capability advertisement is PDP-declared, never requester-selected: nothing in a PEP's request selects, enables, or negotiates a feature profile, and a requester cannot omit a required profile to downgrade enforcement (Section 2).¶
The runtime profile's Security Considerations ([I-D.draft-mcguinness-mission-runtime]) apply in full: placement and bypass, classification integrity, freshness and consumption honesty, Resource policy authority, TOCTOU and replay, and the limits of a compromised PEP or PDP. Threats specific to the evidence records are covered by the runtime evidence companion ([I-D.draft-mcguinness-mission-runtime-evidence]), and threats specific to capability-source binding by Mission Capability Binding ([I-D.draft-mcguinness-mission-capability-binding]). This section covers threats specific to this profile.¶
A PDP that serves both Mission-bound and ordinary AuthZEN traffic has
two policy surfaces, and the request selects between them by carrying
context.mission. If an in-scope request that lost its Mission context
(a PEP defect, or a path an attacker can influence) were evaluated
against the non-Mission surface, a generic allow rule would stand in for
the Mission evaluation this profile requires. The consistency
requirement of Section 5.20 refuses such a request
outright; deployments SHOULD additionally alert on in-scope requests
arriving without Mission context, since each one is a PEP defect or a
probe.¶
A deployment that composes with ARAP adds the Access Request Service to its trusted base: it adjudicates requestable denials and issues the approvals the PDP consumes as input. A compromised or misconfigured Access Request Service can auto-approve escalations, so it MUST be trusted, authenticated, and access-controlled like the PDP, and its auto-approval is bounded as Section 6.6 specifies.¶
The denial-reason identifiers and any contributing_constraints are a
decision oracle: an agent can probe them to map authority it does not
hold. The PEP SHOULD minimize the denial detail it relays to the agent;
a generic refusal suffices to stop the action, and the full reason and
contributing constraints belong in evidence, not in the agent-facing
response. To bound probing through the request loop, deployments SHOULD
rate-limit access requests per Mission and surface request provenance to
Approvers, so a compromised agent driving repeated requestable denials
is visible to the humans adjudicating them.¶
A PDP that evaluates against a materialized view enlarging the
Authority Set's bounds violates the bounded property of
Section 4. The Authority Set that
authority_hash commits is the upper bound. The id and issuer
check, and policy_view_id where the PEP supplies it, let the PDP
detect that the view it loaded does not match the Mission the PEP
referenced and deny with view_inconsistent
(Section 5.20).¶
The PDP endpoint MUST be served over TLS 1.2 or later (TLS 1.3 RECOMMENDED). PEP-to-PDP authentication MUST be mutual, satisfying the integrity and mutual-authentication requirement the runtime profile places on the PEP-PDP channel ([I-D.draft-mcguinness-mission-runtime]). Evidence transport and storage requirements are the runtime evidence companion's ([I-D.draft-mcguinness-mission-runtime-evidence]).¶
The runtime profile's evidence-privacy guidance ([I-D.draft-mcguinness-mission-runtime]) applies in full. The runtime evidence companion covers the privacy properties of Decision Evidence, Execution Evidence, and Refusal Records, including their status as PII sinks, parameter exposure, and actor-chain correlation ([I-D.draft-mcguinness-mission-runtime-evidence]).¶
Of this profile's two Decision Evidence extension members,
mission_history (Section 7) carries behavioral history predicates
and their outcomes. It inherits that guidance in full and receives the
same PII-sink, access-control, and retention treatment as the rest of
the Decision Evidence record, with no exemption. authority_bound
names only an authority bound. This profile defines no other record
content.¶
This document requests the IANA actions in the following subsections.¶
The runtime evidence companion, not this document, registers the
Decision Evidence, Execution Evidence, and Refusal Record media types
([I-D.draft-mcguinness-mission-runtime-evidence]). The request and
response members this document defines (Section 5,
Section 6.1) are AuthZEN extension data and are not registered
in an IANA registry. Members a companion adds are that companion's:
context.capability_source
([I-D.draft-mcguinness-mission-capability-binding]), and
context.taint, context.protected_data, context.work_item, and
action.properties.external_communication
([I-D.draft-mcguinness-mission-harness]). The Mission-bound token
claims this profile consumes are registered by
[I-D.draft-mcguinness-oauth-mission]. This document registers no
obligation type in the AuthZEN Obligation Types registry; the one
obligation type it uses, step-up (Section 6.2.2), is registered by
[AUTHZEN-OBL].¶
This document requests registration of the following seven capabilities in the AuthZEN Policy Decision Point Capabilities registry established by [AUTHZEN]: one for the Decision Base and one for each feature profile (Section 2).¶
Capability Name: :mission-runtime¶
Capability URN: urn:ietf:params:authzen:mission-runtime¶
Capability Description: support for the Mission-Bound Runtime Enforcement AuthZEN profile's Decision Base.¶
Change Controller: the author of this document¶
Specification Document(s): this document¶
Capability Name: :mission-runtime-transaction-assurance¶
Capability URN: urn:ietf:params:authzen:mission-runtime-transaction-assurance¶
Capability Description: support for the Transaction Assurance feature profile (Section 2).¶
Change Controller: the author of this document¶
Specification Document(s): this document¶
Capability Name: :mission-runtime-evidence¶
Capability URN: urn:ietf:params:authzen:mission-runtime-evidence¶
Capability Description: support for the Runtime Evidence feature profile (Section 2).¶
Change Controller: the author of this document¶
Specification Document(s): this document¶
Capability Name: :mission-runtime-obligations¶
Capability URN: urn:ietf:params:authzen:mission-runtime-obligations¶
Capability Description: support for the Obligations feature profile (Section 2).¶
Change Controller: the author of this document¶
Specification Document(s): this document¶
Capability Name: :mission-runtime-arap¶
Capability URN: urn:ietf:params:authzen:mission-runtime-arap¶
Capability Description: support for the ARAP feature profile (Section 2).¶
Change Controller: the author of this document¶
Specification Document(s): this document¶
Capability Name: :mission-runtime-history¶
Capability URN: urn:ietf:params:authzen:mission-runtime-history¶
Capability Description: support for the History feature profile (Section 2).¶
Change Controller: the author of this document¶
Specification Document(s): this document¶
Capability Name: :mission-runtime-batch¶
Capability URN: urn:ietf:params:authzen:mission-runtime-batch¶
Capability Description: support for the Batch feature profile (Section 2).¶
Change Controller: the author of this document¶
Specification Document(s): this document¶
This document registers the following in the "Hypertext Transfer Protocol (HTTP) Field Name" registry ([RFC9110]):¶
Field Name: Mission-Decision¶
Status: permanent¶
Reference: this document, Section 6.10¶
Comments: none¶
[[ To be removed from the final specification ]]¶
Protected-Data Context: context.protected_data is a harness-owned
extension point carrying the exposure determination that the harness
profile's exposure qualification relies on. It is part of the
authorization binding and recorded in Decision Evidence, and
taint_context_missing is unchanged (#2044).¶
History Context: names work_item_prerequisite_completed, the
harness profile's coordinated predicate type (#815).¶
Changes a requirement (#1994): a mediated request carried with an
action class other than the one the PDP's trusted declaration assigns
its operation and phase has no class established, and the PDP refuses
it before evaluation as action_class_missing.¶
Taint, Work-Item and History Context: PDP-enforced taint, the
external_communication member and work-item attribution apply when
a class that applies to the action calls for them, and
action_class_completed counts a permit when the named class is in
its action_classes, or is its action_class where the record
carries no action_classes (#1994). Every such permit needs a
completion witness, a linked completed record whose effective
digests equal the authorized ones; a digest deviation is none, a
failed use or suppressed replay removes none, a single-use permit's
completion other than the one that took its use creates none, a
missing effective digest leaves completion undetermined, and the
evaluation relies on a complete history read (#2029).¶
Credential Decision Context: requiring a credential's whole authority description to be evaluable is this profile's credential validation policy, stricter than Resource Access's alternative-entry rule and not a consequence of the prohibition on falling back to the Mission's authority; an entry the PDP evaluates and finds unsatisfied still lets another complete entry authorize; the interoperability cost is stated (#1806).¶
Changes a requirement (#956, D814): where the runtime Enforcement
Scope Statement declares action classes, the PDP refuses a mediated
request with no action class established before evaluation, records
the Refusal Record action_class_missing, and never evaluates it
under a default class or records one in Decision Evidence.¶
Work-Item Context: context.work_item is a harness-owned extension
point the PEP populates only from the harness's authenticated
attachment. A malformed member is refused before evaluation as
work_item_invalid, and an absent one where work-item attribution is
claimed for the action's class is denied
work_item_context_missing. The member is part of the authorization
binding and the cache key, a permit binds it as the work_item
condition, and a permit for another work item is Execution Evidence
suppressed / work_item_mismatch (#815).¶
Failure-Condition Coverage maps a covered operation's evaluation
context not capturable at the PEP to the Refusal Record
evaluation_context_unresolvable, and limits the parameter_mismatch
row to a parameter no claimed binding declares as a fact; a context
failure at use carries the error the runtime evidence profile's
classification names; the context digest condition is recomputed under
the descriptor the binding committed (#773).¶
Compensation link (#252). context.compensates_evaluation_id is
REQUIRED on a compensate-phase request, established by the PEP from
retained, verified evidence of the committed effect and its Decision,
never from an agent argument. PDP-side consistency check 12 refuses a
missing or malformed link before evaluation as
compensation_link_invalid, and Failure-Condition Coverage maps it and
the PEP's compensation_link_unavailable.¶
Failure-Condition Coverage maps a named target object, or the
effective parameters it determines, not establishable at use to
Execution Evidence target_drift, the post-permit counterpart of the
pre-decision target_unresolvable (#786).¶
Owner-ruled follow-ups to the editorial pass (#1629). A PDP claiming
the Obligations feature publishes its supported obligation types; a
PEP's supported_obligations declaration is optional and its
omission relaxes nothing. Obligation Processing holds the
effective-deny rule for an unrecognized or unfulfillable obligation.
A PEP claiming Runtime Evidence emits Execution Evidence for every
consequential permit. Failure-Condition Coverage maps phase_invalid,
evaluation_context_invalid, and phase_unavailable, and
stale_state covers freshness-bound violations, state the PDP cannot
establish, and state-version mismatch. approval_required is this
profile's value. Metering owns the retried-request rule. Capability
Binding and the harness are normative references, scoped to
deployments adopting them. The history request object is
context.mission_history. Transaction Assurance is required, and
advertised, for the parameter-bound and high-consequence classes. A
propagated Mission-Decision field travels over TLS.¶
Editorial and structural pass. Mission-Bound Authorization for OAuth 2.0 is called the OAuth binding throughout. Each repeated rule keeps one home, with pointers elsewhere: obligation processing, the idempotency claim (now its own subsection), ARAP's re-evaluation reasons, unrecognized denial reasons, evidence as authorization, and the step-up shapes. Decision conditions and obligations gain subsections. Mission Substrate folds into the Introduction and Mission Status Composition into the state observation section. The capability advertisement rules move from IANA Considerations to a Capability Discovery subsection of Conformance, and IANA Considerations drop the withdrawn composite obligation's history. Mission Runtime Evidence is a normative reference and RAR metadata remediation an informative one. No requirement changed.¶
Failure-condition coverage: a duration-lease renewal that names no
lease the PDP issued or an ended activity, or fails continuity with
the evaluation it renews, is denied out_of_authority; a
retransmission of a settled renewal receives that renewal's permit
while it is valid, not duplicate_suppressed (#1464).¶
Runtime Denial Classification and Failure-condition coverage: a
resource contract reference missing where required, or not
resolvable, is denied resource_contract_drift; the PEP records
resource_contract_unresolvable before the decision request or at
use (#249).¶
Resource Contract: resource.properties.resource_contract carries
the reference the PEP will perform under, and the PDP requires it to
equal the applicable entry's. The approval binds it through the
approved Resource, and an approval under another reference is denied
out_of_scope. The permit returns it as conditions.resource_contract,
which the executing PEP compares before release (#249).¶
resource.properties.audience carries the runtime profile's
boundary identifier, the boundary the PEP established, byte for
byte: on OAuth, the protected resource's identifier, never an aud
value or alias. The authorization binding, and so the cache key,
names it. Operation-target matching is unchanged (#853).¶
resource.properties.operation_target carries the operation target
the PEP establishes from its trusted operation contract. The PDP
matches mission_resource_access entries in the credential's and
the current effective authority against it, never against
audience, type or id, and refuses a request whose target is
absent, malformed or outside the PEP's enforcement scope
(operation_target_invalid). The target is part of the operation
identity, the authorization binding and the cache key; a target
that changes at use is target_drift (#1276).¶
context.mission's id and issuer are the binding's Mission
Reference identifier and Controller namespace in that binding's
representation, with the OAuth realization unchanged, and issuer
is distinct from context.credential.issuer. Terminology states the
same (#1169).¶
mission_state_observation gains an OPTIONAL termination, the
Mission's termination when state is terminated. The PDP rule,
which keys only on exact active, is unchanged (#705).¶
Decision Evidence gains authority_bound, registered by this
profile: credential or mission, the authority bound that decided
an out_of_authority or parameter_violation deny (#825).¶
The failure-condition table maps supplied arguments that fail the
PEP-established action's required input schema to the Refusal
Record's request_invalid (#1106).¶
context.credential carries authority, the verified credential's
own authorization_details, on every decision; the PDP enforces it
as the credential authority bound, independently of the matched
Mission entry, and denies credential_invalid when it is absent or
not evaluable (#825). An action no credential entry names is
out_of_authority; one whose parameters violate a constraint on
every entry that names it is parameter_violation.¶
The RAR remediation grain cites the working-group successor draft-ietf-oauth-rar-metadata-remediation and defers its routing to the issuance profile's remediation routing instead of restating it. No requirement changed.¶
Mission-to-Policy Materialization describes the materialized policy
view as one evaluation path: a PDP that evaluates the Mission's
recorded authority directly meets the runtime profile's authority
input without a view and omits policy_view_id. The PDP-side
consistency checks compare the request against the loaded view or
the directly evaluated Mission record, and the policy_view_id
check applies only where a view is used.¶
Defined the input to evaluation_request_digest: the complete
request body as submitted, extension members included, before any
default or enrichment, with header fields and transport framing
excluded; a batch carries the one digest of its body (#971).¶
The state observation's mission_status_issued_at is the RFC 3339
form of a Mission Status Response's iat, which freshness_at
precedes by no more than the published maximum clock skew, and
mission_status_expires_at and the state valid-through are its
mission.fresh_until, not its exp, or a lease's end.¶
This document is the AuthZEN profile of Mission-Bound Runtime Enforcement and builds on the OpenID AuthZEN Authorization API. The author thanks the OpenID AuthZEN community and the Mission-Bound Authorization implementer community for feedback.¶