Internet-Draft Partition-Tolerant Authority Renewal November 2026
Chandra Expires 21 May 2027 [Page]
Workgroup:
Workload Identity in Multi System Environments
Internet-Draft:
draft-chandra-wimse-partition-tolerant-renewal-00
Published:
Intended Status:
Experimental
Expires:
Author:
S. Chandra
Stellarminds.ai

Extend-Only, Threshold-Attested Authority Renewal for Partitioned Agent Meshes

Abstract

Every workload identity architecture in deployment today assumes its credential issuer is reachable: short-lived tokens, fast rotation and timely revocation are guarantees about the connected case. This document specifies what a workload does when that assumption fails, when its credential is nearing or past expiry and its issuer cannot be reached. It defines extend-only, threshold-attested authority renewal. Before any partition, the issuer signs a Mesh Manifest that appoints a bounded set of peers as a limited-authority local issuer: it names the members, fixes a ceiling on total extension, caps the scope any renewal may carry, and sets a validity window. During a partition, a severed workload broadcasts a signed renewal request to those peers; each peer independently verifies that the request extends existing authority without widening it, within the manifest's ceiling, and against its own first-hand observation of the requester's health; each attestation signs the digest of the entire request, so scope, requester, timestamps and predecessor are all under the peer's signature; once a two-thirds threshold of the peers (ceil(2N/3) of N >= 4) has attested, the workload treats its authority as extended through a bounded expiry. Rounds are hash-linked, so a chain's signatures commit to the exact history being extended. The document specifies the manifest, the message formats, the independent-evaluation procedure, the renewal-chain construction for partitions outlasting one round, and the verification procedure a relying party runs given the manifest, the chain and the original credential it already trusts. It also specifies, normatively, what this mechanism does not provide: it is not a consensus protocol, it does not establish that a workload is uncompromised, and a revocation issued during a partition is not enforceable until the partition heals; an implementation MUST NOT represent this mechanism as providing partition-proof revocation.

Status of This Memo

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 21 May 2027.

▲

Table of Contents

1. Introduction

Workload identity architectures, including the WIMSE architecture [WIMSEARCH] and its credential formats [WIMSECREDS], and the SPIFFE/SPIRE framework [SPIFFE] that preceded them, treat short credential lifetimes as a security feature: a stolen token is useful only briefly, provided the workload can reach its issuer for a fresh one before the old one expires. No normative guidance exists for the case where a workload is healthy, mutually authenticated with its peers, and mid-task, but cannot reach its issuer before its credential's stated expiry.

The WIMSE working group charter identifies the shape of an answer: a work item for local issuance of WIMSE tokens where the local issuer operates with limited authority, naming as a candidate local issuer the workload itself or another workload deployed nearby [WIMSECHARTER]. This document specifies a hardening of that idea for the adversarial, disconnected case. No single nearby workload is trusted as a local issuer; a two-thirds threshold of a peer set is, and the peer set is not a local configuration choice but an appointment the issuer itself signed before the partition, in a Mesh Manifest (Section 5). The manifest is what makes the quorum a limited-authority local issuer in the charter's sense rather than a second authority standing beside the first.

This document defines the wire formats and verification procedure for that mechanism: extend-only, threshold-attested authority renewal. It normatively fixes the MeshManifest an issuer signs at provisioning time (Section 5), the RenewalRequest a severed workload broadcasts (Section 6), the PeerAttestation a peer returns after independent evaluation (Section 7), the RenewalProof aggregating a quorum of attestations (Section 8), the RenewalChain covering a partition of more than one round (Section 9), and the verification procedure a relying party runs against a presented chain (Section 9.2). It normatively states what this mechanism does not defend (Section 11): it introduces no independent root of authority but does add trust assumptions, it is a threshold and not a consensus protocol, health evidence establishes activity and not authorization, and the revocation residual is bounded, not removed.

This document is intended as an Experimental contribution to the WIMSE working group's local-issuance discussion. A reference implementation and a deterministic conformance corpus exist (Appendix A); interoperability between independent implementations has not yet been demonstrated.

2. Conventions and Definitions

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.

Issuer: The authority that issued the original credential. It takes part in this procedure exactly once, before any partition, by signing the MeshManifest; it is unreachable for the remainder by definition.

Requester: The workload whose credential is nearing or past expiry and whose issuer is unreachable.

Attester (peer): A member of the mesh, named in the MeshManifest, that independently evaluates a renewal request and, if it passes every check in Section 7.2, signs a PeerAttestation.

Relying party: Any party, peer or otherwise, that receives a request from the requester after its nominal expiry and must decide whether to honor it by verifying the RenewalChain presented alongside it, under the MeshManifest.

Mesh Manifest: The issuer-signed object naming the members of the mesh and fixing the ceiling, clock tolerance, scope ceiling and validity window under which renewals may be attested (Section 5).

Peer set: For a given requester, the manifest's members minus that requester. N is its size and MUST be at least 4.

Quorum: ceil(2 * N / 3), the threshold over the peer set. Two quorums over the same peer set share at least N/3 members; that intersection property, not any agreement protocol, is what the threshold provides.

Ceiling: ceiling_seconds, the maximum total peer-attested extension, measured from the original credential's issuance and fixed by the issuer in the manifest.

Renewal Request: The signed object a requester broadcasts naming its original credential, its requested extension, the manifest it is made under, a fresh nonce, its round number and the digest of the proof it extends (Section 6).

