| Internet-Draft | SMRP | November 2026 |
| Grund, et al. | Expires 19 May 2027 | [Page] |
Pseudonymous Intelligent Transport Systems (ITS) credentials are short-lived and numerous. Verifiers decide at message-reception time, often without connectivity, which makes revocation status hard to deliver. This document specifies Stapled Merkle Revocation Proofs (SMRP). For each partition of a revocation domain, an authorized issuer signs a compact checkpoint that commits to the complete sorted set of revoked credential tokens. A credential holder staples a logarithmic-size proof that its token is absent from that set, and a verifier checks the proof offline against the current checkpoint. Freshness is carried by the checkpoint, which is public, shared by every credential of the partition, and deliverable by any party. Within one stream, a proof remains usable across checkpoints for as long as the set commitment is unchanged and the current checkpoint is admissible. The same commitment supports proofs of revocation that anyone can relay, complete authenticated lists for capable verifiers, and public audit.¶
The document defines a credential identity that does not depend on the certificate signature, a Merkle tree over the intervals of the sorted revoked set with one authentication path per proof, the checkpoint and staple encodings, conservative time validation with a conditional bound on the last affirmative decision after revocation, verifier state with terminal revocation, and carriage in V2X secured messages and in TLS 1.3. It positions SMRP against the companion pOCSP mechanism: pOCSP signs one statement per certificate and validity window, whereas SMRP signs one statement per partition and issuance period. This document is Experimental and allocates no identifier in ETSI, IEEE, or SAE namespaces.¶
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 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
Pseudonymous credentials allow an Intelligent Transport Systems (ITS) station to authenticate messages without placing a permanent identifier in every transmission. A valid signature proves possession of a private key. It does not prove that the credential is still trusted. A credential can be withdrawn after key compromise, detected misbehavior, incorrect issuance, or decommissioning. A receiver that verifies signatures against stale revocation information keeps accepting messages from an entity that the trust infrastructure has already excluded.¶
Revocation information can be distributed as signed lists, signed status responses, or witnesses derived from an authenticated data structure. List-based checking requires the relevant list or a validated representation at the verifier; response-based checking requires current evidence for the certificates actually used. Generation, distribution, verification, and storage costs depend on the deployment. The companion pOCSP proposal [I-D.grund-v2x-pocsp] provides a signed, single-certificate response that the holder staples to an authenticated operation.¶
Stapled Merkle Revocation Proofs (SMRP) specify the authenticated-dictionary approach for an ITS credential profile. The authority signs one statement per partition and issuance period: a checkpoint that commits, through a Merkle tree, to the complete sorted set of revoked credential tokens. The burden of proof lies with the party that wants to be accepted. A holder obtains a short proof that its token lies strictly between two consecutive revoked tokens of the committed set and staples that proof to its messages. The verifier needs the current checkpoint and a few hash computations. It never contacts a server at reception time and never needs the list.¶
Three consequences follow from separating the commitment from the proof:¶
SMRP does not remove the need for current information. A successful non-membership check establishes that a token was absent from an identified snapshot. It does not establish that the credential will remain unrevoked, that it was properly issued, or that the operation is authorized. When fresh checkpoints are suppressed, affirmative status stops at a deadline that this document bounds (Section 11.6). The verifier does not thereby learn that the credential is revoked. Applications need an explicit policy for that state (Section 13.8).¶
This is an individual Internet-Draft with an intended status of Experimental. It is not an adopted IETF working-group specification, an ETSI profile, or an IEEE amendment. It defines evidence objects and their validation rules. It allocates no identifier in ETSI, IEEE, or SAE namespaces.¶
The baseline credential profile covers end-entity IEEE 1609.2 certificates [IEEE1609.2] whose issuance keys and credential keys use NIST P-256. Explicit and implicit certificates are both identified, provided the deployment supplies their complete certificate validation and proof-of-possession procedures. Other curves, X.509 certificates, linkage-value revocation, and vehicle-level revocation identifiers require separately specified profiles. SMRP does not replace certificate-chain validation, permission checks, message freshness, replay protection, or misbehavior adjudication.¶
The evidence objects can be implemented and evaluated independently of a radio stack. Carriage in a production protocol requires a versioned profile of the enclosing protocol by the responsible standards development organization (SDO). Appendix H separates what this document specifies and argues from what remains to be measured or proved.¶
Authoritative revocation state
|
v
+----------------+ one signed checkpoint per
| Checkpoint | partition and issuance period
| issuer |----------------------------+
+----------------+ |
| ordered token list, deltas | any channel:
v | roadside unit,
+----------------+ | cellular, peer
| Distribution | | relay, cache
| point | |
+----------------+ |
| proof for one token |
v v
+----------------+ message + staple +------------+
| Holder |--------------------->| Verifier |
+----------------+ +------------+
no query at reception time
pOCSP [I-D.grund-v2x-pocsp] and SMRP both let a verifier decide offline at reception time from evidence that the holder presents. They differ in what the authority signs. pOCSP signs one status statement per certificate, usage profile, and validity window. SMRP signs one statement per partition and issuance period and lets each holder derive its own proof from it. The two mechanisms therefore scale with different quantities, have different evidence semantics, and suit different traffic. Section 14 compares them property by property, gives a cost model with the conditions under which each is preferable, and specifies how a deployment composes them. A deployment MUST NOT silently substitute one for the other.¶
Section 2 to Section 5 give the terminology, the related work, the design goals, and the system and threat model. Section 6 to Section 10 define the credential identity, the configuration, the Merkle set, the checkpoint, and the wire objects. Section 11 to Section 13 specify time validation, the enforcement bound, and the processing rules of each role. Section 14 positions SMRP against pOCSP and specifies composition. Section 15 to Section 17 cover V2X carriage, TLS 1.3, and engineering guidance. The remaining sections give the security, privacy, and IANA considerations and a summary of the normative requirements. The appendices contain the ASN.1 module, reference algorithms, test vectors, the security arguments, a worked lifecycle, the design rationale, a formal-verification blueprint, and the evaluation plan with claim boundaries.¶
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.¶
H denotes SHA-256 [FIPS180-4]. The operator || denotes concatenation of octet strings. U16, U32, and U64 denote unsigned, fixed-width, big-endian encodings of 2, 4, and 8 octets. Literal strings in hash inputs are ASCII without a terminator. Tokens and hashes are exactly 32 octets. Tokens are ordered as unsigned big-endian integers, which is the lexicographic order of their octets.¶
The expression floor(x) is the greatest integer not exceeding x, and log2 is the binary logarithm.¶
The following symbols are used throughout. E, G, k, A, and a are fields of the configuration; v is a local bound, L is an operational assumption, and m and h describe a tree (Section 7).¶
| Symbol | Meaning |
|---|---|
| E | epochDuration, in seconds |
| G | epochLead, in seconds |
| k | shardBits; a domain has 2^k partitions |
| A | maxSnapshotAge, in seconds |
| a | maxAuthorityClockError, in seconds |
| v | the verifier's clock error bound at the time of a decision, at most maxVerifierClockError |
| L | the ingestion lag of the authority: the longest delay between a revocation decision and its presence in every snapshot (Section 5.2) |
| m, h | the number of leaves of a tree, which is its treeSize, and its height (Section 8.2) |
Three times appear in a checkpoint and have distinct meanings. snapshotTime is the complete-through cutoff of the authoritative revocation database. thisUpdate is the time at which the checkpoint was issued. nextUpdate is its exclusive acceptance deadline. A checkpoint asserts nothing about revocations decided after its cutoff.¶
The verifier returns exactly one of five outcomes for a credential:¶
INDETERMINATE and INVALID are deliberately distinct. An application can tolerate the first in a permissive class and cannot tolerate the second. A diagnostic reason can accompany any outcome. A diagnostic MUST NOT be promoted to an affirmative result.¶
The application-level state UNCONFIRMED has the meaning given in [I-D.grund-v2x-pocsp]: the message is authenticated but the status of its certificate is not currently confirmed. An application status class can map INDETERMINATE or CONFLICT to UNCONFIRMED, and only after the secured-message signature, the certificate chain, the certificate validity, and the application permissions have all been validated. It never maps INVALID or REVOKED to UNCONFIRMED.¶
The following goals guide the protocol and are used to evaluate conformance.¶
The following are explicit non-goals.¶
| Role | Function | Trust placed in it |
|---|---|---|
| Checkpoint issuer | Builds the revoked set of each stream and signs checkpoints | Trusted to build complete, sorted, insert-only sets and to state times truthfully |
| Distribution point | Stores snapshots, serves proofs, lists, and checkpoints | None for integrity; availability only |
| Holder | Presents a credential and a staple | None; it can be revoked, compromised, or withholding |
| Verifier | Decides the status of a credential | Relies on its own protected state and time |
| List holder, auditor | Rebuilds trees, derives proofs and notices | None; its outputs are checked against signed checkpoints |
| Trust administration | Installs domain configurations and checkpoint keys | Authoritative; outside this protocol |
Authorization to sign checkpoints is configured independently of certificate issuance. Possession of a CA certificate, a TLS server key, an ITS station certificate, or an OCSP delegated-responder certificate does not authorize checkpoint signing. A verifier MUST resolve checkpoint keys through its installed configuration and MUST NOT trust a public key supplied only by evidence.¶
The network attacker can observe, inject, modify, delay, reorder, replay, and suppress traffic, in the sense of the symbolic attacker of [DOLEV1983]. It can operate distribution points and relays, hold the private key of a credential that is later revoked, and collude with a revoked holder. A revoked holder does not report its own revocation. The following attacks are in scope:¶
Compromise of a checkpoint-signing key is considered separately (Section 18.3), because it defeats the authenticity of the commitment itself.¶
The protocol does not prevent a compromised, still-authorized issuer from signing a false or incomplete set. A verifier can recognize conflicting statements that reach it. It cannot detect a split view that it never observes. A verifier that receives no status input at all faces a lack of information, which no proof format resolves: affirmative status ends at a deadline and the outcome becomes INDETERMINATE.¶
Rollback of verifier state and manipulation of its clock are deployment threats. A verifier that cannot restore its protected state or a trustworthy time MUST stop producing NOT_REVOKED_AT_SNAPSHOT until recovery. Section 13.1 states precisely which guarantee is lost with which element of state.¶
The verifier MUST first validate the credential and resolve the authority that issued it, and then select the installed domain from local policy. The 16-octet domainId carried in a checkpoint is a consistency check, not a discovery mechanism. A holder MUST NOT be able to choose another domain, profile, issuance key, epoch mapping, or partition because it yields an absence proof.¶
Within a domain the issuance public key is identified in full. A truncated digest of an issuing authority or of a certificate, including an ITS HashedId8, MAY assist lookup but MUST NOT by itself select a security identity. If lookup is ambiguous, the verifier retrieves and validates the full credential and the certificate of its issuing authority. Otherwise the outcome is INDETERMINATE.¶
Let Qissuer = 0x04 || X32 || Y32 be the uncompressed representation [SEC1] of the validated NIST P-256 issuance public key. Each coordinate occupies 32 octets, including leading zero octets. The point MUST be on the curve and MUST NOT be the point at infinity.¶
issuerKeyHash = H("smrp-issuer-p256-v1" || Qissuer)
¶
The issuance key in this formula is the key that validated the issuance of the credential, not a key taken from an unauthenticated hint. For an implicit certificate it is the authorized issuance key used by the reconstruction and validation procedure. The result MUST equal the issuerKeyHash of the configuration.¶
The verifier builds an SmrpItsCredentialIdentity (Appendix A) from the certificate version, the certificate type, the issuerKeyHash, and the canonical COER encoding [X696] of the ToBeSignedCertificate. In this profile the certificate version MUST be 3. The type is 0 for an explicit certificate and 1 for an implicit certificate.¶
Before the ToBeSignedCertificate is encoded, the IEEE 1609.2 canonicalization rules [IEEE1609.2] MUST be applied to the public encryption keys, verification keys, and reconstruction values that it contains. Every elliptic-curve field MUST use a NIST P-256 choice. A curve point takes its compressed-y-0 or compressed-y-1 form according to the parity of its y-coordinate. An x-only public key is not accepted. All fields, the presence of optional fields, permissions, validity data, and extension contents MUST be preserved. An implementation MUST NOT delete authenticated fields that it does not recognize, and MUST NOT invent a normalization of permissions or names. An unsupported type or canonicalization rule yields INDETERMINATE.¶
The checkpoint issuer, when it derives the tokens of revoked credentials, and the verifiers MUST apply the same canonicalization. The received certificate is still validated with the applicable IEEE and ETSI rules [IEEE1609.2] [ETSI103097]. Building an SMRP identity authorizes neither rewriting a received certificate nor skipping its signature, reconstruction, permission, or proof-of-possession checks.¶
identityBytes = COER(SmrpItsCredentialIdentity)
credentialDigest = H(identityBytes)
X = H("smrp-cert-v2" || domainId || credentialDigest)
¶
X is the token. It represents the credential in the revoked set and in the state of a verifier. The credential digest identifies the credential independently of the domain. A verifier can keep it beside a terminal revocation record, so that the record survives a change of domain identifier (Section 13.1).¶
The outer certificate signature is deliberately absent from the identity. Two valid certificates can carry the same ToBeSignedCertificate with different signature octets. If (r, s) is a valid ECDSA signature, so is (r, q - s), where q is the group order. Canonicalization rules that fix the representation of r do not by themselves constrain s. An issuing authority can also sign the same fields again with another nonce. An identifier computed over the whole certificate would give such twins different values, and a revocation recorded for one would not match the other. In this profile, every encoding of a credential under one issuance key has one token.¶
This identity is incompatible with the earlier experimental "smrp-cert-v1" hash of the complete certificate. An implementation MUST NOT accept v1 tokens as v2 tokens and MUST NOT try several derivations until one yields absence. A change of token semantics requires a new profile identifier and an explicit migration of revocation state.¶
Let e be an epoch start, a multiple of E on the time scale of Section 11.1.¶
Y = H("smrp-shard-v1" || U16(profileId) || U64(e) || X)
partitionId = 0 if k = 0
partitionId = leftmost k bits of Y otherwise
¶
The result is an unsigned integer smaller than 2^k. The verifier MUST recompute it from the token that it derived. A geographic region, a roadside-unit identifier, a manufacturer name, or a partition chosen by the holder is not a substitute. The token already binds the domain, and the checkpoint binds the complete configuration.¶
Hash partitioning controls the expected occupancy of a partition. It does not guarantee a maximum. The checkpoint issuer MUST NOT truncate an overfull partition. It MUST stop issuing checkpoints for that partition, which ends affirmative status there, or obtain a configuration with adequate capacity through trust administration. The epoch-dependent mapping redistributes the tokens. It guarantees neither balanced occupancy nor relief of an overfull partition in the next epoch; capacity planning must account for the occupancy tail and possible adversarial influence on credential selection. Section 17.4 discusses the choice of k.¶
An epoch e is in use during the interval [e - G, e + E). The first G seconds are the lead interval. During the lead interval of epoch e + E, the epochs e and e + E are both in use. Because G is smaller than E, at most two epochs are in use at any time.¶
The lead interval lets the issuer build the trees of the next epoch, and lets holders obtain proofs under them, while the current epoch remains valid. Without it, conservative time validation produces an interval at every epoch boundary during which no checkpoint is admissible to any verifier (Section 11.7). A checkpoint issued during the lead interval is an ordinary statement about the revoked set at its own snapshotTime. It is not an assertion about the future.¶
While two epochs are in use, the issuer MUST keep the streams of both current: a revocation is inserted in the applicable partition of each. A verifier accepts evidence of either epoch, subject to the time rules of Section 11. A holder SHOULD obtain its proof for the next epoch at a random instant of the lead interval, so that retrievals do not concentrate at one instant.¶
For an epoch e and a partition p, the applicable revoked set contains the token of every revoked credential that satisfies both conditions:¶
A credential that is revoked before its validity period begins is included as soon as that period intersects the interval. A credential whose validity period has ended before e - G is omitted, since no verifier accepts it. Epochs thereby bound the set to the revoked credentials that could be used during the epoch, instead of every credential ever revoked.¶
Revocation is expressed per credential. Excluding a vehicle means inserting the token of each of its credentials that falls in scope (assumption A9). The number of tokens contributed by one revoked vehicle is the number of distinct credentials whose validity intervals intersect [e - G, e + E). This union can exceed the simultaneously valid pseudonym pool: twelve successive five-minute credentials intersect a one-hour epoch even if only one is valid at a time. Revoked credentials already issued for future use must also be counted when their validity intersects the epoch. This multiplicity affects tree construction, distribution, and proof size (Section 8.5).¶
Two distinct credentials with the same token would require a collision of SHA-256. If the checkpoint issuer ever detects one, neither credential can be accepted through an absence proof for that token, and the event MUST be treated as a security incident.¶
An SmrpConfiguration (Appendix A) identifies the protocol and profile versions, the domain and its issuance key, the authority epoch, the epoch duration and lead, the number of partition bits, the freshness and clock-error ceilings, the resource limits, and the authorized checkpoint keys with their validity intervals. It is distributed through authenticated trust administration. The protocol never bootstraps trust from a staple.¶
configurationHash = H("smrp-config-v1" || COER(configuration))
signerKeyId = H("smrp-checkpoint-key-v1" || Qcheckpoint)
¶
Qcheckpoint is a validated 65-octet uncompressed NIST P-256 point. The authority keys of a configuration MUST be listed in strictly increasing order of signerKeyId, without duplicates. The notBefore of each key MUST be smaller than its notAfter. A checkpoint-signing key SHOULD be dedicated to SMRP and SHOULD differ from every credential issuance key.¶
The protocol version is 1. Section 20 discusses profile identifiers. The following limits apply in addition to the ASN.1 type constraints. A configuration that violates any of them MUST be rejected at installation.¶
| Parameter | Required range or relationship |
|---|---|
| authorityEpoch | 1 to 2^64 - 1; protected monotonic generation |
| epochDuration (E) | 1 to 604800 seconds |
| epochLead (G) | 0 to E - 1 seconds |
| shardBits (k) | 0 to 16 |
| maxSnapshotAge (A) | 1 to 600 seconds, and greater than 2 * (maxAuthorityClockError + maxVerifierClockError) |
| maxCheckpointLifetime | 1 to A seconds |
| maxVerifierClockError | 0 to 60 seconds |
| maxAuthorityClockError (a) | 0 to 60 seconds |
| maxTreeSize | 1 to 2^20 leaves; a tree of m leaves holds m - 1 revoked tokens |
| maxStapleSize | from 309 + 32 * height(maxTreeSize) to 4096 octets |
| authorityKeys | 1 to 16 distinct keys |
The lower limit of maxStapleSize is the size of the largest full staple that a tree of maxTreeSize leaves can require (Section 10.3), so that a configuration cannot admit a tree whose proofs it forbids. The relationship on A leaves room in the snapshot-age budget under the nominal clock-error bounds. It does not by itself ensure a nonempty status interval. The checkpoint lifetime, snapshot-to-issuance delay, key interval, epoch end, and application age limit must also permit the inequalities of Section 11.5 to hold. For example, A = 121, a = 30, a verifier error bound of 30, and a checkpoint lifetime of 1 second satisfy that relationship but cannot yield an affirmative interval. An epochLead of zero is permitted but reproduces the acceptance gap of Section 11.7. A deployment SHOULD choose G using the sufficient overlap conditions of Section 11.7, including a refresh schedule whose admissible intervals cover the transition.¶
These are protocol ceilings for an experiment, not safety constants. A deployment can require fresher status, smaller objects, and more accurate clocks. A verifier MAY apply stricter local limits (Section 15.5). A local limit cannot extend a signed deadline and cannot change a token or partition derivation.¶
Any change to the content of a configuration MUST use a strictly greater authorityEpoch for the same domain and MUST be authenticated by trust administration. A checkpoint cannot authorize a new configuration, authority epoch, issuance key, or signing key. Two administratively authenticated configurations for the same domain and authority epoch with different hashes constitute a configuration conflict and set the conflict barrier of the domain (Section 13.1). Neither arrival order nor a larger version resolves it.¶
The verifier MUST keep the greatest installed authority epoch and its configuration hash in rollback-resistant storage. Recovery from a compromised signing key or from a detected conflict requires an explicit administrative decision that installs a greater authority epoch. Installing it discards the stream state and the proof caches of the previous configuration and clears the conflict barrier. It does not clear terminal revocation records. Changing a domain identifier or a token profile requires preserving every relevant terminal revocation under an explicit authenticated migration policy. A token of an old domain cannot be inverted to recover a credential digest. For token-only records, administration must supply an authenticated mapping to the stable credential identity or the new token, or preserve an effective lookup through the old identity. If coverage of the affected records cannot be established, the verifier MUST NOT activate affirmative decisions for the affected migration scope. Installing a new configuration alone is not a migration of terminal state.¶
This document does not define the transport of configurations. C-ITS deployments can use the trust-list mechanisms of [ETSI102941] and [ETSI103601] or those of the SCMS [SCMS2018]. Until an SDO profile defines an authenticated assertion that binds checkpoint keys to an issuance key and a domain, an explicit locally provisioned configuration is REQUIRED.¶
The set semantics, interval-tree construction, and two proof types below determine the meaning of a checkpoint's signed set commitment.¶
For a stream, the checkpoint issuer forms the complete applicable set S of revoked tokens (Section 6.5) as of snapshotTime. Revocation is terminal in this profile. Reversible suspension and removal from a list require a different profile and MUST NOT be approximated by silently removing a token.¶
Let x_1 < x_2 < ... < x_r be the tokens of S in strictly increasing order. The boundary list is B = (MIN, x_1, ..., x_r, MAX), indexed from 0, with MIN as its first element and MAX as its last. MIN and MAX are boundary types outside the 32-octet token space. They are not the all-zero and all-one tokens, which remain ordinary values. In the typed order, MIN is smaller than every token and MAX is greater than every token.¶
The leaves of the tree are the intervals between consecutive boundaries. Leaf i is the pair (B[i], B[i+1]), for i from 0 to |S|. The number of leaves is m = |S| + 1. It is the treeSize of the checkpoint. A token X is absent from S exactly when it lies strictly inside one interval, that is, when B[i] < X < B[i+1] for some i. Each token of S is the upper boundary of one leaf and the lower boundary of the next. The configured maximum and the absolute limit of 2^20 leaves MUST be enforced before any allocation.¶
enc(MIN) = 0x00
enc(DATA(X)) = 0x01 || X
enc(MAX) = 0x02
leafHash(i, lower, upper) = H(0x00 || U32(i) || enc(lower)
|| enc(upper))
nodeHash(l, r) = H(0x01 || l || r)
padHash(i) = H(0x02 || U32(i))
h = number of bits of (m - 1) -- h = 0 if m = 1;
-- otherwise 2^(h-1) < m <= 2^h
M = 2^h
¶
The height h is computed with integer arithmetic. Positions 0 to m - 1 of the lowest level hold leafHash(i, B[i], B[i+1]). Positions m to M - 1 hold padHash(i). At each level, consecutive pairs are hashed from left to right until one root remains. If m = 1, the root is the hash of the single leaf. MIN is the lower boundary of leaf 0 and of no other leaf. MAX is the upper boundary of leaf m - 1 and of no other leaf. A padding position is never opened by a proof.¶
The leaf index is part of the leaf hash. This binds every interval to its rank and fixes the path that authenticates it. The three one-octet prefixes separate leaves, interior nodes, and padding, so that a value of one kind cannot be presented as another. The encoding of a pair of boundaries is unambiguous, because the first octet of each boundary determines its length.¶
These hash-input encodings are distinct from the ASN.1 encoding of SmrpBoundary. For instance, the COER choice tag of MIN is 0x80, whereas its hash-input type is 0x00. Implementations MUST hash the encodings defined above.¶
An empty revoked set has m = 1 and h = 0. Its root is leafHash(0, MIN, MAX). An empty set MUST still be published under a signed checkpoint. Missing data from an upstream source is not an empty set.¶
A leaf that states an interval free of revoked entries is the range statement of certificate revocation trees [KOCHER98]. The typed sentinels, the index binding, and the padding rule are specific to this document. Appendix F compares this tree with a tree whose leaves are single tokens.¶
An SmrpNonMembershipProof opens one leaf. It carries the index of the leaf, its two boundaries, and the h sibling hashes of its authentication path, lowest level first. With m and root taken from an authenticated checkpoint, the verifier proceeds as follows.¶
VerifyAbsence(m, root, P, X):
h = height(m)
i = P.index
require 0 <= i <= m - 1
require len(P.siblings) = h
require P.lower is MIN if i = 0, else DATA
require P.upper is MAX if i = m - 1, else DATA
require P.lower < X < P.upper -- typed order, strict
c = leafHash(i, P.lower, P.upper)
j = i
for s in P.siblings:
if j is even: c = nodeHash(c, s)
else: c = nodeHash(s, c)
j = floor(j / 2)
accept if and only if c = root
¶
Between DATA boundaries the inequalities are strict: equality with either boundary fails. Every hash and token MUST be exactly 32 octets. A failed requirement yields a bounded failure, never an unhandled error and never an affirmative result.¶
The proof contains one leaf and one path. The leaf authenticates an interval statement; correctness of the complete sorted interval construction remains an issuer obligation. The same proof establishes absence for every token strictly inside that interval. The verifier must therefore derive the query token from the validated credential and select the authorized checkpoint independently of the party supplying the witness.¶
An SmrpMembershipProof shows that X is the lower boundary of the leaf at a stated index. It carries the index, the upper boundary of that leaf, and h sibling hashes. The lower boundary is not transmitted: the verifier supplies the token that it derived.¶
VerifyPresence(m, root, P, X):
h = height(m)
i = P.index
require 1 <= i <= m - 1
require len(P.siblings) = h
require P.upper is MAX if i = m - 1, else DATA with X < P.upper
c = leafHash(i, DATA(X), P.upper)
j = i
for s in P.siblings:
if j is even: c = nodeHash(c, s)
else: c = nodeHash(s, c)
j = floor(j / 2)
accept if and only if c = root
¶
The index of that leaf is the rank of X in S, counted from 1. The type of a proof is explicit on the wire. An implementation MUST NOT reinterpret a failed membership proof as a non-membership proof, or the converse. A failed non-membership proof is not evidence of revocation.¶
Every proof for a tree of m leaves carries exactly h hashes, where h is the number of bits of m - 1, that is, the smallest integer such that 2^h is at least |S| + 1. The following consequences are exact. The companion tests check the height for every tree size from 1 to 4097 and the length of the proof of every leaf for the sizes up to 300 and around 512, 1024, and 4096 (Appendix H).¶
A tree whose leaves are single tokens, as in earlier descriptions of SMRP, proves absence by opening two adjacent leaves and carries 2h hashes for two independent paths. Sharing the common part of the two paths reduces the mean to about h but leaves a largest proof of 2h - 2 hashes. The interval leaf gives h in every case (Appendix F).¶
An SmrpCheckpointTBS has the following fields, in this order. Every field is signed. Signing only the root would leave the tree size, the scope, and the times open to substitution.¶
| Field | Octets | Meaning |
|---|---|---|
| protocolVersion | 1 | 1 in this document |
| profileId | 2 | Profile identifier (Section 20) |
| domainId | 16 | Domain of the configuration; a consistency check |
| configurationHash | 32 | Hash of the complete configuration |
| authorityEpoch | 8 | Administrative generation; a consistency check |
| epochStart | 8 | Start of the epoch; a multiple of E |
| partitionId | 4 | Partition, smaller than 2^k |
| partitionVersion | 8 | Position of the checkpoint in its stream |
| snapshotTime | 8 | Complete-through cutoff of the revocation database |
| thisUpdate | 8 | Issuance time |
| nextUpdate | 8 | Exclusive acceptance deadline |
| treeSize | 4 | Number of leaves m of the tree, equal to |S| + 1 |
| rootHash | 32 | Root of the tree |
| signerKeyId | 32 | Identifier of the signing key in the configuration |
The encoded TBS occupies 171 octets. The fields that repeat content of the configuration allow a receiver to dispatch and to diagnose a mismatch before any signature operation.¶
The following rules bind the checkpoint issuer. Rules 2 to 4 are also checked by verifiers, which treat an authenticated violation as a conflict (Section 13.2).¶
tbsBytes = COER(SmrpCheckpointTBS) signedMessage = "smrp-checkpoint-v1" || tbsBytes signature = ECDSA-P256-SHA256(signedMessage)¶
The signature is the 64-octet string U256(r) || U256(s), where U256 is the 32-octet big-endian encoding. It is not a DER ECDSA signature. The signer MUST output scalars satisfying 1 <= r < q and 1 <= s <= floor(q / 2), where q is the order of the NIST P-256 group, replacing s by q - s if necessary. The verifier MUST enforce these ranges even when a cached authenticated TBS permits skipping the ECDSA operation. The signer MUST generate nonces as required by [FIPS186-5]. Deterministic generation as in [RFC6979] is permitted and is not required by the wire format.¶
The signature operation hashes signedMessage once with SHA-256. An interface that takes a precomputed digest MUST be used in its prehashed mode. Checkpoint signatures are unrelated to IEEE 1609.2 message signatures and to their certificate-hash inputs.¶
checkpointId = H("smrp-checkpoint-id-v1" || tbsBytes)
¶
The checkpointId identifies the statement, not one signature over it. Two valid signatures over identical TBS octets denote the same checkpoint. After checking the signature encoding and scalar ranges, a verifier MAY skip the ECDSA operation when the checkpointId and exact TBS octets match a retained authenticated checkpoint under the installed configuration. In that case the previously authenticated statement, not the newly received signature bytes, provides the trust basis. Key authorization, context, freshness, and state checks still apply. If the statement is retained as the base of a list or as conflict evidence, the verifier retains the signature that actually established its authentication, rather than unverified replacement signature bytes.¶
The set commitment of a checkpoint is the pair (treeSize, rootHash). A proof is a statement about a set commitment. It contains nothing that depends on the version or on the times of a checkpoint. A proof that verifies against one checkpoint therefore verifies against every checkpoint of the same stream that has the same set commitment. Two rules follow, and they are central to the cost of SMRP:¶
A proof needs to be replaced only when the set of its partition changes or when a new epoch begins. The status of an unrevoked credential is otherwise refreshed by checkpoints alone.¶
All SMRP structures are encoded with the Canonical Octet Encoding Rules (COER) of [X696], from the module of Appendix A. A decoder MUST reject trailing octets, non-canonical encodings, unrecognized choices, values out of range, and objects that exceed a protocol or local size limit. Decoding does not replace the semantic checks of this document. The module has no optional field and no extension marker. A change of syntax requires a new protocol version or profile.¶
An SmrpStaple is a choice among three forms.¶
The proof of a full or proof-only staple is a non-membership proof or a membership proof. A holder has no reason to present a membership proof about itself. The form lets a distribution point answer a request about a revoked token with evidence that the requester can verify, and a verifier that receives such a staple applies it (Section 13.3). Third parties convey revocations with the notice of Section 10.4.¶
A checkpoint has a fixed size and is placed first in the two forms that contain one. A verifier MUST authenticate and process that checkpoint independently of what follows it (Section 13.3).¶
The sizes below are exact for the module of Appendix A. They exclude the ITS certificate, its chain, the enclosing signature, and all framing of lower layers. In these formulas, h is the height of the tree (Section 8.2).¶
| Object | Size |
|---|---|
| Checkpoint (TBS of 171 and signature of 64) | 235 |
| Checkpoint-only staple | 236 |
| Full staple, non-membership, two DATA boundaries | 309 + 32 * h |
| Proof-only staple, non-membership, two DATA boundaries | 82 + 32 * h |
| Each sentinel boundary in place of a DATA boundary | 32 fewer |
| Full staple, empty set | 245 |
| Proof-only staple, empty set | 18 |
| Full staple, membership, DATA upper boundary | 276 + 32 * h |
| Proof-only staple, membership, DATA upper boundary | 49 + 32 * h |
| Revocation notice, DATA upper boundary | 79 + 32 * h |
Table 6 gives the sizes for several numbers of revoked tokens in a partition. Each row is the largest set of its height.¶
| Revoked tokens (up to) | h | Proof-only staple | Full staple | Revocation notice |
|---|---|---|---|---|
| 0 | 0 | 18 | 245 | - |
| 3 | 2 | 146 | 373 | 143 |
| 31 | 5 | 242 | 469 | 239 |
| 255 | 8 | 338 | 565 | 335 |
| 1023 | 10 | 402 | 629 | 399 |
| 4095 | 12 | 466 | 693 | 463 |
| 65535 | 16 | 594 | 821 | 591 |
| 1048575 | 20 | 722 | 949 | 719 |
The largest staple of this profile occupies 949 octets, at h = 20. The limit of 4096 octets leaves room for other profiles. It does not authorize additional fields in this one. A configuration bounds the height through maxTreeSize, so that every staple it admits fits its maxStapleSize (Section 7). A path MUST NOT be truncated.¶
An SmrpRevocationNotice names a token and carries a membership proof for it, with the epochStart that designates the stream. Any list holder can produce one for a revoked token, and any party can relay it. A notice is verified against the checkpoint that the receiver already holds for that stream (Section 13.6). It can only establish a revocation.¶
A notice is the means by which a revocation reaches verifiers without the cooperation of the revoked holder. A roadside unit or another list holder that observes a credential whose token is in its list can send the notice to the stations around it. The notice is specific to one credential and occupies at most 79 + 32 * h octets, so it does not require distributing the list.¶
An SmrpSnapshot contains a checkpoint and the complete list of the tokens of its set, in strictly increasing order. It is valid if the checkpoint is authentic, the number of tokens plus one equals treeSize, and the tree rebuilt from the list as specified in Section 8.2 has the root rootHash. A snapshot is what the issuer publishes for distribution points, list holders, and auditors.¶
An SmrpDelta contains the checkpointId of a base checkpoint, a newer checkpoint of the same stream, and the list of inserted tokens in strictly increasing order. The receiver MUST retain the complete authenticated base checkpoint, including its TBS and the signature that actually established its authentication. After authenticating the target, the receiver also compares its monotonic times and commitment with that base under the consistency rules, before advancing a stream; an authenticated violation produces a conflict. The target checkpoint MUST have the same configuration, epoch, and partition as that base and a strictly greater partitionVersion, whether or not the base is the current fresh checkpoint. No inserted token may already be present, and the tree rebuilt from the merged list must have the treeSize and rootHash of the target checkpoint. Rebuilding the root proves, under collision resistance, that the newer set is exactly the base set plus the inserted tokens. A delta therefore shows that the transition is insert-only.¶
Snapshots and deltas are not radio objects and are not bounded by maxStapleSize. Their transport is outside this document. Before general ASN.1 decoding, a receiver MUST check the input length and encoded token count against configured bounds and reject impossible combinations. It MUST authenticate the fixed-size target checkpoint before rebuilding the tree. Length and count checks do not replace canonical decoding or root validation.¶
SMRP times are unsigned counts of whole seconds of International Atomic Time (TAI) elapsed since 00:00:00 UTC on 1 January 2004. This is the time scale of IEEE 1609.2 certificates [IEEE1609.2], whose Time32 type counts the same seconds, here carried in 64 bits. The scale has no leap seconds. The time origin is shared with ITS certificates. An implementation still has to decode certificate-duration units, handle precision and overflow, and conservatively convert validity boundaries before comparing them with whole-second SMRP values.¶
An endpoint whose clock keeps UTC or POSIX time converts with the offset between TAI and UTC in force. The uncertainty of that conversion, the quantization to whole seconds, and any smoothing applied by the clock source MUST be included in the declared clock error. Truncating a clock value does not create zero error. Arithmetic on times MUST detect overflow and underflow.¶
A checkpoint is well formed only if all the following hold, with the parameters of the configuration that it names. A checkpoint that carries a valid signature and violates one of them is INVALID.¶
epochStart mod E = 0 epochStart - G <= snapshotTime <= thisUpdate < nextUpdate nextUpdate <= epochStart + E nextUpdate - thisUpdate <= maxCheckpointLifetime a <= snapshotTime nextUpdate <= snapshotTime - a + A partitionVersion > 0 partitionId < 2^k 1 <= treeSize <= maxTreeSize keyNotBefore <= thisUpdate - a and thisUpdate + a < keyNotAfter¶
keyNotBefore and keyNotAfter are the bounds of the signing key in the configuration. The last line requires the key to be authorized over the whole uncertainty interval of the issuance time. The line before the version bounds the age of the information at the deadline: the deadline of a checkpoint follows its snapshot cutoff, not the moment of its signature.¶
Let C be the reading of the verifier's clock and v its known error bound. v MUST NOT exceed maxVerifierClockError. The verifier keeps a protected time floor F, initially zero, and computes:¶
if C + v < F: time is not trustworthy nowLower = max(C - v, F) nowUpper = C + v F = nowLower¶
True time is assumed to lie in [nowLower, nowUpper]. F never decreases and MUST be kept in rollback-resistant storage, with a persistence lag that the implementation documents. When time is not trustworthy, or when v is unknown or exceeds the configured ceiling, the verifier produces no NOT_REVOKED_AT_SNAPSHOT and admits no checkpoint. The outcomes that rest on recorded state remain available: REVOKED from a terminal record and CONFLICT from the barrier.¶
Once F reaches an absolute deadline D, no later decision can use evidence whose deadline is at most D, provided the protected floor is retained. An earlier conservative refusal because C + v is at least D does not establish that F has reached D: a later, still trustworthy interval can permit acceptance before true time D. For example, with D = 100, readings (C = 99, v = 1) and then (C = 98, v = 1) give F = 98 throughout; the first interval touches the deadline and the second does not. This is compatible with increasing true times 98.8 and 98.9. An epoch e is retired only when F reaches e + E. A policy requiring irreversible refusal from the first uncertain expiry decision needs additional protected state.¶
An authentic checkpoint is one that is well formed, names the installed configuration, and carries a valid signature of a configured key. A verifier classifies an authentic checkpoint as follows.¶
cpDeadline = min(nextUpdate, snapshotTime - a + A,
epochStart + E, keyNotAfter)
if nowLower < keyNotBefore or nowUpper >= keyNotAfter: ignored
else if nowLower < thisUpdate + a: premature
else if nowUpper < cpDeadline: fresh
else: stale
¶
A checkpoint whose signing key is not authorized at the time of processing is ignored for every purpose. Only a fresh checkpoint can become the current checkpoint of its stream and support an affirmative result. A premature or stale checkpoint supports none, but it is still a signed statement of the issuer: it counts in the consistency checks of Section 13.2, and a membership proof that verifies against it establishes a revocation (Section 13.3).¶
Let the current checkpoint of the stream be fresh, and let the credential be valid on [certNotBefore, certNotAfter) after conservative conversion of its validity period. Let Aapp be the maximum snapshot age of the application status class (Section 15.5), at most A; without a class, Aapp = A. The status is affirmative only if:¶
start = max(thisUpdate + a, keyNotBefore, certNotBefore)
deadline = min(nextUpdate, snapshotTime - a + Aapp,
epochStart + E, keyNotAfter, certNotAfter)
nowLower >= start and nowUpper < deadline
¶
The deadline is absolute and exclusive. Transit, a cache hit, a retry, a session resumption, or reception from another peer never restarts a lifetime. The affirmative outcome reports the deadline, the snapshot cutoff, and the checkpointId, so that an application can apply a stricter age at the time of use.¶
For constant v and a time floor that does not tighten the current interval, the allowed clock readings have width at most max(0, A - 2a - 2v - d), where d = thisUpdate - snapshotTime. Key, epoch, certificate, and checkpoint-lifetime limits can reduce that width further. This calculation concerns the interval of clock readings; changing clock bias or a tightening time floor must not be interpreted as a measured wall-clock service duration. Clock uncertainty cannot extend acceptance beyond the conservative absolute deadline.¶
The following bound is the main freshness guarantee. Appendix D gives the definitions and the argument in full.¶
Theorem 1. Assume A1 to A8. Let a revocation decision that affects a credential be taken at true time r. If a verifier returns NOT_REVOKED_AT_SNAPSHOT for that credential at true time u under a maximum snapshot age Aapp, then u < r + L + Aapp.¶
The argument is short. The affirmative result rests on a checkpoint whose set does not contain the token. By A2 and A3, the true cutoff c of that checkpoint precedes r + L. By A4, snapshotTime is at most c + a. The verifier checked that nowUpper is smaller than snapshotTime - a + Aapp, which is at most c + Aapp. By A5, u is at most nowUpper. Hence u is smaller than c + Aapp, which is smaller than r + L + Aapp.¶
Four remarks delimit the result.¶
For example, with L = 20 seconds and Aapp = 60 seconds, affirmative results end less than 80 seconds after the decision. These figures are illustrative. They are neither measurements nor recommended safety limits.¶
Consider the boundary between an epoch e and the next epoch e + E, a verifier with error v, and checkpoints issued without delay. The last checkpoint of epoch e is usable while C + v < e + E. If the first checkpoint of the next epoch could not be issued before e + E, it would be usable only from C - v >= e + E + a. No affirmative result would be available to that verifier for 2v + a seconds, at every boundary and for every station at once. The companion tests reproduce this gap (Appendix H).¶
A lead interval can remove this start-time gap. Under the preceding idealized timing assumptions, G >= 2v + a + d lets a next-epoch checkpoint become usable before the previous epoch stops being usable, if issuance and distribution take at most d seconds. This condition alone does not ensure continuous service: the next-epoch checkpoint must still be fresh at the transition, its key must remain authorized, and subsequent checkpoints must arrive before the applicable deadlines. For instance, E = 600, G = 300, and A = 120 allow an early next-epoch checkpoint to expire before the boundary. A deployment must check coverage by the admissible intervals of the actual refresh schedule, including packet loss and the application age limit.¶
For each stream in use, the issuer maintains the sorted set and proceeds as follows at every issuance.¶
The issuer MUST NOT release a checkpoint before the corresponding snapshot is durable. A checkpoint that refreshes an unchanged set has a new version, new times, and the previous treeSize and rootHash. It requires one signature and no tree work.¶
An issuer MAY issue a checkpoint out of cycle when a revocation is inserted. This does not change the enforcement bound, which depends on the cutoff and not on the cadence. It shortens the time before verifiers can learn the revocation.¶
The signing rate of the issuer is one signature per stream and issuance period. With an issuance period of T seconds it is 2^k / T signatures per second for one epoch, and twice that during a lead interval. This periodic signing rate is independent of the credential and revocation counts only while k and T are fixed. Insertions can trigger additional issuances, and capacity requirements may force a different partition count. Rate monitoring can detect a deviation from a configured schedule, but a deviation can also result from an authorized update or recovery; it does not by itself establish key misuse.¶
A distribution point obtains snapshots and deltas from the issuer and serves checkpoints, proofs, snapshots, and deltas. Before serving anything derived from a snapshot, it MUST validate the checkpoint signature and rebuild the root from the token list. It derives a proof for a token by reading the stored levels of the tree. Deriving a proof requires no signing operation. The distribution point still verifies checkpoint signatures and needs no checkpoint-signing secret.¶
Everything a distribution point serves is public and can be verified by its recipient. A response can therefore be cached, replicated, and relayed by untrusted parties, and a requester needs no authentication for the response to be trustworthy. A distribution point MUST NOT require a holder to authenticate with the credential whose proof it requests or with any long-term identifier (Section 19). The retrieval protocol is outside the scope of this document.¶
A distribution point that serves a proof MUST serve it under the latest checkpoint for which it holds the list, and SHOULD return that checkpoint with the proof.¶
For each credential that it intends to use and each epoch in use, the holder derives its token and its partition exactly as a verifier does. It then obtains evidence in one of two ways.¶
A holder MUST verify a proof against the checkpoint with which it will be used before it staples the proof. A full staple whose proof fails for the presenter's own token is INVALID at every verifier.¶
When a holder obtains a newer checkpoint of its stream, it compares the set commitment with that of its proof.¶
A holder SHOULD obtain a new proof at a random instant within the interval in which the previous evidence remains usable, so that retrievals after a change are spread over time. A holder whose credential is revoked obtains no proof of absence. The protocol requires nothing of it.¶
The choice between staple forms is a scheduling decision.¶
Section 17.3 gives the resulting channel load.¶
A verifier MUST implement the procedure of this section, or one that returns the same outcome for every input. The procedure separates two concerns. Processing an object can update the state of the verifier. The status of a credential is always computed from that state, never from an object alone. In particular, absent, expired, or superseded evidence cannot mask an authenticated revocation.¶
For each domain, the verifier keeps the following state.¶
| Element | Content | Protection |
|---|---|---|
| Configuration floor | Greatest installed authorityEpoch and its configuration hash | Rollback resistant |
| Time floor | F (Section 11.3) | Rollback resistant |
| Terminal records | Tokens with an authenticated revocation | Rollback resistant |
| Conflict barrier | A flag and the contradicting authenticated checkpoints or administrative configurations, with provenance | Rollback resistant |
| Stream records | The current checkpoint of each stream in use | Volatile |
| Proof cache | For a token and an epoch, the set commitment against which a proof of absence was verified | Volatile |
| Lists (optional) | Validated token lists with their set commitments and complete authenticated base checkpoints | Volatile |
A terminal record is keyed by the token. When the record is created while the credential itself is processed, the verifier MUST also keep the credential digest, so that an authenticated domain migration can preserve the credential identity. A token-only record learned from a notice cannot be inverted to obtain that digest. A terminal record is never cleared by the expiry of evidence, a change of epoch, a key rotation, a new configuration, or the eviction of other state.¶
Each guarantee depends on specific elements of state. An implementer can thus see what a loss of state costs.¶
| Guarantee | Depends on | Effect of losing the volatile state |
|---|---|---|
| Enforcement bound (Theorem 1) | Configuration floor, time floor | None |
| A revocation once learned remains REVOKED | Terminal records | None |
| No affirmative status after a detected conflict | Conflict barrier | None |
| An older checkpoint does not displace a newer one | Stream records | An older checkpoint that has not expired is usable again, within the bound of Theorem 1 |
| Status without repeated evidence | Stream records, proof cache, lists | INDETERMINATE until evidence is received again |
A verifier that cannot restore its configuration floor or its time floor MUST NOT return NOT_REVOKED_AT_SNAPSHOT until they are re-established from an authenticated source. A verifier that loses terminal records re-opens, for the credentials concerned, the interval that Theorem 1 bounds, and nothing more: a revoked credential obtains no proof of absence under any later snapshot. Terminal records nevertheless matter after that interval, because they distinguish REVOKED from INDETERMINATE for a holder that presents no evidence (Section 18.5).¶
A checkpoint reaches a verifier in a full staple, in a checkpoint-only staple, in a snapshot or delta, or alone from any source. The processing is the same in every case. It requires the time interval of Section 11.3.¶
Two distinct authentic checkpoints of one stream are consistent only if all the following hold, where lo is the one with the smaller partitionVersion and hi the other:¶
These are rules 2 to 4 of Section 9.2 as far as two checkpoints reveal them. A violation is an authenticated statement that the issuer contradicted its obligations. The verifier MUST set the conflict barrier of the domain and MUST retain the two checkpoints, with their signatures, as evidence. Any party can verify that pair. While the barrier is set, the verifier returns CONFLICT instead of NOT_REVOKED_AT_SNAPSHOT or INDETERMINATE for every credential of the domain. Only the installation of a greater authority epoch clears the barrier (Section 7.1).¶
The check compares a checkpoint with the current one only. It needs no history and bounded state. It does not detect every violation: a set that grows while a token is removed, or two views shown to disjoint groups of verifiers, are found only by parties that validate deltas or compare checkpoints (Section 18.4).¶
A verifier MAY retain a premature checkpoint and classify it again later. It MUST NOT use it earlier.¶
A staple is processed for a credential that the enclosing protocol has validated and whose token X the verifier has derived (Section 6.2). Let p(e) denote the partition of X for an epoch e.¶
Full staple. If the checkpoint was ignored in step 2, nothing further is done. Otherwise:¶
Proof-only staple. The epochStart MUST be a multiple of E; otherwise the staple is INVALID. If the verifier holds no current checkpoint for the stream (epochStart, p(epochStart)), nothing further is done. Otherwise the proof is verified for X against the set commitment of that current checkpoint:¶
The rule for a full staple is strict because the staple is self-contained: its proof either matches the checkpoint beside it or the presenter sent inconsistent evidence. An authentic membership proof is terminal even under a stale or premature checkpoint, because the issuer has signed that the token is in the revoked set and revocation is not reversible. The signing key still has to be authorized at the time of processing (step 5 of Section 13.2).¶
A proof of absence in a full staple whose checkpoint is not the current one is checked but changes no state unless the two set commitments are equal. An older checkpoint cannot produce an affirmative result once a newer set is known.¶
The status of a credential with token X, at an application status class with maximum snapshot age Aapp, is given by the first applicable rule.¶
Rule 6 is the proof-reuse rule of Section 9.4 seen from the verifier. The proof cache holds a commitment, not a deadline. When a newer checkpoint with the same commitment becomes current, every cached proof of the stream yields a new deadline with no message from the holders concerned. When a checkpoint with a different commitment becomes current, the cached proofs of the stream no longer match. The outcome is then INDETERMINATE until the holder presents a proof for the new set. It is not INVALID, because the holder has done nothing wrong.¶
The decision is evaluated at the time of use. A deadline returned earlier is an upper limit. It does not relieve the verifier from applying rules 1 and 2 to each later operation, including operations that carry only a certificate digest (Section 15.4).¶
A conflict barrier blocks affirmative status; it MUST NOT hide a newly verifiable revocation. Before returning CONFLICT, or INDETERMINATE because time is unavailable, for a validated credential, the verifier checks only the following bounded sources of negative evidence. It does not admit a new current checkpoint or create an absence-cache entry on this path.¶
Without trustworthy time, only a list or a root whose prior authentication and installed-configuration provenance are retained can establish new negative knowledge. No full staple is used on this path, including one that might repeat a retained checkpoint; only proof-only evidence, notices, and validated lists are considered. No previously unseen checkpoint is authenticated or admitted. A verified membership creates the terminal record and returns REVOKED; an existing conflict barrier remains set. Absence, malformed evidence, an unverifiable statement, or a missing prerequisite does not clear the barrier and does not produce an affirmative result. The normal byte, path, signature-work, and state limits apply. Evidence validation must not become an unbounded attempt to resolve a domain conflict.¶
Expiry of a signing key prevents a newly received full checkpoint from being authenticated for this purpose. It does not erase a set commitment that was authenticated and retained while the key was authorized: a membership proof or list derived from that retained commitment can still establish a terminal revocation. The receiver keeps the commitment's configuration and authentication provenance. This is a rule about retained authenticated knowledge, not retrospective validation of a previously unseen expired-key signature.¶
A revocation notice is not bound to an authenticated operation and needs no signature of its sender. It is verified against the state of the receiver.¶
The retained root must have been authenticated under the installed configuration while its signing key was authorized. A notice requires no new checkpoint authentication, current clock reading, or positive freshness decision. It may therefore establish REVOKED while time is unavailable or a conflict barrier is set; it cannot clear that barrier or create affirmative state.¶
A notice can only add a revocation that the checkpoint issuer has signed. A forged notice has no effect, and processing it costs at most h + 1 hash invocations. A sender SHOULD precede a notice by the checkpoint that it was derived from, for instance as a checkpoint-only staple, when receivers might not hold it.¶
A verifier MAY restrict the notices that it records to tokens of credentials that it has recently observed. A record created for a credential that the verifier has never authenticated MAY be evicted under memory pressure (Section 13.9).¶
A party that has the capacity can keep the complete token list of one or more streams. It installs a snapshot and applies deltas as follows.¶
The list is stored with its set commitment and complete authenticated base checkpoint, including its TBS and signature. An older snapshot of the same stream MUST NOT replace a retained newer list. The checkpoint consistency checks still apply. This replacement rule does not add a comparison of complete historical lists: auditing a removal hidden by a larger size requires the relevant lists or a validated delta chain (Section 18.4). A verifier that keeps lists applies the following rules in step 5 of Section 13.4:¶
A verifier in list mode therefore needs no staple from any holder. It detects a revoked credential whose holder presents nothing, and it obtains affirmative status for a credential whose staple was lost. It can also produce proofs and revocation notices for others. In exchange it stores 32 octets per revoked token and receives every delta of its streams. Freshness still comes from checkpoints: a list that is not confirmed by a fresh checkpoint supports REVOKED and nothing else.¶
List mode and stapled proofs are two ways to consume the same checkpoint. They can coexist in one neighborhood: roadside units and well-connected vehicles can keep lists, and other stations can rely on staples and on the notices that list holders emit.¶
The verifier reports an outcome. The application status class (Section 15.5) maps it to an action. The following rules apply to every class.¶
A permissive class that maps INDETERMINATE to UNCONFIRMED does not enforce revocation against a holder that omits evidence. Section 18.5 discusses this case and the role of notices and lists.¶
An implementation MUST bound every element of state, globally and per domain. Stream records, proof-cache entries, and lists may be evicted. Eviction of stream records can make an older, still time-admissible checkpoint usable again and therefore reopen acceptance that a newer set had stopped; it does not extend Theorem 1. Losing a list can also remove the ability to discover a revocation that has not yet become a protected terminal record. A deployment requiring persistence of an observed version floor must retain that floor in protected state or stop affirmative decisions until it is restored. Entries of a retired epoch are discarded (Section 11.3).¶
Terminal records are bounded as follows. A record MAY be removed once the end of native validity has been established by a trustworthy lower bound on time, for example F >= certNotAfter, and any required audit retention has ended. A conservative refusal based only on nowUpper >= certNotAfter does not establish that expiry. A record created from a notice or a list for a credential that the verifier has not authenticated MAY be evicted, oldest first: while the credential is valid, the revoked sets of later epochs contain the token and the revocation can be learned again. The record of a credential that authenticated an operation processed by the verifier MUST NOT be evicted while that credential is valid. If such a record cannot be stored, the verifier MUST NOT return NOT_REVOKED_AT_SNAPSHOT for the domain until it can. Storage exhaustion fails closed.¶
Unauthenticated input MUST NOT allocate state. A stream record is created only for an authentic checkpoint, a proof-cache entry only for a verified proof about a validated credential, and a terminal record only for a verified membership proof.¶
This section compares the profiles specified by this document and by draft-grund-v2x-pocsp-00 [I-D.grund-v2x-pocsp]. It does not attribute those profiles' restrictions to every possible Merkle or individual-status design. Both support reception-time verification without an online query. They authenticate different statements and distribute the work differently.¶
pOCSP signs one status statement for one exact certificate and usage context. Its good result requires authoritative knowledge that the certificate was issued and was not revoked at the stated time. SMRP signs a shared commitment to a complete revoked set within a declared scope. A non-membership witness, checked for a query derived from the authenticated credential, establishes absence at that snapshot; it does not assert issuance.¶
Under the respective assumptions, pOCSP Section 5.3 states a stale-GOOD bound of D_status + W_max + Delta, while the SMRP bound in Section 11.6 uses ingestion lag and maximum snapshot age. The latter charges clock uncertainty to the usable interval rather than adding a post-cutoff clock allowance. This is a property of the validation rules, not an intrinsic difference between signatures on individual statements and signatures on Merkle roots. A comparison of operational exposure must align ingestion lag, true-time age, native credential validity, and failure policy.¶
Neither mechanism guarantees delivery of a revocation under indefinite suppression. An expired affirmative result becomes unavailable or indeterminate according to the validator and application policy. An application that continues safety-relevant acceptance in a degraded state has not obtained the same enforcement guarantee as one requiring affirmative status.¶
| Property | pOCSP | SMRP |
|---|---|---|
| Affirmative assertion | Known issuance and no authoritative revocation | Absence from an identified, authorized revoked-set snapshot |
| Object authenticated by the status key | Individual certificate and context statement | Partition checkpoint shared by multiple queries |
| Credential identification | Digest of the complete canonical certificate, with context-specific pID | Identity derived from issuer key, type, version, and canonical TBS |
| Proof production | Authorized responder signs; untrusted caches can distribute the signed object | Authorized issuer signs the checkpoint; any list holder can construct witnesses |
| Refresh while the underlying status is unchanged | New individual signed evidence for the required context | New shared checkpoint can renew a previously checked witness when the scoped commitment is unchanged |
| Effect of another credential's revocation | Does not invalidate otherwise usable evidence for this certificate in the baseline | Adopting a changed commitment requires an absence witness for that commitment |
| Negative status received from another party | Supported by Section 14.6; the target certificate is needed unless already held | Supported by a membership notice or validated list; the required checkpoint must be held |
| Evidence size | Independent of revoked-population size for a fixed profile; depends on encoded fields and signature | Depends on height, boundary types, and whether the checkpoint is included |
| State | Terminal and conflict state per certificate/domain epoch, plus context-specific cache | Terminal credential state, domain conflict state, stream checkpoints, and proof or list cache |
| Usage policy | Context signed by the responder | Application class selected by verifier policy; the shared object is not restricted to one class |
| Publication | No requirement to publish the entire revoked set | Snapshots and deltas enable independent construction and structural audit, and expose revoked tokens |
| Certificate profiles | ITS and X.509 as specified in the pOCSP draft | ITS credentials covered by the identity profile in this document |
| TLS carriage | Negotiated OCSP response type or the specified application exchange | Application exchange or the separately negotiated optional response type in Section 16 |
These properties do not imply that one validator is stateless or that an existing TLS implementation understands either new response type. In particular, pOCSP Sections 14 and 18 specify persistent negative state, conflict handling, responder authorization, and recovery. Its terminal-revocation and omission protections are also relevant precedents for SMRP.¶
Let P = 2^k, let T be the periodic checkpoint issuance interval, E the epoch duration, and G the lead interval. Let N_a be the number of distinct certificates requiring individual status in the observation interval, q the number of contexts used per certificate, and R_p the pOCSP renewal interval. With periodic issuance, regular epochs, and no additional event-triggered or redundant signing, the approximate rates are:¶
Q_pocsp ~= N_a * q / R_p Q_smrp ~= P * (1 + G/E) / T¶
For an illustrative single-epoch comparison with one context, 10^6 certificates renewed every 300 seconds require about 3333 statements per second; 16 partitions refreshed every 30 seconds require about 0.53 checkpoints per second outside the lead interval. These counts omit all set-management and distribution work. The second expression counts checkpoint signatures, not total issuer work. The issuer still resolves revocation decisions to all affected credentials, maintains the sets and trees, and publishes consistent snapshots. Changes to P or T, out-of-cycle issuance, key overlap, and recovery can change the rate. Distribution points do not sign proofs, but they store and index authenticated data and serve the required bandwidth. pOCSP also permits distribution through caches that hold no responder signing key.¶
A lower signing rate may support a particular key-custody design, but this document establishes no hardware throughput threshold and no impossibility of protecting a high-throughput signing service. The relevant comparison includes the security and availability of the complete signing and snapshot-commit service.¶
For witness renewal, suppose revocation events are Poisson with rate lambda and each event inserts B independently distributed tokens. This is an engineering model, not a protocol assumption. A given partition is affected by an event with probability w = 1 - (1 - 1/P)^B. For random B, use w = 1 - E[(1 - 1/P)^B]. Then:¶
p_change(T) = 1 - exp(-lambda * w * T) renewal_intervals_per_second = p_change(T) / T¶
The model must also include epoch changes, new credential activations, recovery, and missed updates. Reducing T can separate changes previously combined in one renewal; constant per-holder cost is justified only for intervals whose commitment remains unchanged. B counts all credentials covered by the stream, including sequential and future-valid credentials, not merely those simultaneously usable at the revocation decision.¶
Verification cost depends on cache misses and distinct objects observed. A useful measurement counts K_p distinct pOCSP objects, K_c distinct checkpoints, and the number and heights of SMRP proofs actually checked. It compares K_p signature verifications with K_c signature verifications plus proof hashing, parsing, and state processing. With one shared partition, T = 30 seconds, and R_p = 300 seconds, a receiver following one certificate can see ten times as many checkpoint signatures as individual response signatures; following ten certificates equalizes those signature rates. Further sharing can reduce the SMRP rate. These are arithmetic examples, not platform measurements. Message signatures common to both schemes do not remove the need to measure their added costs.¶
For the submitted encoding, a two-DATA-boundary proof-only staple has size S = 82 + 32h; sentinels reduce this size, and the empty-set case is separate. Let B_p be the actual encoded pOCSP object size, B_c the checkpoint-only size, V the stations in a neighborhood, f_p and f_s their respective evidence-bearing message rates, C the distinct checkpoints needed, and w_c their aggregate transmission rate per checkpoint. The evidence traffic model is:¶
traffic_pocsp ~= V * f_p * B_p traffic_smrp ~= V * f_s * S + C * w_c * B_c¶
The rates count evidence-bearing full-certificate messages, not every CAM or BSM. pOCSP Sections 8.4, 14.5 and 15.1 constrain evidence inclusion to that certificate schedule; the SMRP privacy profile does likewise. The examples below assume the same justified schedule, f_p = f_s = f. The 256-octet good response in pOCSP Appendix D is a specific test object. DER signature length, pID length, context, OIDs, and other fields can change B_p. With B_p = 256, a two-DATA proof alone is smaller when h is at most 5, but that does not establish a total-channel advantage. At h = 5, S = 242 and B_c = 236; for C = w_c = 1, the above inequality requires V*f greater than 236/14. Full staples, initial acquisition, lower-layer framing, repetitions, and losses must also be counted.¶
Table 10 compares encoded evidence for selected partition sizes with that particular pOCSP GOOD vector. Nonempty rows use the larger two-DATA-boundary absence proof. The table excludes shared-checkpoint transmission, enclosing certificates and lower-layer overhead; it is not a traffic or latency comparison.¶
| Revoked tokens in the partition (up to) | h | SMRP, proof-only | SMRP, full | pOCSP example only |
|---|---|---|---|---|
| 0 | 0 | 18 | 245 | 256 |
| 31 | 5 | 242 | 469 | 256 |
| 1023 | 10 | 402 | 629 | 256 |
| 32767 | 15 | 562 | 789 | 256 |
| 1048575 | 20 | 722 | 949 | 256 |
Checkpoint sharing and duplicate suppression are not independent benefits. If suppression keeps transmissions constant as V grows, the receiver does not obtain V times more transmission opportunities. If every station repeats the checkpoint, opportunities and channel load both grow. New receivers need the relevant checkpoint and witness; shared freshness does not remove acquisition delay or correlated loss. A notice comparison likewise states whether the checkpoint and target certificate are already cached.¶
An issuer-key compromise illustrates the semantic difference: a newly created credential can validate cryptographically while being unknown to the authoritative issuance database. Under its specified rules pOCSP returns unknown, whereas absence from an SMRP revoked set does not distinguish such a credential. Deployments requiring issuance-aware status need an additional issuance-aware predicate. Conversely, requiring such knowledge brings database coverage and synchronization obligations that absence-only checking does not claim to solve.¶
The signature-independent SMRP identity helps preserve a revocation fact across representations that differ only in the outer certificate signature. This does not by itself demonstrate a pOCSP GOOD bypass: modifying the complete certificate also changes its pID, so the old good object no longer matches. Any claimed bypass must establish how new good evidence satisfying the issuance rules is obtained. Composition uses the validated credential to map the two identifiers; it never compares their hash values directly.¶
Published SMRP sets allow an auditor to check sorting, reconstruction, and transitions for the data it obtains. A delta checked against a retained base list demonstrates that particular insert-only transition. Neither operation proves that all real revocation decisions were included, that data were made available to everyone, or that a disjoint view does not exist. pOCSP supports certificate-level contradiction detection from observed assertions; SMRP supplies a different audit object and a wider conflict scope, rather than complete auditability.¶
Tokens, interval boundaries, partitions, and synchronized insertions can disclose relationships. Downloading a whole partition can conceal the selected query at the cost of more data. Both protocols avoid a verifier's reception-time status request; neither thereby guarantees pseudonym unlinkability or prevents observation through other traffic.¶
SMRP is a candidate when many credentials share each checkpoint, checkpoints reach receivers through shared distribution, and root changes or epoch transitions do not make witness renewal excessive. It trades individual status signatures for public set management, proof construction, and common failure dependencies. These conditions must be evaluated with the credential population covered by each epoch and with batch revocations.¶
pOCSP is a candidate when issuance-aware status or signed usage context is required, when independent renewal between certificates matters, or when the fixed-profile individual object fits the channel budget better. Its signing and provisioning capacity must cover the active contexts and peak refresh load. X.509 support and negotiated response-type carriage are additional profile differences, not automatic compatibility with all deployed TLS software.¶
A deployment can use different mechanisms for different authenticated operations. The choice remains a configured authorization policy. It is not negotiated by omitting an inconvenient proof or by weakening the status requirement after a validation failure.¶
A deployment using more than one status mechanism MUST define its accepted sources, credential mapping, required predicates, failure handling, and recovery policy before processing evidence.¶
Under pOCSP Section 14.6, authorized SMRP terminal evidence is an external revocation source if local policy admits it; it does not manufacture a pOCSP statusVersion. Conversely, revoked pOCSP evidence can create a common terminal credential record after validation. The pOCSP conflict decision is INVALID for the certificate, whereas an SMRP conflict barrier affects its domain. These outcomes may require different recovery and application actions.¶
An SMRP proof is publicly verifiable status evidence. It is not a proof of possession and conveys no authority. The following rules apply to every carriage.¶
Relaying public evidence about another station does not give the relay any authority of that station.¶
IEEE 1609.2 and ETSI TS 103 097 provide signed data structures and a contributed-extension mechanism in the header [IEEE1609.2] [ETSI103097]. The preferred mapping carries the COER SmrpStaple as an opaque value of a header extension inside the data covered by the SignedData signature. This is the extension point that [I-D.grund-v2x-pocsp] uses, so that a message can carry either evidence, or both, under one envelope profile.¶
| Field path within SignedData | Content |
|---|---|
| tbsData.payload | CAM, DENM, or J2735 payload octets |
| tbsData.headerInfo.contributedExtensions | SDO-allocated extension carrying COER(SmrpStaple) |
| signer | SignerIdentifier; full certificate on evidence-bearing messages |
| signature | SignedData signature validated by the enclosing IEEE 1609.2 profile |
The signer field is a sibling of tbsData and signature, not a field inside HeaderInfo. The extension is in the signed tbsData; the native profile's complete signature and signer-binding procedure still applies.¶
The extension identifier is to be allocated by the responsible SDO. Until a profile allocates it and defines the enclosing type, the permitted message types, the criticality, the behavior of receivers that do not know the extension, the size bound, and a complete encoding vector, this mapping is suitable only for coordinated experiments and closed deployments. The ETSI contributor identifier denotes ETSI and is not an SMRP identifier. Implementers MUST NOT insert an unallocated value into production traffic or assume that existing receivers ignore an unrecognized extension.¶
ETSI specifications define revocation for authority certificates through trust lists and CRLs [ETSI102941] and specify no revocation method for authorization tickets. SMRP therefore does not conflict with an existing ETSI status mechanism for end-entity certificates, and cannot claim conformance to one.¶
SAE J2735 application objects [SAEJ2735], their IEEE 1609.2 security envelopes, and the identifiers used to dispatch them are separate layers. If the deployed envelope profile offers no interoperable extension point, an SDO MAY define a signed wrapper that contains the original payload octets and the staple. The wrapper MUST preserve the payload encoding octet for octet and MUST itself be inside SignedData. A wrapper changes the octets delivered to the application decoder and is not interoperable with an unmodified receiver. This document allocates no wrapper identifier. A deployment specification chooses one carriage mode and tests it end to end.¶
A legacy receiver that ignores the extension can still authenticate the message where the SDO profile permits unknown extensions to be ignored. It has not performed SMRP validation, and a deployment MUST account for such receivers in its safety policy.¶
V2X senders alternate messages that carry the full signer certificate with messages that carry only its digest. In a pseudonym-privacy profile:¶
A message that carries only a digest is evaluated from the state of the verifier (Section 13.4), provided that the underlying stack has an authenticated and unambiguous mapping from the digest to the exact full certificate. Rules 1 and 2 of the decision apply to every such message, and the status deadline is checked at use. If the digest is unknown or resolves ambiguously, the verifier obtains the full credential or returns INDETERMINATE. Eviction from a certificate cache never becomes permission to accept another certificate with the same short identifier. A change of pseudonym ends the association between the previous credential and its proof.¶
Staple repetition is coordinated with the certificate-inclusion and congestion-control rules of the deployment. This document assumes no fixed certificate or message rate.¶
An application status class consists of a maximum snapshot age Aapp, not greater than the configured maxSnapshotAge, and of a policy for each outcome. The class is selected by the verifier from the authenticated application identifier and permissions of the message. It is never selected by the sender and is not part of the evidence. One checkpoint and one proof serve all classes.¶
The classes below correspond to the V2X profiles of [I-D.grund-v2x-pocsp], and their default ages equal the windows of those profiles, so that the nominal age parameters can be compared for the same class. Their actual stale-affirmative bounds still depend on their respective ingestion, time, and validation rules (Section 14.1). The values are interoperability defaults and initial experimental engineering bounds. They are not safety constants or measured recommendations and require validation by the applicable ETSI, IEEE, SAE, or deployment safety process.¶
| Class | Default Aapp | INDETERMINATE or CONFLICT |
|---|---|---|
| awareness (CAM, BSM) | 600 s | UNCONFIRMED; automated safety control SHOULD require NOT_REVOKED_AT_SNAPSHOT |
| strict (DENM, SRM, SSM) | 300 s | Reject for automated critical processing |
| infrastructure (SPaT, MAP) | 300 s | Reject or mark unusable according to operator policy |
For a target D on the delay of Section 11.6, a class satisfies Aapp <= D - L. The message types are those of [ETSICAM], [ETSIDENM], and [SAEJ2735]. Evidence carriage follows Section 15.4 for the awareness class. A strict message carries the full certificate and a staple unless the deployment profile establishes that receivers hold the corresponding state.¶
A class cannot extend a signed deadline. A deployment that needs an age below about 2 * (a + v) plus the issuance and distribution delay cannot obtain it, since no checkpoint would be usable (Section 11.5).¶
A staple shares the protocol data unit with the payload, the secured header, and the certificate. Lower layers bound that unit. For example, the GeoNetworking protocol limits the service data unit to 1398 octets [ETSI302636]. A deployment MUST choose its configuration so that a message with the full certificate and the largest staple fits without fragmentation. If B octets are available for the staple, a proof-only staple fits when 82 + 32 * h <= B, and a full staple when 309 + 32 * h <= B. These are sufficient worst-case conditions for every non-membership proof at height h. Sentinel-boundary proofs can be smaller, so failure of a worst-case condition does not mean every individual proof fails to fit. The number of partition bits is the parameter that controls h (Section 17.4).¶
TLS 1.3 is specified by [RFC9846]. [RFC8902] specifies, as an Experimental protocol, authentication with ITS certificates in TLS. An endpoint that validates an ITS certificate received in a TLS handshake can derive its token as in Section 6.2, provided that the negotiated certificate type and the issuer validation match this profile. X.509 certificates are not covered by the identity defined in this document.¶
After the handshake, an endpoint sends an SmrpStaple about its own certificate inside the protected connection. The receiving endpoint derives the token from the certificate that the handshake authenticated and applies Section 13. The application protocol specifies the framing, the endpoint roles, the evidence requirement, and the authorization gate. Operations that require status wait for it. Completing a handshake does not satisfy that requirement.¶
No channel binding is required. The evidence is a statement about a credential, not about a connection: it is public, and it cannot be used for another credential because the verifier derives the token itself. For the same reason, the state that results from it serves any connection authenticated by the same credential. It does not establish the identity of a peer: that remains the function of the handshake.¶
This differs from the application-layer mode of pOCSP, whose evidence is bound to one connection by an exporter value signed by the responder and has to be issued online for each connection. SMRP evidence is prepared in advance and reused.¶
TLS 1.3 carries certificate status in the status_request extension of the CertificateEntry [RFC6066] [RFC9846], as a DER-encoded OCSPResponse [RFC6960]. The ResponseBytes of an OCSPResponse identify a response type and carry an octet string whose content that type defines. This subsection defines an OPTIONAL response type for SMRP. It lets a TLS endpoint present SMRP evidence in the handshake, where the transcript protects it, with the negotiation that pOCSP uses. An implementation that does not support it uses Section 16.1.¶
OCSPResponse ::= SEQUENCE {
responseStatus successful (0),
responseBytes [0] EXPLICIT SEQUENCE {
responseType id-pkix-ocsp-smrp,
response OCTET STRING -- contains COER(SmrpStaple)
} }
id-pkix-ocsp-smrp OBJECT IDENTIFIER ::= { id-pkix-ocsp TBD2 }
¶
The envelope adds 30 octets to a staple of 256 octets or more when the response type has an 11-octet DER encoding, as the children of id-pkix-ocsp with a value below 128 do. An SMRP response carries no certificate chain. The checkpoint keys are provisioned through the configuration, exactly as for V2X (Section 7).¶
A generic TLS implementation that expects a BasicOCSPResponse can reject or ignore this response type. The encapsulation therefore requires positive knowledge that both endpoints support it and is not backward compatible with legacy OCSP stapling. The object is not an OCSP basic response and is not a pOCSP response. An implementation MUST NOT label an SMRP staple with another response type.¶
The status deadline is absolute. A TLS KeyUpdate changes traffic keys and does not refresh certificate status. Continued encrypted transport is not evidence that the credential remains acceptable. When the deadline is reached, the application suspends the operations that require affirmative status, obtains a new status, reauthenticates, or closes the connection, according to its policy.¶
Obtaining a new status does not necessarily involve the peer. The verifier evaluates the decision of Section 13.4 again from its state. If it has admitted a newer checkpoint of the stream with an unchanged set commitment, from any source, the status has a new deadline. Checkpoints are public and are the same for every credential of a partition, so an endpoint can obtain them itself without disclosing which certificate it is checking. Only when the set has changed does the endpoint need a new proof, which the peer sends at the application layer or which the endpoint derives from a list. A long-lived connection therefore needs neither a new handshake nor evidence issued for that connection.¶
A session resumed from a PSK inherits a certificate-based identity only if the resuming endpoint has an authenticated association between the ticket or the resumption state and the credential, its domain and authority epoch, and the required class. At every resumption the endpoint MUST evaluate the decision for that credential. A terminal record, a conflict barrier, or a superseded authority epoch causes the resumption to be rejected. Without a current affirmative result where the policy requires one, the endpoint rejects the resumption or performs a full handshake. A ticket lifetime never extends a status deadline, and the time floor prevents a backward clock adjustment from doing so. The validity of the certificate is checked separately at every resumption. An external PSK has no certificate identity.¶
An operation whose authorization requires certificate status MUST NOT be executed irreversibly in 0-RTT before the required status and the replay controls of [RFC9846] hold. SMRP is not an anti-replay mechanism for early data. QUIC status exchanges use application streams and add no TLS handshake message. QUIC prohibits TLS post-handshake client authentication [RFC9001], and this document does not relax that restriction.¶
TLS Exported Authenticators [RFC9261] provide additional channel-bound authentication for X.509 certificates only. Using them with ITS credentials and SMRP would require a separately specified extension.¶
This section is informative. The formulas are engineering models and the numbers are arithmetic illustrations. None of them is a measurement or a recommended safety value.¶
The parameters are chosen in the following order.¶
With R revoked tokens in scope and uniform hashing, the occupancy of a partition follows a binomial law of mean mu = R / 2^k. By the multiplicative Chernoff bound, the probability that a given partition holds at least 2 * mu tokens is at most (e/4)^mu, which is below 2 * 10^-17 for mu = 100. This is a one-partition bound under independent uniform hashing. A union bound for any of the 2^k partitions multiplies the probability by 2^k. An issuer chooses maxTreeSize from its desired global overflow probability and monitors observed occupancy. For small mu use the exact binomial tail; adversarial credential selection or dependent inputs can invalidate the independent model.¶
Consider V stations in mutual range. Each sends f evidence-bearing messages per second, that is, messages with its full certificate. Let S be a common proof-only staple size in the model, 82 + 32 * h for two DATA boundaries. If sizes or presentation rates differ by station, replace V * f * S by the sum of the actual per-station products. Let C be the number of distinct streams used by the stations. For one domain and one epoch, C = 1 without partitioning, and its expectation is 2^k * (1 - (1 - 2^-k)^V) under independent uniform partition choices. Multiple domains and overlapping epochs add streams. If each distinct checkpoint is transmitted w times per second in the neighborhood, the octets of SMRP evidence per second in that neighborhood are approximately:¶
V * f * S + 236 * w * C¶
The first term counts proof-only transmissions and the second counts separate checkpoint-only transmissions at an actual aggregate rate w per stream. If full staples are used instead, their incremental cost over proof-only is 227 octets each and must be counted in place of the corresponding checkpoint-only transmissions. Suppression changes the achieved w and must be evaluated with losses and hidden terminals. A period 1/w is not a delivery guarantee. For comparison, pOCSP contributes V * f * B_p octets per second when B_p is the encoded response size for the selected profile and status. Its first-contact delay also depends on loss, scheduling, and cache state.¶
For example, with V = 50, f = 1, w = 1, no partitioning, and 1023 revoked tokens (h = 10), SMRP contributes 50 * 402 + 236 = 20336 octets per second and pOCSP 12800. With an empty revoked set, SMRP contributes 50 * 18 + 236 = 1136 octets per second. This example uses the supplied 256-octet pOCSP GOOD vector only; that is not a protocol-wide fixed size. The break-even condition is S + 236 * w * C / (V * f) < B_p. At h = 5, S = 242 and B_p = 256, even one checkpoint per second requires V * f > 236 / 14, approximately 16.86, before the model favors SMRP. These figures exclude radio headers, contention, coding, correlated loss, and different status or identifier encodings.¶
Table 13 shows the effect of the number of partition bits for one illustrative domain: 100000 revoked tokens in scope, independent Poisson revocation events at 0.01 events per second, each inserting 20 credential tokens whose validity intervals intersect the epoch, an issuance period of 30 seconds, and 50 stations in range. The height is that of a partition of mean occupancy. The last column is the probability that the proof of a given holder is superseded during one issuance period (Section 14.3).¶
| k | Tokens per partition | h | Proof-only octets | Checkpoints signed per second | Distinct checkpoints among 50 stations | Proof superseded per period |
|---|---|---|---|---|---|---|
| 0 | 100000 | 17 | 626 | 0.0333 | 1 | 0.259 |
| 4 | 6250 | 13 | 498 | 0.533 | 15.4 | 0.195 |
| 8 | 391 | 9 | 370 | 8.53 | 45.5 | 0.0223 |
| 12 | 24.4 | 5 | 242 | 137 | 49.7 | 0.00146 |
| 16 | 1.53 | 2 | 146 | 2185 | 50.0 | 0.000092 |
Three observations follow.¶
If evidence-bearing transmissions are lost independently with probability p and a receiver has n opportunities during an observation window, the probability of missing all of them is p^n. Losses on a radio channel are often correlated, so this is an approximation and not a guarantee.¶
A verifier needs two things about a neighbor: the checkpoint of its stream and its proof. The presentation schedule associates a proof with the neighbor's full certificate; the witness itself is public and can have been obtained from any list holder. The checkpoint comes from any station that shares the stream and from the infrastructure. Without partitioning, all V stations can relay the same checkpoint. They provide V times as many opportunities only if all V actually transmit at the assumed per-station rate, which also increases traffic. If suppression keeps the aggregate rate w fixed, that multiplicative opportunity gain cannot be counted at the same time. Correlated loss can defeat successive attempts. Once the checkpoint is held, a proof-only staple from a new neighbor is sufficient at first contact.¶
A checkpoint refresh reaches all cached proofs at once (Section 13.4). After a period without revocation in the partition, a verifier that receives one checkpoint, from any source, renews the status of every neighbor that it has already verified. No per-neighbor exchange takes place.¶
After an insertion in a partition, all holders of that partition need a new proof. Until they have one, their status at verifiers that hold the new checkpoint is INDETERMINATE. Publishing the authenticated delta promptly lets holders in self-derivation mode compute the new proof before or soon after admission of the new checkpoint. The clock-error allowance a is not a guaranteed distribution window: issuance, encoding, retrieval, and network delay must be scheduled and measured independently.¶
Time can be derived from GNSS, a secure in-vehicle time service, authenticated network time, or a combination. GNSS time alone can be spoofed. A verifier SHOULD track the quality of its time and detect implausible jumps. The error v that it declares has to cover the source, the conversion to ITS time, and the drift since the last synchronization. When it cannot establish v within the configured ceiling, no checkpoint is usable (Section 11.3): the verifier can still return REVOKED, INVALID, and CONFLICT, and otherwise returns INDETERMINATE.¶
The issuer's bound a covers the clock that stamps snapshotTime and thisUpdate, including the database timestamps from which the cutoff is derived. An issuer that derives the cutoff from timestamps of several machines includes their mutual offset in a or in L.¶
Given a tree built as specified from a strictly sorted set, an authentic checkpoint, and a collision-resistant hash function, a non-membership proof that verifies excludes the token from the committed set, and a membership proof that verifies includes it. Appendix D gives the argument and counterexamples to weakened rules.¶
The signature authenticates the statement of the issuer. It does not prove that the statement is true. The issuer's obligations are of two kinds, and they are not equally verifiable.¶
Absence from the revoked set is not evidence of issuance, of permissions, of chain validity, of possession of a private key, or of correct behavior. Every accepted message still needs its ordinary security processing.¶
An attacker that holds the private key of a credential and its last proof of absence can produce accepted messages until the proof is superseded at the verifier or the checkpoint expires. This is inherent to evidence prepared in advance. Theorem 1 bounds it for every verifier, including one that the attacker isolates from all newer checkpoints, since the deadline of the last checkpoint that the verifier holds is absolute. The parameters L and A therefore form a safety parameter set that has to be selected and audited.¶
Stream state rejects an observed return to an older set. Absolute deadlines end the use of a frozen snapshot even if the verifier never learns of a newer one. These are different protections, and only the second is covered by Theorem 1.¶
Message-level replay protection, generation-time checks, sequence logic, geographic plausibility, and application consistency remain necessary. SMRP asserts certificate status only.¶
An attacker that holds an authorized checkpoint key can sign checkpoints that omit revoked tokens, which hides revocations for as long as verifiers accept them, and checkpoints that contain tokens of unrevoked credentials, which creates terminal records at the verifiers that receive the corresponding membership proofs. It can also sign a very large partitionVersion, after which honest checkpoints of the stream no longer become current. None of this is detectable from one checkpoint.¶
The countermeasures are operational. At a fixed partition count and issuance schedule, a deployment can provision signing capacity and monitor departures from that schedule (Section 12.1). Hardware protection, access control, and multi-party authorization depend on the implementation; a low nominal signing rate does not by itself provide them or detect an attacker that signs within the permitted rate. Contradictory checkpoints set the conflict barrier at verifiers that observe them (Section 13.2). Recovery is an authenticated configuration with a greater authority epoch that removes the key (Section 7.1). Accepting a still larger version from an untrusted source is never a recovery.¶
Terminal records created from forged checkpoints are false revocations. A verifier SHOULD record, with each terminal record, the authority epoch and the signing key under which it was learned. Trust administration can accompany a recovery configuration with an explicit, authenticated instruction to discard the records learned under an identified key. This document does not define that instruction. Without it, a verifier MUST NOT clear a terminal record. False revocations of pseudonym certificates otherwise end with the validity of those certificates.¶
Everything the issuer signs is public, and the complete status of a partition is one list. This allows three levels of audit.¶
These audits are possible and not guaranteed. A verifier detects a conflict only among the checkpoints that reach it. An issuer that shows different sets to disjoint groups is detected only if a checkpoint crosses from one group to the other. This document defines no public log of checkpoints. A deployment that requires stronger guarantees can publish checkpoints in a transparency log in the manner of [RFC9162], which is outside the scope of this document.¶
A revoked holder presents no proof. The verifier then obtains INDETERMINATE, exactly as for an honest holder whose staple was lost. The class policy is decisive. Under a strict class the operation is rejected. Under a permissive class it is processed as UNCONFIRMED, and stapling alone enforces nothing against that holder. A permissive class is therefore not revocation enforcement and SHOULD restrict automated or high-impact actions.¶
SMRP provides two mechanisms that do not depend on the holder. A verifier in list mode determines REVOKED from its own list. Any list holder that observes the credential, such as a roadside unit, can send a revocation notice, after which the verifiers that receive it hold a terminal record (Section 13.6). Neither requires the issuer to produce anything for that credential. A verifier without a list can still learn a revocation from a public membership proof delivered by infrastructure or another party that obtained it earlier. If no usable negative evidence reaches the neighborhood, only the configured expiry and application failure policy can apply there.¶
Stripping a staple from a message in transit is detectable when the staple is covered by the signature of the message (Section 15.1): the message no longer verifies. An attacker can still suppress whole messages.¶
The token does not depend on the signature octets of the certificate (Section 6.2). A holder cannot obtain a second identity for the same credential by re-encoding or replacing the certificate signature, and a revocation applies to every encoding. The token does depend on the complete to-be-signed certificate and on the full issuance key, so credentials that differ in an identity field are separated subject to the collision-resistance assumption.¶
For n uniformly distributed 256-bit tokens, the probability of at least one collision is about n * (n - 1) / 2^257. The protocol never uses a short digest as a security identity. A deployment that locates certificates by a truncated digest resolves it to the full credential before any SMRP processing.¶
The size limit of a staple, the bounded number of siblings, the fixed size of a checkpoint, the finite set of keys, and the fixed algorithms bound the work per object. A proof costs at most 2h + 2 hash compressions, and a notice the same. An exact retained authenticated TBS can avoid a repeated signature verification; an uncached statement still requires verification even if its identifier was seen before and later evicted.¶
A verifier SHOULD perform the checks that need no signature first (Section 13.2), cache authenticated checkpoints by checkpointId, and limit the signature verifications that it performs per source and in total. A verifier MAY discard, before signature verification, a checkpoint that its own fields make stale, provided that the object carrying it contains no membership proof. It thereby forgoes the consistency check on that checkpoint. A rate limit MUST NOT turn missing evidence into an affirmative result.¶
A party that installs a snapshot or a delta MUST bound both input length and token count before general decoding and MUST authenticate its checkpoint before tree reconstruction (Section 10.5). The configured tree limit and per-source and aggregate work limits remain necessary for authenticated, repeatedly supplied objects.¶
ASN.1 decoders MUST check that the input is consumed completely. Canonical re-encoding and comparison detect encodings that a permissive decoder accepts, provided that resource limits are applied before decoding. All arithmetic on times, indices, counters, lengths, and allocation sizes requires checked bounds. No check that validity depends on can rest on an assertion that a build option disables.¶
Each insertion in a partition makes the holders of that partition obtain a new proof. An attacker that can cause revocations, for instance by having its own credentials revoked, can thus impose a renewal on a partition at the rate at which the issuer inserts. This is an availability consequence of enforcing newer state. A verifier MUST NOT keep accepting a superseded result to conceal it. Batching insertions over the issuance period bounds the effect to one renewal per period.¶
This profile fixes SHA-256 and ECDSA with NIST P-256. The wire format has no algorithm identifier and no negotiation. Another hash function, another signature algorithm, or another credential type requires a new profile identifier (Section 20), new object sizes, and an explicit migration. Implementations MUST NOT accept an algorithm that the configured profile does not define.¶
The structure of SMRP limits the cost of such a change. The evidence about a credential contains hashes and no signature. The status signature is in the checkpoint, which can be shared by a partition; retransmissions and delivery schedules determine how often it is sent. If a new profile retains the hash width and tree construction, changing the checkpoint signature does not change the Merkle path size. It also changes key material, configuration encoding, validation cost, and potentially transport requirements. For example, an ML-DSA-44 signature occupies 2420 octets [FIPS204]. A checkpoint would then occupy about 2591 octets, and a proof-only staple would still occupy 82 + 32 * h octets. A mechanism that signs one statement per certificate carries such a signature in every evidence object. The same reasoning motivates Merkle Tree Certificates for issuance [I-D.ietf-plants-merkle-tree-certs].¶
This is a property of the structure and not a claim about a defined profile. A checkpoint of that size exceeds the data unit of some access layers and would need its own transport. For an already authenticated set commitment, the Merkle argument relies on collision resistance and the specified encodings. End-to-end status also relies on checkpoint authentication, credential validation, trustworthy time, and authority completeness. Replacing a checkpoint signature would not by itself make an ITS deployment post-quantum secure.¶
A receiver from which all newer status information is withheld cannot distinguish a situation in which a revocation occurred after its last snapshot from one in which none occurred. SMRP resolves this lack of information by expiry and by an INDETERMINATE outcome. It does not offer both unlimited offline availability and a bounded age of affirmative status.¶
A strict class can reject legitimate operations during loss or recovery. A safety assessment has to account for that failure mode and for any fallback. Cryptographic validity is not a safety case, and this Experimental specification does not certify a deployment.¶
This section follows the approach of [RFC6973]. Pseudonym schemes are surveyed in [PETIT2015].¶
Identifier. The token is a deterministic function of a certificate and a domain. Anyone who observes the certificate can compute it. Hashing does not make it secret or unlinkable. SMRP adds no identifier that outlives the certificate: the token changes with every pseudonym certificate.¶
On the air. A staple accompanies the full certificate and is never sent more often (Section 15.4). A proof reveals an interval index and up to two revoked boundary tokens. An observer already holding the same complete public snapshot can derive these values from the credential; an observer without that snapshot learns additional information. The number of sibling hashes reveals the tree height, which bounds the set size, while sentinel boundaries shorten the encoding and reveal an extreme interval. The checkpoint, when present, states the exact tree size. Hash partitioning does not explicitly encode a location, manufacturer, or region, but it does not establish independence from auxiliary observations.¶
Verifier. A verifier sends no query about any certificate. A verifier that retrieves checkpoints, snapshots, or deltas retrieves per-partition objects that are the same for everyone. A single partition index is a k-bit value. This is not an information bound for a retrieval session: timing, network origin, multiple requested partitions, and repeated epoch-dependent indices can add linkage information. For a fixed token, q observed epoch indices provide up to min(q * k, 256) bits of token filtering in the idealized hash model, before accounting for those other observations.¶
Holder and distribution point. A request for the proof of one token discloses that token, the time, and the network origin to the distribution point. Requests for several pseudonyms from one origin link those pseudonyms. Self-derivation avoids a direct request naming a token, but retrieval of selected partitions still exposes timing and network metadata. The holder computes proofs locally from the retrieved lists (Section 12.3). A holder that uses proof retrieval SHOULD NOT request proofs for several of its credentials in a way that links them, and SHOULD NOT retrieve the proof of a pseudonym long before using it from an origin that identifies the vehicle. Distribution points MUST NOT require holder authentication (Section 12.2) and SHOULD minimize logs and their retention. An anonymizing relay or an aggregated retrieval can reduce the exposure. Their actual leakage has to be evaluated, and this document does not claim that a proxy, a random delay, or a change of epoch proves unlinkability.¶
Published set. SMRP publishes the tokens of revoked credentials in scope. The list reveals the number and the timing of revocations. Tokens inserted in the same update can provide a grouping signal. Its strength depends on batching, concurrent revocations, and auxiliary information; simultaneous insertion alone does not establish common ownership. A party that has recorded the corresponding certificates can use that signal when linking pseudonyms. This is inherent to a published per-credential revocation list. A mechanism that only issues per-certificate statements, such as pOCSP, does not publish this information. An issuer can insert the tokens of several devices in one version to weaken the correlation. It cannot remove it.¶
Revocation evidence. A membership proof or a notice tells its recipients that a given credential is revoked. That is its purpose. Terminal records and conflict evidence kept by verifiers are subject to local retention rules.¶
Revocation governance, identity resolution, and the privacy effect of the decision to revoke are deployment responsibilities outside this protocol.¶
If this document is published as an RFC, IANA is requested to create a registry entitled "SMRP Profile Identifiers" with a 16-bit unsigned value. Values 0 and 65535 are Reserved. Values 1 to 65279 are assigned under the Specification Required policy of [RFC8126]. Values 65280 to 65534 are for Private Use. The profile specified by this document is named "ITS P-256 credential identity v2, SHA-256 interval tree, ECDSA P-256 checkpoint" and has the value TBD1, to be assigned by IANA. TBD1 is not a number that implementations can put on the wire.¶
Before such an assignment, implementations and vectors for a coordinated experiment use the Private Use value 65281 (0xff01). This value is not a global assignment and MUST NOT be assumed interoperable across unrelated experiments. Authenticated administration binds the private value to one exact specification and edition. A configuration hash authenticates the octets of a configuration. It does not identify different interpretations of those octets. An implementation MUST reject a reserved or unimplemented profile even if the identifier appears in an installed configuration.¶
The profile identifier is an input to partition selection and to the configuration hash. Migration from the experimental value to an assigned value therefore requires a new authorized configuration and the reconstruction of all trees and proofs. Implementations MUST NOT treat the two values as aliases and MUST NOT clear terminal records during that migration.¶
Each registration identifies the defining document, the credential identity, the token and partition formulas, the hash and signature algorithms, the object syntax, the trust scope, the time semantics, the resource limits, the migration behavior, and a security and privacy analysis. The designated expert verifies that a profile does not reuse an identifier with different token or signature inputs, does not permit affirmative status without bounded freshness, and leaves no identifier ambiguity.¶
For the optional encapsulation of Section 16.2, IANA is requested to allocate one value from the "SMI Security for PKIX Online Certificate Status Protocol (OCSP)" registry under 1.3.6.1.5.5.7.48.1, maintained according to [RFC7299] and [RFC8126]:¶
| Value | Description | Reference |
|---|---|---|
| TBD2 | id-pkix-ocsp-smrp | This document |
The resulting object identifier is id-pkix-ocsp-smrp OBJECT IDENTIFIER ::= { id-pkix-ocsp TBD2 }. Until the assignment, experiments use an object identifier under an arc that they control. The test vectors of this document use an identifier under the enterprise number reserved for documentation [RFC5612], which MUST NOT appear in a deployment.¶
This document requests no TLS extension code point, media type, or transport port. It makes no request for ETSI, IEEE, or SAE identifiers: a carriage profile of a standards body obtains its own allocations. The ASN.1 module of Appendix A has no module object identifier and needs none for compilation or for opaque carriage.¶
This section collects the principal requirements by role. The referenced sections are authoritative.¶
Checkpoint issuer:¶
Distribution point and holder:¶
Verifier:¶
Composition and carriage:¶
This module is normative. It uses ASN.1 notation [X680] and is encoded with COER [X696]. The integer ranges give encoding bounds. The tighter limits stated in the body also apply. The module has no optional field and no extension marker.¶
<CODE BEGINS> file "smrp.asn"
SMRP DEFINITIONS AUTOMATIC TAGS ::= BEGIN
Uint8 ::= INTEGER (0..255)
Uint16 ::= INTEGER (0..65535)
Uint32 ::= INTEGER (0..4294967295)
Uint64 ::= INTEGER (0..18446744073709551615)
Hash32 ::= OCTET STRING (SIZE(32))
DomainId ::= OCTET STRING (SIZE(16))
P256PublicKey ::= OCTET STRING (SIZE(65))
P256Signature ::= OCTET STRING (SIZE(64))
SmrpItsCredentialIdentity ::= SEQUENCE {
certificateVersion Uint8,
certificateType INTEGER (0..1),
issuerKeyHash Hash32,
toBeSignedCertificate OCTET STRING (SIZE(1..65535))
}
SmrpAuthorityKey ::= SEQUENCE {
publicKey P256PublicKey,
notBefore Uint64,
notAfter Uint64
}
SmrpConfiguration ::= SEQUENCE {
protocolVersion Uint8,
profileId Uint16,
domainId DomainId,
issuerKeyHash Hash32,
authorityEpoch Uint64,
epochDuration Uint32,
epochLead Uint32,
shardBits Uint8,
maxSnapshotAge Uint32,
maxCheckpointLifetime Uint32,
maxVerifierClockError Uint32,
maxAuthorityClockError Uint32,
maxTreeSize Uint32,
maxStapleSize Uint16,
authorityKeys SEQUENCE (SIZE(1..16)) OF SmrpAuthorityKey
}
SmrpCheckpointTBS ::= SEQUENCE {
protocolVersion Uint8,
profileId Uint16,
domainId DomainId,
configurationHash Hash32,
authorityEpoch Uint64,
epochStart Uint64,
partitionId Uint32,
partitionVersion Uint64,
snapshotTime Uint64,
thisUpdate Uint64,
nextUpdate Uint64,
treeSize Uint32,
rootHash Hash32,
signerKeyId Hash32
}
SmrpCheckpoint ::= SEQUENCE {
tbs SmrpCheckpointTBS,
signature P256Signature
}
SmrpBoundary ::= CHOICE {
min NULL,
data Hash32,
max NULL
}
SmrpNonMembershipProof ::= SEQUENCE {
index Uint32,
lower SmrpBoundary,
upper SmrpBoundary,
siblings SEQUENCE (SIZE(0..20)) OF Hash32
}
SmrpMembershipProof ::= SEQUENCE {
index Uint32,
upper SmrpBoundary,
siblings SEQUENCE (SIZE(1..20)) OF Hash32
}
SmrpProof ::= CHOICE {
nonMembership SmrpNonMembershipProof,
membership SmrpMembershipProof
}
SmrpFullStaple ::= SEQUENCE {
checkpoint SmrpCheckpoint,
proof SmrpProof
}
SmrpProofStaple ::= SEQUENCE {
epochStart Uint64,
proof SmrpProof
}
SmrpStaple ::= CHOICE {
full SmrpFullStaple,
proofOnly SmrpProofStaple,
checkpointOnly SmrpCheckpoint
}
SmrpRevocationNotice ::= SEQUENCE {
epochStart Uint64,
token Hash32,
proof SmrpMembershipProof
}
SmrpSnapshot ::= SEQUENCE {
checkpoint SmrpCheckpoint,
tokens SEQUENCE (SIZE(0..1048575)) OF Hash32
}
SmrpDelta ::= SEQUENCE {
baseCheckpointId Hash32,
checkpoint SmrpCheckpoint,
inserted SEQUENCE (SIZE(1..1048575)) OF Hash32
}
END
<CODE ENDS>¶
Three rules are not expressed by the syntax. In an SmrpNonMembershipProof, the lower boundary is min or data and the upper boundary is data or max. In an SmrpMembershipProof, the upper boundary is data or max. The number of siblings equals the height of the tree of the applicable checkpoint (Section 8.2).¶
The pseudocode of this appendix restates the body. The body prevails in case of difference. The verification of proofs is given in Section 8.3 and Section 8.4.¶
Token(config, cert, issuanceKey):
-- cert has been validated; issuanceKey validated its issuance
Q = uncompressed P-256 point of issuanceKey -- 65 octets
ikh = H("smrp-issuer-p256-v1" || Q)
require ikh = config.issuerKeyHash
tbs = canonical COER of cert.toBeSigned -- IEEE 1609.2 rules
id = COER(SmrpItsCredentialIdentity{3, type(cert), ikh, tbs})
dig = H(id) -- credentialDigest
return H("smrp-cert-v2" || config.domainId || dig)
Partition(config, e, X):
Y = H("smrp-shard-v1" || U16(config.profileId) || U64(e) || X)
return 0 if config.shardBits = 0
else the leftmost config.shardBits bits of Y
¶
These procedures derive the interval tree and sibling paths from a complete ordered token list. ApplyDelta only forms the sorted union; checkpoint authentication and transition validation follow Section 10.5.¶
Levels(tokens): -- strictly increasing 32-octet values
B = (MIN, DATA(x) for each x in tokens, MAX)
m = len(tokens) + 1
h = number of bits of (m - 1); M = 2^h
level = (leafHash(i, B[i], B[i+1]) for i in 0 .. m-1,
padHash(i) for i in m .. M-1)
levels = list that contains level
while len(level) > 1:
level = (nodeHash(level[2j], level[2j+1])
for j in 0 .. len(level)/2 - 1)
append level to levels
return (B, m, levels) -- the root is levels[h][0]
Siblings(levels, i):
return (levels[d][floor(i / 2^d) XOR 1] for d in 0 .. h-1)
ProveAbsence(tokens, X): -- any list holder
(B, m, levels) = Levels(tokens)
i = number of tokens smaller than X
require X is not in tokens
return {index i, lower B[i], upper B[i+1], Siblings(levels, i)}
ProvePresence(tokens, X):
(B, m, levels) = Levels(tokens)
i = 1 + number of tokens smaller than X
require B[i] = DATA(X)
return {index i, upper B[i+1], Siblings(levels, i)}
ApplyDelta(tokens, inserted): -- both strictly increasing
require inserted is not empty and shares no value with tokens
return the sorted merge of tokens and inserted
¶
Admit(cp, nowLower, nowUpper): -- returns a class, may update state
t = cp.tbs
if t.configurationHash != installed hash: return IGNORED
require WellFormed(t) -- field constraints; else INVALID
s = (t.epochStart, t.partitionId); cur = stream[s]
id = H("smrp-checkpoint-id-v1" || COER(t))
require RawSignatureRanges(cp.signature) -- even if cached
if cur is absent or cur.id != id or COER(cur.tbs) != COER(t):
key = config key with identifier t.signerKeyId; else INVALID
require VerifyLowS(key, "smrp-checkpoint-v1" || COER(t),
cp.signature) -- else INVALID
require key.notBefore <= t.thisUpdate - a
and t.thisUpdate + a < key.notAfter -- else INVALID
else:
key = the key recorded with cur
if nowLower < key.notBefore or nowUpper >= key.notAfter:
return IGNORED
if cur is present and cur.id != id
and not Consistent(cur.tbs, t):
set conflict barrier; retain (cur, cp); return CONFLICT
if nowLower < t.thisUpdate + a: return PREMATURE
deadline = min(t.nextUpdate, t.snapshotTime - a + A,
t.epochStart + E, key.notAfter)
if nowUpper >= deadline: return STALE
if cur is absent or t.partitionVersion > cur.tbs.partitionVersion:
stream[s] = cp
return FRESH
Consistent(x, y):
if x.partitionVersion = y.partitionVersion: return false
(lo, hi) = (x, y) ordered by partitionVersion
return lo.snapshotTime <= hi.snapshotTime
and lo.thisUpdate <= hi.thisUpdate
and lo.treeSize <= hi.treeSize
and (lo.treeSize < hi.treeSize or lo.rootHash = hi.rootHash)
¶
RawSignatureRanges applies the r and low-S bounds of Section 9.3. NegativeOnly and RetainedNegativeOnly implement Section 13.5. The latter uses only retained authenticated roots or lists; neither procedure advances a current checkpoint or caches absence. ProcessStaple also invokes the negative-only procedure if a full staple itself establishes a conflict.¶
Evaluate(staple or none, X, C, v, certNotBefore, certNotAfter, Aapp):
if terminal[X]: return REVOKED
if RetainedNegativeOnly(staple, X): return REVOKED
if conflict barrier:
if NegativeOnly(staple, X, C, v): return REVOKED
return CONFLICT
(nowLower, nowUpper) = TimeInterval(C, v) -- updates the floor
if time is not trustworthy: return INDETERMINATE
if staple is present:
r = ProcessStaple(staple, X, nowLower, nowUpper)
if r in {INVALID, REVOKED, CONFLICT}: return r
for each held list of the partition of X:
if X in list: terminal[X] = true; return REVOKED
if commitment(list) = commitment(stream of the list):
cache[X, epoch] = commitment(list)
best = none
for each epoch e in use:
K = stream[(e, Partition(config, e, X))]
if K is present and cache[X, e] = (K.treeSize, K.rootHash):
start = max(K.thisUpdate + a, key.notBefore, certNotBefore)
dl = min(K.nextUpdate, K.snapshotTime - a + min(A, Aapp),
e + E, key.notAfter, certNotAfter)
if nowLower >= start and nowUpper < dl:
best = later of (best, dl)
if best is present:
return NOT_REVOKED_AT_SNAPSHOT with deadline best
return INDETERMINATE
¶
The values below are produced by the companion artifacts (Appendix H). The private scalars 1 and 2 are public test keys: scalar 1 signs checkpoints and scalar 2 stands for the credential issuance key. They MUST NOT be used by any real authority. The tokens are synthetic 32-octet values, and the times are small synthetic values on the time scale of Section 11.1. Hexadecimal strings are wrapped for display and contain no separator. The checkpoint signature was produced with a deterministic nonce for reproducibility; any valid low-S signature over the same TBS denotes the same checkpoint.¶
Checkpoint public key (uncompressed NIST P-256 point of scalar 1), authorized on [1000, 5000):¶
046b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2 964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51 f5¶
Configuration fields:¶
protocolVersion 1
profileId 65281
domainId 00112233445566778899aabbccddeeff
issuerKeyHash 4d7e6e15223715bd7f32248ffcf5e9a2
83ad561cff5e2129ad37dea58c71d35f
authorityEpoch 1
epochDuration 600
epochLead 60
shardBits 0
maxSnapshotAge 120
maxCheckpointLifetime 90
maxVerifierClockError 2
maxAuthorityClockError 2
maxTreeSize 1048576
maxStapleSize 4096
¶
COER SmrpConfiguration (173 octets):¶
01ff0100112233445566778899aabbccddeeff4d7e6e15223715bd7f32248ffc f5e9a283ad561cff5e2129ad37dea58c71d35f00000000000000010000025800 00003c00000000780000005a00000002000000020010000010000101046b17d1 f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342 e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5000000 00000003e80000000000001388¶
configurationHash:¶
981855e0a5ec53350acf78fcef720a2fd57f6dd99230a157a666c04eeba53080¶
The intermediate hashes below permit reconstruction of the three-token tree and its absence witness.¶
Revoked tokens: 11..11, 44..44, 88..88 (each octet repeated 32 times) treeSize m = 4, height h = 2 leaf 0 (MIN, 11..11): 63086bdc7a20587b543540e2888cb5f8aa9287d90af14c275ee2ef3bfe1939f0 leaf 1 (11..11, 44..44): 4c48edebf9e5b6bd4305435ef78ab6db4a5b1bd78511b2c5eb9f8cf0d24b2a7b leaf 2 (44..44, 88..88): 8ecc1cbbea9c9009a9617f477faff6090c75c9857032c3e5b519dd93011cd2a6 leaf 3 (88..88, MAX): 2567c41b5a472963b1201ddb100b28e88a403debfbf7388746a3b3467a081b6c node at level 1, position 0: b0969de7468f0201edf48463bf469140db78bfd169fccf47e0b957c987244cc4 node at level 1, position 1: 30a6587e1c317554fca562e6229f4b95a44453e06e868eb02deac71e5a511448 rootHash: 3598e37b84e8adad0ae2a691c784ec7c1f86885efd849cbaddd4e38fd84576c4 Non-membership proof for X = 22..22: index 1 lower DATA 11..11 upper DATA 44..44 sibling 0: 63086bdc7a20587b543540e2888cb5f8aa9287d90af14c275ee2ef3bfe1939f0 sibling 1: 30a6587e1c317554fca562e6229f4b95a44453e06e868eb02deac71e5a511448 Empty set: treeSize 1, height 0, rootHash = leafHash(0, MIN, MAX): 9920dfec461cf27f5789b5c331c452188fe4a0340c0a2a2ca23868f29ee40578¶
This checkpoint authenticates the three-token tree under the configuration given above.¶
epochStart 1200 partitionId 0 partitionVersion 1 snapshotTime 1210 thisUpdate 1212 nextUpdate 1290 treeSize 4 COER SmrpCheckpointTBS (171 octets): 01ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fcef 720a2fd57f6dd99230a157a666c04eeba5308000000000000000010000000000 0004b000000000000000000000000100000000000004ba00000000000004bc00 0000000000050a000000043598e37b84e8adad0ae2a691c784ec7c1f86885efd 849cbaddd4e38fd84576c40db130143e3f7d6f0209cef5fb531cac6964b0bbad efbe2412a10f5df5d429ff checkpointId: 8026740952d0ccc0fb05e2a51d2c1fa322bf46d89b25ff03a89579051dbd58f1 signature (r || s, low-S): 35345c4014ee9fec0c39fc8152a4ffbffeda06838bd58dcb7351de5724bac648 6877cfbaab384298f3f53a7fb7a7c5c0addc831a1d86829570682f2468ef37a9¶
Full staple for X = 22..22 (373 octets). Expected outcome at clock reading 1220 with error 2: NOT_REVOKED_AT_SNAPSHOT.¶
8001ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fc ef720a2fd57f6dd99230a157a666c04eeba53080000000000000000100000000 000004b000000000000000000000000100000000000004ba00000000000004bc 000000000000050a000000043598e37b84e8adad0ae2a691c784ec7c1f86885e fd849cbaddd4e38fd84576c40db130143e3f7d6f0209cef5fb531cac6964b0bb adefbe2412a10f5df5d429ff35345c4014ee9fec0c39fc8152a4ffbffeda0683 8bd58dcb7351de5724bac6486877cfbaab384298f3f53a7fb7a7c5c0addc831a 1d86829570682f2468ef37a98000000001811111111111111111111111111111 1111111111111111111111111111111111118144444444444444444444444444 44444444444444444444444444444444444444010263086bdc7a20587b543540 e2888cb5f8aa9287d90af14c275ee2ef3bfe1939f030a6587e1c317554fca562 e6229f4b95a44453e06e868eb02deac71e5a511448¶
Proof-only staple for X = 22..22 (146 octets). Expected outcome at clock reading 1220 with error 2: NOT_REVOKED_AT_SNAPSHOT.¶
8100000000000004b08000000001811111111111111111111111111111111111 1111111111111111111111111111118144444444444444444444444444444444 44444444444444444444444444444444010263086bdc7a20587b543540e2888c b5f8aa9287d90af14c275ee2ef3bfe1939f030a6587e1c317554fca562e6229f 4b95a44453e06e868eb02deac71e5a511448¶
Full staple over an empty set, same times (245 octets). Expected outcome at clock reading 1220 with error 2: NOT_REVOKED_AT_SNAPSHOT.¶
8001ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fc ef720a2fd57f6dd99230a157a666c04eeba53080000000000000000100000000 000004b000000000000000000000000100000000000004ba00000000000004bc 000000000000050a000000019920dfec461cf27f5789b5c331c452188fe4a034 0c0a2a2ca23868f29ee405780db130143e3f7d6f0209cef5fb531cac6964b0bb adefbe2412a10f5df5d429ff76406e1e4c266a94ef988d42d30aa5842808184d 646dd91783cc5c95db68f19f7270355d2b7cb1797f247855155db24913323dd8 0a4e72ee4e87b37ed201242d800000000080820100¶
The token 22..22 is inserted. The checkpoint has partitionVersion 2, snapshotTime 1250, thisUpdate 1252, nextUpdate 1330, and treeSize 5. The token is the lower boundary of leaf 2, whose upper boundary is 44..44.¶
Full staple with the membership proof (372 octets). Expected outcome: REVOKED.¶
8001ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fc ef720a2fd57f6dd99230a157a666c04eeba53080000000000000000100000000 000004b000000000000000000000000200000000000004e200000000000004e4 00000000000005320000000567717a0c23f6cdc54fb663a067753a976b3751bc ab0aae835c62f5901bd63ae40db130143e3f7d6f0209cef5fb531cac6964b0bb adefbe2412a10f5df5d429fff8d7e260e27b25652b1954eeb184eb4b9388f6bb 760b47c45b9a33e43ac003fe73039d924f73db0005e1406baedd9960ec487334 9fc6978e8b3a80ec56045aab8100000002814444444444444444444444444444 44444444444444444444444444444444444401030c4d868a5dcc8d6fae101550 5478087866a97d45c86a6a767a5427dfb16934abb6e680115f4cc0d487b4dea6 d4c0a64bfea976c5ba0ad5dc1ab8bd1110480a4ed178edc312c1ff969b0060bf fce8538cfb68d679d1458037f9ee16588662b8ed¶
Revocation notice for the same token (175 octets):¶
00000000000004b0222222222222222222222222222222222222222222222222 2222222222222222000000028144444444444444444444444444444444444444 4444444444444444444444444401030c4d868a5dcc8d6fae1015505478087866 a97d45c86a6a767a5427dfb16934abb6e680115f4cc0d487b4dea6d4c0a64bfe a976c5ba0ad5dc1ab8bd1110480a4ed178edc312c1ff969b0060bffce8538cfb 68d679d1458037f9ee16588662b8ed¶
Snapshot, 333 octets. It holds the three-token set under the checkpoint above.¶
01ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fcef 720a2fd57f6dd99230a157a666c04eeba5308000000000000000010000000000 0004b000000000000000000000000100000000000004ba00000000000004bc00 0000000000050a000000043598e37b84e8adad0ae2a691c784ec7c1f86885efd 849cbaddd4e38fd84576c40db130143e3f7d6f0209cef5fb531cac6964b0bbad efbe2412a10f5df5d429ff35345c4014ee9fec0c39fc8152a4ffbffeda06838b d58dcb7351de5724bac6486877cfbaab384298f3f53a7fb7a7c5c0addc831a1d 86829570682f2468ef37a9010311111111111111111111111111111111111111 1111111111111111111111111144444444444444444444444444444444444444 4444444444444444444444444488888888888888888888888888888888888888 88888888888888888888888888¶
Delta, 301 octets. It leads from that checkpoint to the version-2 checkpoint and inserts 22..22.¶
8026740952d0ccc0fb05e2a51d2c1fa322bf46d89b25ff03a89579051dbd58f1 01ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fcef 720a2fd57f6dd99230a157a666c04eeba5308000000000000000010000000000 0004b000000000000000000000000200000000000004e200000000000004e400 000000000005320000000567717a0c23f6cdc54fb663a067753a976b3751bcab 0aae835c62f5901bd63ae40db130143e3f7d6f0209cef5fb531cac6964b0bbad efbe2412a10f5df5d429fff8d7e260e27b25652b1954eeb184eb4b9388f6bb76 0b47c45b9a33e43ac003fe73039d924f73db0005e1406baedd9960ec4873349f c6978e8b3a80ec56045aab010122222222222222222222222222222222222222 22222222222222222222222222¶
Synthetic identity: certificate version 3, explicit certificate, issuance key = NIST P-256 base point, opaque TBS octets 01020304. This is not a valid ITS certificate. issuerKeyHash: da24cd0a51b24e7402587fd41b9ef72086274638c28a3d1477ed5b8e232bc88d COER SmrpItsCredentialIdentity: 0300da24cd0a51b24e7402587fd41b9ef72086274638c28a3d1477ed5b8e232b c88d0401020304 credentialDigest: 6723990e803baa5e49244321552a7a48144c4b2adacd8de1fbc7d54c518abaef token X with an all-zero domainId: 8dea9cfc1f177a7cc021c081161797b8839875ad98938e2e6526923fb8dcdaef Partition of X = 22..22 for profileId 65281, epochStart 1200: k=0: 0, k=1: 0, k=2: 0, k=4: 3, k=8: 54, k=16: 13829¶
OCSPResponse, 404 octets. It carries the full staple of Appendix C.4. Its responseType is the documentation object identifier 1.3.6.1.4.1.32473.1.3, which stands for id-pkix-ocsp-smrp in these vectors only.¶
308201900a0100a082018930820185060a2b0601040181fd5901030482017580 01ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fcef 720a2fd57f6dd99230a157a666c04eeba5308000000000000000010000000000 0004b000000000000000000000000100000000000004ba00000000000004bc00 0000000000050a000000043598e37b84e8adad0ae2a691c784ec7c1f86885efd 849cbaddd4e38fd84576c40db130143e3f7d6f0209cef5fb531cac6964b0bbad efbe2412a10f5df5d429ff35345c4014ee9fec0c39fc8152a4ffbffeda06838b d58dcb7351de5724bac6486877cfbaab384298f3f53a7fb7a7c5c0addc831a1d 86829570682f2468ef37a9800000000181111111111111111111111111111111 1111111111111111111111111111111111814444444444444444444444444444 444444444444444444444444444444444444010263086bdc7a20587b543540e2 888cb5f8aa9287d90af14c275ee2ef3bfe1939f030a6587e1c317554fca562e6 229f4b95a44453e06e868eb02deac71e5a511448¶
This appendix states the properties claimed for the construction and the assumptions that each one uses. The arguments are reductions to the collision resistance of H and to the unforgeability of the checkpoint signature. They are not machine-checked (Appendix G).¶
A tree is honest for a token list if the list is strictly increasing and the tree is built from it as in Section 8.2. A checkpoint is authentic if it is well formed and carries a valid signature of a key of the installed configuration. A collision is a pair of distinct inputs with the same image under H.¶
Lemma 1. Let a tree be honest, with m leaves and root r. If the fold of Section 8.3 applied to an index i smaller than m, a value c0, and h siblings yields r, then c0 equals the hash of leaf i of the tree, or a collision of H can be computed from the inputs.¶
Argument. The fold visits the positions floor(i / 2^d) for d from 0 to h, which are the positions of the ancestors of leaf i. At the top, the computed value and the honest value are both r. If the two inputs of the last nodeHash differ from the honest children, a collision is found. Otherwise the computed value at depth h - 1 equals the honest node at that position, and the argument descends one level. It ends at the leaf level with c0 equal to the honest leaf hash. The index is smaller than m, so that position holds a leaf hash and not a padding hash. For m = 1 there is no fold, and c0 = r is the leaf hash.¶
The prefixes separate the three hash-input domains: 0x00 for an interval leaf, 0x01 for a node, and 0x02 for padding. They prevent cross-type input interpretation in the specified construction. Independently, signed treeSize fixes h, so a path of another length is rejected before hashing; the fixed-length argument does not rely on the prefixes alone.¶
Lemma 2 (absence). Let a tree be honest for a list S, with m leaves and root r. If VerifyAbsence(m, r, P, X) accepts, then X is not in S, or a collision of H can be computed.¶
Argument. By Lemma 1, leafHash(i, P.lower, P.upper) equals the hash of the honest leaf i, which is leafHash(i, B[i], B[i+1]). The two inputs have the same prefix and index, and the encoding of a pair of boundaries is unambiguous, so either a collision is found or P.lower = B[i] and P.upper = B[i+1]. The verifier checked B[i] < X < B[i+1] in the typed order. The list B is strictly increasing, so X differs from every element of S.¶
Lemma 3 (presence). Under the same hypotheses, if VerifyPresence(m, r, P, X) accepts, then X is in S, or a collision can be computed.¶
Argument. By Lemma 1 and the unambiguous encoding, DATA(X) = B[i] with i between 1 and m - 1, which is an element of S.¶
Corollary. For an honest tree, no token has both a proof of absence and a proof of presence that verify, unless a collision is exhibited. For an absent token exactly one leaf has an opening that verifies, and for a present token none has. The companion tests check this exhaustively for every subset of an 8-token universe.¶
The checks on sentinels are not redundant with the hash. They ensure that a proof is the canonical opening of a leaf and that a leaf of a malformed tree in which a sentinel is misplaced is rejected locally. The strict inequalities matter: with a non-strict comparison, the leaf (X, Y) would prove the absence of the revoked token X.¶
Lemma 4 (commitment). If two honest trees have the same number of leaves and the same root, they are built from the same list, or a collision can be computed.¶
Argument. If the lists differ, some leaf differs. The two leaf inputs at that index differ, and comparing the two trees upward from that leaf yields a collision or a different root.¶
Consequences. A proof that verifies against one checkpoint verifies against every checkpoint of the stream with the same set commitment, and it is then a statement about the same set (Section 9.4). A party that rebuilds, from a list that it holds, the size and root of an authentic checkpoint holds the committed set. A party that rebuilds the size and root of a newer checkpoint from its base list and the inserted tokens of a delta has established that the newer set is the base set plus those tokens (Section 10.5).¶
Theorem 1. Assume A1 to A8 (Section 5.2). Let a revocation decision that affects a credential with token X be taken at true time r. If a verifier returns NOT_REVOKED_AT_SNAPSHOT for that credential at true time u with maximum snapshot age Aapp, then u < r + L + Aapp.¶
Argument. By the decision rules (Section 13.4), the result rests on a current checkpoint K of a stream (e, p), on a proof of absence of X that verified against a set commitment equal to that of K, and on the status interval of Section 11.5.¶
Steps 3, 5, and 6 give u < c + Aapp < r + L + Aapp. The stream state and the proof cache select K and the proof, and nothing in the argument depends on their history. This is why the bound survives the loss of volatile state.¶
The bound can be approached by permitted configurations and issuance schedules with exact clocks, an adequate checkpoint lifetime, and sufficient remaining key, credential, and epoch validity. A checkpoint whose true cutoff immediately precedes r + L can then remain usable until just before r + L + Aapp. This is a worst-case construction over those choices, not a claim of tightness for every configured lifetime or issuance schedule.¶
A second bound follows from the same steps with nextUpdate in place of the age limit: u < K.nextUpdate, which is at most the true issuance time plus a plus maxCheckpointLifetime. This is a bound relative to issuance. A shorter checkpoint lifetime alone does not improve the bound relative to the revocation decision: the issuer might sign a still-admissible old snapshot late. If true issuance is at most D seconds after the true cutoff, one may additionally derive u < r + L + D + a + maxCheckpointLifetime and take the smaller bound. D is an additional operational assumption, not a consequence of the lifetime field.¶
Proposition 1 (terminal revocation). Once a verifier has created a terminal record for a token, every later decision for that token returns REVOKED, for as long as the record is retained. This is rule 1 of Section 13.4, which precedes every use of evidence and of time.¶
Proposition 2 (authorized negative statement). Under A1, A2, A6 to A8, and the administrative provenance rules, a terminal record created from protocol evidence implies that the issuer committed to an honest set containing the token, or a cryptographic assumption failed. This follows from Lemma 3 for staples and notices and from reconstruction for lists. Without A2, an authenticated local membership opening still attributes a negative statement to the issuer, but it does not prove that all interval leaves form one coherent set. A compromised or dishonest issuer can assert revocations; the protocol does not certify the correctness of its policy decisions.¶
Proposition 3 (conflict). If a verifier holds two authentic checkpoints of one stream that violate the consistency rules, then the issuer violated rule 2, 3, or 4 of Section 9.2, or a signature was forged. For the last rule, two honest insert-only sets of equal size are equal, and by construction have equal roots.¶
The arguments assume an honest issuer (A2) wherever the content of a set matters. They do not cover a compromised checkpoint key, an incomplete resolution of a device to its credentials (A9), a verifier whose clock error exceeds its declared bound, or the validation of the credential itself. They establish no privacy property.¶
This example uses the configuration of Appendix C: E = 600, G = 60, A = 120, a maximum checkpoint lifetime of 90, and clock error bounds of 2 seconds for the issuer and for the verifier. One partition is used. The revoked set initially holds three tokens. The verifier V evaluates the credential of a holder H whose token is not revoked. Every outcome below is reproduced by the companion tests.¶
Earlier descriptions of SMRP used a tree whose leaves are the sorted tokens and proved absence with the inclusion paths of two adjacent leaves, that is, 2h hashes. The two paths share every node above the level at which the two leaves separate. Transmitting the shared part once gives h + t - 1 hashes, where t is the number of trailing one bits of the index of the left leaf. Under a uniform distribution over queried adjacent-leaf gaps in a full tree, this averages slightly less than h. It reaches 2h - 2 for the pair that straddles the two halves. The trailing-bit count has a geometric tail under that gap model; this is not a distribution of holders unless their queries follow that model.¶
The interval leaf carries exactly h hashes for every holder. Its path contains h hashes, whereas the largest shared path contains 2h - 2 hashes; complete object sizes also include boundaries, tags, and the optional checkpoint. The largest proof is what a deployment has to provision, because the data unit of the access layer is bounded and a proof that does not fit leaves an honest holder without evidence. With 4094 revoked tokens in a partition, both trees have height 12. An interval proof-only staple is then 466 octets with two DATA boundaries and 434 octets at either sentinel edge. Under the uniform-gap model, the historical shared-path form is about 470 octets on average and 790 octets at most, and two independent paths carry 24 hashes instead of 12. Verification is also simpler: one leaf, one path, and no reasoning about adjacency.¶
The costs of the interval leaf are small. A membership proof carries one boundary more, at most 33 octets. Each token is hashed in two leaves, so building a tree costs about twice as many leaf compressions. The companion artifacts keep the shared-path variant, with its own tests, for comparison (Appendix H).¶
The interval tree is a profile choice. This document does not establish that it is optimal across all update patterns, hardware, or deployment models.¶
No machine-checked proof of this version exists. This appendix outlines a symbolic model, for instance for the Tamarin prover [TAMARIN2013], so that results can be compared and their limits stated.¶
Roles and state. The model has an issuer with a signing key and, per stream, a version counter and a set; distribution as attacker-controlled channels; holders with a credential and a compromise rule; and verifiers with the state of Section 13.1. The attacker controls the network [DOLEV1983], can compromise credential keys, and, in a separate set of lemmas, the checkpoint key.¶
Abstractions. The Merkle tree is modeled either by an abstract predicate, in which a proof term for (commitment, token) exists exactly when the token is absent from the set, or concretely for small trees with the hash as a free function. The first form relies on Appendix D for the tree and analyzes the protocol. The second analyzes the tree and does not scale. Time is modeled with ordered timestamps and restrictions that encode assumptions A4 and A5.¶
Lemmas.¶
Known difficulties. Lemmas over pairs of stream states, such as L3 and L5, may require inductive invariants on the version counter, retained terminal state, administrative generations, and insert-only sets. Termination of automatic search is not assumed. The thesis reports nontermination within twenty minutes for L2_non_membership_23 in an earlier fixed four-leaf model [GRUND2026]. That model uses other token and sentinel rules and a OneCheckpointPerEpoch restriction; it does not model this version's repeated checkpoints and state transitions. Results obtained for that model, for another protocol, or for bounded trees are not proofs of this version. Any published result has to state the bounds on epochs and trees, the trusted functions, the induction hypotheses, and the proof obligations left open.¶
The companion artifacts are research code, not an ITS security stack. They consist of the ASN.1 module, a reference implementation of the tree and proofs that uses only a standard library, a codec and verifier-state harness, and two deterministic test suites.¶
| Group | Checks |
|---|---|
| Tree and identity, targeted cases | 323 |
| Tree, all subsets of an 8-token universe | 8448 |
| Verifier against a specification-level oracle on mutated proofs | 55290 |
| Height and proof-length law, tree sizes 1 to 4097 | 4406 |
| Snapshot and delta reconstruction | 19 |
| Limits of what a verifier can detect | 2 |
| Exact encoded sizes | 335 |
| Encoding, signature, and binding | 109 |
| Time rules at their boundaries | 40 |
| Epoch transition with and without a lead | 9 |
| Verifier state machine | 107 |
| List mode at the verifier | 55 |
| Revocation notices | 17 |
| Configuration limits | 33 |
| OCSP encapsulation | 7 |
| Total | 69200 |
A counted check is an executed condition, not a separate security proof. Exhaustive enumeration is limited to the stated small universe. The differential oracle shares tree-construction and helper routines with the reference code and therefore offers only partial independence. The document checker separately reads rendered octets and re-derives hashes and signatures, while its lifecycle checks reuse the state harness.¶
The tests exercise the encodings, the sizes, the proof algorithms, the checkpoint signature format, the time rules at their boundaries, and the state machine of Section 13, including every outcome of Appendix E. They contain no IEEE 1609.2 certificate parser or canonicalizer: tokens are derived from a synthetic identity. They provide no authenticated configuration transport, no trusted clock, no rollback-resistant storage, and no radio integration. No execution of these artifacts is a radio experiment, an interoperability test between independent implementations, or a security proof.¶
Each reported experiment identifies the draft version and profile, the implementation and its dependencies, the hardware, the clock source, the populations of certificates and of revoked tokens, the partition occupancy, the workload, the run count, the statistical method, and the location of raw results. A derived parameter such as L is measured or justified independently. Negative results are retained.¶
This document specifies evidence objects, their validation, a verifier state machine, a conditional freshness bound with its argument, and abstract carriage rules. The encodings and signatures of Appendix C are reproducible. The comparison of Section 14 states cost laws and sizes that follow from the two specifications.¶
This document does not establish the end-to-end exclusion of a vehicle, the completeness of the resolution of a device to its credentials, a numerical radio or latency result, a production capacity, an unlinkability result, the detection of every equivocation, or a completed formal proof. It does not establish V2X interoperability until the responsible SDO specifies a secured-envelope mapping, nor OCSP-envelope interoperability until IANA assigns the requested identifier. Unmeasured objectives remain objectives.¶
SMRP was first described in a doctoral thesis [GRUND2026]. This document keeps its principle, a signed commitment to the sorted revoked set with stapled proofs of absence, and differs from that description as follows. Implementations of the earlier description do not interoperate with this one.¶
| Aspect | Earlier description | This document |
|---|---|---|
| Token | 16-octet revocation value carried by the certificate | 32-octet hash of the credential identity; no new certificate field |
| Sentinels and padding | All-zero and all-one values; last leaf repeated | Typed sentinels; index-bound padding hash |
| Proof of absence | Two inclusion paths, 2h hashes | One interval leaf, h hashes |
| Evidence size | 163 + 64 * h octets, checkpoint included | 309 + 32 * h octets with the checkpoint, 82 + 32 * h without |
| Checkpoint | Root with epoch and partition | Root with configuration, version, cutoff, issuance time, deadline, and tree size |
| Freshness | One checkpoint per epoch, with a tolerance counted in epochs | Several checkpoints per epoch, snapshot age, and a bound with its argument |
| Refresh | New proof with each checkpoint | Proof reused while the set commitment is unchanged |
| Partitions | Geographic or administrative | Derived by hashing the token and the epoch |
| Revocation evidence | Absence proofs only | Membership proofs, notices, and list mode |
| Vehicle-level profile | Per-epoch value derived from a vehicle secret | Not defined; requires a separate profile |
| Issuer role name | Revocation authority (RA) | Checkpoint issuer |