Authority Graphs and Economic Blast Radius: Measuring the Cost of Compromised Trust
Abstract
Authorization systems are commonly evaluated through permissions, roles, policies, and access-control decisions. These mechanisms answer whether an identity can perform a particular operation, but they do not necessarily reveal the full consequences of that authority being compromised.
In a distributed financial system, authority rarely exists in isolation. A credential may authorize a service, that service may issue capabilities to other components, and those components may control operations involving custody, settlement, liquidity, or ledger state. The resulting dependency structure creates an authority graph whose topology determines how far a compromise can propagate.
This article develops a graph-based model for analyzing authority concentration and economic blast radius. It examines how transitive delegation, shared credentials, policy dependencies, execution boundaries, and revocation mechanisms influence the amount of value exposed by a compromised authority. It also introduces a distinction between technical reachability and effective economic influence, since a component’s ability to reach another component does not automatically imply the ability to move or irreversibly alter its assets.
The objective is to make authority exposure measurable, allowing security architecture to reason not only about whether an operation is authorized, but also about the maximum economic consequences of that authorization being abused.
- Authorization Is Not a Local Property
Most access-control models describe authorization as a decision associated with an identity and an operation.
A principal requests an action, a policy evaluates the request, and the system returns an authorization result. This is a useful abstraction for individual operations, but it becomes incomplete when the same authority participates in several services and those services depend on one another.
Consider a financial infrastructure with a transaction orchestrator, a custody service, a settlement engine, a policy evaluator, and a ledger. Each component has its own responsibilities, credentials, and execution boundaries. Yet the security of the entire system depends on the relationships between them.
The orchestrator may submit transactions to custody. Custody may authorize signing operations. The settlement engine may consume signed instructions. The ledger may record the resulting economic state. A compromise in one component can therefore affect components that never directly authenticate the compromised identity.
This is the difference between an access-control model and an authority model.
Access control describes individual permissions. An authority model describes the structure through which those permissions influence other components and ultimately produce effects.
The distinction matters because the security impact of a compromised credential is rarely limited to the resource explicitly associated with that credential.
A service account that can invoke a signing API might appear to have a narrow permission. If the signing API accepts arbitrary transaction payloads and the resulting signatures are accepted by a settlement service, the effective authority of that account is considerably larger than its local permission suggests.
The local policy may be correct. The architecture may still expose an unexpectedly large portion of the system.
- Modeling Authority as a Directed Graph
An authority graph provides a way to represent these relationships explicitly.
Let:
[
G_A = (V, E)
]
where (V) represents principals, services, credentials, capabilities, policy authorities, and execution boundaries. The edge set (E) represents relationships through which authority is granted, delegated, exercised, or enforced.
Not all edges mean the same thing. Treating them as interchangeable would produce a misleading security model.
At minimum, an implementation should distinguish:
- Delegation: one authority grants another principal the ability to act.
- Invocation: one component can request an operation from another.
- Approval: one component can authorize an operation that another component executes.
- Execution: a component can produce an irreversible or economically relevant effect.
- Verification: a component determines whether an operation satisfies a policy or cryptographic condition.
- Revocation: an authority can invalidate previously granted permissions or capabilities.
For example, a custody service may delegate signing authority to a constrained signing worker. The worker can invoke a hardware security module, but the HSM may enforce key-specific restrictions. The resulting signature may then be submitted to settlement, where another component verifies transaction constraints.
These relationships form a directed graph, but a simple path through that graph does not necessarily represent a valid execution path.
A delegation edge does not imply unrestricted invocation. An invocation edge does not imply approval. A valid signature does not necessarily imply that settlement will accept the transaction.
Consequently, the graph must preserve the semantics of each relationship.
One possible representation is:
[
e = (u, v, \tau, c, p)
]
where:
- (u) is the originating authority.
- (v) is the target component.
- (\tau) identifies the relationship type.
- (c) represents the constraints associated with the relationship.
- (p) identifies the policy or verification mechanism governing it.
The constraints are essential. A signing worker may be authorized to sign transactions for one asset, below a defined amount, and only for a particular settlement destination.
Representing that relationship as an unrestricted signing edge would overestimate its authority. Omitting the constraints would make the graph technically connected but semantically inaccurate.
- Reachability Does Not Equal Economic Authority
A central problem in authority analysis is confusing technical reachability with effective economic influence.
Suppose a compromised service can communicate with the custody API. That fact alone does not establish that it can withdraw funds.
The custody API may require a capability issued by a separate policy service. The capability may bind the operation to a specific asset, amount, destination, and expiration time. The signing infrastructure may enforce additional constraints, and settlement may independently validate the resulting instruction.
The relevant question is not simply whether a path exists between two components.
It is whether a sequence of operations exists that satisfies every authorization, verification, and execution constraint along that path.
Let (P(s,t)) represent a candidate path from compromised component (s) to an economically relevant target (t).
A path is feasible only if its edge constraints are jointly satisfiable:
[
\operatorname{Feasible}(P) =
\bigwedge_{e \in P} \operatorname{Valid}(e)
]
In a real system, this condition is more complicated because constraints can depend on shared state, time, transaction attributes, and previous operations. Two edges may be individually valid while their combined execution is impossible.
For example, a service might possess permission to request signatures and another permission to initiate withdrawals, but those permissions may apply to different transaction contexts. A graph that simply connects the corresponding components would incorrectly conclude that the service can complete a withdrawal.
This is why authority analysis must incorporate execution semantics rather than relying exclusively on connectivity.
A useful distinction is:
[
\text{Reachability} \neq \text{Executable Authority}
]
And even executable authority does not necessarily imply unrestricted economic exposure.
The amount of value that can actually be affected depends on the constraints enforced at the final execution boundary.
- Authority Concentration and Dominators
Once authority relationships are modeled, graph theory provides useful tools for identifying structural concentration.
One particularly relevant concept is the dominator.
In a directed graph, a node (d) dominates a node (v) relative to a starting node (s) if every path from (s) to (v) passes through (d).
In an authority graph, this can reveal components that serve as unavoidable control points.
Consider a system where several transaction orchestrators can request operations, but every signing operation must pass through a single signing authority. That authority dominates the signing boundary relative to those orchestrators.
If the signing authority is compromised, the attacker may gain influence over every execution path that depends on it.
This does not mean every asset is automatically exposed. Additional transaction constraints may still prevent unauthorized movement. However, the signing authority represents a concentration point whose compromise deserves disproportionate attention.
The same reasoning applies to:
- Centralized policy engines.
- Shared service credentials.
- Root capability issuers.
- Key-management authorities.
- Administrative recovery services.
- Shared infrastructure responsible for approving settlement instructions.
A component that dominates many economically relevant targets can represent a larger systemic risk than a component with more local permissions.
The distinction is architectural, not merely operational.
A service may have relatively few permissions and still become a critical authority concentration point because every meaningful execution path depends on it.
- From Graph Topology to Economic Exposure
A graph becomes much more useful when its structure can be related to measurable economic consequences.
Let (A) represent a compromised authority and (R(A)) the set of economically relevant operations that become feasible under the compromise model.
For each operation (i), define:
- (V_i): the maximum value affected by the operation.
- (q_i): the fraction of that value that can realistically be exposed.
- (p_i): the probability that the operation succeeds under the assumed attack conditions.
- (L_i): the estimated economic loss if the operation succeeds.
A simplified exposure model is:
[
E(A) = \sum_{i \in R(A)} p_i q_i V_i
]
This expression is not a universal risk formula. Its purpose is to make the assumptions visible.
In particular, the operations cannot always be treated as independent. Two withdrawal paths may compete for the same liquidity. Multiple settlement operations may affect the same position. A compromised authority may be able to exhaust a shared limit, preventing subsequent operations from succeeding.
For that reason, the sum can overestimate exposure when operations overlap.
A more conservative approach is to define a feasible set of concurrent operations (X(A)) and calculate the maximum aggregate exposure under the system’s actual constraints:
[
E_{\max}(A) =
\max_{x \in X(A)}
\sum_i x_i L_i
]
Here, (X(A)) must encode the constraints that matter: available balances, withdrawal limits, asset restrictions, transaction dependencies, settlement capacity, and any other enforceable invariant.
This changes the security question.
Instead of asking how many services a compromised credential can access, we ask:
What is the maximum economic effect that the compromised authority can produce while all remaining controls behave according to their specifications?
That is a much more useful architectural metric.
- The Difference Between Authority Reach and Asset Reach
A particularly dangerous assumption is that authority over a service implies authority over all assets managed by that service.
Custody systems should not be modeled this way.
An account may contain several asset classes, each with different settlement mechanisms, withdrawal restrictions, and execution requirements. A service credential might be able to initiate operations across several asset types while only being able to authorize a restricted subset.
Therefore, economic exposure should be modeled at the level of the actual operation and asset boundary.
For example, suppose a compromised orchestration service can initiate transfers for three asset classes:
Asset Available balance Enforced operation limit Potential exposure
Asset A 5,000,000 100,000 100,000
Asset B 2,000,000 25,000 25,000
Asset C 800,000 10,000 10,000
The total balance under management is 7.8 million, but the immediate exposure under these constraints is 135,000.
That difference is not cosmetic. It is the result of architectural controls that limit the economic influence of a compromised authority.
However, the calculation is only valid if those limits are enforced independently of the compromised component.
If the orchestration service can modify its own limits, obtain a broader capability, or bypass the component responsible for enforcement, the assumed exposure boundary does not exist.
An authority graph should therefore identify not only where limits are defined, but also which components can modify, override, or bypass them.
- Shared Dependencies Create Correlated Failure
Distributed architectures frequently introduce shared dependencies to simplify operations.
A single credential may authenticate multiple services. A common policy engine may authorize several transaction types. A shared key-management service may protect signing operations across multiple business domains.
These choices reduce duplication, but they also introduce correlated failure.
If several services depend on the same authority, compromising that authority can affect all of them simultaneously.
Let (D(a)) represent the set of components dependent on authority (a).
A basic measure of dependency concentration is:
[
C(a) = |D(a)|
]
This is useful as an initial indicator, but component count alone is not enough.
A compromised authority affecting ten low-impact monitoring services may be less dangerous than one affecting a single settlement boundary.
A weighted measure is more informative:
[
C_w(a) = \sum_{v \in D(a)} w(v)
]
where (w(v)) represents the security or economic importance of component (v).
The weighting should reflect actual system responsibilities, not organizational labels or subjective importance scores.
A custody execution boundary, for example, should receive a different weight from a read-only reporting service.
Even this weighted model has limitations. Dependencies may overlap, and multiple paths may lead to the same economic operation. The graph must avoid counting the same exposure repeatedly.
The broader lesson is that shared infrastructure should be evaluated by the consequences of its compromise, not simply by its operational convenience.
- Revocation Changes the Graph Over Time
Authority graphs are not static.
Credentials expire. Capabilities are revoked. Policies change. Services are removed. New delegation relationships are introduced. Recovery procedures may temporarily grant elevated permissions.
A graph captured at one moment may therefore misrepresent the authority structure at another.
Let:
[
G_A(t) = (V(t), E(t))
]
represent the authority graph at time (t).
When a credential is revoked, the corresponding authority relationship should become invalid according to the revocation guarantees of the system. However, the graph may continue to contain derived capabilities or downstream relationships that were created before revocation.
This is particularly important in distributed systems where authority is delegated across multiple services.
Revoking a root credential does not necessarily invalidate every capability derived from it unless the architecture explicitly defines that propagation behavior.
A system must therefore distinguish between:
- The authority currently granted.
- The authority already delegated.
- The authority that remains usable under bounded offline conditions.
- The authority that has been revoked but has not yet been observed by every verifier.
This is where the authority graph connects directly to revocation semantics.
A revocation mechanism should not merely update a credential’s status. It should define how the invalidation affects every downstream authority relationship that depends on it.
The graph provides a way to identify those relationships and determine which economic operations remain reachable during the propagation interval.
It also makes it possible to reason about revocation completeness.
If a compromised authority has delegated capabilities to several downstream services, the system must be able to identify those descendants and determine whether they remain usable after the original authority is revoked.
Without that dependency information, revocation becomes an administrative action whose actual security effect is difficult to establish.
- Measuring the Economic Blast Radius
The economic blast radius of a compromised authority is the maximum economic effect that can result from its compromise under a defined set of system assumptions.
It is not necessarily the total value managed by the infrastructure, nor the total number of reachable components.
A useful assessment should include at least four dimensions.
Authority reach describes which operations become executable after the compromise.
Economic reach describes the assets, balances, positions, or settlement obligations that those operations can affect.
Constraint independence describes whether the controls limiting those operations remain effective when the compromised authority is controlled by an attacker.
Temporal exposure describes how long the compromised authority can continue producing effects before revocation or containment becomes effective.
These dimensions should be evaluated together.
A credential with broad authority but a short lifetime and independently enforced transaction limits may have a smaller economic blast radius than a narrowly scoped credential that can bypass settlement controls and remain valid indefinitely.
The distinction is important because authority scope alone is not a sufficient risk metric.
For practical assessment, I would define an exposure record for each critical authority:
AuthorityExposure {
authority_id
affected_operations
reachable_assets
maximum_transaction_value
cumulative_execution_limit
independent_enforcement_points
delegation_depth
revocation_propagation_bound
maximum_stale_authority_window
recovery_dependencies
}
The record should be derived from the actual authorization and execution model. It should not be manually maintained as a parallel description of the architecture, because that would eventually drift away from the system it is supposed to describe.
Ideally, the authority graph should be generated from policy definitions, capability issuance records, service identities, and execution-boundary configuration.
The resulting model can then be evaluated continuously as the architecture changes.
- Designing Against Authority Concentration
Reducing economic blast radius does not require eliminating every shared authority. Some forms of centralization are operationally necessary.
The objective is to ensure that no single compromised authority can produce an economic effect larger than the system is designed to tolerate.
Several architectural techniques help achieve this.
First, delegation should be constrained by operation, asset, amount, destination, and lifetime. A capability should authorize a specific class of behavior rather than granting broad access to a service.
Second, high-impact operations should require independent enforcement. A service that initiates a transaction should not be the only component responsible for validating its economic constraints.
Third, shared authorities should be isolated according to their economic responsibilities. A common credential across custody, settlement, and administrative recovery creates unnecessary correlation between otherwise separate security domains.
Fourth, recovery mechanisms should be included in the authority graph. Emergency access is still authority, even if it is rarely used. A recovery process that bypasses normal controls can become the largest concentration point in the system.
Finally, revocation should operate across the delegation structure. The system needs to identify derived authority, invalidate it according to explicit consistency guarantees, and prevent stale authorization from crossing irreversible execution boundaries.
These controls do not eliminate compromise. They constrain what compromise can accomplish.
That is the more realistic objective.
- Authority Graphs as an Engineering Invariant
The most useful consequence of this model is that authority topology can become part of the system’s engineering invariants.
For example, a financial infrastructure might define the following properties:
- No single application credential may authorize unrestricted movement of assets across all custody domains.
- Every irreversible settlement operation must be subject to an enforcement boundary independent of the initiating service.
- Every delegated capability must have a bounded scope and lifetime.
- Every critical authority must have an identifiable revocation path.
- Emergency recovery authority must be included in blast-radius calculations.
- No authority compromise may exceed a predefined economic exposure limit without triggering additional independent controls.
These are not merely policy statements. They can be translated into graph queries, configuration checks, policy tests, and formal properties.
For example, a deployment pipeline could reject an architecture change if a new delegation relationship creates an unrestricted path from an application identity to a settlement boundary.
A policy verification process could check whether every high-value execution path contains an independent enforcement point.
A risk analysis process could calculate the maximum economic exposure associated with each critical authority and compare it against predefined limits.
The graph then becomes more than a documentation artifact. It becomes an executable representation of security architecture.
- What the Model Cannot Prove
An authority graph is only as accurate as the relationships and constraints represented in it.
It cannot prove that a policy engine correctly implements its specification. It cannot establish that a hardware security module is free from vulnerabilities. It cannot guarantee that an operator will follow recovery procedures. It cannot automatically identify undocumented side channels or infrastructure-level compromise paths.
Nor can a graph-derived exposure estimate replace adversarial testing.
The model should be treated as one layer of assurance, alongside implementation verification, cryptographic controls, operational monitoring, and incident exercises.
Its value lies in making assumptions explicit.
If the architecture assumes that a signing service enforces transaction limits independently, that assumption should be testable. If the revocation model assumes that downstream capabilities become unusable within a bounded interval, that guarantee should be measurable. If a recovery service can bypass normal policy enforcement, that relationship should appear in the graph.
An authority model that omits these dependencies may produce reassuring numbers while describing a system that does not actually exist.
Conclusion
The compromise of a credential is not inherently limited by the permissions attached to that credential. Its real impact depends on the authority relationships it can activate, the execution paths it can influence, and the economic constraints that remain effective after the compromise.
This is why authorization should be analyzed as a graph rather than as a collection of isolated access-control decisions.
Graph topology reveals concentration points. Execution semantics distinguish reachable services from feasible operations. Economic constraints translate authority into measurable exposure. Revocation analysis determines how that exposure changes over time.
Together, these elements provide a more precise way to reason about the consequences of compromised trust.
The central architectural question is not simply whether a component has permission to perform an operation.
It is how much of the system’s economic state can be affected when that component can no longer be trusted.
A secure financial system should be designed so that the answer is known before the compromise occurs.