TL;DR: Modern infrastructure increasingly issues valid credentials that outlive the runtime context they were meant to protect, making possession-based trust too weak for workload security, according to Riptides. The decisive gap is not token validity but whether the current actor is still legitimate at the moment access is used.
At a glance
What this is: This is an analysis of why bearer token validity is no longer enough for modern workload security, because runtime context can change after issuance.
Why it matters: It matters because IAM, PAM, NHI, and workload identity teams need controls that verify current execution state, not just earlier authentication, when access decisions are made.
Context
Bearer tokens are transferable credentials that prove a workload authenticated at some earlier point, but not that the same actor is still valid when the action occurs. In dynamic cloud and API-heavy environments, that gap turns possession into an unreliable trust signal for NHI governance.
The core governance problem is not issuance alone. It is the widening gap between credential validity and runtime legitimacy, especially where service accounts, federated trust, and short-lived certificates move across boundaries at machine speed.
Key questions
Q: What fails when workload security relies only on valid bearer tokens?
A: The failure is not cryptographic validity, but stale trust. A token can be correctly signed and unexpired while the current process using it is compromised, replaced, or operating outside its intended context. In that situation, access control is evaluating a credential artifact instead of the live actor, which leaves modern workload environments exposed.
Q: What is the difference between federation and runtime enforcement in workload identity?
A: Federation decides which external identities are trusted to authenticate. Runtime enforcement decides which authenticated identities can actually create a communication path at the moment a connection begins. A program can have one without the other, but only the second turns identity into a usable control boundary.
Q: What are the signs that possession-based trust is failing in workload environments?
A: Look for systems that accept credentials without checking the current process, execution state, or connection boundary. Reused tokens, replayable identities, and policy decisions made away from the runtime boundary are strong indicators that authorization is drifting back to artifact trust instead of live legitimacy.
Q: Should teams prioritise token rotation or runtime enforcement first?
A: Runtime enforcement should come first where credentials are highly transferable or workloads are ephemeral, because rotation alone does not stop a valid token from being reused during its lifetime. Rotation still matters, but it only reduces exposure if the access decision also checks the current actor at use time.
Technical breakdown
Why token validity stops short of runtime legitimacy
A signed, unexpired token proves that an authority issued a credential and that the credential has not expired. It does not prove that the current process using it is the same process that originally authenticated, or that the workload state is unchanged. In static environments that shortcut was often tolerable because runtime and identity moved together. In modern environments, workloads are ephemeral, identities are federated, and credentials are transferable, so the trust decision must follow the execution context rather than the artifact alone.
Practical implication: do not treat signature verification and expiration checks as complete authorization in dynamic workload environments.
Why adjacent policy layers can still fall back to possession-based trust
Proxies, service meshes, SDKs, and centralized policy engines can evaluate rich rules, but they often sit beside execution instead of inside it. That means they may know a token is valid while still missing whether the actual process, container, or runtime context has drifted. When enforcement is detached from the boundary where the connection is created, the architecture quietly reverts to trusting the portable credential rather than the live workload. That is why runtime enforcement changes the security model, not just the control stack.
Practical implication: place enforcement where connection decisions are made, not only where credentials are validated.
What federation changes and what it does not
Federation extends trust across domains, clouds, and organizational boundaries, which is useful but also expands the blast radius of transferable credentials. A federated identity chain can remain cryptographically valid even after the original runtime context has shifted, which means the access decision can still be stale. The article’s central point is that federation solves propagation of trust, not the continuous proof of legitimacy at use time. For NHI governance, that distinction is fundamental because the control objective is no longer just who issued the credential, but whether the current actor still deserves the session.
Practical implication: pair federated trust with live context checks if you want the access decision to reflect current legitimacy.
Threat narrative
Attacker objective: The objective is to turn a valid credential into unauthorized workload access that survives beyond the original execution context.
- Entry occurs when a valid bearer token, JWT, SPIFFE identity, or short-lived certificate is exposed, replayed, or reused outside its original runtime context. Escalation follows because the infrastructure continues to accept the credential as proof of legitimacy even when the current actor has changed. Impact occurs when the attacker or compromised process uses that transferable trust to access downstream APIs and workloads without the runtime boundary rejecting the action.
Breaches seen in the wild
- Microsoft Storm-0558 key breach 2023: China-based Storm-0558 used a stolen, never-retired Microsoft signing key to forge tokens and read email at 22 organisations in 2023.
Read and download The State of NHI & AI Agent Breach Report 2026, covering 200+ breaches impacting Non-Human Identities including AI Agents.
NHI Mgmt Group analysis
Bearer token validity is not the same as runtime legitimacy. That assumption was designed for environments where authentication and execution stayed tightly coupled. It fails when workloads are ephemeral and credentials are transferable, because the actor presenting the token can change after issuance. The implication is that workload governance has to move from artifact trust to live actor verification.
Runtime enforcement is the missing control plane for modern workload security. Systems that validate credentials at the edge but do not observe the running process still inherit possession-based trust. Proxies, meshes, and policy engines can improve decision quality, but they do not solve the underlying problem if they cannot tie the decision to the current execution state. Practitioners should treat enforcement location as a governance decision, not just an architecture choice.
Federation increases the need for context-bound authorization, not less. Extending trust across cloud and organizational boundaries is useful only if the receiving side can continuously test whether the current actor still matches the original trust assumption. The broader lesson is that NHI governance cannot stop at identity portability. Practitioners must re-evaluate where legitimacy is proven and where it is simply assumed.
Credential possession is becoming an insufficient trust primitive for machine identity. Modern systems increasingly need to ask whether the process behind the token is the one that should still be acting. That changes the centre of gravity from issuance and expiration to runtime-state verification, and it makes access control dependent on continuous context, not a one-time proof. Security teams should treat this as a structural shift in workload identity governance.
Runtime-bound identity creates a more honest security model for machine access. The article points toward a category of enforcement that binds identity decisions to the process and connection boundary rather than to a reusable token alone. That is the right direction for workloads, service-to-service communication, and federated access flows. Practitioners should assume that any control built only on credential validity will increasingly lag the environments it is meant to protect.
What this signals
Runtime-bound identity: The governance shift is from proving that a workload authenticated at some point to proving that the same actor is still entitled to act right now. That matters most where tokens move faster than review cycles and where access decisions are made by adjacent infrastructure rather than the workload boundary.
Modern NHI programmes should assume that possession and legitimacy will continue to diverge in dynamic environments. The practical consequence is that access control, federation, and workload identity need to be evaluated together, because any one of them can still fail open when runtime context is not enforced.
For practitioners
- Audit possession-based trust paths Map where bearer tokens, JWTs, SPIFFE identities, and short-lived certificates are still treated as sufficient proof of legitimacy after issuance. Flag every place where the runtime context is no longer checked at the moment of use.
- Move enforcement to the connection boundary Prefer controls that evaluate which process is initiating the connection and whether the current execution state still matches the original trust assumptions, rather than relying only on adjacent policy layers.
- Re-evaluate federated trust assumptions Treat federation as trust propagation, not trust completion, and require continuous legitimacy checks when identities cross cloud or organizational boundaries.
- Separate credential validity from actor legitimacy Build review criteria that ask whether a valid credential still belongs to the same workload, process, or session that was authorised, especially in ephemeral environments.
- Prioritise runtime-bound enforcement for high-blast-radius workloads Focus first on workloads that can reach sensitive APIs, shared data stores, or cross-boundary services, where replayed credentials create the most downstream exposure.
Key takeaways
- Bearer token validity can no longer be treated as proof that a workload should still have access at the moment of use.
- The real control gap is the separation between credential validation and runtime legitimacy in dynamic environments.
- Teams need enforcement that evaluates the current actor and execution state, not just the token that was issued earlier.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP Non-Human Identity Top 10 and MITRE ATT&CK address the attack and risk surface, while NIST CSF 2.0 sets the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| OWASP Non-Human Identity Top 10 | NHI-04 — Insecure Authentication | The article argues that credential validity alone is insufficient for current-actor trust. |
| NHI-05 — Overprivileged NHI | Transferable credentials can preserve access beyond the intended runtime boundary. | |
| NHI-07 — Long-Lived Secrets | Even short-lived credentials can remain reusable long enough to outlive the intended context. | |
| Recommendation — Bind workload authentication to live runtime context instead of relying on token possession alone. Reduce the standing blast radius of workload credentials and re-check entitlement at use time. Treat credential lifetime as only one part of the control and enforce live legitimacy at connection time. | ||
| MITRE ATT&CK | TA0006; TA0010 — Credential Access; Exfiltration | The article describes how stolen or reused credentials can be turned into downstream access and misuse. |
| Recommendation — Map replayable credential abuse to credential access and exfiltration tactics in detection and response planning. | ||
| NIST CSF 2.0 | PR.AA-05 — Access Permissions, Entitlements and Authorizations | The topic is fundamentally about whether access remains authorized at the moment of use. |
| Recommendation — Revalidate access permissions at the point of action rather than at token issuance alone. | ||
Key terms
- Runtime Enforcement: Runtime enforcement is the practice of blocking malicious behaviour while software is running, rather than only detecting it after the fact. It monitors process activity, network actions, and privilege changes so a live attack can be interrupted at the point of execution.
- Bearer Token: A bearer token is a credential that grants access to whoever possesses it, without requiring strong proof that the holder is the intended client. In NHI environments, that makes theft and replay the main risk, especially when tokens are long-lived, broadly scoped, or stored in local files.
- Federated Trust: A federated trust is the relationship that allows one identity system to vouch for a user or workload to another system. In ADFS-style models, the application accepts claims from the federation layer instead of authenticating directly. That reduces friction, but it also expands the number of components that must be trusted and defended.
- Runtime Legitimacy: Runtime legitimacy is the question of whether the current actor presenting a valid credential still deserves access right now. It goes beyond token validity and focuses on process state, connection context, and whether the original trust assumption still holds.
Deepen your knowledge
NHI governance, agentic AI identity, and machine identity lifecycle are core topics in our NHI Foundation Level course, the industry's only accredited NHI security programme. If you are building or maturing an IAM programme, it is worth exploring.
Published by the NHIMG editorial team on June 10, 2026.
Updated on October 10, 2026.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org