<?xml version='1.0' encoding='utf-8'?>
<rfc version="3" ipr="trust200902" category="exp" submissionType="IETF" docName="draft-grund-khatoun-pujolle-serhrouchni-smrp-00" consensus="false" tocInclude="true" tocDepth="2" symRefs="true" sortRefs="true">
  <front>
    <title abbrev="SMRP">Stapled Merkle Revocation Proofs for Pseudonymous ITS Credentials (SMRP)</title>
    <author surname="Grund" initials="J.-J." fullname="Jean-Jacques Grund">
      <organization abbrev="Telecom Paris, IP Paris">Telecom Paris, Institut Polytechnique de Paris</organization>
      <address>
        <postal>
          <street>19 place Marguerite Perey</street>
          <city>Palaiseau</city>
          <code>91120</code>
          <country>France</country>
        </postal>
        <email>jean-jacques.grund@telecom-paris.fr</email>
      </address>
    </author>
    <author surname="Khatoun" initials="R." fullname="Rida Khatoun">
      <organization abbrev="Telecom Paris, IP Paris">Telecom Paris, Institut Polytechnique de Paris</organization>
      <address>
        <postal>
          <street>19 place Marguerite Perey</street>
          <city>Palaiseau</city>
          <code>91120</code>
          <country>France</country>
        </postal>
        <email>rida.khatoun@telecom-paris.fr</email>
      </address>
    </author>
    <author surname="Pujolle" initials="G." fullname="Guy Pujolle">
      <organization abbrev="Sorbonne University">Sorbonne Universite, CNRS, LIP6</organization>
      <address>
        <postal><city>Paris</city><country>France</country></postal>
        <email>guy.pujolle@lip6.fr</email>
      </address>
    </author>
    <author surname="Serhrouchni" initials="A." fullname="Ahmed Serhrouchni">
      <organization abbrev="Telecom Paris / Institut CyberIA">Telecom Paris, Institut Polytechnique de Paris, and Institut CyberIA</organization>
      <address>
        <postal>
          <street>19 place Marguerite Perey</street>
          <city>Palaiseau</city>
          <code>91120</code>
          <country>France</country>
        </postal>
        <email>ahmed.serhrouchni@telecom-paris.fr</email>
      </address>
    </author>
    <date year="2026" month="November" day="15"/>
    <area>Security</area>
    <keyword>certificate revocation</keyword>
    <keyword>V2X</keyword>
    <keyword>Merkle tree</keyword>
    <keyword>pseudonym certificate</keyword>
    <keyword>authenticated dictionary</keyword>
    <abstract>
      <t>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.</t>
      <t>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.</t>
    </abstract>
  </front>
  <middle>
    <section anchor="intro">
      <name>Introduction</name>
      <t>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.</t>
      <t>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 <xref target="I-D.grund-v2x-pocsp"/> provides a signed, single-certificate response that the holder staples to an authenticated operation.</t>
      <t>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.</t>
      <t>Three consequences follow from separating the commitment from the proof:</t>
      <ol>
        <li>At a fixed partition count and periodic issuance schedule, checkpoint signing scales with the number of active streams. Tree construction, proof distribution, and insertion-triggered issuance have separate costs.</li>
        <li>Freshness travels in the checkpoint. The checkpoint is public and identical for every credential of a partition, so any station, roadside unit, or cache can deliver it. A proof remains usable across successive checkpoints for as long as the set of its partition is unchanged.</li>
        <li>The committed set is one authoritative object with several consumers: holders that staple proofs, capable verifiers that keep the complete list and need no staple, parties that relay a proof of revocation about a credential they observe, and auditors that rebuild the tree.</li>
      </ol>
      <t>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 (<xref target="bound"/>). The verifier does not thereby learn that the credential is revoked. Applications need an explicit policy for that state (<xref target="failure"/>).</t>
      <section anchor="scope">
        <name>Scope and Experimental Status</name>
        <t>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.</t>
        <t>The baseline credential profile covers end-entity IEEE 1609.2 certificates <xref target="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.</t>
        <t>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). <xref target="claims"/> separates what this document specifies and argues from what remains to be measured or proved.</t>
      </section>
      <section anchor="overview">
        <name>Overview of the Mechanism</name>
        <figure anchor="fig-roles">
          <name>SMRP roles and data flow</name>
          <artwork type="ascii-art"><![CDATA[
 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
]]></artwork>
        </figure>
        <ol>
          <li>For each epoch and partition, the checkpoint issuer forms the sorted set of tokens of the revoked credentials, builds a Merkle tree whose leaves are the intervals between consecutive tokens, and signs a checkpoint. The checkpoint binds the scope, a version, the cutoff of the revocation database, the issuance time, a deadline, the tree size, and the root.</li>
          <li>The issuer publishes the checkpoint and the ordered token list. A distribution point, or any party that holds the list, derives proofs from it. Distribution points hold no signing key and are not trusted for integrity.</li>
          <li>A holder derives its token from its own certificate, obtains a proof of absence under the current checkpoint, and staples it to messages that carry its full certificate. A full staple carries the checkpoint. A proof-only staple omits it and relies on the checkpoint that the verifier already holds.</li>
          <li>The verifier authenticates the message and the credential, derives the token and its partition itself, authenticates the checkpoint, verifies the proof against its current checkpoint for that partition, and applies a conservative time check. The result is NOT_REVOKED_AT_SNAPSHOT with an absolute deadline.</li>
          <li>When a newer admissible checkpoint of the same stream commits to the same set, a cached proof can support a new deadline, subject to credential validity and the application status class. No new witness is required from the holder. When a newer checkpoint commits to a changed set, the proofs of that partition are superseded. Unrevoked holders obtain new proofs. A revoked holder cannot.</li>
          <li>A membership proof establishes REVOKED. That result is terminal at the verifier and does not depend on the cooperation of the revoked holder: any party that holds the list can produce the proof.</li>
        </ol>
      </section>
      <section anchor="pocsp-overview">
        <name>Relationship to pOCSP</name>
        <t>pOCSP <xref target="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. <xref target="pocsp"/> 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 <bcp14>MUST NOT</bcp14> silently substitute one for the other.</t>
      </section>
      <section anchor="organization">
        <name>Document Organization</name>
        <t><xref target="terms"/> to <xref target="model"/> give the terminology, the related work, the design goals, and the system and threat model. <xref target="identity"/> to <xref target="objects"/> define the credential identity, the configuration, the Merkle set, the checkpoint, and the wire objects. <xref target="time"/> to <xref target="verifier"/> specify time validation, the enforcement bound, and the processing rules of each role. <xref target="pocsp"/> positions SMRP against pOCSP and specifies composition. <xref target="carriage"/> to <xref target="engineering"/> 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.</t>
      </section>
    </section>
    <section anchor="terms">
      <name>Conventions and Terminology</name>
      <t>The key words "<bcp14>MUST</bcp14>", "<bcp14>MUST NOT</bcp14>", "<bcp14>REQUIRED</bcp14>", "<bcp14>SHALL</bcp14>", "<bcp14>SHALL NOT</bcp14>", "<bcp14>SHOULD</bcp14>", "<bcp14>SHOULD NOT</bcp14>", "<bcp14>RECOMMENDED</bcp14>", "<bcp14>NOT RECOMMENDED</bcp14>", "<bcp14>MAY</bcp14>", and "<bcp14>OPTIONAL</bcp14>" in this document are to be interpreted as described in BCP 14 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and only when, they appear in all capitals, as shown here.</t>
      <section anchor="notation">
        <name>Notation</name>
        <t>H denotes SHA-256 <xref target="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.</t>
        <t>The expression floor(x) is the greatest integer not exceeding x, and log2 is the binary logarithm.</t>
        <t>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 (<xref target="configuration"/>).</t>
        <table anchor="tab-symbols">
          <name>Symbols</name>
          <thead>
            <tr><th>Symbol</th><th>Meaning</th></tr>
          </thead>
          <tbody>
            <tr><td>E</td><td>epochDuration, in seconds</td></tr>
            <tr><td>G</td><td>epochLead, in seconds</td></tr>
            <tr><td>k</td><td>shardBits; a domain has 2^k partitions</td></tr>
            <tr><td>A</td><td>maxSnapshotAge, in seconds</td></tr>
            <tr><td>a</td><td>maxAuthorityClockError, in seconds</td></tr>
            <tr><td>v</td><td>the verifier's clock error bound at the time of a decision, at most maxVerifierClockError</td></tr>
            <tr><td>L</td><td>the ingestion lag of the authority: the longest delay between a revocation decision and its presence in every snapshot (<xref target="assumptions"/>)</td></tr>
            <tr><td>m, h</td><td>the number of leaves of a tree, which is its treeSize, and its height (<xref target="tree-build"/>)</td></tr>
          </tbody>
        </table>
      </section>
      <section anchor="terminology">
        <name>Terminology</name>
        <dl newline="false" spacing="normal">
          <dt>Checkpoint issuer:</dt>
          <dd>The entity authorized to publish SMRP checkpoints for a domain. In this document, "the issuer" without qualification means the checkpoint issuer. The entity that issues credentials is called the issuing authority, and its key the issuance key. The checkpoint issuer is also distinct from a Registration Authority of an ITS PKI, and the abbreviation RA is not used for it.</dd>
          <dt>Distribution point (DP):</dt>
          <dd>A service that stores published snapshots and derives proofs from them. It holds no checkpoint-signing key.</dd>
          <dt>Holder:</dt>
          <dd>The station or endpoint that possesses a credential and presents evidence about it. The term sender is used when the holder transmits a message.</dd>
          <dt>Verifier:</dt>
          <dd>A receiver that validates an authenticated operation, the credential behind it, and SMRP evidence.</dd>
          <dt>List holder:</dt>
          <dd>Any party that keeps the complete ordered token list of a partition (<xref target="snapshot"/>). A holder, a verifier, a distribution point, a roadside unit, or an auditor can be a list holder.</dd>
          <dt>Domain:</dt>
          <dd>A configured 16-octet namespace bound to one credential-issuance public key, its authorization context, and one SMRP configuration.</dd>
          <dt>Credential digest:</dt>
          <dd>The SHA-256 digest of the canonical credential identity (<xref target="credential-identity"/>). It identifies a credential independently of the domain and of the certificate signature.</dd>
          <dt>Token:</dt>
          <dd>The 32-octet value, derived from the domain and the credential digest, that represents a credential in the revocation set.</dd>
          <dt>Partition:</dt>
          <dd>One of the 2^k deterministic subsets of the tokens of a domain for a given epoch.</dd>
          <dt>Epoch:</dt>
          <dd>A configured interval of E seconds, identified by its start time epochStart. The epoch selects the partition mapping and the scope of the revoked set. Checkpoints of an epoch can be issued from G seconds before its start (<xref target="epochs"/>).</dd>
          <dt>Authority epoch:</dt>
          <dd>An administrative generation of the trusted configuration. It is unrelated to the time epoch.</dd>
          <dt>Stream:</dt>
          <dd>The sequence of checkpoints that share one configuration, one epoch, and one partition. Checkpoints of a stream are ordered by partitionVersion.</dd>
          <dt>Snapshot:</dt>
          <dd>The complete set of revoked tokens of a stream as of a cutoff time, snapshotTime.</dd>
          <dt>Checkpoint:</dt>
          <dd>The signed statement that binds a snapshot commitment to its scope, version, and times (<xref target="checkpoint"/>).</dd>
          <dt>Set commitment:</dt>
          <dd>The pair (treeSize, rootHash) of a checkpoint. Two checkpoints of one stream with equal set commitments commit to the same set.</dd>
          <dt>Current checkpoint:</dt>
          <dd>The checkpoint of greatest partitionVersion that a verifier has admitted for a stream (<xref target="checkpoint-processing"/>).</dd>
          <dt>Staple:</dt>
          <dd>The SMRP object that a holder attaches to an authenticated operation. A full staple contains a checkpoint and a proof. A proof-only staple contains a proof and an epoch reference. A checkpoint-only staple contains a checkpoint (<xref target="staple-forms"/>).</dd>
          <dt>Evidence-bearing message:</dt>
          <dd>A secured V2X message that conveys the complete signer certificate together with a staple.</dd>
          <dt>Revocation notice:</dt>
          <dd>A membership proof about a named token, produced by any list holder and addressed to verifiers that can observe the corresponding credential (<xref target="notice"/>).</dd>
          <dt>Application status class:</dt>
          <dd>An application-defined requirement on status, consisting of a maximum snapshot age and a policy for each outcome (<xref target="classes"/>).</dd>
          <dt>ITS time:</dt>
          <dd>The time scale of this document: the number of TAI seconds elapsed since 00:00:00 UTC on 1 January 2004 (<xref target="timescale"/>).</dd>
        </dl>
        <t>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.</t>
      </section>
      <section anchor="outcomes">
        <name>Status Outcomes</name>
        <t>The verifier returns exactly one of five outcomes for a credential:</t>
        <dl newline="false" spacing="normal">
          <dt>NOT_REVOKED_AT_SNAPSHOT:</dt>
          <dd>A verified proof shows the token absent from the set committed by the current checkpoint of its stream, and the conservative time check passes. The outcome carries the checkpoint identifier, the snapshot cutoff, and an absolute deadline.</dd>
          <dt>REVOKED:</dt>
          <dd>An authenticated revocation of the credential is recorded. The outcome is terminal (<xref target="state"/>).</dd>
          <dt>INDETERMINATE:</dt>
          <dd>No usable evidence supports an affirmative result. Evidence is absent, not yet valid, expired, superseded by a newer set, or refers to a checkpoint or configuration that the verifier does not hold. This outcome alone does not establish whether evidence was lost, withheld, or unavailable.</dd>
          <dt>INVALID:</dt>
          <dd>Evidence bound to the authenticated operation is malformed, not canonical, unauthentic, bound to the wrong partition, or inconsistent with the checkpoint that it carries. When the enclosing operation authenticates these evidence octets, the presenter supplied an invalid object; the outcome does not distinguish a software fault from deliberate misuse.</dd>
          <dt>CONFLICT:</dt>
          <dd>The verifier holds authenticated statements of the checkpoint issuer that contradict its obligations. No affirmative result is produced for the domain until administrative recovery (<xref target="admin"/>).</dd>
        </dl>
        <t>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 <bcp14>MUST NOT</bcp14> be promoted to an affirmative result.</t>
        <t>The application-level state UNCONFIRMED has the meaning given in <xref target="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.</t>
      </section>
    </section>
    <section anchor="related">
      <name>Background and Related Work</name>
      <t>Revocation mechanisms differ in the state they authenticate, the party that retrieves that state, and the assumptions under which a verifier can use it. A comparison must distinguish an online query from a previously obtained assertion, an individual assertion from a shared commitment, and the representation of a revoked set from the distribution of that representation. Freshness, source completeness, and failure policy are additional requirements in every case. A survey of vehicular revocation schemes provides a broader taxonomy <xref target="WANG2020"/>.</t>
      <section anchor="related-lists">
        <name>Revocation Lists and Their Distribution</name>
        <t>CRLs support local checking after distribution. RFC 5280 specifies scope and validation rules, including the use of a base CRL with a delta CRL <xref target="RFC5280"/>. A verifier needs sufficiently fresh, applicable information covering the credential; it need not download every revocation in a PKI. Vehicular work addresses dissemination through compact representations, fragmentation, selective distribution, and cooperation among vehicles <xref target="HAAS2011"/> <xref target="KHODAEI2018"/>. These mechanisms remain relevant baselines for SMRP, including its complete-list mode.</t>
        <t>A stale or unavailable list does not erase an authenticated terminal revocation already learned. Conversely, absence from a list whose scope or completeness is insufficient is not affirmative status. Comparisons with SMRP must use the same credential coverage, information age, transmission opportunities, and failure policy.</t>
        <t>ETSI TS 103 097 V2.2.1 specifies hash-based revocation for EA and AA certificates and no revocation method for authorization tickets and enrolment credentials in that profile <xref target="ETSI103097"/>. This identifies an integration question; it does not allocate an extension or establish that an additional mechanism is interoperable with existing deployments.</t>
      </section>
      <section anchor="related-status">
        <name>Individual Status, Caching, and Stapling</name>
        <t>OCSP defines signed certificate-status information, and a BasicOCSPResponse can contain several SingleResponse values <xref target="RFC6960"/>. Its good status does not, by itself, necessarily assert that a certificate was issued. The lightweight profile supports response preproduction and caching <xref target="RFC9919"/>, and TLS can carry a response supplied by the certificate holder <xref target="RFC6066"/> <xref target="RFC9846"/>. RFC 9919 obsoletes RFC 5019. Describing every OCSP deployment as a verifier-initiated online query would therefore be inaccurate.</t>
        <t>The TLS Feature extension provides an antecedent for making expected stapling part of certificate policy and detecting its omission <xref target="RFC7633"/>. That X.509 mechanism does not define an ITS extension. The companion pOCSP draft specifies a distinct, single-certificate response with a signed usage context; unlike generic OCSP good semantics, its affirmative status requires authoritative knowledge of issuance <xref target="I-D.grund-v2x-pocsp"/>.</t>
        <t>Periodic individual evidence does not always require a fresh public key signature. NOVOMODO uses hash-chain values for certificate validation <xref target="NOVOMODO"/>, and Aiello, Lodha, and Ostrovsky study related identity-revocation constructions <xref target="ALO98"/>. Their credential format, initialization, and update assumptions differ from the pOCSP and SMRP profiles considered here.</t>
      </section>
      <section anchor="related-ads">
        <name>Authenticated Dictionaries and Revocation Trees</name>
        <t>Merkle trees authenticate multiple values through a common commitment <xref target="MERKLE80"/>. Certificate revocation trees and authenticated search structures have long separated an authorized signer from an untrusted directory that serves compact status proofs <xref target="KOCHER98"/> <xref target="NAORNISSIM98"/>. SMRP uses this established architecture.</t>
        <t>Revocation Transparency describes both a sparse Merkle representation and a sorted-list construction whose leaves contain consecutive revoked entries. Absence is demonstrated by opening a pair that brackets the queried certificate <xref target="RT2012"/>. The interval construction in this document belongs to that family. Its contribution is the exact profile, including typed boundaries, index and hash inputs, credential identity, encodings, and processing rules; it is not the invention of interval-based non-membership.</t>
      </section>
      <section anchor="related-vanet">
        <name>Related Vehicular Proof Mechanisms</name>
        <t>COACH embeds a hash tree in an extended CRL so that parties holding that CRL can provide short authenticated responses. Its EvCOACH extension addresses periods in which revocation information remains unchanged by using a hash chain to extend its validity <xref target="COACH2013"/>. Reusing authenticated content while renewing freshness is therefore an established objective, although SMRP uses separately signed checkpoints and its own time rules.</t>
        <t>EPA combines Merkle non-revocation proofs with anonymous retrieval and explicitly allows vehicles to retain proofs of their own certificates and present them to other entities <xref target="GANAN2015"/>. Holder-carried Merkle evidence and avoidance of a verifier query at reception are consequently not unique to SMRP. The comparison concerns the specified ITS identity, commitment format, time semantics, state transitions, and integration rules. The presence of those rules does not by itself establish greater security or better performance than an earlier mechanism.</t>
      </section>
      <section anchor="related-structures">
        <name>Sparse Trees and Accumulators</name>
        <t>Sparse Merkle trees give keys stable positions and support membership and non-membership with compressed default subtrees <xref target="SMT2016"/>. V'CER applies sparse trees and collaborative updates to certificate validation in constrained, intermittently connected networks <xref target="VCER2022"/>. These are relevant alternatives when considering witness updates and intermittent connectivity. The indexed sorted tree selected here can require substantial reconstruction after insertion; its merits must be assessed together with that cost.</t>
        <t>Universal accumulators provide another family of compact membership and non-membership witnesses. The construction of Li, Li, and Xue uses the strong RSA assumption and supplies dynamic witness-update procedures <xref target="LLX2007"/>. Selecting a hash-based construction avoids adopting that particular algebraic construction, but does not prove that all accumulator alternatives are less suitable. Witness size, update work, setup and trust requirements, and computational assumptions must be compared for a concrete scheme.</t>
      </section>
      <section anchor="related-coverage">
        <name>Population Coverage and Compressed Client State</name>
        <t>SCMS linkage values can represent revocation covering multiple present and future pseudonyms through linkage-chain information <xref target="SCMS2018"/>. This trades explicit enumeration for a particular issuance architecture and post-revocation linkability. The number of revoked vehicles, the number of linkage chains, the number of simultaneously usable pseudonyms, and the number of credentials intersecting an SMRP epoch are different quantities. The baseline SMRP profile does not implement linkage-based compression.</t>
        <t>CRLite distributes a compact client-side representation derived from an issuance corpus and revocation information <xref target="CRLITE"/>. Its filter construction and coverage handling differ from storing an exact token list. Mozilla's deployed implementation uses a later representation and update strategy <xref target="MOZILLA-CRLITE"/>. Chromium CRLSets instead provide emergency blocking and a selected subset of CRL-derived revocations <xref target="CRLSETS"/>. Neither mechanism should be equated to the complete-list mode of SMRP without accounting for its coverage and freshness rules.</t>
        <t>Trusted-component approaches provide a further alternative: they constrain use of credentials at the holder rather than distribute equivalent status evidence to every verifier <xref target="SCOP2024"/>. Their enforcement assumptions differ from a proof checked by a receiver, and their formal or experimental results do not transfer to SMRP.</t>
      </section>
      <section anchor="related-logs">
        <name>Transparency and Related Internet-Drafts</name>
        <t>Certificate Transparency authenticates an append-only issuance log <xref target="RFC9162"/>. Its consistency proof cannot be applied unchanged to a sorted mutable revocation set. SMRP deltas can demonstrate a transition to a party that holds the required base list and reconstructs the new commitment; they do not establish global agreement or completeness of the underlying revocation decisions.</t>
        <t>Merkle Tree Certificates integrate X.509 issuance and public logging and can amortize large signatures <xref target="I-D.ietf-plants-merkle-tree-certs"/>. That work remains an Internet-Draft and does not define a replacement certificate-level revocation mechanism. Its signature-amortization argument is relevant, but it neither establishes a post-quantum SMRP profile nor validates this document's performance claims. DRL Stapling is a separate individual proposal using a sparse tree and a consortium trust model for WebPKI revocation <xref target="I-D.premont-lamps-drl-stapling"/>; SMRP does not adopt that consensus or threshold-signature architecture.</t>
      </section>
      <section anchor="contribution">
        <name>Contribution and Claim Boundaries</name>
        <t>This document specifies an experimental composition of established techniques for pseudonymous ITS credentials. The intended contribution is a common, testable definition of credential identity, set commitment, evidence encodings, conservative freshness checks, persistent negative state, and composition with other authorized status sources. Shared checkpoint refresh and independent proof construction are properties of this specified composition, not claims of first use.</t>
        <t>An interval proof establishes absence for every query strictly between its authenticated boundaries. Its bytes need not be unique to a credential. Credential binding results from validating the credential, deriving the query and scope locally, and checking the proof against an authorized checkpoint for that scope. The protocol does not claim that the same witness bytes can never be useful for another query.</t>
        <t>The claimed security properties are conditional on the assumptions and arguments stated in this document. The evaluation boundary in <xref target="claims"/> distinguishes implemented checks from real ITS interoperability, durable-state recovery, formal verification, and radio measurements. No universal advantage over CRLs, individual status, sparse trees, or accumulators is claimed.</t>
      </section>
    </section>
    <section anchor="goals">
      <name>Design Goals and Non-Goals</name>
      <t>The following goals guide the protocol and are used to evaluate conformance.</t>
      <ul>
        <li>G1 - Offline reception-time validation: a verifier decides without contacting any service.</li>
        <li>G2 - Explicit snapshot semantics and bounded stale acceptance: an affirmative result names the cutoff of the information on which it rests, and the delay between a revocation decision and the last affirmative result is bounded under stated assumptions.</li>
        <li>G3 - Shared periodic signatures: at a fixed partition count and issuance period, the periodic checkpoint-signature rate is independent of the credential and revocation counts. This statement does not cover tree maintenance, credential resolution, distribution, event-triggered issuance, or capacity-driven changes of parameters.</li>
        <li>G4 - Freshness separable from the per-credential proof: the object that carries freshness is public, shared, and deliverable by any party; a proof survives a refresh that does not change the set.</li>
        <li>G5 - Exact and stable credential binding: the verifier derives the token, the domain, and the partition from the credential that it has authenticated; the token does not depend on the encoding of the certificate signature.</li>
        <li>G6 - Revocation that does not depend on the revoked holder: revocation evidence is terminal, can be produced by any list holder, and can be relayed by any party.</li>
        <li>G7 - One commitment, several consumers: the same signed object supports stapled proofs, complete lists, and audit by reconstruction.</li>
        <li>G8 - Privacy regression avoidance: no verifier-initiated status query, no evidence more frequent than the full certificate, and a retrieval mode that discloses no individual credential to the distribution service.</li>
        <li>G9 - Denial-of-service resistance: strict sizes, canonical encodings, bounded work per object, and hash-only work per credential.</li>
        <li>G10 - Implementability: a complete ASN.1 module, reference algorithms, and reproducible vectors.</li>
      </ul>
      <t>The following are explicit non-goals.</t>
      <ul>
        <li>NG1 - SMRP does not provide instantaneous revocation. Evidence issued before a revocation remains usable until its deadline.</li>
        <li>NG2 - SMRP does not assert issuance. Absence from the revoked set is the semantics of a revocation list, not the "good" status of OCSP, which pOCSP reserves for certificates known to be issued (<xref target="pocsp-semantics"/>).</li>
        <li>NG3 - SMRP does not prove that the authority's set is complete, sorted, or current. Those are obligations of the checkpoint issuer that list holders can audit and that a lightweight verifier cannot check (<xref target="soundness"/>).</li>
        <li>NG4 - SMRP does not make a token unlinkable. A token is a deterministic function of a certificate.</li>
        <li>NG5 - SMRP does not define misbehavior detection, identity resolution, or the governance of revocation decisions.</li>
        <li>NG6 - SMRP does not define a vehicle-level revocation identifier. Revoking a vehicle means inserting the tokens of its relevant credentials (<xref target="set-scope"/>).</li>
        <li>NG7 - SMRP does not allocate ETSI, IEEE, or SAE identifiers and does not replace CRLs, linkage values, or pOCSP.</li>
      </ul>
    </section>
    <section anchor="model">
      <name>System Model, Trust, and Threats</name>
      <section anchor="roles">
        <name>Roles</name>
        <table anchor="tab-roles">
          <name>Roles and trust</name>
          <thead>
            <tr><th>Role</th><th>Function</th><th>Trust placed in it</th></tr>
          </thead>
          <tbody>
            <tr><td>Checkpoint issuer</td><td>Builds the revoked set of each stream and signs checkpoints</td><td>Trusted to build complete, sorted, insert-only sets and to state times truthfully</td></tr>
            <tr><td>Distribution point</td><td>Stores snapshots, serves proofs, lists, and checkpoints</td><td>None for integrity; availability only</td></tr>
            <tr><td>Holder</td><td>Presents a credential and a staple</td><td>None; it can be revoked, compromised, or withholding</td></tr>
            <tr><td>Verifier</td><td>Decides the status of a credential</td><td>Relies on its own protected state and time</td></tr>
            <tr><td>List holder, auditor</td><td>Rebuilds trees, derives proofs and notices</td><td>None; its outputs are checked against signed checkpoints</td></tr>
            <tr><td>Trust administration</td><td>Installs domain configurations and checkpoint keys</td><td>Authoritative; outside this protocol</td></tr>
          </tbody>
        </table>
        <t>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 <bcp14>MUST</bcp14> resolve checkpoint keys through its installed configuration and <bcp14>MUST NOT</bcp14> trust a public key supplied only by evidence.</t>
      </section>
      <section anchor="assumptions">
        <name>Assumptions</name>
        <ul>
          <li>A1 - Authentic configuration. The verifier holds an authentic configuration for each domain it accepts, obtained through trust administration (<xref target="configuration"/>).</li>
          <li>A2 - Honest construction. For every checkpoint that it signs, the issuer builds the tree exactly as specified from the complete set of applicable revoked tokens as of snapshotTime, and it never removes a token within a stream (<xref target="issuance"/>).</li>
          <li>A3 - Bounded ingestion lag. Every snapshot whose true cutoff is at least L seconds later than a revocation decision contains the tokens that the decision affects, in every stream whose scope includes them. A deployment that cannot bound L has no finite enforcement bound.</li>
          <li>A4 - Authority clock. The clock that produces snapshotTime and thisUpdate differs from true time by at most a.</li>
          <li>A5 - Verifier clock. The verifier knows a bound v on the error of its clock, with v not greater than maxVerifierClockError, and maintains a protected lower bound on time that never decreases (<xref target="time-floor"/>).</li>
          <li>A6 - Credential validation. The enclosing protocol authenticates the operation, validates the certificate chain, validity period, and permissions, and identifies the exact issuance key. SMRP performs none of these.</li>
          <li>A7 - Cryptography. SHA-256 is collision resistant and the checkpoint signature scheme is existentially unforgeable under chosen-message attack <xref target="FIPS186-5"/>.</li>
          <li>A8 - Binding. The enclosing protocol binds the staple to the authenticated operation and to the credential that authenticates it (<xref target="binding"/>).</li>
          <li>A9 - Device coverage. When the authoritative decision excludes a device and not one certificate, the authority resolves the device to every still-usable credential, including credentials provisioned for future validity periods, and treats each as revoked. SMRP does not define that resolution.</li>
        </ul>
      </section>
      <section anchor="adversary">
        <name>Adversary and Attacks in Scope</name>
        <t>The network attacker can observe, inject, modify, delay, reorder, replay, and suppress traffic, in the sense of the symbolic attacker of <xref target="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:</t>
        <ul>
          <li>replay of a proof and checkpoint obtained before a revocation;</li>
          <li>freezing: suppression of newer checkpoints so that a verifier keeps an old view;</li>
          <li>substitution of evidence across credentials, domains, partitions, epochs, or configurations;</li>
          <li>malformed proofs: an interval that is not a leaf of the tree, a padding position or a misplaced sentinel, a wrong path length, a tree size that is not the signed one;</li>
          <li>re-encoding of a certificate signature to obtain a certificate that a revocation record does not match;</li>
          <li>omission of evidence by a revoked holder, and stripping of evidence in transit;</li>
          <li>conflicting statements by the checkpoint issuer or by redundant signing instances;</li>
          <li>oversized, non-canonical, or computationally expensive inputs;</li>
          <li>manipulation of the verifier clock and rollback of verifier state;</li>
          <li>tracking through tokens, proofs, partitions, and retrieval patterns.</li>
        </ul>
        <t>Compromise of a checkpoint-signing key is considered separately (<xref target="compromise"/>), because it defeats the authenticity of the commitment itself.</t>
      </section>
      <section anchor="limits">
        <name>Limits of the Model</name>
        <t>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.</t>
        <t>Rollback of verifier state and manipulation of its clock are deployment threats. A verifier that cannot restore its protected state or a trustworthy time <bcp14>MUST</bcp14> stop producing NOT_REVOKED_AT_SNAPSHOT until recovery. <xref target="state"/> states precisely which guarantee is lost with which element of state.</t>
      </section>
    </section>
    <section anchor="identity">
      <name>Credential Identity and Partitioning</name>
      <section anchor="domain">
        <name>Domain Selection</name>
        <t>The verifier <bcp14>MUST</bcp14> 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 <bcp14>MUST NOT</bcp14> be able to choose another domain, profile, issuance key, epoch mapping, or partition because it yields an absence proof.</t>
        <t>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, <bcp14>MAY</bcp14> assist lookup but <bcp14>MUST NOT</bcp14> 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.</t>
      </section>
      <section anchor="credential-identity">
        <name>Stable ITS Credential Identity</name>
        <t>Let Qissuer = 0x04 || X32 || Y32 be the uncompressed representation <xref target="SEC1"/> of the validated NIST P-256 issuance public key. Each coordinate occupies 32 octets, including leading zero octets. The point <bcp14>MUST</bcp14> be on the curve and <bcp14>MUST NOT</bcp14> be the point at infinity.</t>
        <sourcecode type="pseudocode"><![CDATA[
issuerKeyHash = H("smrp-issuer-p256-v1" || Qissuer)
]]></sourcecode>
        <t>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 <bcp14>MUST</bcp14> equal the issuerKeyHash of the configuration.</t>
        <t>The verifier builds an SmrpItsCredentialIdentity (<xref target="asn1"/>) from the certificate version, the certificate type, the issuerKeyHash, and the canonical COER encoding <xref target="X696"/> of the ToBeSignedCertificate. In this profile the certificate version <bcp14>MUST</bcp14> be 3. The type is 0 for an explicit certificate and 1 for an implicit certificate.</t>
        <t>Before the ToBeSignedCertificate is encoded, the IEEE 1609.2 canonicalization rules <xref target="IEEE1609.2"/> <bcp14>MUST</bcp14> be applied to the public encryption keys, verification keys, and reconstruction values that it contains. Every elliptic-curve field <bcp14>MUST</bcp14> 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 <bcp14>MUST</bcp14> be preserved. An implementation <bcp14>MUST NOT</bcp14> delete authenticated fields that it does not recognize, and <bcp14>MUST NOT</bcp14> invent a normalization of permissions or names. An unsupported type or canonicalization rule yields INDETERMINATE.</t>
        <t>The checkpoint issuer, when it derives the tokens of revoked credentials, and the verifiers <bcp14>MUST</bcp14> apply the same canonicalization. The received certificate is still validated with the applicable IEEE and ETSI rules <xref target="IEEE1609.2"/> <xref target="ETSI103097"/>. Building an SMRP identity authorizes neither rewriting a received certificate nor skipping its signature, reconstruction, permission, or proof-of-possession checks.</t>
        <sourcecode type="pseudocode"><![CDATA[
identityBytes    = COER(SmrpItsCredentialIdentity)
credentialDigest = H(identityBytes)
X                = H("smrp-cert-v2" || domainId || credentialDigest)
]]></sourcecode>
        <t>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 (<xref target="state"/>).</t>
        <t>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.</t>
        <t>This identity is incompatible with the earlier experimental "smrp-cert-v1" hash of the complete certificate. An implementation <bcp14>MUST NOT</bcp14> accept v1 tokens as v2 tokens and <bcp14>MUST NOT</bcp14> try several derivations until one yields absence. A change of token semantics requires a new profile identifier and an explicit migration of revocation state.</t>
      </section>
      <section anchor="partition">
        <name>Partition Function</name>
        <t>Let e be an epoch start, a multiple of E on the time scale of <xref target="timescale"/>.</t>
        <sourcecode type="pseudocode"><![CDATA[
Y = H("smrp-shard-v1" || U16(profileId) || U64(e) || X)
partitionId = 0                        if k = 0
partitionId = leftmost k bits of Y     otherwise
]]></sourcecode>
        <t>The result is an unsigned integer smaller than 2^k. The verifier <bcp14>MUST</bcp14> 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.</t>
        <t>Hash partitioning controls the expected occupancy of a partition. It does not guarantee a maximum. The checkpoint issuer <bcp14>MUST NOT</bcp14> truncate an overfull partition. It <bcp14>MUST</bcp14> 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. <xref target="tradeoff"/> discusses the choice of k.</t>
      </section>
      <section anchor="epochs">
        <name>Epochs and the Lead Interval</name>
        <t>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.</t>
        <t>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 (<xref target="epoch-transition"/>). 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.</t>
        <t>While two epochs are in use, the issuer <bcp14>MUST</bcp14> 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 <xref target="time"/>. A holder <bcp14>SHOULD</bcp14> obtain its proof for the next epoch at a random instant of the lead interval, so that retrievals do not concentrate at one instant.</t>
      </section>
      <section anchor="set-scope">
        <name>Scope of the Revoked Set</name>
        <t>For an epoch e and a partition p, the applicable revoked set contains the token of every revoked credential that satisfies both conditions:</t>
        <ul>
          <li>its validity period intersects the interval [e - G, e + E) during which the epoch is in use; and</li>
          <li>its token maps to p under the partition function for e.</li>
        </ul>
        <t>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.</t>
        <t>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 (<xref target="proof-size"/>).</t>
        <t>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 <bcp14>MUST</bcp14> be treated as a security incident.</t>
      </section>
    </section>
    <section anchor="configuration">
      <name>Configuration and Administrative Recovery</name>
      <t>An SmrpConfiguration (<xref target="asn1"/>) 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.</t>
      <sourcecode type="pseudocode"><![CDATA[
configurationHash = H("smrp-config-v1" || COER(configuration))
signerKeyId       = H("smrp-checkpoint-key-v1" || Qcheckpoint)
]]></sourcecode>
      <t>Qcheckpoint is a validated 65-octet uncompressed NIST P-256 point. The authority keys of a configuration <bcp14>MUST</bcp14> be listed in strictly increasing order of signerKeyId, without duplicates. The notBefore of each key <bcp14>MUST</bcp14> be smaller than its notAfter. A checkpoint-signing key <bcp14>SHOULD</bcp14> be dedicated to SMRP and <bcp14>SHOULD</bcp14> differ from every credential issuance key.</t>
      <t>The protocol version is 1. <xref target="iana"/> discusses profile identifiers. The following limits apply in addition to the ASN.1 type constraints. A configuration that violates any of them <bcp14>MUST</bcp14> be rejected at installation.</t>
      <table anchor="tab-config">
        <name>Configuration limits</name>
        <thead>
          <tr><th>Parameter</th><th>Required range or relationship</th></tr>
        </thead>
        <tbody>
          <tr><td>authorityEpoch</td><td>1 to 2^64 - 1; protected monotonic generation</td></tr>
          <tr><td>epochDuration (E)</td><td>1 to 604800 seconds</td></tr>
          <tr><td>epochLead (G)</td><td>0 to E - 1 seconds</td></tr>
          <tr><td>shardBits (k)</td><td>0 to 16</td></tr>
          <tr><td>maxSnapshotAge (A)</td><td>1 to 600 seconds, and greater than 2 * (maxAuthorityClockError + maxVerifierClockError)</td></tr>
          <tr><td>maxCheckpointLifetime</td><td>1 to A seconds</td></tr>
          <tr><td>maxVerifierClockError</td><td>0 to 60 seconds</td></tr>
          <tr><td>maxAuthorityClockError (a)</td><td>0 to 60 seconds</td></tr>
          <tr><td>maxTreeSize</td><td>1 to 2^20 leaves; a tree of m leaves holds m - 1 revoked tokens</td></tr>
          <tr><td>maxStapleSize</td><td>from 309 + 32 * height(maxTreeSize) to 4096 octets</td></tr>
          <tr><td>authorityKeys</td><td>1 to 16 distinct keys</td></tr>
        </tbody>
      </table>
      <t>The lower limit of maxStapleSize is the size of the largest full staple that a tree of maxTreeSize leaves can require (<xref target="sizes"/>), 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 <xref target="deadline"/> 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 <xref target="epoch-transition"/>. A deployment <bcp14>SHOULD</bcp14> choose G using the sufficient overlap conditions of <xref target="epoch-transition"/>, including a refresh schedule whose admissible intervals cover the transition.</t>
      <t>These are protocol ceilings for an experiment, not safety constants. A deployment can require fresher status, smaller objects, and more accurate clocks. A verifier <bcp14>MAY</bcp14> apply stricter local limits (<xref target="classes"/>). A local limit cannot extend a signed deadline and cannot change a token or partition derivation.</t>
      <section anchor="admin">
        <name>Administrative Changes and Recovery</name>
        <t>Any change to the content of a configuration <bcp14>MUST</bcp14> use a strictly greater authorityEpoch for the same domain and <bcp14>MUST</bcp14> 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 (<xref target="state"/>). Neither arrival order nor a larger version resolves it.</t>
        <t>The verifier <bcp14>MUST</bcp14> 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 <bcp14>MUST NOT</bcp14> activate affirmative decisions for the affected migration scope. Installing a new configuration alone is not a migration of terminal state.</t>
        <t>This document does not define the transport of configurations. C-ITS deployments can use the trust-list mechanisms of <xref target="ETSI102941"/> and <xref target="ETSI103601"/> or those of the SCMS <xref target="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 <bcp14>REQUIRED</bcp14>.</t>
      </section>
    </section>
    <section anchor="merkle">
      <name>The Sorted Merkle Revocation Set</name>
      <t>The set semantics, interval-tree construction, and two proof types below determine the meaning of a checkpoint's signed set commitment.</t>
      <section anchor="set-semantics">
        <name>Set Semantics</name>
        <t>For a stream, the checkpoint issuer forms the complete applicable set S of revoked tokens (<xref target="set-scope"/>) as of snapshotTime. Revocation is terminal in this profile. Reversible suspension and removal from a list require a different profile and <bcp14>MUST NOT</bcp14> be approximated by silently removing a token.</t>
      </section>
      <section anchor="tree-build">
        <name>Tree Construction</name>
        <t>Let x_1 &lt; x_2 &lt; ... &lt; 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.</t>
        <t>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] &lt; X &lt; 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 <bcp14>MUST</bcp14> be enforced before any allocation.</t>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
        <t>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.</t>
        <t>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.</t>
        <t>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 <bcp14>MUST</bcp14> hash the encodings defined above.</t>
        <t>An empty revoked set has m = 1 and h = 0. Its root is leafHash(0, MIN, MAX). An empty set <bcp14>MUST</bcp14> still be published under a signed checkpoint. Missing data from an upstream source is not an empty set.</t>
        <t>A leaf that states an interval free of revoked entries is the range statement of certificate revocation trees <xref target="KOCHER98"/>. The typed sentinels, the index binding, and the padding rule are specific to this document. <xref target="rationale"/> compares this tree with a tree whose leaves are single tokens.</t>
      </section>
      <section anchor="adjacent">
        <name>Non-Membership Proof</name>
        <t>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.</t>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
        <t>Between DATA boundaries the inequalities are strict: equality with either boundary fails. Every hash and token <bcp14>MUST</bcp14> be exactly 32 octets. A failed requirement yields a bounded failure, never an unhandled error and never an affirmative result.</t>
        <t>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.</t>
      </section>
      <section anchor="membership">
        <name>Membership Proof</name>
        <t>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.</t>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
        <t>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 <bcp14>MUST NOT</bcp14> reinterpret a failed membership proof as a non-membership proof, or the converse. A failed non-membership proof is not evidence of revocation.</t>
      </section>
      <section anchor="proof-size">
        <name>Proof Size and Work</name>
        <t>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 (<xref target="claims"/>).</t>
        <ul>
          <li>All paths have the same number of sibling hashes at a fixed tree size. Encoded proof size also depends on the boundary types: each sentinel saves 32 octets relative to a DATA boundary, and the empty tree has two sentinels. Capacity planning uses the largest permitted encoding; a typical size requires a model of which intervals are queried (<xref target="lower-size"/>).</li>
          <li>The size of the set enters only through h. Doubling the set adds one hash of 32 octets. If a nonempty set of R tokens is replaced by R * P tokens for a positive integer P, the increase is height(R * P + 1) - height(R + 1), at most ceil(log2(P)) hashes. For vehicle-level estimates, P counts credentials whose validity intersects the epoch, not only those valid simultaneously.</li>
          <li>Verification invokes the hash function h + 1 times. The leaf input has at most 71 octets and an interior-node input has 65 octets, so each occupies at most two SHA-256 compression blocks. A proof therefore costs at most 2h + 2 compression calls. No signature operation is involved.</li>
        </ul>
        <t>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 (<xref target="rationale"/>).</t>
      </section>
    </section>
    <section anchor="checkpoint">
      <name>Checkpoints</name>
      <section anchor="checkpoint-fields">
        <name>Authenticated Fields</name>
        <t>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.</t>
        <table anchor="tab-tbs">
          <name>Fields of SmrpCheckpointTBS</name>
          <thead>
            <tr><th>Field</th><th>Octets</th><th>Meaning</th></tr>
          </thead>
          <tbody>
            <tr><td>protocolVersion</td><td>1</td><td>1 in this document</td></tr>
            <tr><td>profileId</td><td>2</td><td>Profile identifier (<xref target="iana"/>)</td></tr>
            <tr><td>domainId</td><td>16</td><td>Domain of the configuration; a consistency check</td></tr>
            <tr><td>configurationHash</td><td>32</td><td>Hash of the complete configuration</td></tr>
            <tr><td>authorityEpoch</td><td>8</td><td>Administrative generation; a consistency check</td></tr>
            <tr><td>epochStart</td><td>8</td><td>Start of the epoch; a multiple of E</td></tr>
            <tr><td>partitionId</td><td>4</td><td>Partition, smaller than 2^k</td></tr>
            <tr><td>partitionVersion</td><td>8</td><td>Position of the checkpoint in its stream</td></tr>
            <tr><td>snapshotTime</td><td>8</td><td>Complete-through cutoff of the revocation database</td></tr>
            <tr><td>thisUpdate</td><td>8</td><td>Issuance time</td></tr>
            <tr><td>nextUpdate</td><td>8</td><td>Exclusive acceptance deadline</td></tr>
            <tr><td>treeSize</td><td>4</td><td>Number of leaves m of the tree, equal to |S| + 1</td></tr>
            <tr><td>rootHash</td><td>32</td><td>Root of the tree</td></tr>
            <tr><td>signerKeyId</td><td>32</td><td>Identifier of the signing key in the configuration</td></tr>
          </tbody>
        </table>
        <t>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.</t>
      </section>
      <section anchor="issuance">
        <name>Issuance Rules</name>
        <t>The following rules bind the checkpoint issuer. Rules 2 to 4 are also checked by verifiers, which treat an authenticated violation as a conflict (<xref target="checkpoint-processing"/>).</t>
        <ol>
          <li>Truthful times. thisUpdate is the reading of the issuer's clock when it signs. snapshotTime is the cutoff through which the database view used to build the set is complete. The issuer <bcp14>MUST NOT</bcp14> sign a checkpoint whose snapshotTime or thisUpdate is later than its clock, and <bcp14>MUST NOT</bcp14> advance snapshotTime by signing again a view that it has not refreshed. An issuer that cannot establish the cutoff of its view, for instance behind a lagging replica, <bcp14>MUST NOT</bcp14> issue.</li>
          <li>Unique versions. Within a stream, partitionVersion starts at a positive value and strictly increases with every newly issued TBS, including one that only refreshes the times of an unchanged set. Redundant signing instances <bcp14>MUST</bcp14> be coordinated so that two different statements never share a version. The issuer <bcp14>MUST</bcp14> persist its counters and commit its snapshot before releasing a checkpoint.</li>
          <li>Monotonic times. Within a stream, snapshotTime and thisUpdate never decrease as the version increases.</li>
          <li>Insert-only streams. Within a stream, the set of a higher version contains the set of every lower version. Consequently treeSize never decreases, and two checkpoints with equal treeSize have equal rootHash. Tokens leave the revoked set only when the sets of a new epoch are built (<xref target="set-scope"/>).</li>
          <li>Regular refresh. While a stream is in use, the issuer <bcp14>SHOULD</bcp14> issue a new checkpoint before the previous one expires, whether or not the set changed. This is what keeps the status of unrevoked credentials fresh.</li>
          <li>Device coverage. When a decision excludes a device, the tokens of all its credentials in scope are inserted in the same version of each affected stream (assumption A9).</li>
        </ol>
      </section>
      <section anchor="signature">
        <name>Signature</name>
        <sourcecode type="pseudocode"><![CDATA[
tbsBytes      = COER(SmrpCheckpointTBS)
signedMessage = "smrp-checkpoint-v1" || tbsBytes
signature     = ECDSA-P256-SHA256(signedMessage)
]]></sourcecode>
        <t>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 <bcp14>MUST</bcp14> output scalars satisfying 1 &lt;= r &lt; q and 1 &lt;= s &lt;= floor(q / 2), where q is the order of the NIST P-256 group, replacing s by q - s if necessary. The verifier <bcp14>MUST</bcp14> enforce these ranges even when a cached authenticated TBS permits skipping the ECDSA operation. The signer <bcp14>MUST</bcp14> generate nonces as required by <xref target="FIPS186-5"/>. Deterministic generation as in <xref target="RFC6979"/> is permitted and is not required by the wire format.</t>
        <t>The signature operation hashes signedMessage once with SHA-256. An interface that takes a precomputed digest <bcp14>MUST</bcp14> be used in its prehashed mode. Checkpoint signatures are unrelated to IEEE 1609.2 message signatures and to their certificate-hash inputs.</t>
      </section>
      <section anchor="carry-over">
        <name>Checkpoint Identifier, Set Commitment, and Proof Reuse</name>
        <sourcecode type="pseudocode"><![CDATA[
checkpointId = H("smrp-checkpoint-id-v1" || tbsBytes)
]]></sourcecode>
        <t>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 <bcp14>MAY</bcp14> 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.</t>
        <t>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:</t>
        <ul>
          <li>A holder that receives a newer checkpoint with an unchanged set commitment keeps its proof. It can pair the proof with the newer checkpoint without contacting any service.</li>
          <li>A verifier that has checked a proof against a set commitment extends the resulting status to every newer checkpoint of the stream that it admits with the same commitment, without receiving anything further from the holder (<xref target="decision"/>).</li>
        </ul>
        <t>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.</t>
      </section>
    </section>
    <section anchor="objects">
      <name>Evidence Objects</name>
      <section anchor="encoding">
        <name>Encoding Rules</name>
        <t>All SMRP structures are encoded with the Canonical Octet Encoding Rules (COER) of <xref target="X696"/>, from the module of <xref target="asn1"/>. A decoder <bcp14>MUST</bcp14> 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.</t>
      </section>
      <section anchor="staple-forms">
        <name>Staple Forms</name>
        <t>An SmrpStaple is a choice among three forms.</t>
        <dl newline="false" spacing="normal">
          <dt>full:</dt>
          <dd>A checkpoint and a proof. The staple is self-contained: a verifier that holds only the configuration can evaluate it. The checkpoint <bcp14>MUST</bcp14> belong to the stream of the presenter's token, and the proof <bcp14>MUST</bcp14> verify against the set commitment of that checkpoint.</dd>
          <dt>proofOnly:</dt>
          <dd>An epochStart and a proof. The verifier evaluates the proof against the current checkpoint that it holds for the stream designated by the epochStart and by the partition of the presenter's token. Without such a checkpoint the staple yields INDETERMINATE.</dd>
          <dt>checkpointOnly:</dt>
          <dd>A checkpoint alone. It conveys no statement about the presenter. It lets any station deliver a checkpoint to its neighbors, for its own partition or for another.</dd>
        </dl>
        <t>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 (<xref target="evidence-processing"/>). Third parties convey revocations with the notice of <xref target="notice"/>.</t>
        <t>A checkpoint has a fixed size and is placed first in the two forms that contain one. A verifier <bcp14>MUST</bcp14> authenticate and process that checkpoint independently of what follows it (<xref target="evidence-processing"/>).</t>
      </section>
      <section anchor="sizes">
        <name>Object Sizes</name>
        <t>The sizes below are exact for the module of <xref target="asn1"/>. 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 (<xref target="tree-build"/>).</t>
        <table anchor="tab-formulas">
          <name>Encoded sizes in octets</name>
          <thead>
            <tr><th>Object</th><th>Size</th></tr>
          </thead>
          <tbody>
            <tr><td>Checkpoint (TBS of 171 and signature of 64)</td><td>235</td></tr>
            <tr><td>Checkpoint-only staple</td><td>236</td></tr>
            <tr><td>Full staple, non-membership, two DATA boundaries</td><td>309 + 32 * h</td></tr>
            <tr><td>Proof-only staple, non-membership, two DATA boundaries</td><td>82 + 32 * h</td></tr>
            <tr><td>Each sentinel boundary in place of a DATA boundary</td><td>32 fewer</td></tr>
            <tr><td>Full staple, empty set</td><td>245</td></tr>
            <tr><td>Proof-only staple, empty set</td><td>18</td></tr>
            <tr><td>Full staple, membership, DATA upper boundary</td><td>276 + 32 * h</td></tr>
            <tr><td>Proof-only staple, membership, DATA upper boundary</td><td>49 + 32 * h</td></tr>
            <tr><td>Revocation notice, DATA upper boundary</td><td>79 + 32 * h</td></tr>
          </tbody>
        </table>
        <t><xref target="tab-sizes"/> gives the sizes for several numbers of revoked tokens in a partition. Each row is the largest set of its height.</t>
        <table anchor="tab-sizes">
          <name>Sizes in octets by number of revoked tokens in a partition</name>
          <thead>
            <tr><th>Revoked tokens (up to)</th><th>h</th><th>Proof-only staple</th><th>Full staple</th><th>Revocation notice</th></tr>
          </thead>
          <tbody>
            <tr><td>0</td><td>0</td><td>18</td><td>245</td><td>-</td></tr>
            <tr><td>3</td><td>2</td><td>146</td><td>373</td><td>143</td></tr>
            <tr><td>31</td><td>5</td><td>242</td><td>469</td><td>239</td></tr>
            <tr><td>255</td><td>8</td><td>338</td><td>565</td><td>335</td></tr>
            <tr><td>1023</td><td>10</td><td>402</td><td>629</td><td>399</td></tr>
            <tr><td>4095</td><td>12</td><td>466</td><td>693</td><td>463</td></tr>
            <tr><td>65535</td><td>16</td><td>594</td><td>821</td><td>591</td></tr>
            <tr><td>1048575</td><td>20</td><td>722</td><td>949</td><td>719</td></tr>
          </tbody>
        </table>
        <t>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 (<xref target="configuration"/>). A path <bcp14>MUST NOT</bcp14> be truncated.</t>
      </section>
      <section anchor="notice">
        <name>Revocation Notice</name>
        <t>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 (<xref target="notice-processing"/>). It can only establish a revocation.</t>
        <t>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.</t>
      </section>
      <section anchor="snapshot">
        <name>Snapshot and Delta</name>
        <t>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 <xref target="tree-build"/> has the root rootHash. A snapshot is what the issuer publishes for distribution points, list holders, and auditors.</t>
        <t>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 <bcp14>MUST</bcp14> 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 <bcp14>MUST</bcp14> 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.</t>
        <t>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 <bcp14>MUST</bcp14> check the input length and encoded token count against configured bounds and reject impossible combinations. It <bcp14>MUST</bcp14> authenticate the fixed-size target checkpoint before rebuilding the tree. Length and count checks do not replace canonical decoding or root validation.</t>
      </section>
    </section>
    <section anchor="time">
      <name>Time, Freshness, and the Enforcement Bound</name>
      <section anchor="timescale">
        <name>Time Scale</name>
        <t>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 <xref target="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.</t>
        <t>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 <bcp14>MUST</bcp14> be included in the declared clock error. Truncating a clock value does not create zero error. Arithmetic on times <bcp14>MUST</bcp14> detect overflow and underflow.</t>
      </section>
      <section anchor="field-constraints">
        <name>Constraints on Signed Fields</name>
        <t>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.</t>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
        <t>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.</t>
      </section>
      <section anchor="time-floor">
        <name>Verifier Time Interval and Time Floor</name>
        <t>Let C be the reading of the verifier's clock and v its known error bound. v <bcp14>MUST NOT</bcp14> exceed maxVerifierClockError. The verifier keeps a protected time floor F, initially zero, and computes:</t>
        <sourcecode type="pseudocode"><![CDATA[
if C + v < F:  time is not trustworthy
nowLower = max(C - v, F)
nowUpper = C + v
F        = nowLower
]]></sourcecode>
        <t>True time is assumed to lie in [nowLower, nowUpper]. F never decreases and <bcp14>MUST</bcp14> 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.</t>
        <t>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.</t>
      </section>
      <section anchor="admissibility">
        <name>Admissibility of a Checkpoint</name>
        <t>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.</t>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
        <t>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 <xref target="checkpoint-processing"/>, and a membership proof that verifies against it establishes a revocation (<xref target="evidence-processing"/>).</t>
      </section>
      <section anchor="deadline">
        <name>Status Interval</name>
        <t>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 (<xref target="classes"/>), at most A; without a class, Aapp = A. The status is affirmative only if:</t>
        <sourcecode type="pseudocode"><![CDATA[
start    = max(thisUpdate + a, keyNotBefore, certNotBefore)
deadline = min(nextUpdate, snapshotTime - a + Aapp,
               epochStart + E, keyNotAfter, certNotAfter)

nowLower >= start   and   nowUpper < deadline
]]></sourcecode>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="bound">
        <name>Enforcement Bound</name>
        <t>The following bound is the main freshness guarantee. <xref target="proofs"/> gives the definitions and the argument in full.</t>
        <t>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 &lt; r + L + Aapp.</t>
        <t>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.</t>
        <t>Four remarks delimit the result.</t>
        <ul>
          <li>The clock errors a and v do not appear in the bound. Interval arithmetic charges them to availability.</li>
          <li>The bound concerns the end of affirmative results. It is not a bound on the delivery of REVOKED, and it starts at the revocation decision, not at the misbehavior that led to it.</li>
          <li>The bound depends on the stated cryptographic, completeness, ingestion, time, and credential-validation assumptions. It does not require retention of volatile stream records. Such records can shorten the exposure after a newer checkpoint is received; losing them can reopen acceptance of older evidence, but cannot extend it beyond the theorem under those assumptions.</li>
          <li>The bound applies to every verifier and every delivery path, including a verifier from which all newer checkpoints are withheld. In that case the outcome after the deadline is INDETERMINATE.</li>
        </ul>
        <t>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.</t>
      </section>
      <section anchor="epoch-transition">
        <name>Epoch Transition</name>
        <t>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 &lt; 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 &gt;= 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 (<xref target="claims"/>).</t>
        <t>A lead interval can remove this start-time gap. Under the preceding idealized timing assumptions, G &gt;= 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.</t>
      </section>
    </section>
    <section anchor="producers">
      <name>Issuer, Distribution Point, and Holder Processing</name>
      <section anchor="issuer-processing">
        <name>Checkpoint Issuer</name>
        <t>For each stream in use, the issuer maintains the sorted set and proceeds as follows at every issuance.</t>
        <ol>
          <li>Fix a cutoff and read the authoritative revocation database through that cutoff. Insert the tokens that have entered the scope of the stream (<xref target="set-scope"/>).</li>
          <li>Build the tree, or update it, and form the TBS with the next partitionVersion, the cutoff as snapshotTime, the current clock reading as thisUpdate, and a nextUpdate that satisfies <xref target="field-constraints"/>.</li>
          <li>Commit the snapshot and the version to durable storage, then sign.</li>
          <li>Publish the checkpoint together with the snapshot or with a delta from the previous snapshot (<xref target="snapshot"/>).</li>
        </ol>
        <t>The issuer <bcp14>MUST NOT</bcp14> 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.</t>
        <t>An issuer <bcp14>MAY</bcp14> 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.</t>
        <t>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.</t>
      </section>
      <section anchor="dp-processing">
        <name>Distribution Point</name>
        <t>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 <bcp14>MUST</bcp14> 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.</t>
        <t>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 <bcp14>MUST NOT</bcp14> require a holder to authenticate with the credential whose proof it requests or with any long-term identifier (<xref target="privacy"/>). The retrieval protocol is outside the scope of this document.</t>
        <t>A distribution point that serves a proof <bcp14>MUST</bcp14> serve it under the latest checkpoint for which it holds the list, and <bcp14>SHOULD</bcp14> return that checkpoint with the proof.</t>
      </section>
      <section anchor="holder-processing">
        <name>Holder</name>
        <t>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.</t>
        <dl newline="false" spacing="normal">
          <dt>Proof retrieval:</dt>
          <dd>The holder asks a distribution point for the proof of one token. The request discloses that token to the distribution point.</dd>
          <dt>Self-derivation:</dt>
          <dd>The holder keeps the token list of its partition, obtained as a snapshot and maintained with deltas, validates it as a list holder does (<xref target="list-mode"/>), and computes its own proofs. It sends no request about any credential. Deltas can reach it by broadcast.</dd>
        </dl>
        <t>A holder <bcp14>MUST</bcp14> 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.</t>
        <t>When a holder obtains a newer checkpoint of its stream, it compares the set commitment with that of its proof.</t>
        <ul>
          <li>If the commitment is unchanged, the holder keeps its proof and uses the newer checkpoint in full staples. No retrieval takes place.</li>
          <li>If the commitment changed, the holder needs a new proof. Until it has one, it can only present its previous evidence, which verifiers that hold the newer checkpoint treat as superseded.</li>
        </ul>
        <t>A holder <bcp14>SHOULD</bcp14> 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.</t>
        <t>The choice between staple forms is a scheduling decision.</t>
        <ul>
          <li>A proof-only staple is sufficient for every verifier that holds the current checkpoint of the stream.</li>
          <li>A full staple also delivers the checkpoint. A holder <bcp14>SHOULD</bcp14> send one in its first evidence-bearing message after it obtains a new checkpoint, and thereafter at a configured interval.</li>
          <li>A holder <bcp14>MAY</bcp14> skip a scheduled full staple when it has itself received the same checkpoint from another station within that interval. This is an optional suppression heuristic inspired by <xref target="RFC6206"/>. A receiver hearing a checkpoint does not establish that its neighbors heard it. Without a fully specified suppression algorithm, hidden-terminal model, and loss analysis, no density-independent transmission rate or delivery guarantee follows.</li>
          <li>A checkpoint-only staple lets a station that holds a newer checkpoint than its neighbors deliver it, including for a partition other than its own.</li>
        </ul>
        <t><xref target="scheduling"/> gives the resulting channel load.</t>
      </section>
    </section>
    <section anchor="verifier">
      <name>Verifier Processing</name>
      <t>A verifier <bcp14>MUST</bcp14> 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.</t>
      <section anchor="state">
        <name>Verifier State</name>
        <t>For each domain, the verifier keeps the following state.</t>
        <table anchor="tab-state">
          <name>Verifier state</name>
          <thead>
            <tr><th>Element</th><th>Content</th><th>Protection</th></tr>
          </thead>
          <tbody>
            <tr><td>Configuration floor</td><td>Greatest installed authorityEpoch and its configuration hash</td><td>Rollback resistant</td></tr>
            <tr><td>Time floor</td><td>F (<xref target="time-floor"/>)</td><td>Rollback resistant</td></tr>
            <tr><td>Terminal records</td><td>Tokens with an authenticated revocation</td><td>Rollback resistant</td></tr>
            <tr><td>Conflict barrier</td><td>A flag and the contradicting authenticated checkpoints or administrative configurations, with provenance</td><td>Rollback resistant</td></tr>
            <tr><td>Stream records</td><td>The current checkpoint of each stream in use</td><td>Volatile</td></tr>
            <tr><td>Proof cache</td><td>For a token and an epoch, the set commitment against which a proof of absence was verified</td><td>Volatile</td></tr>
            <tr><td>Lists (optional)</td><td>Validated token lists with their set commitments and complete authenticated base checkpoints</td><td>Volatile</td></tr>
          </tbody>
        </table>
        <t>A terminal record is keyed by the token. When the record is created while the credential itself is processed, the verifier <bcp14>MUST</bcp14> 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.</t>
        <t>Each guarantee depends on specific elements of state. An implementer can thus see what a loss of state costs.</t>
        <table anchor="tab-dependency">
          <name>Guarantees and the state they depend on</name>
          <thead>
            <tr><th>Guarantee</th><th>Depends on</th><th>Effect of losing the volatile state</th></tr>
          </thead>
          <tbody>
            <tr><td>Enforcement bound (Theorem 1)</td><td>Configuration floor, time floor</td><td>None</td></tr>
            <tr><td>A revocation once learned remains REVOKED</td><td>Terminal records</td><td>None</td></tr>
            <tr><td>No affirmative status after a detected conflict</td><td>Conflict barrier</td><td>None</td></tr>
            <tr><td>An older checkpoint does not displace a newer one</td><td>Stream records</td><td>An older checkpoint that has not expired is usable again, within the bound of Theorem 1</td></tr>
            <tr><td>Status without repeated evidence</td><td>Stream records, proof cache, lists</td><td>INDETERMINATE until evidence is received again</td></tr>
          </tbody>
        </table>
        <t>A verifier that cannot restore its configuration floor or its time floor <bcp14>MUST NOT</bcp14> 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 (<xref target="omission"/>).</t>
      </section>
      <section anchor="checkpoint-processing">
        <name>Checkpoint Processing</name>
        <t>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 <xref target="time-floor"/>.</t>
        <ol>
          <li>Decode the 235 octets canonically. A failure is INVALID.</li>
          <li>If configurationHash is not that of the installed configuration, the checkpoint is ignored. An unknown configuration is not a fault of the presenter.</li>
          <li>Check that the protocol version, profile, domain, and authority epoch are those of the configuration, and check every constraint of <xref target="field-constraints"/> that does not involve the key. A failure is INVALID.</li>
          <li>Check the raw signature scalar ranges. If the checkpointId and exact TBS equal those of the current authenticated checkpoint of the stream, its retained authentication may be reused. Otherwise, resolve signerKeyId in the configuration and verify the signature (<xref target="signature"/>), and check the key constraint of <xref target="field-constraints"/>. A failure is INVALID. From this point the checkpoint is authentic.</li>
          <li>If the signing key is not authorized now, that is, if nowLower &lt; keyNotBefore or nowUpper &gt;= keyNotAfter, the checkpoint is ignored for every purpose.</li>
          <li>If the stream has a current checkpoint with a different checkpointId, apply the consistency check below. A violation sets the conflict barrier.</li>
          <li>Classify the checkpoint as premature, fresh, or stale (<xref target="admissibility"/>).</li>
          <li>If the checkpoint is fresh and the stream has no current checkpoint, or the current one has a smaller partitionVersion, the checkpoint becomes the current checkpoint of the stream.</li>
        </ol>
        <t>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:</t>
        <ul>
          <li>their partitionVersion values differ;</li>
          <li>lo.snapshotTime &lt;= hi.snapshotTime and lo.thisUpdate &lt;= hi.thisUpdate;</li>
          <li>lo.treeSize &lt;= hi.treeSize;</li>
          <li>if lo.treeSize = hi.treeSize, then lo.rootHash = hi.rootHash.</li>
        </ul>
        <t>These are rules 2 to 4 of <xref target="issuance"/> as far as two checkpoints reveal them. A violation is an authenticated statement that the issuer contradicted its obligations. The verifier <bcp14>MUST</bcp14> set the conflict barrier of the domain and <bcp14>MUST</bcp14> 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 (<xref target="admin"/>).</t>
        <t>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 (<xref target="audit"/>).</t>
        <t>A verifier <bcp14>MAY</bcp14> retain a premature checkpoint and classify it again later. It <bcp14>MUST NOT</bcp14> use it earlier.</t>
      </section>
      <section anchor="evidence-processing">
        <name>Staple Processing</name>
        <t>A staple is processed for a credential that the enclosing protocol has validated and whose token X the verifier has derived (<xref target="credential-identity"/>). Let p(e) denote the partition of X for an epoch e.</t>
        <ol>
          <li>Check that the staple does not exceed maxStapleSize or the local limit, and read the choice tag. An unknown tag is INVALID.</li>
          <li>For a full or checkpoint-only staple, process the checkpoint, which occupies the 235 octets after the tag, as specified in <xref target="checkpoint-processing"/>. This step is complete before the rest of the staple is considered. If it sets the conflict barrier, no positive state is updated. For a full staple, the bounded negative-evidence procedure of <xref target="negative-conflict"/> is still applied before returning CONFLICT.</li>
          <li>Decode the whole staple canonically. A failure is INVALID. A checkpoint admitted in step 2 remains admitted.</li>
          <li>A checkpoint-only staple requires nothing further.</li>
          <li>
            <t>Full staple. If the checkpoint was ignored in step 2, nothing further is done. Otherwise:</t>
            <ul>
              <li>the partitionId of the checkpoint <bcp14>MUST</bcp14> equal p(epochStart); a mismatch is INVALID;</li>
              <li>the proof <bcp14>MUST</bcp14> verify for X against the treeSize and rootHash of that checkpoint; a failure is INVALID;</li>
              <li>if the proof is a membership proof, a terminal record is created and the outcome is REVOKED, whether the checkpoint is fresh, stale, or premature;</li>
              <li>if the proof is a non-membership proof and the set commitment of the checkpoint equals that of the current checkpoint of the stream, the proof cache records that commitment for X and the epoch.</li>
            </ul>
          </li>
          <li>
            <t>Proof-only staple. The epochStart <bcp14>MUST</bcp14> 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:</t>
            <ul>
              <li>a membership proof that verifies creates a terminal record, and the outcome is REVOKED;</li>
              <li>a non-membership proof that verifies is recorded in the proof cache;</li>
              <li>a proof that does not verify has no effect. It can refer to a checkpoint that the verifier does not hold, so it is not INVALID.</li>
            </ul>
          </li>
        </ol>
        <t>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 <xref target="checkpoint-processing"/>).</t>
        <t>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.</t>
      </section>
      <section anchor="decision">
        <name>Decision</name>
        <t>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.</t>
        <ol>
          <li>If a terminal record exists for X, return REVOKED. Otherwise, consult retained authenticated negative knowledge first: a validated held list or a proof-only membership under a retained authenticated root can create the terminal record and return REVOKED before any time, conflict, or malformed-input decision. This preliminary path admits no checkpoint and records no absence (<xref target="negative-conflict"/>).</li>
          <li>If the conflict barrier of the domain is set, apply the bounded negative-evidence procedure of <xref target="negative-conflict"/>. Return REVOKED if it establishes membership for X, and otherwise return CONFLICT.</li>
          <li>If time is not trustworthy (<xref target="time-floor"/>), consult only retained authenticated negative knowledge as specified in <xref target="negative-conflict"/>. Return REVOKED if membership is established, and otherwise INDETERMINATE. Do not admit a new checkpoint on this path.</li>
          <li>If the operation carries a staple, process it (<xref target="evidence-processing"/>). Return INVALID, REVOKED, or CONFLICT if that processing yields one of them.</li>
          <li>If the verifier keeps lists, consult them (<xref target="list-mode"/>). Return REVOKED if X is in a list.</li>
          <li>For each epoch e in use, let K be the current checkpoint of the stream (e, p(e)). If the proof cache holds, for X and e, a set commitment equal to that of K, and the status interval of <xref target="deadline"/> holds for K, the credential validity, and Aapp, the candidate deadline is the one computed there. If at least one epoch yields a candidate, return NOT_REVOKED_AT_SNAPSHOT with the latest candidate deadline and the corresponding checkpointId and snapshotTime.</li>
          <li>Otherwise return INDETERMINATE.</li>
        </ol>
        <t>Rule 6 is the proof-reuse rule of <xref target="carry-over"/> 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.</t>
        <t>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 (<xref target="omission-cert"/>).</t>
      </section>
      <section anchor="negative-conflict">
        <name>Negative Evidence under Conflict or Unavailable Time</name>
        <t>A conflict barrier blocks affirmative status; it <bcp14>MUST NOT</bcp14> 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.</t>
        <ul>
          <li>For a full staple with trustworthy time, enforce the object and path bounds, authenticate the checkpoint under the installed configuration, check its semantics, the signing key's current authorization, and the partition derived from X, then verify a membership proof for X against that exact commitment. A checkpoint that reveals the conflict can still authenticate such a membership proof.</li>
          <li>For a proof-only staple or notice, a membership proof may be checked against a commitment already authenticated and retained for the designated stream.</li>
          <li>A retained validated list may establish membership for X. It is consulted only for presence on this path.</li>
        </ul>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="notice-processing">
        <name>Revocation Notice Processing</name>
        <t>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.</t>
        <ol>
          <li>Decode the notice canonically and check that its epochStart is a multiple of E. A malformed notice is discarded.</li>
          <li>Compute the partition of the named token for that epoch. If the verifier holds no current checkpoint for the stream, discard the notice.</li>
          <li>Verify the membership proof for the named token against the set commitment of that current checkpoint. If it verifies, create a terminal record for the token. Otherwise discard the notice.</li>
        </ol>
        <t>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.</t>
        <t>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 <bcp14>SHOULD</bcp14> precede a notice by the checkpoint that it was derived from, for instance as a checkpoint-only staple, when receivers might not hold it.</t>
        <t>A verifier <bcp14>MAY</bcp14> 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 <bcp14>MAY</bcp14> be evicted under memory pressure (<xref target="state-bounds"/>).</t>
      </section>
      <section anchor="list-mode">
        <name>List Mode</name>
        <t>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.</t>
        <ul>
          <li>Snapshot: process the checkpoint (<xref target="checkpoint-processing"/>), check that the tokens are in strictly increasing order and that their number plus one equals treeSize, and rebuild the root. The list is accepted only if the rebuilt root equals rootHash.</li>
          <li>Delta: after bounded preflight, the base checkpointId <bcp14>MUST</bcp14> identify the retained authenticated checkpoint of the held list. Authenticate the target checkpoint, require the same stream and a strictly greater version than the retained base TBS, and compare that base TBS with the target under the consistency rules even when the base was not the current checkpoint. An authenticated monotonicity violation sets the conflict barrier before stream advancement and retains both checkpoints with their actually authenticated signatures. Merge the inserted tokens, which <bcp14>MUST</bcp14> be in strictly increasing order and absent from the held list. Rebuild the root and compare it and the size with the target commitment. The merged list replaces the held one only if all checks pass.</li>
        </ul>
        <t>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 <bcp14>MUST NOT</bcp14> 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 (<xref target="audit"/>). A verifier that keeps lists applies the following rules in step 5 of <xref target="decision"/>:</t>
        <ul>
          <li>If X is in a held list of its partition, a terminal record is created and the outcome is REVOKED. Streams are insert-only, so membership in any validated list of the stream is final, even if the list is not the latest.</li>
          <li>If X is absent from a held list whose set commitment equals that of the current checkpoint of the stream, the proof cache records that commitment for X and the epoch. Rule 6 then applies as if the holder had presented a proof.</li>
          <li>If the set commitment of the held list differs from that of the current checkpoint, the list supports no affirmative result until the missing delta is applied.</li>
        </ul>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="failure">
        <name>Failure Semantics and Application Policy</name>
        <t>The verifier reports an outcome. The application status class (<xref target="classes"/>) maps it to an action. The following rules apply to every class.</t>
        <ul>
          <li>REVOKED and INVALID <bcp14>MUST</bcp14> cause rejection of the operation for any purpose that requires an unrevoked credential.</li>
          <li>INDETERMINATE and CONFLICT <bcp14>MUST NOT</bcp14> be treated as NOT_REVOKED_AT_SNAPSHOT. A class either rejects the operation or processes it in an explicitly degraded state such as UNCONFIRMED (<xref target="outcomes"/>).</li>
          <li>A class <bcp14>MUST NOT</bcp14> be selected, weakened, or bypassed in response to missing evidence, to a failure of another status mechanism, or to anything the peer supplies.</li>
          <li>A rate limit or a resource limit that prevents processing yields INDETERMINATE, never an affirmative result.</li>
        </ul>
        <t>A permissive class that maps INDETERMINATE to UNCONFIRMED does not enforce revocation against a holder that omits evidence. <xref target="omission"/> discusses this case and the role of notices and lists.</t>
      </section>
      <section anchor="state-bounds">
        <name>State Bounds</name>
        <t>An implementation <bcp14>MUST</bcp14> 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 (<xref target="time-floor"/>).</t>
        <t>Terminal records are bounded as follows. A record <bcp14>MAY</bcp14> be removed once the end of native validity has been established by a trustworthy lower bound on time, for example F &gt;= certNotAfter, and any required audit retention has ended. A conservative refusal based only on nowUpper &gt;= certNotAfter does not establish that expiry. A record created from a notice or a list for a credential that the verifier has not authenticated <bcp14>MAY</bcp14> 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 <bcp14>MUST NOT</bcp14> be evicted while that credential is valid. If such a record cannot be stored, the verifier <bcp14>MUST NOT</bcp14> return NOT_REVOKED_AT_SNAPSHOT for the domain until it can. Storage exhaustion fails closed.</t>
        <t>Unauthenticated input <bcp14>MUST NOT</bcp14> 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.</t>
      </section>
    </section>
    <section anchor="pocsp">
      <name>Relationship to pOCSP and Composition</name>
      <t>This section compares the profiles specified by this document and by draft-grund-v2x-pocsp-00 <xref target="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.</t>
      <section anchor="pocsp-models">
        <name>Evidence and Freshness Models</name>
        <t>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.</t>
        <t>Under the respective assumptions, pOCSP Section 5.3 states a stale-GOOD bound of D_status + W_max + Delta, while the SMRP bound in <xref target="bound"/> 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.</t>
        <t>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.</t>
      </section>
      <section anchor="pocsp-table">
        <name>Property Comparison</name>
        <table anchor="tab-compare-sem">
          <name>Comparison of the specified evidence profiles</name>
          <thead><tr><th>Property</th><th>pOCSP</th><th>SMRP</th></tr></thead>
          <tbody>
            <tr><td>Affirmative assertion</td><td>Known issuance and no authoritative revocation</td><td>Absence from an identified, authorized revoked-set snapshot</td></tr>
            <tr><td>Object authenticated by the status key</td><td>Individual certificate and context statement</td><td>Partition checkpoint shared by multiple queries</td></tr>
            <tr><td>Credential identification</td><td>Digest of the complete canonical certificate, with context-specific pID</td><td>Identity derived from issuer key, type, version, and canonical TBS</td></tr>
            <tr><td>Proof production</td><td>Authorized responder signs; untrusted caches can distribute the signed object</td><td>Authorized issuer signs the checkpoint; any list holder can construct witnesses</td></tr>
            <tr><td>Refresh while the underlying status is unchanged</td><td>New individual signed evidence for the required context</td><td>New shared checkpoint can renew a previously checked witness when the scoped commitment is unchanged</td></tr>
            <tr><td>Effect of another credential's revocation</td><td>Does not invalidate otherwise usable evidence for this certificate in the baseline</td><td>Adopting a changed commitment requires an absence witness for that commitment</td></tr>
            <tr><td>Negative status received from another party</td><td>Supported by Section 14.6; the target certificate is needed unless already held</td><td>Supported by a membership notice or validated list; the required checkpoint must be held</td></tr>
            <tr><td>Evidence size</td><td>Independent of revoked-population size for a fixed profile; depends on encoded fields and signature</td><td>Depends on height, boundary types, and whether the checkpoint is included</td></tr>
            <tr><td>State</td><td>Terminal and conflict state per certificate/domain epoch, plus context-specific cache</td><td>Terminal credential state, domain conflict state, stream checkpoints, and proof or list cache</td></tr>
            <tr><td>Usage policy</td><td>Context signed by the responder</td><td>Application class selected by verifier policy; the shared object is not restricted to one class</td></tr>
            <tr><td>Publication</td><td>No requirement to publish the entire revoked set</td><td>Snapshots and deltas enable independent construction and structural audit, and expose revoked tokens</td></tr>
            <tr><td>Certificate profiles</td><td>ITS and X.509 as specified in the pOCSP draft</td><td>ITS credentials covered by the identity profile in this document</td></tr>
            <tr><td>TLS carriage</td><td>Negotiated OCSP response type or the specified application exchange</td><td>Application exchange or the separately negotiated optional response type in <xref target="tls"/></td></tr>
          </tbody>
        </table>
        <t>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.</t>
      </section>
      <section anchor="pocsp-cost">
        <name>Conditional Cost Model</name>
        <t>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:</t>
        <sourcecode type="pseudocode"><![CDATA[
Q_pocsp ~= N_a * q / R_p
Q_smrp  ~= P * (1 + G/E) / T
]]></sourcecode>
        <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.</t>
        <t>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.</t>
        <t>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:</t>
        <sourcecode type="pseudocode"><![CDATA[
p_change(T) = 1 - exp(-lambda * w * T)
renewal_intervals_per_second = p_change(T) / T
]]></sourcecode>
        <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.</t>
        <t>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.</t>
        <t>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:</t>
        <sourcecode type="pseudocode"><![CDATA[
traffic_pocsp ~= V * f_p * B_p
traffic_smrp  ~= V * f_s * S + C * w_c * B_c
]]></sourcecode>
        <t>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.</t>
        <t><xref target="tab-evidence"/> 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.</t>
        <table anchor="tab-evidence">
          <name>Illustrative evidence octets with the 256-octet pOCSP GOOD vector</name>
          <thead>
            <tr><th>Revoked tokens in the partition (up to)</th><th>h</th><th>SMRP, proof-only</th><th>SMRP, full</th><th>pOCSP example only</th></tr>
          </thead>
          <tbody>
            <tr><td>0</td><td>0</td><td>18</td><td>245</td><td>256</td></tr>
            <tr><td>31</td><td>5</td><td>242</td><td>469</td><td>256</td></tr>
            <tr><td>1023</td><td>10</td><td>402</td><td>629</td><td>256</td></tr>
            <tr><td>32767</td><td>15</td><td>562</td><td>789</td><td>256</td></tr>
            <tr><td>1048575</td><td>20</td><td>722</td><td>949</td><td>256</td></tr>
          </tbody>
        </table>
        <t>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.</t>
      </section>
      <section anchor="pocsp-semantics">
        <name>Semantics, Identity, and Audit</name>
        <t>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.</t>
        <t>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.</t>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="pocsp-selection">
        <name>Selection Guidance</name>
        <t>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.</t>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="composition">
        <name>Composition Rules</name>
        <t>A deployment using more than one status mechanism <bcp14>MUST</bcp14> define its accepted sources, credential mapping, required predicates, failure handling, and recovery policy before processing evidence.</t>
        <ol>
          <li>An authenticated, authorized terminal revocation of the validated credential learned from any configured source <bcp14>MUST</bcp14> prevent every affirmative result for that credential. Source authorization, native credential binding, and administrative epoch checks remain mandatory; an unauthenticated status label does not create a terminal fact.</li>
          <li>The pOCSP full-certificate identifier and the SMRP credential identity are different. A composition implementation <bcp14>MUST</bcp14> establish their mapping from the validated certificate and selected issuer, retain sufficient stable identity and provenance for terminal facts, and consult those facts before an affirmative decision through either mechanism. Expiration or eviction of a status-evidence cache entry, or a representation change, <bcp14>MUST NOT</bcp14> clear those facts. This does not prohibit garbage collection once no mapped credential representation can still be natively valid and the applicable audit-retention period has ended.</li>
          <li>If policy requires both predicates, both <bcp14>MUST</bcp14> hold. If policy permits alternatives, the alternatives and freshness limits <bcp14>MUST</bcp14> be authenticated configuration. The profile <bcp14>MUST</bcp14> identify which conflicts and invalid-input conditions block all alternatives and which availability failures permit another configured path. It <bcp14>MUST NOT</bcp14> relabel a pOCSP conflict-derived INVALID result as a mere absence of evidence to bypass that policy.</li>
          <li>Each affirmative predicate retains its own provenance, absolute deadline, and native credential validity checks. One mechanism <bcp14>MUST NOT</bcp14> restart or extend the other's lifetime. Time conversion between pOCSP UTC values and the SMRP timescale <bcp14>MUST</bcp14> include its uncertainty.</li>
          <li>Unknown, missing, expired, or unavailable evidence is not a terminal revocation and <bcp14>MUST NOT</bcp14> clear one. A signed unknown pOCSP assertion is also not semantically identical to absence of a usable SMRP checkpoint.</li>
          <li>Clearing a terminal record or a conflict after compromise requires the explicitly authorized recovery procedure. A new key, new configuration number, ordinary cache eviction, or a favorable object from the other mechanism is insufficient. The recovery scope <bcp14>MUST</bcp14> preserve the distinctions between credential revocation, source compromise, and replacement of an administrative trust generation.</li>
        </ol>
        <t>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.</t>
      </section>
    </section>
    <section anchor="carriage">
      <name>V2X Carriage</name>
      <section anchor="binding">
        <name>Binding to the Authenticated Operation</name>
        <t>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.</t>
        <ul>
          <li>The verifier <bcp14>MUST</bcp14> derive the token from the credential that authenticates the operation. It <bcp14>MUST NOT</bcp14> accept a token, a partition, or a domain supplied beside the operation.</li>
          <li>A staple that a holder attaches to an operation <bcp14>MUST</bcp14> be covered by the signature of that operation, or a collision-resistant hash of its exact octets <bcp14>MUST</bcp14> be covered and the staple transported in the same authenticated unit. A staple is carried only in secured messages.</li>
          <li>The outcome INVALID is defined only for a staple bound in this way, since it identifies invalid evidence bound to the operation; it does not by itself establish malicious intent. SMRP objects received in any other way are third-party input: a checkpoint, a proof, or a notice that verifies is applied, and one that does not is discarded without effect on any outcome.</li>
          <li>Removal of a staple <bcp14>MUST NOT</bcp14> lead to an affirmative result. A class that tolerates missing evidence defines an explicit degraded state (<xref target="failure"/>).</li>
          <li>Application payload schemas are unchanged unless the responsible SDO defines an application extension.</li>
        </ul>
        <t>Relaying public evidence about another station does not give the relay any authority of that station.</t>
      </section>
      <section anchor="envelope">
        <name>ETSI TS 103 097 and IEEE 1609.2 Secured Envelope</name>
        <t>IEEE 1609.2 and ETSI TS 103 097 provide signed data structures and a contributed-extension mechanism in the header <xref target="IEEE1609.2"/> <xref target="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 <xref target="I-D.grund-v2x-pocsp"/> uses, so that a message can carry either evidence, or both, under one envelope profile.</t>
        <table anchor="fig-envelope">
          <name>Preferred secured-envelope carriage</name>
          <thead><tr><th>Field path within SignedData</th><th>Content</th></tr></thead>
          <tbody>
            <tr><td>tbsData.payload</td><td>CAM, DENM, or J2735 payload octets</td></tr>
            <tr><td>tbsData.headerInfo.contributedExtensions</td><td>SDO-allocated extension carrying COER(SmrpStaple)</td></tr>
            <tr><td>signer</td><td>SignerIdentifier; full certificate on evidence-bearing messages</td></tr>
            <tr><td>signature</td><td>SignedData signature validated by the enclosing IEEE 1609.2 profile</td></tr>
          </tbody>
        </table>
        <t>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.</t>
        <t>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 <bcp14>MUST NOT</bcp14> insert an unallocated value into production traffic or assume that existing receivers ignore an unrecognized extension.</t>
        <t>ETSI specifications define revocation for authority certificates through trust lists and CRLs <xref target="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.</t>
      </section>
      <section anchor="wrapper">
        <name>SAE Payloads and Signed Wrapper</name>
        <t>SAE J2735 application objects <xref target="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 <bcp14>MAY</bcp14> define a signed wrapper that contains the original payload octets and the staple. The wrapper <bcp14>MUST</bcp14> preserve the payload encoding octet for octet and <bcp14>MUST</bcp14> 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.</t>
        <t>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 <bcp14>MUST</bcp14> account for such receivers in its safety policy.</t>
      </section>
      <section anchor="omission-cert">
        <name>Certificate Omission and Privacy-Aware Scheduling</name>
        <t>V2X senders alternate messages that carry the full signer certificate with messages that carry only its digest. In a pseudonym-privacy profile:</t>
        <ul>
          <li>a staple <bcp14>MUST</bcp14> accompany the full certificate in the same authenticated envelope and <bcp14>MUST NOT</bcp14> be sent more frequently than the full certificate;</li>
          <li>a holder <bcp14>MUST NOT</bcp14> transmit a proof for a credential other than the one that signs the message, and <bcp14>MUST NOT</bcp14> publish proofs of its future credentials together.</li>
        </ul>
        <t>A message that carries only a digest is evaluated from the state of the verifier (<xref target="decision"/>), 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.</t>
        <t>Staple repetition is coordinated with the certificate-inclusion and congestion-control rules of the deployment. This document assumes no fixed certificate or message rate.</t>
      </section>
      <section anchor="classes">
        <name>Application Status Classes</name>
        <t>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.</t>
        <t>The classes below correspond to the V2X profiles of <xref target="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 (<xref target="pocsp-models"/>). 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.</t>
        <table anchor="tab-classes">
          <name>Application status classes</name>
          <thead>
            <tr><th>Class</th><th>Default Aapp</th><th>INDETERMINATE or CONFLICT</th></tr>
          </thead>
          <tbody>
            <tr><td>awareness (CAM, BSM)</td><td>600 s</td><td>UNCONFIRMED; automated safety control <bcp14>SHOULD</bcp14> require NOT_REVOKED_AT_SNAPSHOT</td></tr>
            <tr><td>strict (DENM, SRM, SSM)</td><td>300 s</td><td>Reject for automated critical processing</td></tr>
            <tr><td>infrastructure (SPaT, MAP)</td><td>300 s</td><td>Reject or mark unusable according to operator policy</td></tr>
          </tbody>
        </table>
        <t>For a target D on the delay of <xref target="bound"/>, a class satisfies Aapp &lt;= D - L. The message types are those of <xref target="ETSICAM"/>, <xref target="ETSIDENM"/>, and <xref target="SAEJ2735"/>. Evidence carriage follows <xref target="omission-cert"/> 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.</t>
        <t>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 (<xref target="deadline"/>).</t>
      </section>
      <section anchor="lower-size">
        <name>Size Limits of Lower Layers</name>
        <t>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 <xref target="ETSI302636"/>. A deployment <bcp14>MUST</bcp14> 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 &lt;= B, and a full staple when 309 + 32 * h &lt;= 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 (<xref target="tradeoff"/>).</t>
      </section>
    </section>
    <section anchor="tls">
      <name>TLS 1.3 and Persistent Authentication Contexts</name>
      <t>TLS 1.3 is specified by <xref target="RFC9846"/>. <xref target="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 <xref target="credential-identity"/>, 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.</t>
      <section anchor="tls-app">
        <name>Application-Layer Exchange</name>
        <t>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 <xref target="verifier"/>. 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.</t>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="tls-status">
        <name>Optional Encapsulation in status_request</name>
        <t>TLS 1.3 carries certificate status in the status_request extension of the CertificateEntry <xref target="RFC6066"/> <xref target="RFC9846"/>, as a DER-encoded OCSPResponse <xref target="RFC6960"/>. The ResponseBytes of an OCSPResponse identify a response type and carry an octet string whose content that type defines. This subsection defines an <bcp14>OPTIONAL</bcp14> 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 <xref target="tls-app"/>.</t>
        <sourcecode type="asn.1"><![CDATA[
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 }
]]></sourcecode>
        <ol>
          <li>For server-certificate status, the client lists id-pkix-ocsp-smrp in the AcceptableResponses extension (Section 4.4.3 of <xref target="RFC6960"/>) of its OCSPStatusRequest.request_extensions. It <bcp14>MAY</bcp14> also list id-pkix-ocsp-basic and the pOCSP response type. A server <bcp14>MUST NOT</bcp14> infer SMRP support from status_request alone and <bcp14>MUST NOT</bcp14> staple an SMRP response unless id-pkix-ocsp-smrp was offered or an authenticated out-of-band profile establishes equivalent capability.</li>
          <li>For client-certificate status, the server requests stapling with an empty status_request extension in its CertificateRequest. That form cannot carry AcceptableResponses. The client therefore includes an SMRP response only when an authenticated TLS profile or out-of-band configuration has established that the server supports it.</li>
          <li>The response is DER encoded. The octet string contains exactly one COER SmrpStaple, which <bcp14>SHOULD</bcp14> be a full staple, since the peer might hold no checkpoint. A responseStatus other than successful, trailing octets, or an indefinite or non-minimal length is INVALID.</li>
          <li>The endpoint applies <xref target="verifier"/> in addition to the certificate validation of TLS and of <xref target="RFC8902"/>. The CertificateEntry is protected by the transcript, which satisfies <xref target="binding"/>.</li>
          <li>A client that obtains REVOKED aborts the handshake with a certificate_revoked alert. A client that obtains INVALID, or INDETERMINATE or CONFLICT where its policy requires an affirmative result, aborts with a bad_certificate_status_response alert. A server that validates client evidence uses certificate_revoked and bad_certificate respectively.</li>
        </ol>
        <t>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 (<xref target="configuration"/>).</t>
        <t>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 <bcp14>MUST NOT</bcp14> label an SMRP staple with another response type.</t>
      </section>
      <section anchor="tls-long">
        <name>Resumption, Long-Lived Connections, 0-RTT, and QUIC</name>
        <t>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.</t>
        <t>Obtaining a new status does not necessarily involve the peer. The verifier evaluates the decision of <xref target="decision"/> 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.</t>
        <t>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 <bcp14>MUST</bcp14> 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.</t>
        <t>An operation whose authorization requires certificate status <bcp14>MUST NOT</bcp14> be executed irreversibly in 0-RTT before the required status and the replay controls of <xref target="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 <xref target="RFC9001"/>, and this document does not relax that restriction.</t>
        <t>TLS Exported Authenticators <xref target="RFC9261"/> provide additional channel-bound authentication for X.509 certificates only. Using them with ITS credentials and SMRP would require a separately specified extension.</t>
      </section>
    </section>
    <section anchor="engineering">
      <name>Operational Engineering Guidance</name>
      <t>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.</t>
      <section anchor="params">
        <name>Parameter Selection</name>
        <t>The parameters are chosen in the following order.</t>
        <ol>
          <li>Exposure. For a target D on the delay between a revocation decision and the end of affirmative results, choose the maximum snapshot age so that A &lt;= D - L (<xref target="bound"/>). The bound assumes an honest, complete issuer and trustworthy time; A alone does not constrain a compromised issuer that lies about its cutoff. A shorter lifetime W yields an additional decision-relative bound only if a maximum true cutoff-to-issuance delay D_issue is established: the resulting bound is L + D_issue + a + W (<xref target="proofs-bound"/>).</li>
          <li>Continuity. Under a fixed clock offset and error bound, and when key, epoch, certificate and application limits do not shorten the interval, the nominal usable width in clock readings is U = max(0, min(W, A - a - d) - a - 2v), where d = thisUpdate - snapshotTime. Continuous service additionally requires delivered admissible intervals to overlap. A periodic no-loss model can use T + x &lt;= U as a planning check; tolerating one skipped issuance requires 2T + x &lt;= U. These are conditional scheduling calculations, not guarantees under arbitrary loss or clock changes.</li>
          <li>Epoch. Every holder must establish evidence for each applicable epoch. The partition mapping and scoped set may change. If the new authorized commitment happens to be identical, the same witness bytes can be reused after validation; such coincidence is not a renewal strategy. The epoch duration E is chosen from credential lifetimes, the union of credentials in scope, state limits, and renewal load; it is independent of the checkpoint issuance period. A long epoch keeps in the set the tokens of credentials that expire during the epoch. That cost is bounded by the number of revoked credentials that expire in one epoch.</li>
          <li>Lead. The lead G is chosen with the start-time and refresh-coverage conditions of <xref target="epoch-transition"/>, including issuance and distribution delays and the interval over which holders spread retrieval. Early availability alone does not ensure that evidence remains usable at the boundary.</li>
          <li>Partitions. The number of partition bits k is chosen with <xref target="tradeoff"/>, and maxTreeSize with the occupancy model below.</li>
        </ol>
        <t>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.</t>
      </section>
      <section anchor="authority-cost">
        <name>Issuer and Distribution-Point Cost</name>
        <t>The issuer signs one checkpoint per stream and period (<xref target="issuer-processing"/>). The leaf index is part of every leaf hash, so an insertion changes the hashes of all leaves that follow the inserted token. Building a tree requires m interval-leaf hashes, M - m padding hashes, and M - 1 node hashes. For m &gt;= 2, the two sentinel leaves use one SHA-256 compression block each, other interval leaves use two, padding uses one, and internal nodes use two: the total is m + 3 * M - 4 compression calls. The empty tree uses one call. For example, m = 17 and M = 32 require 109 compression calls, not the 98 obtained by omitting part of the padding cost. The largest tree requires 4 * 2^20 - 4 calls. The raw stored hash levels occupy 32 * (2 * M - 1) octets, excluding tokens, indices, language objects and allocator overhead. A checkpoint that only refreshes the times of an unchanged set requires no tree work.</t>
        <t>A distribution point reads h stored hashes and two boundaries to serve a proof. With stored tree levels, serving a proof requires lookup and serialization but no new Merkle hashes or signature generation. The size of a snapshot is 32 octets per revoked token plus one checkpoint, and that of a delta is 32 octets per inserted token plus one checkpoint and one identifier.</t>
      </section>
      <section anchor="scheduling">
        <name>Channel Load and Staple Scheduling</name>
        <t>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:</t>
        <sourcecode type="pseudocode"><![CDATA[
V * f * S  +  236 * w * C
]]></sourcecode>
        <t>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.</t>
        <t>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) &lt; B_p. At h = 5, S = 242 and B_p = 256, even one checkpoint per second requires V * f &gt; 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.</t>
      </section>
      <section anchor="tradeoff">
        <name>Partitioning Trade-Off</name>
        <t><xref target="tab-shard"/> 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 (<xref target="pocsp-cost"/>).</t>
        <table anchor="tab-shard">
          <name>Effect of the number of partition bits (illustrative)</name>
          <thead>
            <tr><th>k</th><th>Tokens per partition</th><th>h</th><th>Proof-only octets</th><th>Checkpoints signed per second</th><th>Distinct checkpoints among 50 stations</th><th>Proof superseded per period</th></tr>
          </thead>
          <tbody>
            <tr><td>0</td><td>100000</td><td>17</td><td>626</td><td>0.0333</td><td>1</td><td>0.259</td></tr>
            <tr><td>4</td><td>6250</td><td>13</td><td>498</td><td>0.533</td><td>15.4</td><td>0.195</td></tr>
            <tr><td>8</td><td>391</td><td>9</td><td>370</td><td>8.53</td><td>45.5</td><td>0.0223</td></tr>
            <tr><td>12</td><td>24.4</td><td>5</td><td>242</td><td>137</td><td>49.7</td><td>0.00146</td></tr>
            <tr><td>16</td><td>1.53</td><td>2</td><td>146</td><td>2185</td><td>50.0</td><td>0.000092</td></tr>
          </tbody>
        </table>
        <t>Three observations follow.</t>
        <ul>
          <li>Each partition bit halves mean occupancy under uniform hashing and doubles the number of periodic checkpoints. Integer heights, occupancy variation, and sentinel boundaries prevent a deterministic 32-octet reduction for every proof. At k = 16 the issuer of this example signs about 2185 checkpoints per second, and almost every station in the 50-station example depends on a distinct checkpoint. A comparison with individual status additionally needs its active certificate population, context count, and renewal interval.</li>
          <li>Partitioning reduces the modeled rate continuously, but the effect is small while nearly every event touches a given partition. An event that inserts P tokens changes a given partition with probability 1 - (1 - 2^-k)^P, which stays close to 1 while 2^k is below P.</li>
          <li>The shared checkpoint is what distinguishes SMRP from a per-certificate statement. Sharing is strongest at k = 0 for one domain and epoch, and weakens as distinct observed credentials occupy distinct partitions. A deployment can start with the smallest k for which proofs fit the data unit (<xref target="lower-size"/>) and the modeled renewal load is acceptable, then evaluate authority capacity, privacy, and delivery costs. This is a planning heuristic, not an optimality result.</li>
        </ul>
      </section>
      <section anchor="loss">
        <name>Loss, Warm-Up, and Shared Freshness</name>
        <t>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.</t>
        <t>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.</t>
        <t>A checkpoint refresh reaches all cached proofs at once (<xref target="decision"/>). 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.</t>
        <t>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.</t>
      </section>
      <section anchor="time-sources">
        <name>Time Sources</name>
        <t>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 <bcp14>SHOULD</bcp14> 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 (<xref target="time-floor"/>): the verifier can still return REVOKED, INVALID, and CONFLICT, and otherwise returns INDETERMINATE.</t>
        <t>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.</t>
      </section>
    </section>
    <section anchor="security">
      <name>Security Considerations</name>
      <section anchor="soundness">
        <name>Soundness and Its Limits</name>
        <t>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. <xref target="proofs"/> gives the argument and counterexamples to weakened rules.</t>
        <t>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.</t>
        <ul>
          <li>Structure. The tokens are sorted, the intervals are consecutive, the sentinels are in place, and the padding is as specified. The root is a deterministic function of the token list, so any list holder verifies all of this by rebuilding the root (<xref target="list-mode"/>). A verifier that sees only proofs cannot.</li>
          <li>Completeness and timeliness. Every applicable revoked token is in the set as of the stated cutoff. No party can verify this from the commitment. It rests on the issuer and on the process that feeds it (assumptions A2, A3, and A9).</li>
        </ul>
        <t>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.</t>
      </section>
      <section anchor="replay">
        <name>Replay, Freezing, and Eclipse</name>
        <t>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.</t>
        <t>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.</t>
        <t>Message-level replay protection, generation-time checks, sequence logic, geographic plausibility, and application consistency remain necessary. SMRP asserts certificate status only.</t>
      </section>
      <section anchor="compromise">
        <name>Compromise of a Checkpoint Key</name>
        <t>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.</t>
        <t>The countermeasures are operational. At a fixed partition count and issuance schedule, a deployment can provision signing capacity and monitor departures from that schedule (<xref target="issuer-processing"/>). 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 (<xref target="checkpoint-processing"/>). Recovery is an authenticated configuration with a greater authority epoch that removes the key (<xref target="admin"/>). Accepting a still larger version from an untrusted source is never a recovery.</t>
        <t>Terminal records created from forged checkpoints are false revocations. A verifier <bcp14>SHOULD</bcp14> 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 <bcp14>MUST NOT</bcp14> clear a terminal record. False revocations of pseudonym certificates otherwise end with the validity of those certificates.</t>
      </section>
      <section anchor="audit">
        <name>Equivocation and Audit</name>
        <t>Everything the issuer signs is public, and the complete status of a partition is one list. This allows three levels of audit.</t>
        <ul>
          <li>A list holder checks the structure of every snapshot and, through deltas, that every transition only inserts tokens (<xref target="snapshot"/>). A removal within an epoch, a reordering, or a gap in the intervals changes the root and is detected.</li>
          <li>Any two parties that exchange the checkpoints they hold for a stream detect contradictory statements with the consistency rules of <xref target="checkpoint-processing"/>. The two checkpoints form evidence that a third party can verify with the configuration alone.</li>
          <li>A party that knows of a revocation decision checks that the token appears in the snapshots whose cutoff follows the decision by more than L.</li>
        </ul>
        <t>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 <xref target="RFC9162"/>, which is outside the scope of this document.</t>
      </section>
      <section anchor="omission">
        <name>Evidence Omission and Stripping</name>
        <t>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 <bcp14>SHOULD</bcp14> restrict automated or high-impact actions.</t>
        <t>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 (<xref target="notice-processing"/>). 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.</t>
        <t>Stripping a staple from a message in transit is detectable when the staple is covered by the signature of the message (<xref target="binding"/>): the message no longer verifies. An attacker can still suppress whole messages.</t>
      </section>
      <section anchor="identity-sec">
        <name>Credential Identity and Collisions</name>
        <t>The token does not depend on the signature octets of the certificate (<xref target="credential-identity"/>). 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.</t>
        <t>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.</t>
      </section>
      <section anchor="dos">
        <name>Denial of Service and Parser Behavior</name>
        <t>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.</t>
        <t>A verifier <bcp14>SHOULD</bcp14> perform the checks that need no signature first (<xref target="checkpoint-processing"/>), cache authenticated checkpoints by checkpointId, and limit the signature verifications that it performs per source and in total. A verifier <bcp14>MAY</bcp14> 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 <bcp14>MUST NOT</bcp14> turn missing evidence into an affirmative result.</t>
        <t>A party that installs a snapshot or a delta <bcp14>MUST</bcp14> bound both input length and token count before general decoding and <bcp14>MUST</bcp14> authenticate its checkpoint before tree reconstruction (<xref target="snapshot"/>). The configured tree limit and per-source and aggregate work limits remain necessary for authenticated, repeatedly supplied objects.</t>
        <t>ASN.1 decoders <bcp14>MUST</bcp14> 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.</t>
        <t>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 <bcp14>MUST NOT</bcp14> keep accepting a superseded result to conceal it. Batching insertions over the issuance period bounds the effect to one renewal per period.</t>
      </section>
      <section anchor="agility">
        <name>Algorithm Agility and Large Signatures</name>
        <t>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 (<xref target="iana"/>), new object sizes, and an explicit migration. Implementations <bcp14>MUST NOT</bcp14> accept an algorithm that the configured profile does not define.</t>
        <t>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 <xref target="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 <xref target="I-D.ietf-plants-merkle-tree-certs"/>.</t>
        <t>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.</t>
      </section>
      <section anchor="safety">
        <name>Availability and Safety Claims</name>
        <t>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.</t>
        <t>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.</t>
      </section>
    </section>
    <section anchor="privacy">
      <name>Privacy Considerations</name>
      <t>This section follows the approach of <xref target="RFC6973"/>. Pseudonym schemes are surveyed in <xref target="PETIT2015"/>.</t>
      <t>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.</t>
      <t>On the air. A staple accompanies the full certificate and is never sent more often (<xref target="omission-cert"/>). 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.</t>
      <t>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.</t>
      <t>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 (<xref target="holder-processing"/>). A holder that uses proof retrieval <bcp14>SHOULD NOT</bcp14> request proofs for several of its credentials in a way that links them, and <bcp14>SHOULD NOT</bcp14> retrieve the proof of a pseudonym long before using it from an origin that identifies the vehicle. Distribution points <bcp14>MUST NOT</bcp14> require holder authentication (<xref target="dp-processing"/>) and <bcp14>SHOULD</bcp14> 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.</t>
      <t>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.</t>
      <t>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.</t>
      <t>Revocation governance, identity resolution, and the privacy effect of the decision to revoke are deployment responsibilities outside this protocol.</t>
    </section>
    <section anchor="iana">
      <name>IANA Considerations</name>
      <section anchor="iana-profiles">
        <name>SMRP Profile Identifiers Registry</name>
        <t>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 <xref target="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.</t>
        <t>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 <bcp14>MUST NOT</bcp14> 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 <bcp14>MUST</bcp14> reject a reserved or unimplemented profile even if the identifier appears in an installed configuration.</t>
        <t>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 <bcp14>MUST NOT</bcp14> treat the two values as aliases and <bcp14>MUST NOT</bcp14> clear terminal records during that migration.</t>
        <t>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.</t>
      </section>
      <section anchor="iana-ocsp">
        <name>OCSP Response Type</name>
        <t>For the optional encapsulation of <xref target="tls-status"/>, 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 <xref target="RFC7299"/> and <xref target="RFC8126"/>:</t>
        <table anchor="tab-iana-ocsp">
          <name>OCSP response-type request</name>
          <thead>
            <tr><th>Value</th><th>Description</th><th>Reference</th></tr>
          </thead>
          <tbody>
            <tr><td>TBD2</td><td>id-pkix-ocsp-smrp</td><td>This document</td></tr>
          </tbody>
        </table>
        <t>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 <xref target="RFC5612"/>, which <bcp14>MUST NOT</bcp14> appear in a deployment.</t>
      </section>
      <section anchor="iana-none">
        <name>No Other Actions</name>
        <t>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 <xref target="asn1"/> has no module object identifier and needs none for compilation or for opaque carriage.</t>
      </section>
    </section>
    <section anchor="summary">
      <name>Summary of Normative Requirements</name>
      <t>This section collects the principal requirements by role. The referenced sections are authoritative.</t>
      <t>Checkpoint issuer:</t>
      <ul>
        <li>The set of each stream <bcp14>MUST</bcp14> be complete for its scope as of snapshotTime, built exactly as specified, and insert-only within the stream (<xref target="set-scope"/>, <xref target="tree-build"/>, and <xref target="issuance"/>).</li>
        <li>snapshotTime and thisUpdate <bcp14>MUST NOT</bcp14> exceed the issuer's clock, versions <bcp14>MUST</bcp14> be unique and increasing, and the snapshot <bcp14>MUST</bcp14> be durable before the checkpoint is released (<xref target="issuance"/> and <xref target="issuer-processing"/>).</li>
        <li>An overfull partition <bcp14>MUST NOT</bcp14> be truncated, and an empty set <bcp14>MUST</bcp14> still be published (<xref target="partition"/> and <xref target="tree-build"/>).</li>
        <li>Signatures <bcp14>MUST</bcp14> use the low-S form over the prefixed TBS (<xref target="signature"/>).</li>
      </ul>
      <t>Distribution point and holder:</t>
      <ul>
        <li>A distribution point <bcp14>MUST</bcp14> validate a snapshot before serving from it and <bcp14>MUST NOT</bcp14> require holder authentication (<xref target="dp-processing"/>).</li>
        <li>A holder <bcp14>MUST</bcp14> verify its evidence before stapling it, <bcp14>MUST</bcp14> send a staple only with the full certificate and under the signature of the message, and <bcp14>MUST NOT</bcp14> transmit proofs of other credentials (<xref target="holder-processing"/>, <xref target="binding"/>, and <xref target="omission-cert"/>).</li>
      </ul>
      <t>Verifier:</t>
      <ul>
        <li>The domain, the token, and the partition <bcp14>MUST</bcp14> be derived from the validated credential and the installed configuration, never from the evidence (<xref target="domain"/> to <xref target="partition"/>).</li>
        <li>Checkpoint keys <bcp14>MUST</bcp14> come from the configuration, and a configuration change <bcp14>MUST</bcp14> carry a greater authority epoch (<xref target="roles"/> and <xref target="admin"/>).</li>
        <li>Decoding <bcp14>MUST</bcp14> be canonical and bounded (<xref target="encoding"/>).</li>
        <li>Time <bcp14>MUST</bcp14> be handled as an interval with a protected floor, and deadlines are absolute and exclusive (<xref target="time-floor"/> to <xref target="deadline"/>).</li>
        <li>The status <bcp14>MUST</bcp14> be computed from state against the current checkpoint of the stream, with the order of rules of <xref target="decision"/>. A terminal record or a conflict barrier is never overridden by evidence.</li>
        <li>Contradictory checkpoints <bcp14>MUST</bcp14> set the conflict barrier and be retained (<xref target="checkpoint-processing"/>).</li>
        <li>State <bcp14>MUST</bcp14> be bounded, unauthenticated input <bcp14>MUST NOT</bcp14> allocate state, and storage exhaustion fails closed (<xref target="state-bounds"/>).</li>
        <li>INDETERMINATE and CONFLICT <bcp14>MUST NOT</bcp14> be treated as affirmative, and a class <bcp14>MUST NOT</bcp14> be weakened in response to missing evidence (<xref target="failure"/>).</li>
      </ul>
      <t>Composition and carriage:</t>
      <ul>
        <li>A revocation learned through any trusted mechanism dominates, and it is applied to the credential identity (<xref target="composition"/>).</li>
        <li>Unallocated extension identifiers <bcp14>MUST NOT</bcp14> be used in production traffic, and an SMRP staple <bcp14>MUST NOT</bcp14> be labeled with another OCSP response type (<xref target="envelope"/> and <xref target="tls-status"/>).</li>
      </ul>
    </section>
  </middle>
  <back>
    <references>
      <name>References</name>
      <references>
        <name>Normative References</name>
        <reference anchor="RFC2119" target="https://www.rfc-editor.org/info/rfc2119">
          <front>
            <title>Key words for use in RFCs to Indicate Requirement Levels</title>
            <author initials="S." surname="Bradner"/>
            <date month="March" year="1997"/>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="2119"/>
          <seriesInfo name="DOI" value="10.17487/RFC2119"/>
        </reference>
        <reference anchor="RFC6066" target="https://www.rfc-editor.org/info/rfc6066">
          <front>
            <title>Transport Layer Security (TLS) Extensions: Extension Definitions</title>
            <author initials="D." surname="Eastlake 3rd"/>
            <date month="January" year="2011"/>
          </front>
          <seriesInfo name="RFC" value="6066"/>
          <seriesInfo name="DOI" value="10.17487/RFC6066"/>
        </reference>
        <reference anchor="RFC6960" target="https://www.rfc-editor.org/info/rfc6960">
          <front>
            <title>X.509 Internet Public Key Infrastructure Online Certificate Status Protocol - OCSP</title>
            <author initials="S." surname="Santesson"/>
            <author initials="M." surname="Myers"/>
            <author initials="R." surname="Ankney"/>
            <author initials="A." surname="Malpani"/>
            <author initials="S." surname="Galperin"/>
            <author initials="C." surname="Adams"/>
            <date month="June" year="2013"/>
          </front>
          <seriesInfo name="RFC" value="6960"/>
          <seriesInfo name="DOI" value="10.17487/RFC6960"/>
        </reference>
        <reference anchor="RFC7299" target="https://www.rfc-editor.org/info/rfc7299">
          <front>
            <title>Object Identifier Registry for the PKIX Working Group</title>
            <author initials="R." surname="Housley"/>
            <date month="July" year="2014"/>
          </front>
          <seriesInfo name="RFC" value="7299"/>
          <seriesInfo name="DOI" value="10.17487/RFC7299"/>
        </reference>
        <reference anchor="RFC8126" target="https://www.rfc-editor.org/info/rfc8126">
          <front>
            <title>Guidelines for Writing an IANA Considerations Section in RFCs</title>
            <author initials="M." surname="Cotton"/>
            <author initials="B." surname="Leiba"/>
            <author initials="T." surname="Narten"/>
            <date month="June" year="2017"/>
          </front>
          <seriesInfo name="BCP" value="26"/>
          <seriesInfo name="RFC" value="8126"/>
          <seriesInfo name="DOI" value="10.17487/RFC8126"/>
        </reference>
        <reference anchor="RFC8174" target="https://www.rfc-editor.org/info/rfc8174">
          <front>
            <title>Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words</title>
            <author initials="B." surname="Leiba"/>
            <date month="May" year="2017"/>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="8174"/>
          <seriesInfo name="DOI" value="10.17487/RFC8174"/>
        </reference>
        <reference anchor="RFC8902" target="https://www.rfc-editor.org/info/rfc8902">
          <front>
            <title>TLS Authentication Using Intelligent Transport System (ITS) Certificates</title>
            <author initials="M." surname="Msahli" role="editor"/>
            <author initials="N." surname="Cam-Winget" role="editor"/>
            <author initials="W." surname="Whyte" role="editor"/>
            <author initials="A." surname="Serhrouchni"/>
            <author initials="H." surname="Labiod"/>
            <date month="September" year="2020"/>
          </front>
          <seriesInfo name="RFC" value="8902"/>
          <seriesInfo name="DOI" value="10.17487/RFC8902"/>
        </reference>
        <reference anchor="RFC9846" target="https://www.rfc-editor.org/info/rfc9846">
          <front>
            <title>The Transport Layer Security (TLS) Protocol Version 1.3</title>
            <author initials="E." surname="Rescorla"/>
            <date month="July" year="2026"/>
          </front>
          <seriesInfo name="RFC" value="9846"/>
          <seriesInfo name="DOI" value="10.17487/RFC9846"/>
        </reference>
        <reference anchor="FIPS180-4" target="https://doi.org/10.6028/NIST.FIPS.180-4">
          <front>
            <title>Secure Hash Standard (SHS)</title>
            <author>
              <organization>National Institute of Standards and Technology</organization>
            </author>
            <date month="August" year="2015"/>
          </front>
          <seriesInfo name="FIPS" value="180-4"/>
          <seriesInfo name="DOI" value="10.6028/NIST.FIPS.180-4"/>
        </reference>
        <reference anchor="FIPS186-5" target="https://doi.org/10.6028/NIST.FIPS.186-5">
          <front>
            <title>Digital Signature Standard (DSS)</title>
            <author>
              <organization>National Institute of Standards and Technology</organization>
            </author>
            <date month="February" year="2023"/>
          </front>
          <seriesInfo name="FIPS" value="186-5"/>
          <seriesInfo name="DOI" value="10.6028/NIST.FIPS.186-5"/>
        </reference>
        <reference anchor="SEC1" target="https://www.secg.org/sec1-v2.pdf">
          <front>
            <title>SEC 1: Elliptic Curve Cryptography</title>
            <author>
              <organization>Certicom Research</organization>
            </author>
            <date month="May" year="2009"/>
          </front>
          <seriesInfo name="Version" value="2.0"/>
        </reference>
        <reference anchor="X680">
          <front>
            <title>Information technology - Abstract Syntax Notation One (ASN.1): Specification of basic notation</title>
            <author>
              <organization>ITU-T</organization>
            </author>
            <date month="February" year="2021"/>
          </front>
          <seriesInfo name="ITU-T Recommendation" value="X.680"/>
        </reference>
        <reference anchor="X696">
          <front>
            <title>Information technology - ASN.1 encoding rules: Specification of Octet Encoding Rules (OER)</title>
            <author>
              <organization>ITU-T</organization>
            </author>
            <date month="February" year="2021"/>
          </front>
          <seriesInfo name="ITU-T Recommendation" value="X.696"/>
        </reference>
        <reference anchor="IEEE1609.2">
          <front>
            <title>IEEE Standard for Wireless Access in Vehicular Environments--Security Services for Application and Management Messages</title>
            <author>
              <organization>IEEE</organization>
            </author>
          </front>
          <seriesInfo name="IEEE Std" value="1609.2-2025"/>
        </reference>
        <reference anchor="ETSI103097">
          <front>
            <title>Intelligent Transport Systems (ITS); Security; Security header and certificate formats</title>
            <author>
              <organization>ETSI</organization>
            </author>
            <date month="March" year="2026"/>
          </front>
          <seriesInfo name="ETSI TS" value="103 097 V2.2.1"/>
        </reference>
      </references>
      <references>
        <name>Informative References</name>
        <reference anchor="I-D.grund-v2x-pocsp" target="https://datatracker.ietf.org/doc/html/draft-grund-v2x-pocsp-00">
          <front>
            <title>Pseudonymous Stapled Certificate Status Evidence for V2X and TLS with ITS Certificates (pOCSP)</title>
            <author initials="J.-J." surname="Grund"/>
            <author initials="R." surname="Khatoun"/>
            <author initials="G." surname="Pujolle"/>
            <author initials="A." surname="Serhrouchni"/>
            <date day="14" month="November" year="2026"/>
          </front>
          <seriesInfo name="Internet-Draft" value="draft-grund-v2x-pocsp-00"/>
          <refcontent>Work in Progress</refcontent>
        </reference>
        <reference anchor="I-D.ietf-plants-merkle-tree-certs" target="https://datatracker.ietf.org/doc/html/draft-ietf-plants-merkle-tree-certs-08">
      <front><title>Merkle Tree Certificates</title><author initials="D." surname="Benjamin"/><author initials="D." surname="O'Brien"/><author initials="B. E." surname="Westerbaan"/><author initials="L." surname="Valenta"/><author initials="F." surname="Valsorda"/><date year="2026" month="November" day="2"/></front>
      <seriesInfo name="Internet-Draft" value="draft-ietf-plants-merkle-tree-certs-08"/><refcontent>Work in Progress</refcontent>
    </reference>
        <reference anchor="RFC5280" target="https://www.rfc-editor.org/info/rfc5280">
          <front>
            <title>Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile</title>
            <author initials="D." surname="Cooper"/>
            <author initials="S." surname="Santesson"/>
            <author initials="S." surname="Farrell"/>
            <author initials="S." surname="Boeyen"/>
            <author initials="R." surname="Housley"/>
            <author initials="W." surname="Polk"/>
            <date month="May" year="2008"/>
          </front>
          <seriesInfo name="RFC" value="5280"/>
          <seriesInfo name="DOI" value="10.17487/RFC5280"/>
        </reference>
        <reference anchor="RFC5612" target="https://www.rfc-editor.org/info/rfc5612">
          <front>
            <title>Enterprise Number for Documentation Use</title>
            <author initials="P." surname="Eronen"/>
            <author initials="D." surname="Harrington"/>
            <date month="August" year="2009"/>
          </front>
          <seriesInfo name="RFC" value="5612"/>
          <seriesInfo name="DOI" value="10.17487/RFC5612"/>
        </reference>
        <reference anchor="RFC6206" target="https://www.rfc-editor.org/info/rfc6206">
          <front>
            <title>The Trickle Algorithm</title>
            <author initials="P." surname="Levis"/>
            <author initials="T." surname="Clausen"/>
            <author initials="J." surname="Hui"/>
            <author initials="O." surname="Gnawali"/>
            <author initials="J." surname="Ko"/>
            <date month="March" year="2011"/>
          </front>
          <seriesInfo name="RFC" value="6206"/>
          <seriesInfo name="DOI" value="10.17487/RFC6206"/>
        </reference>
        <reference anchor="RFC6973" target="https://www.rfc-editor.org/info/rfc6973">
          <front>
            <title>Privacy Considerations for Internet Protocols</title>
            <author initials="A." surname="Cooper"/>
            <author initials="H." surname="Tschofenig"/>
            <author initials="B." surname="Aboba"/>
            <author initials="J." surname="Peterson"/>
            <author initials="J." surname="Morris"/>
            <author initials="M." surname="Hansen"/>
            <author initials="R." surname="Smith"/>
            <date month="July" year="2013"/>
          </front>
          <seriesInfo name="RFC" value="6973"/>
          <seriesInfo name="DOI" value="10.17487/RFC6973"/>
        </reference>
        <reference anchor="RFC6979" target="https://www.rfc-editor.org/info/rfc6979">
          <front>
            <title>Deterministic Usage of the Digital Signature Algorithm (DSA) and Elliptic Curve Digital Signature Algorithm (ECDSA)</title>
            <author initials="T." surname="Pornin"/>
            <date month="August" year="2013"/>
          </front>
          <seriesInfo name="RFC" value="6979"/>
          <seriesInfo name="DOI" value="10.17487/RFC6979"/>
        </reference>
        <reference anchor="RFC9001" target="https://www.rfc-editor.org/info/rfc9001">
          <front>
            <title>Using TLS to Secure QUIC</title>
            <author initials="M." surname="Thomson" role="editor"/>
            <author initials="S." surname="Turner" role="editor"/>
            <date month="May" year="2021"/>
          </front>
          <seriesInfo name="RFC" value="9001"/>
          <seriesInfo name="DOI" value="10.17487/RFC9001"/>
        </reference>
        <reference anchor="RFC9162" target="https://www.rfc-editor.org/info/rfc9162">
          <front>
            <title>Certificate Transparency Version 2.0</title>
            <author initials="B." surname="Laurie"/>
            <author initials="E." surname="Messeri"/>
            <author initials="R." surname="Stradling"/>
            <date month="December" year="2021"/>
          </front>
          <seriesInfo name="RFC" value="9162"/>
          <seriesInfo name="DOI" value="10.17487/RFC9162"/>
        </reference>
        <reference anchor="RFC9261" target="https://www.rfc-editor.org/info/rfc9261">
          <front>
            <title>Exported Authenticators in TLS</title>
            <author initials="N." surname="Sullivan"/>
            <date month="July" year="2022"/>
          </front>
          <seriesInfo name="RFC" value="9261"/>
          <seriesInfo name="DOI" value="10.17487/RFC9261"/>
        </reference>
        <reference anchor="RFC9919" target="https://www.rfc-editor.org/info/rfc9919">
          <front>
            <title>The Lightweight Online Certificate Status Protocol (OCSP) Profile for High-Volume Environments</title>
            <author initials="T." surname="Ito"/>
            <author initials="C." surname="Wilson"/>
            <author initials="C." surname="Bonnell"/>
            <author initials="S." surname="Turner"/>
            <date month="July" year="2026"/>
          </front>
          <seriesInfo name="RFC" value="9919"/>
          <seriesInfo name="DOI" value="10.17487/RFC9919"/>
        </reference>
        <reference anchor="ETSI102941">
          <front>
            <title>Intelligent Transport Systems (ITS); Security; Trust and Privacy Management</title>
            <author>
              <organization>ETSI</organization>
            </author>
            <date month="November" year="2022"/>
          </front>
          <seriesInfo name="ETSI TS" value="102 941 V2.2.1"/>
        </reference>
        <reference anchor="ETSI103601">
          <front>
            <title>Intelligent Transport Systems (ITS); Security; Security management messages communication requirements and distribution protocols</title>
            <author>
              <organization>ETSI</organization>
            </author>
            <date month="March" year="2024"/>
          </front>
          <seriesInfo name="ETSI TS" value="103 601 V2.1.1"/>
        </reference>
        <reference anchor="ETSI302636">
          <front>
            <title>Intelligent Transport Systems (ITS); Vehicular Communications; GeoNetworking; Part 4: Geographical addressing and forwarding for point-to-point and point-to-multipoint communications; Sub-part 1: Media-Independent Functionality</title>
            <author>
              <organization>ETSI</organization>
            </author>
            <date month="January" year="2020"/>
          </front>
          <seriesInfo name="ETSI EN" value="302 636-4-1 V1.4.1"/>
        </reference>
        <reference anchor="ETSICAM">
          <front>
            <title>Intelligent Transport Systems (ITS); Vehicular Communications; Basic Set of Applications; Part 2: Specification of Cooperative Awareness Basic Service</title>
            <author>
              <organization>ETSI</organization>
            </author>
            <date month="April" year="2019"/>
          </front>
          <seriesInfo name="ETSI EN" value="302 637-2 V1.4.1"/>
        </reference>
        <reference anchor="ETSIDENM">
          <front>
            <title>Intelligent Transport Systems (ITS); Vehicular Communications; Basic Set of Applications; Part 3: Specifications of Decentralized Environmental Notification Basic Service</title>
            <author>
              <organization>ETSI</organization>
            </author>
            <date month="April" year="2019"/>
          </front>
          <seriesInfo name="ETSI EN" value="302 637-3 V1.3.1"/>
        </reference>
        <reference anchor="SAEJ2735" target="https://doi.org/10.4271/J2735_202409">
          <front>
            <title>V2X Communications Message Set Dictionary</title>
            <author>
              <organization>SAE International</organization>
            </author>
            <date month="September" year="2024"/>
          </front>
          <seriesInfo name="SAE Standard" value="J2735_202409"/>
          <seriesInfo name="DOI" value="10.4271/J2735_202409"/>
        </reference>
        <reference anchor="FIPS204" target="https://doi.org/10.6028/NIST.FIPS.204">
          <front>
            <title>Module-Lattice-Based Digital Signature Standard</title>
            <author>
              <organization>National Institute of Standards and Technology</organization>
            </author>
            <date month="August" year="2024"/>
          </front>
          <seriesInfo name="FIPS" value="204"/>
          <seriesInfo name="DOI" value="10.6028/NIST.FIPS.204"/>
        </reference>
        <reference anchor="KOCHER98" target="https://doi.org/10.1007/BFb0055481">
          <front>
            <title>On Certificate Revocation and Validation</title>
            <author initials="P." surname="Kocher"/>
            <date year="1998"/>
          </front>
          <seriesInfo name="DOI" value="10.1007/BFb0055481"/>
          <refcontent>Financial Cryptography (FC 1998), LNCS 1465, pp. 172-177</refcontent>
        </reference>
        <reference anchor="NAORNISSIM98" target="https://www.usenix.org/conference/7th-usenix-security-symposium/certificate-revocation-and-certificate-update">
          <front>
            <title>Certificate Revocation and Certificate Update</title>
            <author initials="M." surname="Naor"/>
            <author initials="K." surname="Nissim"/>
            <date month="January" year="1998"/>
          </front>
          <refcontent>Proc. 7th USENIX Security Symposium, pp. 217-228</refcontent>
        </reference>
        <reference anchor="MERKLE80" target="https://doi.org/10.1109/SP.1980.10006">
          <front>
            <title>Protocols for Public Key Cryptosystems</title>
            <author initials="R." surname="Merkle"/>
            <date month="April" year="1980"/>
          </front>
          <seriesInfo name="DOI" value="10.1109/SP.1980.10006"/>
          <refcontent>Proc. IEEE Symposium on Security and Privacy, pp. 122-134</refcontent>
        </reference>
        <reference anchor="ALO98">
          <front>
            <title>Fast Digital Identity Revocation</title>
            <author initials="W." surname="Aiello"/>
            <author initials="S." surname="Lodha"/>
            <author initials="R." surname="Ostrovsky"/>
            <date year="1998"/>
          </front>
          <refcontent>Advances in Cryptology - CRYPTO '98, LNCS 1462, pp. 137-152</refcontent>
        </reference>
        <reference anchor="NOVOMODO">
          <front>
            <title>NOVOMODO: Scalable Certificate Validation and Simplified PKI Management</title>
            <author initials="S." surname="Micali"/>
            <date month="April" year="2002"/>
          </front>
          <refcontent>Proc. 1st Annual PKI Research Workshop</refcontent>
        </reference>
        <reference anchor="COACH2013">
          <front>
            <title>COACH: COllaborative certificate stAtus CHecking mechanism for VANETs</title>
            <author initials="C." surname="Ganan"/>
            <author initials="J." surname="Munoz"/>
            <author initials="O." surname="Esparza"/>
            <author initials="J." surname="Mata-Diaz"/>
            <author initials="J." surname="Hernandez-Serrano"/>
            <author initials="J." surname="Alins"/>
            <date month="September" year="2013"/>
          </front>
          <refcontent>Journal of Network and Computer Applications, Vol. 36, No. 5</refcontent>
        </reference>
        <reference anchor="GANAN2015" target="https://doi.org/10.1016/j.pmcj.2014.01.002">
          <front>
            <title>EPA: An Efficient and Privacy-Aware Revocation Mechanism for Vehicular Ad Hoc Networks</title>
            <author initials="C." surname="Ganan"/>
            <author initials="J." surname="Munoz"/>
            <author initials="O." surname="Esparza"/>
            <author initials="J." surname="Mata-Diaz"/>
            <author initials="J." surname="Alins"/>
            <date month="August" year="2015"/>
          </front>
          <seriesInfo name="DOI" value="10.1016/j.pmcj.2014.01.002"/>
          <refcontent>Pervasive and Mobile Computing, Vol. 21, pp. 75-91</refcontent>
        </reference>
        <reference anchor="CRLITE">
          <front>
            <title>CRLite: A Scalable System for Pushing All TLS Revocations to All Browsers</title>
            <author initials="J." surname="Larisch"/>
            <author initials="D." surname="Choffnes"/>
            <author initials="D." surname="Levin"/>
            <author initials="B." surname="Maggs"/>
            <author initials="A." surname="Mislove"/>
            <author initials="C." surname="Wilson"/>
            <date month="May" year="2017"/>
          </front>
          <refcontent>Proc. IEEE Symposium on Security and Privacy</refcontent>
        </reference>
        <reference anchor="HAAS2011" target="https://doi.org/10.1109/JSAC.2011.110309">
          <front>
            <title>Efficient Certificate Revocation List Organization and Distribution</title>
            <author initials="J." surname="Haas"/>
            <author initials="Y-C." surname="Hu"/>
            <author initials="K." surname="Laberteaux"/>
            <date month="March" year="2011"/>
          </front>
          <seriesInfo name="DOI" value="10.1109/JSAC.2011.110309"/>
          <refcontent>IEEE Journal on Selected Areas in Communications, Vol. 29, No. 3, pp. 595-604</refcontent>
        </reference>
        <reference anchor="KHODAEI2018" target="https://doi.org/10.1145/3212480.3212481">
          <front>
            <title>Efficient, Scalable, and Resilient Vehicle-Centric Certificate Revocation List Distribution in VANETs</title>
            <author initials="M." surname="Khodaei"/>
            <author initials="P." surname="Papadimitratos"/>
            <date month="June" year="2018"/>
          </front>
          <seriesInfo name="DOI" value="10.1145/3212480.3212481"/>
          <refcontent>Proc. ACM WiSec 2018</refcontent>
        </reference>
        <reference anchor="WANG2020" target="https://doi.org/10.1109/ACCESS.2020.2970460">
          <front>
            <title>Certificate Revocation Schemes in Vehicular Networks: A Survey</title>
            <author initials="Q." surname="Wang"/>
            <author initials="D." surname="Gao"/>
            <author initials="D." surname="Chen"/>
            <date month="January" year="2020"/>
          </front>
          <seriesInfo name="DOI" value="10.1109/ACCESS.2020.2970460"/>
          <refcontent>IEEE Access, Vol. 8, pp. 26223-26234</refcontent>
        </reference>
        <reference anchor="SCMS2018" target="https://doi.org/10.1109/TITS.2018.2797529">
          <front>
            <title>A Security Credential Management System for V2X Communications</title>
            <author initials="B." surname="Brecht"/>
            <author initials="D." surname="Therriault"/>
            <author initials="A." surname="Weimerskirch"/>
            <author initials="W." surname="Whyte"/>
            <author initials="V." surname="Kumar"/>
            <author initials="T." surname="Hehn"/>
            <author initials="R." surname="Goudy"/>
            <date month="December" year="2018"/>
          </front>
          <seriesInfo name="DOI" value="10.1109/TITS.2018.2797529"/>
          <refcontent>IEEE Transactions on Intelligent Transportation Systems, Vol. 19, No. 12, pp. 3850-3871</refcontent>
        </reference>
        <reference anchor="SCOP2024" target="https://doi.org/10.14722/ndss.2024.24017">
          <front>
            <title>Efficient and Timely Revocation of V2X Credentials</title>
            <author initials="G." surname="Scopelliti"/>
            <author initials="C." surname="Baumann"/>
            <author initials="F." surname="Alder"/>
            <author initials="E." surname="Truyen"/>
            <author initials="J. T." surname="Muehlberg"/>
            <date month="February" year="2024"/>
          </front>
          <seriesInfo name="DOI" value="10.14722/ndss.2024.24017"/>
          <refcontent>Proc. NDSS 2024</refcontent>
        </reference>
        <reference anchor="PETIT2015" target="https://doi.org/10.1109/COMST.2014.2345420">
          <front>
            <title>Pseudonym Schemes in Vehicular Networks: A Survey</title>
            <author initials="J." surname="Petit"/>
            <author initials="F." surname="Schaub"/>
            <author initials="M." surname="Feiri"/>
            <author initials="F." surname="Kargl"/>
            <date year="2015"/>
          </front>
          <seriesInfo name="DOI" value="10.1109/COMST.2014.2345420"/>
          <refcontent>IEEE Communications Surveys and Tutorials, Vol. 17, No. 1, pp. 228-255</refcontent>
        </reference>
        <reference anchor="DOLEV1983" target="https://doi.org/10.1109/TIT.1983.1056650">
          <front>
            <title>On the Security of Public Key Protocols</title>
            <author initials="D." surname="Dolev"/>
            <author initials="A." surname="Yao"/>
            <date month="March" year="1983"/>
          </front>
          <seriesInfo name="DOI" value="10.1109/TIT.1983.1056650"/>
          <refcontent>IEEE Transactions on Information Theory, Vol. 29, No. 2, pp. 198-208</refcontent>
        </reference>
        <reference anchor="TAMARIN2013" target="https://doi.org/10.1007/978-3-642-39799-8_48">
          <front>
            <title>The TAMARIN Prover for the Symbolic Analysis of Security Protocols</title>
            <author initials="S." surname="Meier"/>
            <author initials="B." surname="Schmidt"/>
            <author initials="C." surname="Cremers"/>
            <author initials="D." surname="Basin"/>
            <date year="2013"/>
          </front>
          <seriesInfo name="DOI" value="10.1007/978-3-642-39799-8_48"/>
          <refcontent>Proc. CAV 2013</refcontent>
        </reference>
        <reference anchor="GRUND2026">
          <front>
            <title>Securiser les echanges V2X sous contrainte de latence: une approche par composition de protocoles</title>
            <author initials="J.-J." surname="Grund"/>
            <date month="November" year="2026"/>
          </front>
          <refcontent>Doctoral thesis, Institut Polytechnique de Paris, Telecom Paris</refcontent>
        </reference>
