Zero-trust: rethinking authn/authz in OpenStack

Short version: requirements, state, path

Artem Goncharov

2026-10-23

Agenda

  • Requirements: what security and the law ask of us
  • Where we are: how authn/authz works in OpenStack today
  • How we get there: the target design and the roadmap
  • Lessons learned: what it costs and what we would do again

What are we protecting? Three questions on every call

  • Who is calling?
  • Where (which project, domain, system) does the call act?
  • What is this caller allowed to do there, now?
  • Today one object answers all three: the Fernet token
  • Zero-trust here means: answer each separately, cryptographically, at the time of the call

Security requirements

  • No trust by network position: "internal" is not an identity
  • Identity from the runtime, not from a password in a file
  • No long-lived bearer secrets: a stolen token must be useless to a thief
  • Least privilege per request: a workload gets one operation, not admin
  • Bounded revocation and freshness: stale answers have a stated limit and fail closed
  • Auditable delegation: always visible who acted for whom

Constraints we do not get to ignore

  • Compatibility: unmodified services, Fernet tokens and Python Keystone keep working
  • Small clouds: most deployments have fewer than 100 nodes
  • Every step additive, with an off switch per service
  • Community: each project adopts on its own schedule

Today: how a request is authenticated

image

Today: where it fails the requirements

image

Gap analysis

Requirement Today
No trust by network position Plaintext back-channel, "internal" endpoints
Identity from the runtime Service passwords in config files, clouds.yaml
Useless when stolen Bearer Fernet token
Least privilege per request Scope and roles frozen at issuance, member or admin per workload
Bounded freshness Validation caches: availability bought with staleness
Auditable delegation Trusts and app credentials; OSSA-2026-005, OSSA-2026-015

The target: who, where, what

image

  • Who: scope-less JWT. Where: OpenStack-Target header. What: /v4/authz/check
  • Control plane identities come from SPIRE (SPIFFE)

Services: identity from the handshake

image

  • Every process holds a short-lived SPIFFE identity from SPIRE
  • Internal interfaces terminate mTLS: the TLS peer is the identity
  • Gone: service passwords, X-Service-Token, plaintext back-channel

Clients: a token that only says who

image

  • Short-lived JWT, validated offline: no project, no domain, no roles
  • OAuth2 DPoP (RFC 9449): token bound to the client key, every request carries a signed proof
  • Safe only with sender constraint, audience narrowing and self-imposed restrictions

Authorization: the service asks, Keystone decides

image

  • Each request states where it acts; each check decides what is allowed, now
  • No decision cache: freshness from replicas, fail closed when none is reachable

Delegation and workloads: no secrets handed around

  • Trusts replaced by service grants (work with no user present) and on-behalf-of exchange (RFC 8693)
  • The acting service is always visible in the token (act)
  • VMs and cluster nodes prove placement to Keystone and get an identity bound to their project: no credentials injected into guests
  • App credentials and EC2 keys shrink to off-cloud automation
  • Humans and CLI: passkeys (WebAuthn), device flow for headless; sensitive operations require step-up

Roadmap

image

  • Every step is additive: Python Keystone, Fernet and unmodified services keep working
  • Scope-less JWT is gated behind its mitigations, not the calendar

Lessons learned

  • Compatibility is a design input: off switch per feature, or nobody adopts
  • Fail closed hurts at bootstrap: SVID before service, service before token
  • Revocation expectations: operators expect "immediate", get "lag, with a number"
  • Python world needs patches: middleware and keystoneauth, SPIFFE support still WIP
  • Silent retries hide misconfiguration: a wrong SVID made storage init hang with no error line
  • Operations lag behind design: SPIRE and a stateful Keystone are new things to run
  • Community acceptance is not granted

The cost and what we do not do

Cost Not (yet) done
Operators run SPIRE: a new tier-0 dependency Per-host node identity in production-grade form
Availability model: no cache, fail closed Continuous, risk-based re-evaluation
Keystone becomes stateful Network microsegmentation
Shared contracts need agreement across projects Signing keys in an HSM

Advice and takeaways

  • Hunt perimeter assumptions first: plaintext hops, shared passwords, "internal" endpoints
  • Split who / where / what before choosing tools
  • Identity from the runtime (SPIFFE); sender-constrained tokens (DPoP) for clients
  • Prefer replicas to caches; state your staleness bound
  • Keep every step additive; be honest about what you do not do
  • Join the discussion, raise your voice so upstream sees the demand:

Questions