master branch as of 2026-06-03 (no specific release tag; this v0 predates maintainer review).@kumaab) on 2026-06-12, who answered every §14 question — those answers are folded into §1–§13 below.Version binding. Once ratified, this model is intended to be versioned alongside Ranger and tagged with releases. A report against Ranger version N should be triaged against the model as it stood at N, not at HEAD. This v0 carries no such binding yet.
Reporting cross-reference. Apache Ranger has no SECURITY.md in the repository (confirmed 404) and no dedicated security/threat-model page on https://ranger.apache.org/ at the time of writing (documented — absence verified). Vulnerabilities in Apache projects are reported to security@ranger.apache.org / security@apache.org per the ASF-wide process. Findings that fall under §8 (claimed properties) should be reported through that channel; findings that fall under §3 or §9 will be closed citing this document once it is ratified.
Provenance legend. Every non-trivial claim carries exactly one tag:
Confidence: PMC-reviewed v1.2 — all 20 §14 questions answered by the maintainer on 2026-06-12 and folded into §1–§13. A handful of items (e.g. the “no resource guarantee” line, §8 #6) were explicitly deferred by the PMC for later ratification.
What Apache Ranger is. Apache Ranger is “a framework to enable, monitor and manage comprehensive data security across 20+ data processing services” (documented — ranger.apache.org). It provides centralized & fine-grained authorization, audit, and key management for data services (Trino, Polaris, Ozone, HDFS, Hive, HBase, Kafka, NiFi, Knox, Kudu, YARN, Solr, Atlas and others). The administrator defines access-control policies in a central web application (Ranger Admin); lightweight per-service Java plugins, deployed inside each data service's own process, pull those policies and enforce authorization decisions locally on every access request. In threat-model terms Ranger is a distributed Policy Decision / Policy Enforcement system: the policy decision authority lives with the admin server (which authors and distributes policy), but the actual enforcement (the PEP) runs as plugin code co-located inside the data service it guards (documented — FAQ: plugins “run as part of the same process as the namenode (HDFS), Hive2Server(Hive), HBase server (Hbase)”).
Primary intended use. Centralized authoring of fine-grained authorization policies (resource-based and tag-based) and their enforcement across many independent data services, plus unified audit of access decisions and a key-management service (Ranger KMS) for HDFS transparent encryption (documented — ranger.apache.org goals: “Centralized security administration”, “Fine grained authorization”, “Centralize auditing of user access”).
Deployment context. Ranger is not an in-process library. It is a multi-component distributed system deployed across a cluster: a central web application/daemon (Ranger Admin, default port 6080 (documented — README)), a user/group sync daemon, an optional tag-sync daemon, the Ranger KMS daemon, the Ranger PDP server that exposes a network authorization API for non-embedded callers and a fleet of plugins each embedded inside a separate data-service process on separate (typically trusted, intra-cluster) hosts (documented — README lists Admin Tool, User Synchronization, and component plugins as the deployment tiers).
Caller roles. Because Ranger is a distributed service rather than a single library, “the caller” splits into distinct roles, each modeled separately in §6/§7:
service.admin.users / service.admin.groups config. Trusted for that service’s policies and for every Ranger role: roles are global, not scoped to a service, so being Service Admin of any service lets the caller create, delete, and grant/revoke membership of any role, including roles used only by other services' policies. This is by design, so services with role management in their authorization interface (e.g. Hive GRANT ROLE) can use Ranger roles (maintainer, 2026-10-23).Component-family table.
| Family | Representative entry point | Touches outside its process | In this model? |
|---|---|---|---|
| Ranger Admin web app | security-admin/, agents-common/, REST /service/..., /public/v2/api/... (documented — API docs) | DB, network (serves plugins + UI), LDAP/AD | In |
| PDP service | pdp/, authz-api/, authz-embedded/, authz-remote/ | Network (serves remote authz API); Admin (policy pull); audit sink | In (maintainer, 2026-06-12 — §14 Q6/Q10) |
| Per-service plugins (PEPs) | *-agent/ (hdfs-agent/, hive-agent/, hbase-agent/), plugin-*/ (plugin-kafka/, plugin-nifi, plugin-ozone, plugin-trino, plugin-kms), agents-common/ | Embedded in host service; network to Admin; audit sink | In |
| Plugin shims / classloader | ranger-*-plugin-shim/, ranger-plugin-classloader/ | Class loading inside host service | In (as part of PEP delivery) |
| User/group sync | ugsync/, ugsync-util/ | LDAP/AD/Unix; writes to Admin DB | In |
| Tag sync | tagsync/ | Atlas/Kafka; writes to Admin | In |
| Audit framework | agents-audit/, audit-server/ | Solr/OpenSearch/Kafka/HDFS/DB audit sinks | In |
| Ranger KMS | kms/, plugin-kms/ | Key store (DB/HSM), HDFS NameNode/DataNode | In (model at its own trust level — handles key material) |
| Authentication | ranger-authn/, unixauthservice/, agents-cred/, credentialbuilder/ | Kerberos/SPNEGO/LDAP; credential stores | In |
| Examples / sample app + tools | ranger-examples/, ranger-tools/ (documented — repo layout) | Demo / utility | In (maintainer, 2026-06-12 — §14 Q4) |
| Build / install / migration / ugsync tooling | distro/, agents-installer/, migration-util/, ugsync filesourceusersynctool/ldapconfigchecktool, dev-support/ | Build/deploy host | Out (maintainer, 2026-06-12 — §14 Q4) |
distro/, agents-installer/, migration-util/, Docker build scripts) and the ugsync utilities filesourceusersynctool / ldapconfigchecktool. SDLC/deployment hygiene, not the runtime trust surface (maintainer, 2026-06-12 — §14 Q4). Note: unlike a typical project, ranger-examples/ and ranger-tools/ are IN scope here per the PMC (§2) — do not treat example/tool code as out-of-model.Where the boundary sits. Ranger has several trust boundaries, not one:
End user ↔ guarded data service (the access request). The user‘s identity + requested resource/action enters the host service, which calls the embedded Ranger plugin (PEP). This is the primary untrusted-input boundary: the requested resource name and action are derived from an untrusted user, though the identity is asserted by the host service’s authentication layer, which Ranger trusts (inferred).
Plugin (PEP) ↔ Ranger Admin (policy distribution). Plugins “pull the policy-changes using REST API at a configured regular interval (e.g.: 30 second)” (documented — FAQ). The plugin trusts that the policy it downloads genuinely originates from the legitimate Admin server, and the Admin trusts that only authorized plugins download policy. This boundary is authenticated via Kerberos, JWT, or header-based auth with a trusted proxy — the policy-download path (and the separate PDP service process) requires an authenticated identity (maintainer, 2026-06-12 — §14 Q6/Q10). Plugins cache the last-known policy and “function even if the policy server is temporarily down” (documented — FAQ), so the cache is load-bearing.
Admin UI / REST client ↔ Ranger Admin (administration). Administrators author policy and read audits over /service/... and /public/v2/api/... REST endpoints (documented — API docs). This is the highest-value boundary: anyone who can author policy can grant themselves or others access to all guarded data.
Usersync/tagsync ↔ Admin, and Admin ↔ DB / audit sink / key store. Internal data-plane boundaries; integrity of the user/group/role data and the policy store determines the integrity of every downstream decision (inferred).
Client ↔ PDP service (remote authorization request). Where a caller cannot embed a PEP, it calls the PDP's /authz/* API with (principal, resource, action). Authenticated (Kerberos/JWT/trusted-header); the resource/action are attacker-influenced, the principal is asserted by the authenticated caller — same trust split as the in-process PEP, but over the network (inferred).
Data flow (authorization path). Untrusted user request → host service authenticates principal → host service calls embedded Ranger plugin with (principal, resource, action) → plugin evaluates locally-cached policy (resource-based + tag-based) → returns allow/deny → plugin emits an audit record to the configured sink → host service enforces the decision (documented in part — FAQ; full flow inferred).
Reachability preconditions per component (the triager's first test):
agents-common is in-model only if reachable from a policy-evaluation input — i.e., from the (principal, resource, action) tuple of an untrusted access request, or from the downloaded policy document, or from the plugin's local config (inferred).pdp/, authz-api/, authz-embedded/, authz-remote/) is reached over the network, not in-process. Its authorization API (/authz/*) requires an authenticated client (Kerberos/JWT/trusted-header; the server refuses to start with no auth handler configured), so treat it like an authenticated Ranger Admin REST endpoint — there is no anonymous path into the authz API. Only the liveness/readiness/metrics probes (/health/live, /health/ready, /metrics) are reachable unauthenticated, mirroring Admin's public health/metrics bucket (§14 Q10) (inferred)./jmx instrumentation servlet, requires the same authentication as /kms/*. A KMS endpoint that answers without authentication is a finding, not a public probe (maintainer, 2026-10-23).ranger-examples/ is out of model (§3) (inferred).--add-opens=java.base/java.nio=ALL-UNNAMED and related flags for supported operation (documented — README), implying modern JDK module assumptions.What Ranger does not do to its host (negative side-effect inventory — predominantly inference, high-priority confirmation target):
Ranger's security envelope is governed primarily by runtime configuration, not compile-time flags. The variants that change which properties hold:
BY-DESIGN / operator-hardening, not VALID.admin, rangerusersync, rangertagsync, keyadmin) at bootstrap, but the installer mandates an explicit, complexity-checked password on fresh install — a seeded/default password is not a supported production posture (maintainer, 2026-06-12 — §14 Q3).ranger.admin.allow.unauthenticated.access (default false). Setting it to true lets callers with no authenticated session use Admin's plugin endpoints: policy grant/revoke and, because it also becomes the default of the download flag below, every plugin download endpoint. It is not a supported production posture (documented — ranger-admin-default-site.xml: “can not be used in production environment”). A finding that only shows up with it set is OUT-OF-MODEL: non-default-build; enabling it in production is an operator-hardening failure (§10, §11) (maintainer, 2026-10-23).ranger.admin.allow.unauthenticated.download.access (defaults to the flag above, so false). Setting it to true opens only the plugin download endpoints (policies, tags, roles, users/groups, GDS) to unauthenticated callers, which the shipped config suggests for Kerberos clusters with low security needs (documented — ranger-admin-default-site.xml). It is a supported, reduced posture: exposure of the downloaded data is BY-DESIGN: property-disclaimed (§9), but any write, or any access beyond those downloads, is still VALID (maintainer, 2026-10-23).For each knob whose default is the less-secure value, the PMC's ruling (supported production posture → reports are VALID; vs. dev-convenience requiring operator action → OUT-OF-MODEL: non-default-build) is recorded once confirmed. Rulings made so far are the (maintainer)-tagged entries above.
Ranger is a network service, so the trust table is keyed by endpoint/message, not function. Header-presence and identity-assertion checks are the prime “false friends.”
| Endpoint / input | Parameter | Attacker-controllable? | Caller/operator must enforce |
|---|---|---|---|
| Plugin authorization call (in-process, from host service) | principal identity | no — asserted by host service auth (inferred) | host service must authenticate before calling |
| Plugin authorization call | resource name, action | yes — derived from untrusted user request (inferred) | plugin must evaluate policy correctly against arbitrary resource strings |
GET /service/plugins/policies/download (policy pull) | requesting plugin identity | no — must be authenticated plugin (inferred) | mutual auth between plugin and Admin |
POST/PUT /public/v2/api/policy (documented — API docs) | policy body | partly — authored by Ranger admins, and within their scope by Service Admins, security-zone admins and delegated admins (maintainer, 2026-10-23) | endpoint must require admin authz; never expose unauthenticated |
| Script fields in a policy (custom-condition expressions; row-filter expressions a plugin evaluates as JavaScript) | script text | yes — any policy author, including delegated, security-zone and Service Admins (maintainer, 2026-10-23) | plugin must evaluate it only in the sandboxed script engine (§8 #7) |
/service/xusers/users, /groups, /roleassignments (documented — API docs) | user/group/role data | partly — usersync feeds it from LDAP/AD (inferred) | trust in the identity source; admin authz on the endpoint |
PUT /service/roles/roles/grant/{serviceName}, /roles/revoke/{serviceName}; POST /service/roles/roles?serviceName=; DELETE /service/roles/roles/name/{name}?serviceName= | serviceName | yes — the caller picks it; it only selects whose Service Admin list is checked and does not limit which role can be changed (maintainer, 2026-10-23) | grant Service Admin only to principals trusted to manage every Ranger role (§2, §10) |
/service/assets/accessAudit, /xaudit/... (documented — API docs) | audit query params | depends on who can reach it | restrict audit read to authorized roles |
Ranger KMS /keys/key, /keys/keys (documented — API docs) | key name, key ops | by an authenticated KMS client (inferred) | KMS must authorize each key operation against policy |
| Usersync input | LDAP/AD/Unix records | as trusted as the identity source (inferred) | secure + authenticate the directory connection |
| Tagsync input | tags from Atlas/Kafka | as trusted as the tag source (inferred) | secure the tag source channel |
Size/shape/rate. Policy documents downloaded by plugins, audit batches, and REST payload sizes are assumed bounded by normal operation; explicit limits are unconfirmed (inferred).
In-scope adversaries (hypothesized — all to be confirmed):
Attacker capabilities assumed. Send arbitrary access requests to guarded services; reach Admin/KMS network endpoints; observe network traffic if transport is unprotected; supply arbitrary resource strings and policy/identity data at the boundaries marked attacker-controllable in §6 (inferred).
Explicitly out of scope (hypothesized):
Authenticated-but-Byzantine participant. Ranger is a distributed PDP/PEP system: a plugin holds a legitimate service identity and could, if its host is compromised, behave arbitrarily (return wrong decisions, withhold audit). Ranger treats every PEP as fully trusted once authenticated and makes no cross-node integrity claim — complete plugin trust is a deliberate design choice that keeps runtime overhead low (maintainer, 2026-06-12 — §14 Q8).
(All entries below are hypothesized for the PMC to confirm; none are maintainer-ratified yet.)
Authorization decisions reflect the authored policy. Given correctly-distributed policy and a correctly-authenticated principal, a plugin's allow/deny matches what the central policy specifies for that (principal, resource, action). Violation symptom: a user is granted access the policy denies (or denied access the policy grants) — i.e., a policy-evaluation/matching bug. Severity: security-critical — an existing deny-policy (or the absence of any grant) that nonetheless yields access is CVE-class VALID (maintainer, 2026-06-12 — §14 Q11).
Centralized policy is faithfully distributed to enforcement points. Policy authored in Admin is delivered to plugins via the periodic pull and applied; plugins fall back to last-cached policy when Admin is unreachable rather than failing open arbitrarily. Violation symptom: a plugin enforces stale or wrong policy in a way that grants access the current policy denies; or distribution lets an attacker substitute policy. Severity: security-critical. (documented in part — FAQ on pull interval + cache fallback; the “faithfully/integrity” guarantee is inferred)
Administrative actions are access-controlled. Authoring/modifying policy, managing users/roles, and reading audits via the REST API and UI require appropriate authenticated, authorized identity; delegated admins are confined to their delegated scope. A Service Admin‘s scope is their service’s policies plus all Ranger roles, because roles are global (§2, §9) (maintainer, 2026-10-23). Violation symptom: an unauthenticated or under-privileged actor authors/reads policy, escalates a role, or reads audit/keys. Severity: security-critical. (documented in part — delegation in FAQ; enforcement details inferred)
Access decisions are audited. Allow/deny decisions and administrative actions are recorded to the configured audit sink. Violation symptom: an in-scope access produces no audit record, or audit can be silently suppressed/forged by a non-admin. Severity: security-relevant — a non-admin able to tamper or forge audit records IS a security finding (maintainer, 2026-06-12 — §14 Q14); missed records alone are correctness-grade. (documented — ranger.apache.org: “Centralize auditing of user access and administrative actions”)
KMS authorizes key access per policy. Ranger KMS releases key material only to clients authorized by key-access policy. Violation symptom: unauthorized key retrieval / decryption capability. Severity: security-critical — the key is the KMS-policy resource; unauthorized key retrieval is CVE-class VALID (maintainer, 2026-06-12 — §14 Q13).
Policy evaluation is bounded and thread-safe. Each authorization call terminates promptly and concurrent evaluation during a policy refresh does not corrupt decisions. Violation symptom: hang/CPU exhaustion inside the host service on crafted resource input, or a race producing a wrong decision. Severity: the engine is bounded and thread-safe (maintainer, 2026-06-12 — §14 Q12). Super-linear evaluation cost in policy size or resource-string length is NOT a bug; a hang inside the host service may be a security issue; whether no resource guarantee is made was deferred by the PMC for later ratification.
Scripts in policies cannot run host code. Script fields in a policy (custom-condition expressions, and row-filter expressions a plugin evaluates as JavaScript) run in a sandboxed engine: no host class lookup or loading, host access limited to Ranger's script API, no threads, no native access. Violation symptom: a policy script reaches Java classes, the file system, or process execution on a plugin host. Severity: VALID when a delegated, security-zone or Service Admin can author the script, since that runs code outside any delegated scope; VALID-HARDENING when only a top-level Ranger admin can (§7) (maintainer, 2026-10-23).
(Hypothesized; confirm/correct.)
ranger.admin.allow.unauthenticated.download.access=true, any network peer that reaches Admin can read policies, tags, roles, users/groups and GDS data through the download endpoints (§5a) (maintainer, 2026-10-23).False friends (highest-value warnings — confirm):
Well-known attack classes left to the integrator/operator:
For Ranger the “downstream user” is the cluster operator who deploys Admin + plugins. To keep §5–§7 assumptions valid, the operator must (hypothesized — confirm):
service.admin.users / service.admin.groups of any service can manage every Ranger role (§2). Do not use roles to separate services whose admins should not affect each other (maintainer, 2026-10-23).ranger.admin.allow.unauthenticated.access at its default false. Enable ranger.admin.allow.unauthenticated.download.access only where policies, roles, tags and user/group data need no confidentiality on the cluster network (§5a) (maintainer, 2026-10-23).(Hypothesized — confirm/expand.)
service.admin.groups to public. Every authenticated user then becomes Service Admin and can manage every Ranger role (§2) (inferred).ranger.admin.allow.unauthenticated.access=true in production. Plugin grant/revoke and download endpoints then accept callers with no authenticated session (§5a) (documented — ranger-admin-default-site.xml).(To be populated by the PMC from real scanner/report history — this is a high-value section the team cannot fill from public sources alone.)
Provisional candidates (inferred):
filesourceusersynctool, ldapconfigchecktool) — out of scope per §3. (Note: ranger-examples/ and ranger-tools/ are in scope per the PMC — do not file them as non-findings.)BY-DESIGN / operator-hardening, not a code vulnerability (maintainer, 2026-06-12 — §14 Q2).ROLE_USER without module/tab permissions) can look up any user, group, or role name in the Ranger UI via lookup REST endpoints (GET /service/xusers/lookup/users, /lookup/groups, /lookup/principals, GET /service/roles/lookup/roles/names). By design for UI typeahead in policy and service forms; returns names only, not full profiles. Disposition: KNOWN-NON-FINDING (maintainer, 2026-07-14).PUT /service/roles/roles/grant/{serviceName}, /roles/revoke/{serviceName}, or role create/delete with ?serviceName=. Adding or removing a user this way can flip the other service’s decisions (deny↔allow). By design: roles are global, and Service Admins manage them so services like Hive can use Ranger roles (§2, §9). Disposition: KNOWN-NON-FINDING (maintainer, 2026-10-23).Correction (do NOT wave off): a “default/seeded admin password” finding is not a non-finding — the installer mandates a complexity-checked password on fresh install, so a seeded/default password is not a supported posture (§5a) (maintainer, 2026-06-12 — §14 Q3/Q18).
Correction (do NOT wave off): the public health/metrics buckets of Admin and the PDP (§4, §14 Q10) do not extend to Ranger KMS. A KMS endpoint, including /jmx, that answers without authentication is not a known non-finding (§4) (maintainer, 2026-10-23).
Correction (do NOT wave off): “policy content comes from a trusted admin” does not cover a script in a policy escaping the sandbox. Delegated, security-zone and Service Admins author policies too, so route such reports by §8 #7, not as OUT-OF-MODEL: trusted-input (maintainer, 2026-10-23).
ranger-examples/ into core.| Disposition | Meaning | Licensed by |
|---|---|---|
VALID | Violates a claimed property (e.g., authorization bypass via policy-eval bug, unauthenticated policy write) by an in-scope adversary/input. | §8, §6, §7 |
VALID-HARDENING | No §8 property broken, but Ranger elects to harden an easy misuse (e.g., tighten a default). Reported privately; CVE at maintainer discretion. | §11 |
OUT-OF-MODEL: trusted-input | Requires control of an input the model marks trusted (e.g., the authenticated principal identity, or directly-tampered DB/key store). | §6 |
OUT-OF-MODEL: adversary-not-in-scope | Requires an excluded capability (code execution on a plugin host; malicious top-level admin; side channel). | §7 |
OUT-OF-MODEL: unsupported-component | Lands in ranger-examples/ or build/install/migration tooling. | §3 |
OUT-OF-MODEL: non-default-build | Only manifests under a discouraged/non-default config knob. | §5a |
BY-DESIGN: property-disclaimed | Concerns a property §9 explicitly disclaims (no end-user auth, no transport security by default, stale-policy window, etc.). | §9 |
KNOWN-NON-FINDING | Matches a documented recurring false positive. | §11a |
MODEL-GAP | Cannot be cleanly routed — triggers a model revision. | §12 |
The Apache Ranger PMC (Abhishek Kumar, @kumaab) reviewed this model on apache/ranger#994 and answered all 20 open questions on 2026-06-12. The answers are recorded below and folded into §1–§13; confirmed claims are promoted to (maintainer, 2026-06-12). Abhishek volunteered to own ongoing revision (Q20).
Wave 1 — scope & defaults
admin, rangerusersync, rangertagsync, keyadmin) as install-bootstrap values, but the standard installer requires an explicit, complexity-checked password on fresh install (changeable any time via UI/REST). A seeded/default password is not a supported production posture.ranger-examples and ranger-tools are IN scope. Out of model: migration-util and the ugsync utilities (filesourceusersynctool, ldapconfigchecktool).Wave 2 — trust & authentication 6. Plugin↔Admin auth: plugins and the PDP service (a separate process, not a plugin) authenticate via Kerberos, JWT, or header-based auth with a trusted proxy to download policy. 7. End-user identity: Ranger Admin authenticates management/UI users (LDAP, AD, Unix, PAM, Kerberos/SPNEGO, Knox SSO, header, JWT, internal DB). At data-access time Ranger does not authenticate the end user — the host service authenticates the principal and the PEP hands Ranger an already-authenticated principal. 8. Byzantine plugin: full trust once authenticated — a deliberate design choice that keeps runtime overhead low; Ranger makes no cross-node integrity claim. 9. Fail mode: if a plugin can neither evaluate fresh nor cached policy it denies — except the HDFS plugin, which can fall through to native ACLs. 10. REST endpoint matrix: three buckets — (1) public (login/static, /service/actuator/health, /service/metrics/**); (2) plugin/PEP identity (policy/tag/role/user/GDS download + grant/revoke — security="none" at Spring but app-layer authenticated by service client-cert or SPNEGO, with secure/...download variants requiring a user in policy.download.auth.users); (3) authenticated admin/user (everything else: policy/service/user/role/zone/audit CRUD, plugin info, KMS keys — session + @PreAuthorize RBAC, writes blocked for read-only Auditor). Clarification (2026-10-23): “grant/revoke” in bucket (2) means policy grant/revoke (/service/plugins/services/grant|revoke/**). Role grant/revoke (/service/roles/roles/grant|revoke/{serviceName}) is in bucket (3): Ranger admins and Service Admins (§2) call it directly, and a service's plugin user can call it on behalf of an end user.
Wave 3 — properties, resources, KMS 11. Authorization-bypass severity: an existing deny-policy (or absence of a grant) that nonetheless yields access is CVE-class VALID. 12. Resource / DoS line: “policy evaluation is bounded and thread-safe” is correct; super-linear evaluation cost is NOT a bug; a hang inside the host service could be a security issue; whether no resource guarantee is made is left for later ratification. 13. KMS authorization: the key is the KMS-policy resource; unauthorized key retrieval is CVE-class VALID. 14. Audit integrity: a non-admin able to tamper audit records IS a security finding. 15. Stale-policy window: revocation-propagation delay (pull interval + cache) is by design.
Wave 4 — misuse, non-findings, ownership 16. Tagsync/usersync trust: confirmed — policy is only as trustworthy as the tag/identity source; upstream injection is out of model. 17. Resource canonicalization: resource names must map correctly between service and policy — a shared responsibility with the host service. 18. Known non-findings: the §11a list is a good starting point and can evolve; one correction — admin password is mandated at installation, so an insecure default password is NOT a supported posture (folded into §5a/§11a). 19. Side channels / co-tenancy: out of scope. 20. Ownership: yes — this becomes the canonical Ranger security model; Abhishek Kumar volunteers to own its revision.
Remaining genuinely-open item: whether Ranger makes no resource guarantee at all (§8 #6) — the PMC deferred this for later ratification.