<reference anchor="RFC7633" target="https://www.rfc-editor.org/info/rfc7633">
      <front><title>X.509v3 Transport Layer Security (TLS) Feature Extension</title><author initials="P." surname="Hallam-Baker"/><date year="2015" month="October"/></front>
      <seriesInfo name="RFC" value="7633"/><seriesInfo name="DOI" value="10.17487/RFC7633"/>
    </reference>
<reference anchor="RT2012" target="https://www.links.org/files/RevocationTransparency.pdf">
      <front><title>Revocation Transparency</title><author initials="B." surname="Laurie"/><author initials="E." surname="Kasper"/><date year="2012"/></front>
      <refcontent>Research proposal</refcontent>
    </reference>
<reference anchor="SMT2016" target="https://eprint.iacr.org/2016/683">
      <front><title>Efficient Sparse Merkle Trees: Caching Strategies and Secure (Non-)Membership Proofs</title><author initials="R." surname="Dahlberg"/><author initials="T." surname="Pulls"/><author initials="R." surname="Peeters"/><date year="2016"/></front>
      <seriesInfo name="Cryptology ePrint Archive" value="2016/683"/><refcontent>Author version for NordSec 2016</refcontent>
    </reference>
<reference anchor="VCER2022" target="https://www.usenix.org/conference/usenixsecurity22/presentation/koisser">
      <front><title>V'CER: Efficient Certificate Validation in Constrained Networks</title><author initials="D." surname="Koisser"/><author initials="P." surname="Jauernig"/><author initials="G." surname="Tsudik"/><author initials="A.-R." surname="Sadeghi"/><date year="2022" month="August"/></front>
      <refcontent>31st USENIX Security Symposium</refcontent>
    </reference>