Peer Attestation: The signed object a peer returns after passing every independent-evaluation check for one RenewalRequest; it commits to the digest of the whole request (Section 7).

Renewal Proof: The signed RenewalRequest together with at least a quorum of valid, distinct PeerAttestation objects for it (Section 8). It carries no signature of its own; every field a verifier acts on is inside the signed request or recomputed.

Renewal Chain: The ordered sequence of RenewalProof objects issued during one continuous partition, each extending the expiry granted by the one before it and committing to it by digest (Section 9).

3. Roles and Preconditions

The following are established before any partition:

A requester MUST NOT invoke this procedure before attempting and failing to reach its issuer through its normal channel.

4. Identity and Encoding

Every signing identity in this document is assumed to be an Ed25519 key resolvable to a did:key [DIDKEY], consistent with WIMSE Workload Identifier practice [WIMSEID]. Every signed object MUST be canonicalized per RFC 8785 (JCS) [RFC8785] before signing or verifying; a signature covers the canonical JSON of every field except signature itself. Signatures and nonces are standard base64 in the canonical form of [RFC4648], Section 4 (padded, no other characters, pad bits zero); a signature is exactly 64 octets of raw Ed25519 signature. A verifier MUST reject any other spelling of the same octets: each spelling gives the signed object a different digest, so a lenient decoder would let anyone who sees a request mint copies of it that attesters sign (Section 11). Timestamps are RFC 3339 [RFC3339], second precision, UTC, Z suffix.

Every wire object defined by this document (MeshManifest, RenewalRequest, PeerAttestation, RenewalProof) has a closed field set: a verifier MUST reject an object carrying any member not listed in that object's required-members list, in addition to rejecting one missing a required member, even when the extra member was present at signing time and the signature is otherwise valid.

Every wire object MUST be I-JSON [RFC7493], which RFC 8785 presumes: no string contains an unpaired surrogate, and no integer member exceeds 2^53 - 1 (none is negative in this document). Appendix B states the structure of every wire object in CDDL [RFC8610]; an object that does not match it is malformed, as is one that breaks a constraint stated only in prose (ordering, uniqueness, the relation between two members). A verifier MUST reject a malformed object, an object it cannot canonicalize, and an arithmetic result it cannot represent (an expiry after 9999-12-31T23:59:59Z, the last instant RFC 3339 can write) with the same outcome as any other failed check. It MUST NOT abort or fail open on one: every object this document defines can arrive from an adversary.

5. Mesh Manifest

A MeshManifest is a signed JSON object produced by the issuer at provisioning time. It is the single object a relying party verifies first, and the only place the mesh's parameters live. Required members: version (MUST equal "renewal/0.3"), manifest_id (a non-empty opaque string chosen by the issuer; UUIDv4 recommended), issuer_did (the issuer's did:key), members (array of did:key strings, sorted lexicographically, unique, at least 5 entries, so that every member's peer set has at least 4), ceiling_seconds (positive integer), max_clock_skew_seconds (non-negative integer), scope_ceiling (array of strings, sorted, unique: every scope claim a renewal under this manifest may carry), issued_at and expires_at (RFC 3339; expires_at MUST be after issued_at), and signature (Ed25519 by issuer_did over the canonical manifest minus this field).

5.1. Verification

Any party, attester or relying party, MUST, before evaluating anything else under a manifest: check the closed field set and every type and ordering constraint above; resolve issuer_did and verify signature; and compute manifest_hash as "sha256:" followed by the lowercase hexadecimal SHA-256 of the JCS canonical form of the manifest including its signature, so that a re-signed manifest with identical fields is a distinct manifest. A manifest failing either check is rejected and nothing under it is evaluated.

5.2. Peer Set

For a requester R, the peer set is members minus R, and N is its size. N MUST be at least 4. A requester is always a member, so N is the size of members minus one, which is why Section 5 requires at least 5 members. A requester not listed in members is not a member of the mesh and cannot be attested under it, since the issuer signed the credential of a member it named (Section 7.2, item 3).

5.3. Binding

Every RenewalRequest, PeerAttestation and RenewalProof carries manifest_hash. A verifier MUST compare each one to the hash of the manifest it is evaluating under and MUST reject a mismatch. Nothing produced under one manifest can be spliced into a chain evaluated under another, even when both manifests come from the same issuer and name the same members.

5.4. Lifecycle

The issuer rotates the mesh by signing a new manifest; it ends the mechanism by letting the manifest expire or by revoking it through whatever revocation channel it already operates for credentials. A new manifest does not reach into an old signed delegation: a party that has not learned of the rotation or revocation continues to honor the old manifest until it does, which is why expires_at, the one bound that needs no delivery, is the issuer's real lever. A revoked manifest_hash MUST be treated exactly like a revoked original_credential_hash (Section 7.2, item 4; Section 9.2). Revocation of a manifest during a partition has the same structural limit as revocation of a credential (Section 11): it takes effect when the partition heals.

6. Renewal Request

A RenewalRequest is a signed JSON object with the following required members: version (MUST equal "renewal/0.3"), request_id (UUIDv4), requester_did (MUST be listed in the manifest's members), manifest_hash (Section 5.1), original_credential_hash (sha256: followed by the lowercase hexadecimal SHA-256 of the original credential: of its JCS form when the credential is a JSON object, otherwise of the exact octets the issuer produced, such as a JWT's compact serialization), original_issuer_did (MUST equal the manifest's issuer_did), original_scope (array of strings, sorted, fixed for the life of the chain, MUST be a subset of the manifest's scope_ceiling), original_issued_at and original_expiry (RFC 3339; original_expiry MUST be after original_issued_at), requested_extension_seconds (positive integer), nonce (base64, >= 16 bytes, fresh per request), round (integer, 1 for the first round of a partition), prior_proof_digest (null when round is 1, otherwise the digest of the immediately preceding RenewalProof, Section 8.2), created_at (RFC 3339, MUST lie within the manifest's validity window), and signature (Ed25519 by requester_did over the canonical request minus this field). The prior chain is not embedded; it travels alongside the request, as does the original credential (Section 3).

The request digest is "sha256:" followed by the lowercase hexadecimal SHA-256 of the JCS canonical form of the signed request including signature. Every attestation carries it (Section 7), so a request cannot be re-signed with different content after attestation without every attestation ceasing to bind.

A RenewalRequest carries no field capable of widening original_scope; there is no field to smuggle a wider claim into. original_scope, original_issued_at, original_expiry and requester_did are nonetheless the requester's copy of the credential's claims, and attesters (Section 7.2, item 3) and relying parties (Section 9.2, step 2) MUST check them against the credential the issuer actually signed. requested_extension_seconds, combined with the cumulative extension already granted by the prior chain, MUST NOT push the resulting effective expiry past original_issued_at + ceiling_seconds; a request that would MUST be rejected by every honest evaluator at the arithmetic stage (Section 8.1), independent of quorum. An effective expiry RFC 3339 cannot write is past every ceiling.

7. Peer Attestation

A PeerAttestation is a signed JSON object with required members: version ("renewal/0.3"), attester_did (MUST be in the manifest peer set for the requester and MUST NOT equal the request's requester_did), manifest_hash, request_digest (the digest of the signed request, Section 6; this is the binding, committing the attester to every field of the request and not only those repeated here), request_id and nonce (copied verbatim from the request), original_credential_hash (copied verbatim), granted_extension_seconds (MUST equal the request's requested_extension_seconds; attestation is binary, never a counter-offer), as_of (RFC 3339, the peer's own timestamp for its health observation), health_evidence (one of the closed vocabulary below), and signature (Ed25519 by attester_did).

health_evidence MUST be one of: heartbeat_current, task_participation, consensus_round, or other. A strict verifier MAY refuse to honor an other attestation.

7.1. Health Evidence

The vocabulary is deliberately small. heartbeat_current means the attester received a signed heartbeat from the requester within its own freshness window; task_participation means the attester directly observed the requester taking part in a shared task or protocol round; consensus_round means the attester and requester jointly completed a coordination round; other is a mesh-specific signal that deployments SHOULD document. In every case the evidence is the attester's own first-hand observation, never a claim relayed by the requester. It establishes that the requester was recently active, not that it is uncompromised or still entitled to its permissions; the issuer accepts that distinction when it signs a manifest, and an attestation MUST NOT be represented as more than it is.

7.2. Independent Evaluation

Before signing a PeerAttestation, an attester MUST verify all of the following and MUST NOT sign if any check fails:

  1. The MeshManifest verifies per Section 5.1; the request's manifest_hash equals its hash; original_issuer_did equals the manifest's issuer_did; original_scope is within scope_ceiling; created_at is within the manifest's validity window and within max_clock_skew_seconds of the attester's own clock; and the attester's own identity is in the peer set for this requester (Section 5.2).
  2. attester_did (its own identity) MUST NOT equal requester_did. An attester MUST NOT sign an attestation about itself, under any identity it holds.
  3. signature on the RenewalRequest verifies against requester_did; the credential presented alongside the request (or the attester's own copy, Section 3) hashes to original_credential_hash and carries a valid signature by original_issuer_did; and the request's requester_did, original_scope, original_issued_at and original_expiry equal the corresponding claims of that credential. (The mechanism for authenticating the credential is outside this document's scope; it depends on the credential's own format, e.g. [WIMSECREDS]. The comparison is not optional.)
  4. Neither the credential identified by original_credential_hash nor the manifest identified by manifest_hash is present in the attester's own cached revocation state.
  5. The chain the requester presents alongside the request has exactly round - 1 proofs; if non-empty, it verifies per Section 9.1 under the same manifest, prior_proof_digest equals the digest of its last proof, and the request repeats the root request's requester_did, manifest_hash, original_credential_hash, original_issuer_did, original_scope, original_issued_at and original_expiry verbatim. The request's nonce MUST differ from the nonce of every request in that chain, and its created_at MUST NOT be earlier than that of the chain's last request (Section 9.1, items 5 and 9). An attester that did not sign an earlier round never saw that round's nonce, so item 9 alone cannot catch its reuse.
  6. The resulting effective expiry does not exceed original_issued_at + ceiling_seconds.
  7. original_scope is unchanged across every entry in the prior chain and this request.
  8. The requester is healthy per the attester's own fresh, first-hand observation, not a claim relayed by the requester or a third party.
  9. The attester has not already signed an attestation carrying this exact nonce.
  10. The attester has not already signed an attestation for a different request extending the same chain position: the same prior_proof_digest, or for round 1 the same original_credential_hash. One attestation per position per attester is what makes two conflicting proofs for one position require at least N/3 equivocating peers (Section 8.1).

An attestation produced without all ten checks passing is non-conformant, independent of whether the resulting RenewalProof happens to reach quorum. Items 1 and 2 MUST be re-verified independently by every relying party at verification time (Section 8.1, Section 9.1), not only by the attester at signing time: a verifier that trusts an assembled RenewalProof or RenewalChain without re-checking membership and self-attestation can be shown an attestation from a key the issuer never named, or a self-signed one, spliced in after assembly, bypassing whatever an honest assembler would have filtered.

8. Renewal Proof

A requester assembles a RenewalProof once it holds quorum-many attestations for one RenewalRequest. Required members: version, manifest_hash, request (the complete signed RenewalRequest this proof answers; everything a verifier needs about the round is read from here, under the requester's signature and, via request_digest, under every attester's), effective_expiry (RFC 3339; MUST equal the baseline expiry, which is the original expiry or the prior proof's effective_expiry in a chain, plus the request's requested_extension_seconds, exactly; a verifier MUST recompute and compare, not trust the field alone), and attestations (array of PeerAttestation, at least quorum-many, pairwise-distinct attester_did).

A RenewalProof carries no signature of its own and needs none: every field a verifier acts on is inside the signed request or is recomputed, and every attestation commits to the request by digest.

8.1. Quorum Arithmetic

Let N be the size of the manifest peer set for the requester (Section 5.2). The quorum is quorum(N) = ceil(2 * N / 3). N MUST be at least 4. A RenewalProof is valid only if attestations contains at least quorum(N) entries with pairwise-distinct attester_did values, and every attestation it contains passes items 1 to 7 below. A relying party cannot re-run the attester-local checks of Section 7.2 (items 8 to 10); the quorum is what it relies on for those.

What the threshold establishes, and what it does not: quorum(N) signatures establish that at least that many keys the issuer named signed this exact request. Because any two sets of quorum(N) peers out of N share at least 2 * quorum(N) - N >= N/3 members, and an honest attester signs at most one request per chain position (Section 7.2, item 10), two conflicting proofs for the same position cannot both exist unless at least N/3 peers equivocated. That is the whole of the guarantee. The procedure does not run an agreement protocol, does not lock a predecessor before signing, and does not establish that the peers agree on one authoritative history; a relying party learns only that the history it was shown is one a threshold of named peers signed in full. This document does not describe the mechanism as consensus.

A verifier counting attestations toward quorum, whether an attester validating the presented chain per Section 7.2 or a relying party verifying a presented proof or chain per Section 9.2, MUST independently confirm, for every attestation in the proof, all of the following, and MUST reject the proof if any attestation fails any of them. A proof is one object: the next round commits to its entire attestation set through prior_proof_digest (Section 8.2), so a proof is never repaired by dropping the attestations that fail:

  1. The attestation MUST be well formed (Section 4, Section 7) and its signature MUST verify against attestation.attester_did; attestation.manifest_hash MUST equal the hash of the manifest being verified under; and attestation.attester_did MUST be in the manifest peer set for the proof's requester_did. A validly signed attestation from a key the issuer did not name is not an attestation.
  2. attestation.attester_did MUST NOT equal the proof's own requester_did. This MUST be re-checked here regardless of whether the proof's assembler already filtered it.
  3. attestation.request_digest MUST equal the digest of the proof's request. This is the check that binds the signature to the whole decision; items 4 to 6 are redundant with it and kept as cheap, explicit consistency checks.
  4. attestation.request_id and attestation.nonce MUST equal the request's.
  5. attestation.original_credential_hash MUST equal the request's.
  6. attestation.granted_extension_seconds MUST equal the request's requested_extension_seconds.
  7. Every as_of MUST lie within max_clock_skew_seconds of the request's created_at and within the manifest's validity window widened by max_clock_skew_seconds, and the as_of values within one proof MUST lie within max_clock_skew_seconds of one another. The mesh has no trusted clock; these are consistency checks, not ground truth.

Without item 3, a genuinely-signed attestation collected for a different request is individually valid and can be spliced into an unrelated proof to pad it to quorum, and, worse, a requester can collect attestations on one request and present a re-signed request with the same request_id and nonce but different content. The digest closes both. Without item 1, an adversary enlarges the electorate by generating keys.

8.2. Proof Digest

The proof digest is "sha256:" followed by the lowercase hexadecimal SHA-256 of the JCS canonical form of the entire RenewalProof, attestations included. The next round's request carries it as prior_proof_digest; since that request is then signed by the requester and digested into every attestation of the next round, the chain is linked by hash from the last round back to the root.

9. Renewal Chain

A partition MAY outlast one RenewalProof's extension. A RenewalChain is the ordered array of every RenewalProof issued during one continuous partition, each extending the one before it.

9.1. Chain Validity

A chain [p_1, ..., p_k] is valid under a manifest if and only if, for every p_i:

  1. p_i.manifest_hash equals the hash of the manifest the chain is being verified under (Section 5.3).
  2. p_i.request is structurally valid, its signature verifies against its requester_did, its round is i, and its prior_proof_digest is null for i = 1 and equal to the digest of p_{i-1} (Section 8.2) otherwise. A chain whose rounds are not linked this way is not a chain, whatever its arithmetic says.
  3. p_i.request repeats p_1.request's requester_did, manifest_hash, original_credential_hash, original_issuer_did, original_scope, original_issued_at and original_expiry verbatim. A round for a different requester MUST NOT be accepted merely because its credential hash happens to match.
  4. p_i.attestations independently satisfies Section 8.1 (quorum, distinctness, membership, and per-attestation binding to p_i.request by digest) against the peer set derived from the same manifest.
  5. p_i.request.nonce differs from p_j.request.nonce for every j < i. Every attestation carries its request's nonce (Section 8.1, item 4), so the attestations of one round share it; the rule constrains reuse across rounds, and item 4 extends it to every attestation.
  6. p_i.effective_expiry equals p_{i-1}.effective_expiry (or original_expiry, for p_1) plus p_i.request.requested_extension_seconds exactly. A verifier MUST recompute this, not trust effective_expiry as an independent claim.
  7. p_i.effective_expiry is strictly greater than p_{i-1}.effective_expiry (or than original_expiry, for p_1).
  8. The cumulative extension represented by p_i.effective_expiry - original_issued_at MUST NOT exceed the manifest's ceiling_seconds.
  9. For i > 1, p_i.request.created_at is not earlier than p_{i-1}.request.created_at. Round i extends a proof that exists only after round i-1 was requested; a chain whose request times run backwards was not produced in the order it claims.

A chain failing any of these at round i is valid only through round i-1.

9.2. Relying-Party Verification

This section binds only a relying party that has adopted this procedure for a given issuer: one that already trusts the issuer for the original credential and has decided, as policy, to honor that issuer's manifests. A relying party that has not adopted it is unaffected by this document and rejects an expired credential as it always did.

An adopting relying party receiving a request from the requester after original_expiry MUST NOT reject solely on that basis. It MUST instead:

  1. Obtain the MeshManifest (from the requester alongside the chain, or from its own provisioning) and verify it per Section 5.1, resolving issuer_did through the same trust configuration under which it accepts that issuer's credentials. The manifest supplies the peers, the quorum and the ceiling; it does not supply a reason to trust the issuer, which the relying party must already have.
  2. Authenticate the original credential, as presented by the requester alongside the chain or from its own copy (Section 3), in its own format; check that it hashes to the root request's original_credential_hash; and compare the chain's root request against it: requester_did, original_scope, original_issued_at, original_expiry and original_issuer_did MUST match. A relying party that cannot authenticate the original credential has no basis for the chain and MUST NOT accept it.
  3. Verify the requester's current RenewalChain per Section 9.1 under that manifest.
  4. Verify its own cached revocation state covers neither original_credential_hash nor manifest_hash.
  5. Treat the requester's effective authority as valid through the last chain entry's effective_expiry, at original_scope, and no further.

Any failure in steps 1 to 4 means the credential MUST be treated as expired. Beyond what it already needed to accept the original credential, a relying party needs only the manifest and the chain; that is what distinguishes the manifest from a local configuration that happened to be shared.

10. Settlement

On reconnection to its issuer, the requester MUST request a fresh, issuer-signed credential before processing any further peer attestations, transmit its full RenewalChain to the issuer for audit, and synchronize its revocation cache from the issuer before honoring or issuing any further attestation. An issuer-issued credential supersedes any peer-attested RenewalChain on sight.

11. Security Considerations

What is new trust, and what is not. No independent root of authority is introduced: every signature a verifier checks resolves to the issuer's key (the manifest) or to a key the issuer named (the attestations), and the quorum is a limited-authority local issuer the issuer appointed. That is a narrower claim than "no new trust assumptions", and this document does not make the broader one. Relative to the connected case, a deployment newly assumes that the manifest was provisioned honestly, that mesh clocks agree within the manifest's tolerance, and that attesters report health in good faith. Each is named below.

No unilateral self-grant. A requester's own signature is never part of any attestation and never counts toward quorum. This MUST be enforced independently at two points: an honest attester refuses to sign a self-attestation (Section 7.2), and every verifier of an assembled proof or chain, including a relying party that did not itself assemble it, independently re-checks that no counted attestation's attester_did equals the proof's requester_did (Section 8.1). The second check is not redundant with the first: an adversary who controls the requester can hand-craft a RenewalProof directly, bypassing whatever an honest assembly routine would have filtered, and splice in a validly self-signed attestation to reach quorum. A verifier that skips the second check because assembly should have handled it is not actually enforcing this property.

The manifest is the delegation. Without the manifest, a peer set is whatever each peer was configured with, and a quorum of peers grants authority the issuer never delegated; a relying party outside the mesh has no way to learn the peer set, the quorum, or the ceiling it is supposed to check against. With it, the quorum is a limited-authority local issuer the issuer appointed in writing: the ceiling a verifier applies is the one under the issuer's signature, the scope a renewal may carry is capped by the issuer, and the electorate is the issuer's list. The membership check (Section 8.1, item 1) is load-bearing in the same way the self-attestation check is: without it, an adversary who cannot coerce honest peers simply generates N keys of its own. Every object carries manifest_hash so that nothing produced under one manifest verifies under another. Rotating the manifest invalidates everything produced under the old one for every party that holds the new one or has learned the old one is revoked; a party that has not will honor the old delegation until it does, which is the same residual as credential revocation below and the reason expires_at is the issuer's real lever.

Binding to the whole decision. Each attestation carries request_digest, the hash of the complete signed request. An attestation that signed only the fields it repeats (request identifier, nonce, credential hash, extension) would not bind the scope, the requester, the timestamps or the predecessor; since request_id is requester-chosen, a requester could collect attestations on a narrow-scope request and present a re-signed copy with the same identifier and nonce and a wider scope, and every per-field check would pass. The digest closes that; and because consistency across a chain is not truth, Section 9.2 step 2 separately requires the relying party to check the root request's claims against the credential the issuer actually signed.

Predecessor binding and forks. A request carries prior_proof_digest; the digest of the signed request is in every attestation; so a quorum's signatures commit to the exact history being extended, not merely to an extension amount that happens to add up. A relying party shown a different predecessor than the one a round was attested against sees the link break. Separately, an honest attester signs at most one request per chain position (Section 7.2, item 10); two sets of ceil(2N/3) peers share at least N/3 members, so two conflicting proofs for one position require at least N/3 equivocating peers. That is a bound on forks, not agreement: the protocol does not establish that the peers hold one authoritative history, only that any history a relying party is shown was signed in full by a threshold of named peers. The threshold is borrowed from Byzantine fault tolerant systems for its intersection property; this document is not a consensus protocol and does not claim to be.

Forgery bound. Assembling a valid RenewalProof requires ceil(2N/3) distinct, independently verifying signatures from the peer set the issuer named, each independently bound by digest to the manifest and to that specific request (Section 8.1). A colluding minority of up to N - ceil(2N/3) peers cannot forge a proof without honest participation. The digest binding is load-bearing for this bound, not incidental: without it, a genuinely-signed attestation collected for a different request, even one signed by an honest peer for an unrelated requester, is individually valid and can be spliced into an unrelated proof to pad it to quorum, without forging or coercing anything.

Malformed input is a reject. Every check in Sections 5 to 9 runs on input an adversary chose: the presented manifest, the request, the attestations and the chain. A verifier that aborts on an object it cannot canonicalize, an integer outside the I-JSON range, or an expiry RFC 3339 cannot write, instead of rejecting it, turns any member's malformed message into a denial of service against its peers and relying parties. Section 4 requires the reject.

One spelling per signature. A base64 decoder that ignores stray characters or nonzero pad bits reads many strings as the same signature, and each string gives the request a different request_digest. An on-path party that cannot sign anything could then rebroadcast copies of a genuine request, and an honest attester that signed a copy has spent its one attestation for that chain position (Section 7.2, item 10): spreading copies across the peer set denies the round its quorum. Requiring the canonical encoding (Section 4) leaves one valid request per signature.

Liveness bound, not a backdoor. A malicious or unavailable minority can withhold attestation and force fail-closed (deny a renewal); it cannot force an unauthorized grant.

Bounded exposure. ceiling_seconds, fixed by the issuer in the signed manifest and measured from the original credential's issuance, terminates peer-attested authority even if the partition never heals. The manifest's own expires_at bounds the window in which any request can be made at all. Both numbers are the issuer's; a peer cannot raise either locally.

Monotonic scope. original_scope is verified unchanged, byte for byte, by every attester at grant time and every relying party at use time, across every round of a chain, and it MUST lie within the manifest's scope_ceiling. No field in RenewalRequest or PeerAttestation is capable of carrying a wider claim.

Front-loading. Health is observed once per round, and this revision bounds neither the extension one round may request nor how long before the current expiry a round may be requested. A requester can therefore secure the whole of ceiling_seconds on one quorum's observation, in a single round or in rounds requested back to back early in a partition, and no later observation is needed to keep it. The ceiling, not the round, bounds the exposure; an issuer that wants health re-observed at intervals sets a short ceiling. Chain validity requires request times to run forwards (Section 9.1, item 9) but does not tie them to the expiry being extended. A per-round extension limit and a lead time (how long before the expiry it extends a round may be requested), both signed in the manifest, would make step-wise renewal enforceable; Appendix E lists them as an open issue.

The revocation residual. If the issuer revokes the original credential, or the manifest, while the requester is partitioned, the revocation cannot take effect until the partition heals. Peers attesting in good faith, against their own last-cached revocation state, may extend a credential the issuer has already condemned, up to the ceiling. This is a structural property of every credential system under partition; it is not eliminated by this document's mechanism, only bounded (by the ceiling and the manifest window) and priced (by the mandatory revocation resynchronization at settlement, Section 10). An implementation MUST NOT represent this mechanism as providing partition-proof revocation.

Manifest provisioning and clock agreement are trusted computing base. This document specifies how a manifest is verified, not whom the issuer should list in it. A manifest signed by a compromised issuer key, or one into which a hostile member was admitted before signing, is honored exactly as written. Membership change during a partition is not supported: a new manifest cannot reach a severed mesh. This document does not provide a trusted clock; as_of and created_at are validated for well-formedness, against the manifest's validity window, for mutual consistency within max_clock_skew_seconds and for order along a chain, not against ground truth.

Health evidence is attester-asserted, and establishes activity, not authorization. health_evidence is what the attester claims to have observed, not something this mechanism independently measures, and at best it establishes that the requester was recently active: it sent a heartbeat, took part in a task, completed a round. That is not evidence that the requester is uncompromised or still entitled to its permissions. The issuer accepts that distinction when it signs a manifest; the quorum bound limits the damage from a misreporting attester; neither resolves the distinction, and this document does not claim they do.

12. IANA Considerations

This document requests no IANA actions. The version string (renewal/0.3) and the health_evidence vocabulary are governed by this document and its successors. A future revision MAY register a media type for the RenewalChain object (candidate: application/renewal-chain+json) once transport contexts warrant it.

13. References

13.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC3339]
Klyne, G. and C. Newman, "Date and Time on the Internet: Timestamps", RFC 3339, , <https://www.rfc-editor.org/info/rfc3339>.
[RFC4648]
Josefsson, S., "The Base16, Base32, and Base64 Data Encodings", RFC 4648, , <https://www.rfc-editor.org/info/rfc4648>.
[RFC7493]
Bray, T., "The I-JSON Message Format", RFC 7493, , <https://www.rfc-editor.org/info/rfc7493>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8610]
Birkholz, H., Vigano, C., and C. Bormann, "Concise Data Definition Language (CDDL): A Notational Convention to Express Concise Binary Object Representation (CBOR) and JSON Data Structures", RFC 8610, , <https://www.rfc-editor.org/info/rfc8610>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, , <https://www.rfc-editor.org/info/rfc8785>.

13.2. Informative References

[CORROB]
Chandra, S., "Multi-Source Corroboration for AI Agent Discovery", Work in Progress, Internet-Draft, draft-chandra-agent-registry-corroboration-02, , <https://datatracker.ietf.org/doc/draft-chandra-agent-registry-corroboration/>.
[DIDKEY]
W3C Credentials Community Group, "The did:key Method", , <https://w3c-ccg.github.io/did-key-spec/>.
[NANDAINDEX]
Raskar, R. and P. Chari, "Beyond DNS: Unlocking the Internet of AI Agents via the NANDA Index and Verified AgentFacts", , <https://arxiv.org/abs/2507.14263>.
[PBFT]
Castro, M. and B. Liskov, "Practical Byzantine Fault Tolerance", OSDI 1999, , <https://pmg.csail.mit.edu/papers/osdi99.pdf>.
[RAR]
Raskar, R., Sharaf, S., and P. Chari, "Registry-Assisted Resolution for Known Subjects Without DNS Discovery Anchors", Work in Progress, Internet-Draft, draft-raskar-agentic-web-federated-resolution-03, , <https://datatracker.ietf.org/doc/draft-raskar-agentic-web-federated-resolution/03/>.
[RFC4838]
Cerf, V., Burleigh, S., Hooke, A., Torgerson, L., Durst, R., Scott, K., Fall, K., and H. Weiss, "Delay-Tolerant Networking Architecture", RFC 4838, , <https://www.rfc-editor.org/info/rfc4838>.
[SPIFFE]
Cloud Native Computing Foundation, "Secure Production Identity Framework for Everyone (SPIFFE)", <https://github.com/spiffe/spiffe/blob/main/standards/SPIFFE.md>.
[WIMSEARCH]
Salowey, J., Rosomakho, Y., and H. Tschofenig, "Workload Identity in a Multi System Environment (WIMSE) Architecture", Work in Progress, Internet-Draft, draft-ietf-wimse-arch, , <https://datatracker.ietf.org/doc/draft-ietf-wimse-arch/>.
[WIMSECHARTER]
IETF, "Workload Identity in Multi System Environments (WIMSE) - Working Group Charter", , <https://datatracker.ietf.org/wg/wimse/about/>.
[WIMSECREDS]
Campbell, B., Salowey, J., Schwenkschuster, A., Sheffer, Y., and Y. Rosomakho, "WIMSE Workload Credentials", Work in Progress, Internet-Draft, draft-ietf-wimse-workload-creds, , <https://datatracker.ietf.org/doc/draft-ietf-wimse-workload-creds/>.
[WIMSEID]
Rosomakho, Y. and J. Salowey, "Workload Identifier", Work in Progress, Internet-Draft, draft-ietf-wimse-identifier, , <https://datatracker.ietf.org/doc/draft-ietf-wimse-identifier/>.

Appendix A. Mapping to the Reference Implementation

Every normative element of this document is implemented in the reference implementation, sm-renewal (version 0.4.0): the MeshManifest (Section 5), the RenewalRequest, PeerAttestation, RenewalProof and RenewalChain wire shapes with their digests (Sections 6-9), the independent-evaluation procedure including the credential-claims comparison and the one-attestation-per-position rule (Section 7.2), the quorum, membership, binding and ceiling arithmetic (Section 8.1), and the chain and relying-party verification procedures (Section 9) are all covered by a deterministic conformance corpus of 35 vectors (3 valid chains and 32 hostile paths, including a request re-signed with wider scope after attestation, a broken predecessor link, a credential-claims mismatch, a relying party holding incomplete credential claims, an attester outside the peer set, a full quorum padded with one non-member attestation, a manifest too small for any requester, a tampered manifest signature, request times running backwards, an integer outside the I-JSON range, an unpaired surrogate, an expiry past what RFC 3339 can write and a genuine request signature re-spelled with a nonzero pad bit) and a test suite. The test suite checks the CDDL in Appendix B against every vector, and it was cross-checked with the reference CDDL tool: every well-formed object matches it, and every object malformed in a way CDDL can state does not. Each vector names the first failing check with a stage label; the accept or reject outcome is what a second implementation must reproduce, and the labels are informative. Conformance vectors demonstrate that the implementation enforces what this document states; they are not a proof that the design has no further gaps, and independent review is invited. The reference implementation is available (MIT License) at https://pypi.org/project/sm-renewal/; its source distribution includes this document, the specification and the conformance corpus.

Appendix B. CDDL

The structure of each wire object, in CDDL [RFC8610] applied to JSON. A map lists every member its object may carry, so a member it does not list is malformed (Section 4). .regexp patterns match the whole string. The prose states the rules CDDL does not: sorting and uniqueness of the members, scope_ceiling and original_scope arrays, the quorum size of attestations, original_expiry after original_issued_at, expires_at after issued_at, and every rule relating one object to another.

; renewal/0.3 wire objects in CDDL (RFC 8610), as JSON.
; Maps are closed: a member not listed is a reject (Section 4).
; Sorting, uniqueness, quorum size and cross-field rules are in
; the prose and are not repeated here.

renewal-chain = [+ renewal-proof]

mesh-manifest = {
  version: renewal-version,
  manifest_id: tstr .ne "",
  issuer_did: did-key,
  members: [5* did-key],
  ceiling_seconds: positive-int,
  max_clock_skew_seconds: non-negative-int,
  scope_ceiling: [* tstr],
  issued_at: timestamp,
  expires_at: timestamp,
  signature: signature-b64,
}

renewal-request = {
  version: renewal-version,
  request_id: uuid-v4,
  requester_did: did-key,
  manifest_hash: digest,
  original_credential_hash: digest,
  original_issuer_did: did-key,
  original_scope: [* tstr],
  original_issued_at: timestamp,
  original_expiry: timestamp,
  requested_extension_seconds: positive-int,
  nonce: nonce-b64,
  round-position,
  created_at: timestamp,
  signature: signature-b64,
}

; Round 1 extends the credential; a later round extends a proof.
round-position = (
  round: 1, prior_proof_digest: null //
  round: 2..9007199254740991, prior_proof_digest: digest
)

peer-attestation = {
  version: renewal-version,
  attester_did: did-key,
  manifest_hash: digest,
  request_digest: digest,
  request_id: uuid-v4,
  nonce: nonce-b64,
  original_credential_hash: digest,
  granted_extension_seconds: positive-int,
  as_of: timestamp,
  health_evidence: health-evidence,
  signature: signature-b64,
}

renewal-proof = {
  version: renewal-version,
  manifest_hash: digest,
  request: renewal-request,
  effective_expiry: timestamp,
  attestations: [+ peer-attestation],
}

renewal-version = "renewal/0.3"
health-evidence = "heartbeat_current" / "task_participation" /
                  "consensus_round" / "other"

; Integers stay in the I-JSON range (RFC 7493), as RFC 8785 needs.
positive-int = 1..9007199254740991
non-negative-int = 0..9007199254740991

; RFC 3339, second precision, UTC, "Z" suffix.
timestamp = tstr .regexp
  "[0-9]{4}(-[0-9]{2}){2}T[0-9]{2}(:[0-9]{2}){2}Z"
digest = tstr .regexp "sha256:[0-9a-f]{64}"
did-key = tstr .regexp "did:key:z6Mk[1-9A-HJ-NP-Za-km-z]+"
uuid-v4 = tstr .regexp
"[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}"

; Canonical standard base64 (RFC 4648, Section 4): padded, and the
; pad bits of the last character are zero. A nonce is at least 16
; octets (24 characters); a signature is exactly 64 octets.
b64 = b64-whole / b64-pad1 / b64-pad2
b64-whole = tstr .regexp "([A-Za-z0-9+/]{4})*"
b64-pad1 = tstr .regexp
  "([A-Za-z0-9+/]{4})*[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]="
b64-pad2 = tstr .regexp "([A-Za-z0-9+/]{4})*[A-Za-z0-9+/][AQgw]=="
nonce-b64 = b64 .and (tstr .regexp ".{24,}")
signature-b64 = tstr .regexp "[A-Za-z0-9+/]{85}[AQgw]=="

Appendix C. Worked Example

Seven workloads coordinate at a remote site, each holding a 4-hour WIMSE Workload Identity Token [WIMSECREDS]. At provisioning, their issuer signed a MeshManifest listing all seven, with a 12-hour ceiling, a 5-minute clock tolerance, a scope ceiling of the two scopes any of them was issued, and a one-year validity window. The WAN drops for 45 minutes. One workload, 20 minutes from expiry, fails its issuer contact and broadcasts a RenewalRequest (a one-hour extension, round 1, fresh nonce, the manifest's hash) to its six peers, together with its token. N = 6, so quorum(6) = ceil(2*6/3) = 4. Five peers independently verify the manifest, their own membership, the issuer signature and the token's actual claims, cached revocation state, extend-only scope within the ceiling, ceiling headroom, and the requester's task participation within the last minute, and each signs a PeerAttestation over the digest of the request; four would have sufficed. The requester assembles a RenewalProof and continues; any peer receiving its subsequent requests verifies the chain independently, and a relying party that already trusts the operator's credential service and has adopted this procedure can do the same from the manifest, the chain and the token. Thirty minutes later the WAN returns; the requester requests a fresh token, transmits its RenewalChain for audit, and synchronizes revocation state. Total protocol overhead: one manifest signed once at provisioning, one broadcast, four-to-five signatures, read-only verification by each relying party. No independent root authority introduced; the issuer delegated bounded renewal authority to peers it named, and the deployment now relies on that manifest, on its clocks, and on its peers' honesty about what they observed.

Appendix E. Open Issues

Acknowledgements

The WIMSE working group's charter framed the local-issuance problem this document builds on. The registry-lease application in the Related Work section is prompted by the registry-assisted resolution work of Ramesh Raskar, Samuel Sharaf and Pradyumna Chari; any misreading of their draft is the author's own. An anonymous security review of an earlier text of this document identified that the attestations did not bind the whole request, that rounds were not cryptographically linked, and that several claims were stronger than the format supported; the request digest, the proof digest, the credential-claims requirement, the equivocation rule and the corrected claims language in this revision are the response.

Author's Address

Sharath Chandra
Stellarminds.ai
Richmond, California
United States of America