<reference anchor="LLX2007" target="https://www.cerias.purdue.edu/assets/pdf/bibtex_archive/2007-47.pdf">
      <front><title>Universal Accumulators with Efficient Nonmembership Proofs</title><author initials="J." surname="Li"/><author initials="N." surname="Li"/><author initials="R." surname="Xue"/><date year="2007"/></front>
      <refcontent>Applied Cryptography and Network Security 2007; author copy in CERIAS Technical Report 2007-47</refcontent>
    </reference>
<reference anchor="MOZILLA-CRLITE" target="https://hacks.mozilla.org/2025/08/crlite-fast-private-and-comprehensive-certificate-revocation-checking-in-firefox/">
      <front><title>CRLite: Fast, private, and comprehensive certificate revocation checking in Firefox</title><author initials="J." surname="Schanck"><organization>Mozilla</organization></author><date year="2025" month="August" day="19"/></front>
    </reference>
<reference anchor="CRLSETS" target="https://www.chromium.org/Home/chromium-security/crlsets/">
      <front><title>CRLSets</title><author><organization>The Chromium Projects</organization></author></front>
      <refcontent>Project documentation, accessed 15 November 2026</refcontent>
    </reference>
<reference anchor="I-D.premont-lamps-drl-stapling" target="https://datatracker.ietf.org/doc/html/draft-premont-lamps-drl-stapling-00">
      <front><title>TLS Extension for Distributed Revocation Ledger (DRL) Stapling using a Sparse Merkle Tree</title><author initials="A." surname="Premont"/><author initials="H." surname="Afifi"/><date year="2026" month="July" day="6"/></front>
      <seriesInfo name="Internet-Draft" value="draft-premont-lamps-drl-stapling-00"/><refcontent>Work in Progress</refcontent>
    </reference>
      </references>
    </references>
    <section anchor="asn1">
      <name>ASN.1 Module</name>
      <t>This module is normative. It uses ASN.1 notation <xref target="X680"/> and is encoded with COER <xref target="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.</t>
      <sourcecode type="asn.1" name="smrp.asn" markers="true"><![CDATA[
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
]]></sourcecode>
      <t>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 (<xref target="tree-build"/>).</t>
    </section>
    <section anchor="algorithms">
      <name>Reference Algorithms</name>
      <t>The pseudocode of this appendix restates the body. The body prevails in case of difference. The verification of proofs is given in <xref target="adjacent"/> and <xref target="membership"/>.</t>
      <section anchor="alg-token">
        <name>Token and Partition</name>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
      </section>
      <section anchor="alg-root">
        <name>Root of a Token List and Proof Derivation</name>
        <t>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 <xref target="snapshot"/>.</t>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
      </section>
      <section anchor="alg-admit">
        <name>Checkpoint Admission</name>
        <sourcecode type="pseudocode"><![CDATA[
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)
]]></sourcecode>
      </section>
      <section anchor="alg-decide">
        <name>Decision</name>
      <t>RawSignatureRanges applies the r and low-S bounds of <xref target="signature"/>. NegativeOnly and RetainedNegativeOnly implement <xref target="negative-conflict"/>. 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.</t>
        <sourcecode type="pseudocode"><![CDATA[
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
]]></sourcecode>
      </section>
    </section>
    <section anchor="vectors">
      <name>Test Vectors</name>
      <t>The values below are produced by the companion artifacts (<xref target="claims"/>). The private scalars 1 and 2 are public test keys: scalar 1 signs checkpoints and scalar 2 stands for the credential issuance key. They <bcp14>MUST NOT</bcp14> 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 <xref target="timescale"/>. 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.</t>
      <section anchor="vec-config">
        <name>Configuration</name>
        <t>Checkpoint public key (uncompressed NIST P-256 point of scalar 1), authorized on [1000, 5000):</t>
        <sourcecode type="test-vectors"><![CDATA[
046b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2
964fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51
f5
]]></sourcecode>
        <t>Configuration fields:</t>
        <sourcecode type="test-vectors"><![CDATA[
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
]]></sourcecode>
        <t>COER SmrpConfiguration (173 octets):</t>
        <sourcecode type="test-vectors"><![CDATA[
01ff0100112233445566778899aabbccddeeff4d7e6e15223715bd7f32248ffc
f5e9a283ad561cff5e2129ad37dea58c71d35f00000000000000010000025800
00003c00000000780000005a00000002000000020010000010000101046b17d1
f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c2964fe342
e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5000000
00000003e80000000000001388
]]></sourcecode>
        <t>configurationHash:</t>
        <sourcecode type="test-vectors"><![CDATA[
981855e0a5ec53350acf78fcef720a2fd57f6dd99230a157a666c04eeba53080
]]></sourcecode>
      </section>
      <section anchor="vec-tree">
        <name>Tree and Proof</name>
        <t>The intermediate hashes below permit reconstruction of the three-token tree and its absence witness.</t>
        <sourcecode type="test-vectors"><![CDATA[
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
]]></sourcecode>
      </section>
      <section anchor="vec-checkpoint">
        <name>Checkpoint</name>
        <t>This checkpoint authenticates the three-token tree under the configuration given above.</t>
        <sourcecode type="test-vectors"><![CDATA[
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
]]></sourcecode>
      </section>
      <section anchor="vec-staples">
        <name>Staples</name>
        <t>Full staple for X = 22..22 (373 octets). Expected outcome at clock reading 1220 with error 2: NOT_REVOKED_AT_SNAPSHOT.</t>
        <sourcecode type="test-vectors"><![CDATA[
8001ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fc
ef720a2fd57f6dd99230a157a666c04eeba53080000000000000000100000000
000004b000000000000000000000000100000000000004ba00000000000004bc
000000000000050a000000043598e37b84e8adad0ae2a691c784ec7c1f86885e
fd849cbaddd4e38fd84576c40db130143e3f7d6f0209cef5fb531cac6964b0bb
adefbe2412a10f5df5d429ff35345c4014ee9fec0c39fc8152a4ffbffeda0683
8bd58dcb7351de5724bac6486877cfbaab384298f3f53a7fb7a7c5c0addc831a
1d86829570682f2468ef37a98000000001811111111111111111111111111111
1111111111111111111111111111111111118144444444444444444444444444
44444444444444444444444444444444444444010263086bdc7a20587b543540
e2888cb5f8aa9287d90af14c275ee2ef3bfe1939f030a6587e1c317554fca562
e6229f4b95a44453e06e868eb02deac71e5a511448
]]></sourcecode>
        <t>Proof-only staple for X = 22..22 (146 octets). Expected outcome at clock reading 1220 with error 2: NOT_REVOKED_AT_SNAPSHOT.</t>
        <sourcecode type="test-vectors"><![CDATA[
8100000000000004b08000000001811111111111111111111111111111111111
1111111111111111111111111111118144444444444444444444444444444444
44444444444444444444444444444444010263086bdc7a20587b543540e2888c
b5f8aa9287d90af14c275ee2ef3bfe1939f030a6587e1c317554fca562e6229f
4b95a44453e06e868eb02deac71e5a511448
]]></sourcecode>
        <t>Full staple over an empty set, same times (245 octets). Expected outcome at clock reading 1220 with error 2: NOT_REVOKED_AT_SNAPSHOT.</t>
        <sourcecode type="test-vectors"><![CDATA[
8001ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fc
ef720a2fd57f6dd99230a157a666c04eeba53080000000000000000100000000
000004b000000000000000000000000100000000000004ba00000000000004bc
000000000000050a000000019920dfec461cf27f5789b5c331c452188fe4a034
0c0a2a2ca23868f29ee405780db130143e3f7d6f0209cef5fb531cac6964b0bb
adefbe2412a10f5df5d429ff76406e1e4c266a94ef988d42d30aa5842808184d
646dd91783cc5c95db68f19f7270355d2b7cb1797f247855155db24913323dd8
0a4e72ee4e87b37ed201242d800000000080820100
]]></sourcecode>
      </section>
      <section anchor="vec-membership">
        <name>Membership Proof and Revocation Notice</name>
        <t>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.</t>
        <t>Full staple with the membership proof (372 octets). Expected outcome: REVOKED.</t>
        <sourcecode type="test-vectors"><![CDATA[
8001ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fc
ef720a2fd57f6dd99230a157a666c04eeba53080000000000000000100000000
000004b000000000000000000000000200000000000004e200000000000004e4
00000000000005320000000567717a0c23f6cdc54fb663a067753a976b3751bc
ab0aae835c62f5901bd63ae40db130143e3f7d6f0209cef5fb531cac6964b0bb
adefbe2412a10f5df5d429fff8d7e260e27b25652b1954eeb184eb4b9388f6bb
760b47c45b9a33e43ac003fe73039d924f73db0005e1406baedd9960ec487334
9fc6978e8b3a80ec56045aab8100000002814444444444444444444444444444
44444444444444444444444444444444444401030c4d868a5dcc8d6fae101550
5478087866a97d45c86a6a767a5427dfb16934abb6e680115f4cc0d487b4dea6
d4c0a64bfea976c5ba0ad5dc1ab8bd1110480a4ed178edc312c1ff969b0060bf
fce8538cfb68d679d1458037f9ee16588662b8ed
]]></sourcecode>
        <t>Revocation notice for the same token (175 octets):</t>
        <sourcecode type="test-vectors"><![CDATA[
00000000000004b0222222222222222222222222222222222222222222222222
2222222222222222000000028144444444444444444444444444444444444444
4444444444444444444444444401030c4d868a5dcc8d6fae1015505478087866
a97d45c86a6a767a5427dfb16934abb6e680115f4cc0d487b4dea6d4c0a64bfe
a976c5ba0ad5dc1ab8bd1110480a4ed178edc312c1ff969b0060bffce8538cfb
68d679d1458037f9ee16588662b8ed
]]></sourcecode>
      </section>
      <section anchor="vec-lists">
        <name>Snapshot and Delta</name>
        <t>Snapshot, 333 octets. It holds the three-token set under the checkpoint above.</t>
        <sourcecode type="test-vectors"><![CDATA[
01ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fcef
720a2fd57f6dd99230a157a666c04eeba5308000000000000000010000000000
0004b000000000000000000000000100000000000004ba00000000000004bc00
0000000000050a000000043598e37b84e8adad0ae2a691c784ec7c1f86885efd
849cbaddd4e38fd84576c40db130143e3f7d6f0209cef5fb531cac6964b0bbad
efbe2412a10f5df5d429ff35345c4014ee9fec0c39fc8152a4ffbffeda06838b
d58dcb7351de5724bac6486877cfbaab384298f3f53a7fb7a7c5c0addc831a1d
86829570682f2468ef37a9010311111111111111111111111111111111111111
1111111111111111111111111144444444444444444444444444444444444444
4444444444444444444444444488888888888888888888888888888888888888
88888888888888888888888888
]]></sourcecode>
        <t>Delta, 301 octets. It leads from that checkpoint to the version-2 checkpoint and inserts 22..22.</t>
        <sourcecode type="test-vectors"><![CDATA[
8026740952d0ccc0fb05e2a51d2c1fa322bf46d89b25ff03a89579051dbd58f1
01ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fcef
720a2fd57f6dd99230a157a666c04eeba5308000000000000000010000000000
0004b000000000000000000000000200000000000004e200000000000004e400
000000000005320000000567717a0c23f6cdc54fb663a067753a976b3751bcab
0aae835c62f5901bd63ae40db130143e3f7d6f0209cef5fb531cac6964b0bbad
efbe2412a10f5df5d429fff8d7e260e27b25652b1954eeb184eb4b9388f6bb76
0b47c45b9a33e43ac003fe73039d924f73db0005e1406baedd9960ec4873349f
c6978e8b3a80ec56045aab010122222222222222222222222222222222222222
22222222222222222222222222
]]></sourcecode>
      </section>
      <section anchor="vec-token">
        <name>Token and Partition</name>
        <sourcecode type="test-vectors"><![CDATA[
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
]]></sourcecode>
      </section>
      <section anchor="vec-ocsp">
        <name>OCSP Encapsulation</name>
        <t>OCSPResponse, 404 octets. It carries the full staple of <xref target="vec-staples"/>. 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.</t>
        <sourcecode type="test-vectors"><![CDATA[
308201900a0100a082018930820185060a2b0601040181fd5901030482017580
01ff0100112233445566778899aabbccddeeff981855e0a5ec53350acf78fcef
720a2fd57f6dd99230a157a666c04eeba5308000000000000000010000000000
0004b000000000000000000000000100000000000004ba00000000000004bc00
0000000000050a000000043598e37b84e8adad0ae2a691c784ec7c1f86885efd
849cbaddd4e38fd84576c40db130143e3f7d6f0209cef5fb531cac6964b0bbad
efbe2412a10f5df5d429ff35345c4014ee9fec0c39fc8152a4ffbffeda06838b
d58dcb7351de5724bac6486877cfbaab384298f3f53a7fb7a7c5c0addc831a1d
86829570682f2468ef37a9800000000181111111111111111111111111111111
1111111111111111111111111111111111814444444444444444444444444444
444444444444444444444444444444444444010263086bdc7a20587b543540e2
888cb5f8aa9287d90af14c275ee2ef3bfe1939f030a6587e1c317554fca562e6
229f4b95a44453e06e868eb02deac71e5a511448
]]></sourcecode>
      </section>
    </section>
    <section anchor="proofs">
      <name>Security Arguments</name>
      <t>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 (<xref target="formal"/>).</t>
      <section anchor="proofs-defs">
        <name>Definitions</name>
        <t>A tree is honest for a token list if the list is strictly increasing and the tree is built from it as in <xref target="tree-build"/>. 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.</t>
      </section>
      <section anchor="proofs-binding">
        <name>Binding of Leaves</name>
        <t>Lemma 1. Let a tree be honest, with m leaves and root r. If the fold of <xref target="adjacent"/> 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.</t>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="proofs-absence">
        <name>Soundness of Proofs</name>
        <t>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.</t>
        <t>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] &lt; X &lt; B[i+1] in the typed order. The list B is strictly increasing, so X differs from every element of S.</t>
        <t>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.</t>
        <t>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.</t>
        <t>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.</t>
        <t>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.</t>
      </section>
      <section anchor="proofs-commit">
        <name>Set Commitment and Deltas</name>
        <t>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.</t>
        <t>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.</t>
        <t>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 (<xref target="carry-over"/>). 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 (<xref target="snapshot"/>).</t>
      </section>
      <section anchor="proofs-bound">
        <name>Enforcement Bound</name>
        <t>Theorem 1. Assume A1 to A8 (<xref target="assumptions"/>). 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 &lt; r + L + Aapp.</t>
        <t>Argument. By the decision rules (<xref target="decision"/>), 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 <xref target="deadline"/>.</t>
        <ol>
          <li>K is authentic. By A1 and A7 it was signed by the issuer. By A2 its tree is honest for the applicable set as of its cutoff. By Lemma 2 and Lemma 4, X is not in that set.</li>
          <li>The verifier checked nowLower &gt;= K.thisUpdate + a and nowUpper &lt; e + E, and it checked that the credential is valid on [nowLower, nowUpper]. Since K.thisUpdate is at least K.snapshotTime, which is at least e - G, the true time u lies in the interval during which epoch e is in use, and the credential is valid at u. The token is therefore in the scope of the stream (<xref target="set-scope"/>).</li>
          <li>Let c be the true cutoff of K. If c were at least r + L, the set would contain X by A3 and step 2. Hence c &lt; r + L.</li>
          <li>By A4, K.snapshotTime is at most c + a.</li>
          <li>The verifier checked nowUpper &lt; K.snapshotTime - a + Aapp, which is at most c + Aapp.</li>
          <li>By A5, the clock reading C satisfies C - v &lt;= u &lt;= C + v, and the floor is the lower end of an earlier such interval, so u &lt;= nowUpper.</li>
        </ol>
        <t>Steps 3, 5, and 6 give u &lt; c + Aapp &lt; 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.</t>
        <t>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.</t>
        <t>A second bound follows from the same steps with nextUpdate in place of the age limit: u &lt; 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 &lt; r + L + D + a + maxCheckpointLifetime and take the smaller bound. D is an additional operational assumption, not a consequence of the lifetime field.</t>
      </section>
      <section anchor="proofs-state">
        <name>State Properties</name>
        <t>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 <xref target="decision"/>, which precedes every use of evidence and of time.</t>
        <t>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.</t>
        <t>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 <xref target="issuance"/>, 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.</t>
      </section>
      <section anchor="proofs-limits">
        <name>What the Arguments Do Not Cover</name>
        <t>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.</t>
      </section>
    </section>
    <section anchor="lifecycle">
      <name>Worked Lifecycle</name>
      <t>This example uses the configuration of <xref target="vectors"/>: 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.</t>
      <ol>
        <li>Checkpoint 1 has version 1, snapshotTime 1210, thisUpdate 1212, and nextUpdate 1290. H staples it with its proof. V, whose clock reads 1220, returns NOT_REVOKED_AT_SNAPSHOT with deadline 1290. With a clock error of 2, the checkpoint is usable for clock readings from 1216 to 1287.</li>
        <li>H then sends proof-only staples of 146 octets. Messages that carry only the certificate digest are evaluated from the state of V.</li>
        <li>Checkpoint 2 has version 2, snapshotTime 1250, thisUpdate 1252, nextUpdate 1330, and the same treeSize and rootHash. V receives it from a third station at 1260. At 1300, after the first deadline, V still returns NOT_REVOKED_AT_SNAPSHOT for H, now with deadline 1330. H sent nothing new.</li>
        <li>A token is inserted. Checkpoint 3 has version 3, snapshotTime 1300, thisUpdate 1301, nextUpdate 1380, and a new root. Once V holds it, the cached proof of H no longer matches and the outcome is INDETERMINATE. Replaying the staples of versions 1 and 2 changes nothing.</li>
        <li>H obtains its proof for the new set and sends it as a proof-only staple. V returns NOT_REVOKED_AT_SNAPSHOT with deadline 1380.</li>
        <li>In another run, the inserted token is that of H. H can obtain only a membership proof. A roadside unit that keeps the list sends a revocation notice of 175 octets. V, which holds the checkpoint, creates a terminal record. From then on V returns REVOKED for H, with or without a staple, whatever its clock reads.</li>
        <li>A verifier W that was isolated since checkpoint 1 keeps accepting H until its clock reading reaches 1288 and then returns INDETERMINATE. This is the situation that Theorem 1 bounds.</li>
      </ol>
    </section>
    <section anchor="rationale">
      <name>Design Rationale and Rejected Alternatives</name>
      <section anchor="rat-leaf">
        <name>Interval Leaves Instead of Token Leaves</name>
        <t>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.</t>
        <t>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.</t>
        <t>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 (<xref target="claims"/>).</t>
      </section>
      <section anchor="rat-other">
      <name>Other Structures</name>
      <t>The interval tree is a profile choice. This document does not establish that it is optimal across all update patterns, hardware, or deployment models.</t>
      <ul>
        <li>Sparse Merkle trees assign stable positions to key digests and can omit default siblings from proofs <xref target="SMT2016"/>. Their encoded proof length and caching behavior differ from the fixed-height path of this tree. Stable positions can reduce update work compared with an indexed sorted representation; epoch rebuilds, witness distribution, and actual occupancy must be included in a comparison. V'CER demonstrates the relevance of collaborative updates in constrained networks <xref target="VCER2022"/>.</li>
        <li>Universal accumulators can offer compact non-membership witnesses under different computational assumptions <xref target="LLX2007"/>. Their concrete setup, verification, and witness-update algorithms must be evaluated. An accumulator commitment can itself be authenticated by an independently selected signature scheme; accumulators do not inherently conflict with signature agility. Moving to a different accumulator or hash construction can nevertheless require witness migration, just as changing this tree's hash inputs would.</li>
        <li>CRLite uses compressed client-side membership structures with an issuance corpus and coverage rules <xref target="CRLITE"/> <xref target="MOZILLA-CRLITE"/>. A simple probabilistic filter must handle false positives; a structured cascade can remove ambiguity for its modeled universe. This is not equivalent to SMRP list mode, which retains an exact token list and reconstructs its commitment. Compare representation size, universe coverage, update bandwidth, and failure semantics separately.</li>
        <li>Shortening tree hashes trades proof size for collision security. A 128-bit hash has a generic birthday bound near 2^64, while the 256-bit hashes selected here target a 128-bit generic collision margin. A shorter-hash profile would require its own security analysis and identifiers.</li>
      </ul>
    </section>
      <section anchor="rat-choices">
        <name>Other Choices</name>
        <ul>
          <li>Typed sentinels. Using the all-zero and all-one values as sentinels would make two tokens unrepresentable and would let a boundary be confused with a token. A type outside the token space avoids both.</li>
          <li>Hashed leaf index. Ordered left/right node hashing already binds a leaf to a path position. Including the index additionally makes that position explicit in the leaf statement and in the input validated by this profile; it is not the sole source of order binding.</li>
          <li>Checkpoint separate from the proof. A proof that embedded the version or the times of a checkpoint would have to be reissued at every refresh. Keeping the proof a statement about the set commitment is what allows freshness to be shared (<xref target="carry-over"/>).</li>
          <li>Three staple forms. A staple that always contains the checkpoint repeats 235 octets that most receivers already hold.</li>
          <li>Epochs with a lead interval. Epochs bound the set and the state. A sufficiently maintained lead interval can cover the transition gap under the conditions stated (<xref target="epoch-transition"/>).</li>
          <li>Snapshot cutoff distinct from issuance time. The age of the information, not the time of the signature, bounds the exposure. An issuer that signs again an old view cannot extend it.</li>
          <li>Terminal membership under a stale checkpoint. The issuer has signed that the token is revoked, and revocation is not reversible. Ignoring that statement because it is old would only serve the revoked holder.</li>
          <li>CONFLICT distinct from INVALID. INVALID is a fault of the presented evidence and concerns one operation. CONFLICT is a fault of the issuer and concerns the domain until recovery.</li>
          <li>Fixed-size raw signature and COER without extensions. Fixed offsets allow the checkpoint to be authenticated before the rest of a staple is parsed, and one canonical encoding makes identifiers and vectors reproducible.</li>
        </ul>
      </section>
    </section>
    <section anchor="formal">
      <name>Formal Verification Blueprint</name>
      <t>No machine-checked proof of this version exists. This appendix outlines a symbolic model, for instance for the Tamarin prover <xref target="TAMARIN2013"/>, so that results can be compared and their limits stated.</t>
      <t>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 <xref target="state"/>. The attacker controls the network <xref target="DOLEV1983"/>, can compromise credential keys, and, in a separate set of lemmas, the checkpoint key.</t>
      <t>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 <xref target="proofs"/> 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.</t>
      <t>Lemmas.</t>
      <ul>
        <li>L1, absence soundness: under honest construction and the cryptographic, configuration, credential-validation and binding assumptions, an affirmative result for X implies an issuer event signing a checkpoint whose applicable set does not contain X.</li>
        <li>L2, decision binding: every affirmative result uses the token derived from the credential that authenticates the operation, the locally selected configuration and partition, and an admissible checkpoint of that scope. A public interval witness can legitimately prove absence for several tokens or verify under equal commitments in distinct streams. Reuse of its octets alone neither authenticates a credential nor establishes freshness.</li>
        <li>L3, terminal revocation: after a REVOKED result for X, no affirmative result for X occurs while its terminal record is required to be retained and no explicitly authorized recovery instruction has changed that decision. The model must distinguish mandatory retention from permitted garbage collection or eviction for never-observed credentials.</li>
        <li>L4, enforcement: under Theorem 1, no affirmative result for X occurs at true time u greater than or equal to r + L + Aapp. Equivalently, if every applicable snapshot with true cutoff at least c contains X, the cutoff-based bound is u &lt; c + Aapp. A single insertion event in one stream is insufficient to assert coverage of every applicable stream.</li>
        <li>L5, conflict: with honest issuance, consistent authenticated trust administration, uncompromised authorized keys, and the assumed hash properties, no verifier sets a conflict barrier. The model includes both checkpoint and configuration conflicts.</li>
        <li>L6, negative attribution: with honest tree construction and intact authorization, a newly learned terminal REVOKED fact for X implies issuer insertion. Without honest construction, the weaker property is attribution of a locally authenticated negative statement, as in Proposition 2. The model must represent key compromise and authorized administrative recovery separately.</li>
        <li>Executability lemmas for each outcome, so that the model is not vacuous.</li>
      </ul>
      <t>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 <xref target="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.</t>
    </section>
    <section anchor="claims">
      <name>Evaluation Plan and Claim Boundaries</name>
      <section anchor="claims-artifacts">
        <name>Companion Artifacts</name>
        <t>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.</t>
        <table anchor="tab-tests">
          <name>Checks performed by the companion test suites</name>
          <thead>
            <tr><th>Group</th><th>Checks</th></tr>
          </thead>
          <tbody>
            <tr><td>Tree and identity, targeted cases</td><td>323</td></tr>
            <tr><td>Tree, all subsets of an 8-token universe</td><td>8448</td></tr>
            <tr><td>Verifier against a specification-level oracle on mutated proofs</td><td>55290</td></tr>
            <tr><td>Height and proof-length law, tree sizes 1 to 4097</td><td>4406</td></tr>
            <tr><td>Snapshot and delta reconstruction</td><td>19</td></tr>
            <tr><td>Limits of what a verifier can detect</td><td>2</td></tr>
            <tr><td>Exact encoded sizes</td><td>335</td></tr>
            <tr><td>Encoding, signature, and binding</td><td>109</td></tr>
            <tr><td>Time rules at their boundaries</td><td>40</td></tr>
            <tr><td>Epoch transition with and without a lead</td><td>9</td></tr>
            <tr><td>Verifier state machine</td><td>107</td></tr>
            <tr><td>List mode at the verifier</td><td>55</td></tr>
            <tr><td>Revocation notices</td><td>17</td></tr>
            <tr><td>Configuration limits</td><td>33</td></tr>
            <tr><td>OCSP encapsulation</td><td>7</td></tr>
            <tr><td>Total</td><td>69200</td></tr>
          </tbody>
        </table>
        <t>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.</t>
        <t>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 <xref target="verifier"/>, including every outcome of <xref target="lifecycle"/>. 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.</t>
      </section>
      <section anchor="claims-plan">
        <name>Work Packages</name>
        <ul>
          <li>E1, interoperability: two independent implementations of the credential canonicalization, the COER codec, the tree, and the verifier, exchanging the vectors of <xref target="vectors"/> and real ITS certificates. Negative tests are required: malformed lengths, altered metadata, bad signatures, forks, rollback, clock uncertainty, key rotation, restart, and cache eviction.</li>
          <li>E2, carriage: an explicitly controlled experimental mapping in a secured V2X envelope, with complete packet sizes, behavior of receivers that ignore the extension, and congestion control.</li>
          <li>E3, channel: evidence load, checkpoint dissemination, and time to first affirmative status under realistic density, with correlated loss, for several numbers of partition bits and several sizes of the revoked set, against a CRL baseline and against pOCSP under the same population, schedule, and outage policy.</li>
          <li>E4, enforcement delay: the lag L measured from decision to snapshot, and the operation-level delay to the end of acceptance, with and without list holders in the neighborhood.</li>
          <li>E5, issuer and distribution: tree construction, delta production, proof service, and the retrieval load after an insertion, including the tail of partition occupancy.</li>
          <li>E6, verifier state and recovery: bounded state under pseudonym churn, full storage, restart, rollback of persistent state, corruption, change of authority epoch, and the demonstration that a terminal record required to be retained or a conflict barrier does not become an affirmative result through eviction, restart, omitted evidence, clock rollback, or cache reuse.</li>
          <li>E7, privacy: observers, auxiliary information, retrieval channels, and the reference system without SMRP; additional linkability across pseudonym changes, including through retrieval and through the published set.</li>
          <li>E8, formal analysis: the model of <xref target="formal"/>, with its logs.</li>
        </ul>
        <t>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.</t>
      </section>
      <section anchor="claims-scope">
        <name>Present Scope of Defensible Claims</name>
        <t>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 <xref target="vectors"/> are reproducible. The comparison of <xref target="pocsp"/> states cost laws and sizes that follow from the two specifications.</t>
        <t>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.</t>
      </section>
    </section>
    <section anchor="history">
      <name>Relationship to Earlier Descriptions</name>
      <t>SMRP was first described in a doctoral thesis <xref target="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.</t>
      <table anchor="tab-history">
        <name>Differences from the earlier description</name>
        <thead>
          <tr><th>Aspect</th><th>Earlier description</th><th>This document</th></tr>
        </thead>
        <tbody>
          <tr><td>Token</td><td>16-octet revocation value carried by the certificate</td><td>32-octet hash of the credential identity; no new certificate field</td></tr>
          <tr><td>Sentinels and padding</td><td>All-zero and all-one values; last leaf repeated</td><td>Typed sentinels; index-bound padding hash</td></tr>
          <tr><td>Proof of absence</td><td>Two inclusion paths, 2h hashes</td><td>One interval leaf, h hashes</td></tr>
          <tr><td>Evidence size</td><td>163 + 64 * h octets, checkpoint included</td><td>309 + 32 * h octets with the checkpoint, 82 + 32 * h without</td></tr>
          <tr><td>Checkpoint</td><td>Root with epoch and partition</td><td>Root with configuration, version, cutoff, issuance time, deadline, and tree size</td></tr>
          <tr><td>Freshness</td><td>One checkpoint per epoch, with a tolerance counted in epochs</td><td>Several checkpoints per epoch, snapshot age, and a bound with its argument</td></tr>
          <tr><td>Refresh</td><td>New proof with each checkpoint</td><td>Proof reused while the set commitment is unchanged</td></tr>
          <tr><td>Partitions</td><td>Geographic or administrative</td><td>Derived by hashing the token and the epoch</td></tr>
          <tr><td>Revocation evidence</td><td>Absence proofs only</td><td>Membership proofs, notices, and list mode</td></tr>
          <tr><td>Vehicle-level profile</td><td>Per-epoch value derived from a vehicle secret</td><td>Not defined; requires a separate profile</td></tr>
          <tr><td>Issuer role name</td><td>Revocation authority (RA)</td><td>Checkpoint issuer</td></tr>
        </tbody>
      </table>
    </section>
  </back>
</rfc>
