Internet-Draft pOCSP November 2026
Grund, et al. Expires 18 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-grund-v2x-pocsp-00
Published:
Intended Status:
Experimental
Expires:
Authors:
J.-J. Grund
Telecom Paris, IP Paris
R. Khatoun
Telecom Paris, IP Paris
G. Pujolle
Sorbonne University
A. Serhrouchni
Telecom Paris / Institut CyberIA

Pseudonymous Stapled Certificate Status Evidence for V2X and TLS with ITS Certificates (pOCSP)

Abstract

Vehicle-to-Everything (V2X) systems authenticate broadcast and unicast messages with short-lived pseudonymous certificates. Revocation status validation is difficult in this environment: Certificate Revocation Lists (CRLs) can be costly to distribute at pseudonym scale, while verifier-initiated OCSP requests introduce online dependencies, latency, metadata leakage, and denial-of-service exposure.

This document specifies pOCSP, an OCSP-derived response type and a set of deployment profiles for short-lived certificate-status evidence that is obtained by the certificate holder and stapled to an authenticated message or TLS CertificateEntry. A verifier validates pOCSP evidence locally, without contacting a responder at message-reception time. pOCSP retains the OCSP status semantics good, revoked, and unknown; defines an explicit signed usage context; defines a compact context-specific certificate identifier; and specifies deterministic, bounded validation, caching, and failure behavior. pOCSP does not claim that its identifier is unlinkable. The identifier is deterministic and can be correlated whenever the underlying certificate is observable or inferable. The V2X profiles therefore require single-certificate evidence and prohibit transmitting pOCSP evidence more frequently than the corresponding full certificate. The document prohibits future-active good evidence, bounds replay by mandatory thisUpdate and nextUpdate values, and makes an authenticated revocation terminal at the verifier: omitted, expired, unknown, or higher-versioned good evidence cannot mask it. It defines profiles for ETSI CAM/DENM, SAE J2735 messages, and TLS 1.3 with ITS certificates, requests an OCSP response-type object identifier, and establishes a registry of pOCSP profile identifiers.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 18 May 2027.

▲

Table of Contents

1. Introduction

Cooperative Intelligent Transport Systems exchange safety, traffic-efficiency, and infrastructure-control messages over wireless channels. In European deployments, Cooperative Awareness Messages (CAM) [ETSI-CAM] and Decentralized Environmental Notification Messages (DENM) [ETSI-DENM] are representative facilities-layer messages. In North American deployments, SAE J2735 [SAE-J2735] defines message types including Basic Safety Message (BSM), Signal Request Message (SRM), Signal Status Message (SSM), Signal Phase and Timing (SPaT), and MAP. These messages are commonly protected by IEEE 1609.2 [IEEE-1609.2] security services and ETSI TS 103 097 [ETSI-TS-103097] profiles.

A valid signature proves possession of the private key corresponding to a credential. It does not prove that the credential should still be trusted. A certificate can require early invalidation after private-key compromise, security-module compromise, detected misbehavior, incorrect issuance, decommissioning, or policy change. A receiver that checks the signature but uses stale or unavailable revocation information can continue to accept cryptographically valid messages from an entity that the trust infrastructure has already decided to exclude.

V2X revocation has a distinctive scaling problem. Privacy protection relies on rotating pseudonymous certificates, so a single vehicle can hold many certificates over time. A revocation representation with one entry per pseudonym grows with both the number of revoked vehicles and the number of credentials provisioned per vehicle. Conversely, a representation that revokes a vehicle with one compact linkage value can reduce distribution cost but may reveal relationships among pseudonyms after revocation. The revocation design must therefore be evaluated jointly for safety, scale, availability, and privacy.

Verifier-initiated OCSP is also a poor direct fit. Safety messages are broadcast, reception-time connectivity is not guaranteed, a round trip adds variable latency, and status queries disclose which certificate a verifier is checking and when. The lightweight OCSP profile for high-volume environments [RFC9919] improves pre-production and caching, but it remains based on the classical OCSP request/response identifiers and does not by itself define V2X secured-message carriage or application-specific failure policies.

pOCSP moves the reception-time status lookup away from the verifier. The holder obtains a short-lived, responder-signed status object ahead of transmission and staples it to the message or TLS certificate presentation. The verifier validates the object offline. This changes the critical path, but it does not eliminate the fundamental freshness trade-off: a signed good response remains usable until its nextUpdate. This specification makes that limitation explicit and constrains it.

The design therefore specifies the order in which presented evidence, cached state, and authenticated revocation are combined, scopes negative status to the certificate rather than to one evidence object or application profile, and defines when cached state is discarded or must be retained.

1.1. Scope

This document defines the pOCSP status object, responder semantics, certificate and context binding, validation algorithms, caching rules, V2X and TLS profiles, privacy constraints, and IANA actions. It deliberately does not redefine CAM, DENM, or SAE J2735 [SAE-J2735] application payload schemas. Exact numerical extension identifiers and ASN.1 integration points in ETSI, IEEE, and SAE namespaces require allocation or profiling by the corresponding standards-development organizations.

The baseline supports status evidence for one certificate per response. Bulk status distribution, vehicle-level linkage-value generation, misbehavior detection, certificate issuance, and identity resolution remain outside the protocol core. pOCSP can coexist with CRLs and linkage-based revocation as an additional low-latency status channel. Status evidence is normally carried by the certificate holder; Section 14.6 additionally defines how a verifier incorporates authenticated revocation obtained from other sources.

1.2. Document Organization

Sections Section 2 through Section 7 define terminology, the relationship to existing mechanisms, design goals, the threat model, the trust architecture, and the protocol overview. Sections Section 8 and Section 9 define the certificate canonicalization, the signed context, the pID, and the protocol objects. Sections Section 10 through Section 14 specify responder processing, sender provisioning, cryptographic binding and V2X carriage, verifier processing, and the verifier status state. Sections Section 15 and Section 16 define the V2X application profiles and the TLS 1.3 integration. Sections Section 17 through Section 22 provide operational guidance, security and privacy considerations, deployment considerations, IANA actions, and a summary of normative requirements. Appendices provide the complete ASN.1 module, pseudocode, protocol scenarios, test vectors, a formal-verification blueprint, design rationale, SDO mapping guidance, and a framework for experimental evaluation and claim boundaries.

2. Conventions and Terminology

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

2.1. Terminology

Authoritative status source
The PKI component whose revocation state is authoritative for the target certificate. It may be the issuing Pseudonym Certificate Authority (PCA), a delegated status service, or a service backed by the same authoritative database.
pOCSP Responder (R)
An entity authorized to create and sign pOCSP responses for a defined certificate population and profile.
Responder authorization domain
The authoritative certificate population and policy namespace for which one or more responder keys are authorized. Redundant responders and responder-key rotations within one authorization domain share one revocation history and MUST NOT create independent status timelines. The domain applicable to a target certificate is determined from the exact issuer certificate selected by successful path validation and local trust configuration (Section 6.1), not by the evidence, an issuer-name string, or the profile.
Issuer certificate identifier
SHA-256 of the canonical encoding of the exact issuer certificate selected by successful validation of the target certificate path. For X.509 the canonical encoding is the complete DER Certificate; for an ITS certificate it is the exact COER certificate encoding. This identifier is local trust-configuration input and is not carried in pOCSP evidence.
Sender (V)
A vehicle, roadside unit, infrastructure device, or TLS endpoint that possesses the target certificate and staples pOCSP evidence.
Verifier (U)
A receiver that validates a secured message, a certificate, and the attached pOCSP evidence.
Target certificate
The end-entity pseudonymous ITS certificate or X.509 certificate whose status is asserted by pOCSP.
CertCanonical
The canonical octet representation of the target certificate defined in Section 8.1.
pID
A compact, context-specific, deterministic identifier derived from CertCanonical. It is a transport and matching identifier, not an anonymity primitive.
POCSPContext
A DER-encoded structure that identifies the protocol profile and, only where required, a channel binding.
Evidence
One DER-encoded OCSPResponse whose responseType is id-pkix-ocsp-pocsp and whose response octets contain POCSPBasicResponse.
Validity window W
nextUpdate minus thisUpdate.
Clock tolerance Delta
A deployment-specific bound on the difference between responder and verifier UTC errors at the relevant issuance and validation instants, including accumulated rate error and drift over one evidence window. Delta is a verifier-time acceptance tolerance; it is not a grace interval after nextUpdate.
Status lag D_status
The maximum real elapsed time between an authoritative revocation decision and its availability to every pOCSP Responder of the authorization domain. D_status includes status propagation and processing delay and is defined independently of timestamp skew.
Native certificate validity
The validity predicate of the target certificate type. An X.509 certificate is valid through notAfter, inclusive, as specified by [RFC5280]. An ITS certificate using the validityPeriod representation of [ETSI-TS-103097] is valid in the half-open interval whose start is included and whose end is excluded. pOCSP does not replace either native predicate with a common certificate-expiry comparison.
Status version
The version of the authorization-domain-wide authoritative status snapshot from which a good or revoked assertion is derived. Value zero is reserved for unknown. Every committed change to that snapshot advances the positive version, and all good or revoked evidence derived from the same snapshot carries the same value. The sequence is global to one responder authorization-domain epoch, is not assigned per certificate, vehicle, or subscriber, and is independent of responder wall-clock time and responder-key rotation.
Responder authorization-domain epoch
An authenticated generation of a responder authorization domain in local trust configuration. A new epoch is created only by administrative recovery, for example after responder compromise or exhaustion of the statusVersion space. The certificate status state of Section 14 is scoped to the epoch and MUST NOT be reset merely by responder-key rotation.
Recovery statement
An authenticated trust-management assertion, issued under an authority independent of every responder key that it retires, which creates a new authorization-domain epoch and states exactly which protected verifier state may be cleared. Section 18.6 defines its required security properties; its wire encoding is supplied by the applicable trust-management profile.
Certificate status state
The verifier state attached to one target certificate within one responder authorization-domain epoch: a sticky revoked flag, the lowest authenticated revoked statusVersion, the highest authenticated good statusVersion, and an equivocation-conflict flag (Section 14.1). It is independent of the application profile.
Usable evidence
Authenticated evidence whose validity window contains the verifier's current time under the rules of Section 13.2.
Full-certificate message
A secured V2X message whose signer identifier conveys the complete target certificate rather than only a digest or cached-certificate reference.
UNCONFIRMED
An application-level state, produced by an application profile as the mapping of the core validator results UNAVAILABLE or UNKNOWN only after the secured-message signature, certificate chain, certificate validity, and application permissions have been successfully validated. It indicates that the message is authenticated but its certificate status is not currently confirmed by pOCSP. UNCONFIRMED is never an output of the core validator itself (Section 13.1).

3. Relationship to Existing Revocation Mechanisms

pOCSP is not a replacement for every revocation mechanism. It occupies a particular design point: short-lived, single-certificate, presenter-carried evidence that enables offline verification at reception time. This section explains how it relates to existing mechanisms.

The problem characterization and design trade-offs are consistent with the V2X revocation and pseudonym literature, including the revocation survey [WANG2020], the pseudonym-scheme survey [PETIT2015], CRL organization and distribution [HAAS2011], vehicle-centric CRL distribution [KHODAEI2018], formally verified bounded self-revocation [SCOP2024], Merkle-based privacy-aware revocation [GANAN2015], and verifier-local group-signature revocation [BONEH2004].

3.1. CRLs and Delta CRLs

CRLs provide local verification after distribution and remain a useful baseline and recovery mechanism. Their principal V2X limitations are distribution volume, dissemination delay, partial reception under mobility, version management, and the multiplication of entries when many pseudonyms correspond to one revoked vehicle. Fragmentation, regionalization, delta updates, erasure coding, vehicle-to-vehicle forwarding, and linkage-based compression reduce some of these costs but do not eliminate the need to absorb fresh revocation state. pOCSP does not require that CRLs disappear. A deployment can use CRLs for comprehensive background state and pOCSP for a bounded, recent status assertion on the reception path. Because revocation is terminal in the baseline (Section 9.1), an authenticated revocation of the target certificate obtained from a CRL, a linkage-based revocation list, or another authoritative source accepted by local policy sets the sticky revoked state of Section 14.1 whatever its age relative to the pOCSP evidence. Valid pOCSP good evidence never overrides it.

3.2. OCSP and the High-Volume Profile

RFC 6960 [RFC6960] defines OCSP status semantics and the OCSPResponse envelope. RFC 9919 [RFC9919] defines a lightweight profile for high-volume environments, including response pre-production, caching, and reduced message size; it obsoletes RFC 5019. pOCSP reuses the OCSPResponse envelope and status semantics but defines a distinct response type, a context-specific certificate identifier, and V2X/TLS carriage profiles.

pOCSP stapling is deliberately request-independent on the data plane. A verifier never sends an OCSP request as part of reception-time validation. Direct diagnostic requests, when implemented, are outside the safety critical path. A responder that processes nonce-bearing diagnostic requests follows RFC 9654 [RFC9654], but nonce-bound responses are not used as reusable broadcast evidence. RFC 9654 also carries the current normative ASN.1 module for OCSP, from which Appendix A imports.

3.3. Linkage-Based and Vehicle-Level Revocation

Security Credential Management System (SCMS) architectures [SCMS2018] and related work use linkage values or seeds to represent revocation at vehicle level. These mechanisms can be substantially more compact than one-entry-per-pseudonym CRLs, but they depend on a specific back-end architecture and introduce a post-revocation privacy trade-off. pOCSP does not define linkage derivation. It can carry status for a certificate issued in such an architecture and can coexist with linkage-based CRLs.

3.4. Self-Revocation and Trusted-Hardware Schemes

Recent research provides predictable revocation-time bounds by relying on a trusted processing element that disables or erases credentials [SCOP2024]. Such mechanisms address a different point in the design space and can provide stronger guarantees against a compromised holder. pOCSP does not assume that the sender cooperates after revocation and cannot force a stolen private key to stop signing. Its security bound is instead the validity window of the last acceptable good evidence plus time and status-propagation tolerances.

4. Design Goals and Non-Goals

The following goals guide the protocol and are used to evaluate conformance.

The following are explicit non-goals.

Appendix H separates specified mechanisms and conditional analytical bounds from empirical, interoperability, privacy, and formal-proof claims that require evidence outside this document.

5. Threat Model and Assumptions

The network attacker can observe, inject, modify, delay, reorder, replay, and suppress radio or IP traffic, in the sense of the symbolic attacker of [DOLEV1983]. The attacker can operate multiple receivers and correlate observations across locations and layers. Compromise of a sender private key is in scope. Compromise of the pOCSP Responder signing key is considered separately because it defeats the evidence authenticity property.

5.1. Attacks in Scope

  • Replay of a secured CAM, DENM, BSM, or other message with still-valid good evidence.
  • Reuse of evidence with a different certificate or a different application profile.
  • Removal or substitution of evidence when it is not cryptographically bound to the message.
  • Presentation of good evidence after an authenticated revocation of the same certificate was observed, including by omitting, expiring, or version-manipulating evidence.
  • Conflicting good and revoked assertions (equivocation) issued by redundant responders or across responder-key rotations.
  • Oversized, malformed, deeply nested, or algorithm-agile inputs intended to exhaust CPU or memory.
  • Time-shift attacks that exploit a verifier clock error or GNSS time spoofing.
  • Passive tracking using a repeated pID, certificate, radio address, timing pattern, position, or cross-layer metadata.
  • Responder or distribution-point unavailability.

5.2. Assumptions

  • A1 - Verifiers possess an authenticated trust anchor or local authorization mapping for each accepted pOCSP Responder.
  • A2 - The responder receives authoritative revocation state with a bounded status lag D_status.
  • A3 - For profiles that accept time-based evidence, write the responder and verifier clock readings at real instants tau and t as R(tau) = tau + e_R(tau) and V(t) = t + e_V(t). For every issuance and validation pair within one evidence lifetime, |e_R(tau) - e_V(t)| <= Delta. This bound includes offset, rate error, and permitted drift of both clocks.
  • A4 - The target certificate encoding is available to the verifier whenever evidence is processed.
  • A5 - The V2X secured-message envelope or TLS handshake protects the association between the target certificate, the application payload, and the evidence.
  • A6 - Cryptographic hash and signature algorithms meet the deployment security level and are implemented correctly.
  • A7 - When the authoritative decision excludes a device rather than one certificate, the authoritative status source covers every still-usable certificate of that device, including certificates provisioned for future validity periods, in the same snapshot (Section 10, step 5). pOCSP does not define how the source resolves a device to its certificates.

5.3. Revocation-Effect Bound

This section bounds the time during which good evidence issued before a revocation can still produce a GOOD result. Instants are expressed in UTC. The bound assumes an honest responder, no future-active good evidence, assumptions A2 and A3, and clocks whose rates remain within the drift budget included in Delta over one window W_max.

Let t_r be the instant of the revocation decision. By A2, every responder of the domain holds the revocation at t_r + D_status at the latest, so every good response that predates it was signed at an instant tau <= t_r + D_status. Let R(t) denote the responder time base and V(t) the verifier clock. Such a response satisfies:

   nextUpdate <= thisUpdate + W_max <= producedAt + W_max
               = R(tau) + W_max

The verifier treats the response as usable only while V(t) < nextUpdate (Section 13.2, step 10). Substituting the error terms of A3, usability implies

   t + e_V(t) < tau + e_R(tau) + W_max

and therefore t - tau < W_max + e_R(tau) - e_V(t), which is at most W_max + Delta. Therefore:

   D_effective <= D_status + W_max + Delta

where D_effective is the maximum delay between t_r and the last instant at which previously issued good evidence can produce GOOD. A deployment that estimates D_status from timestamps produced by different clocks MUST include the uncertainty of that measurement in the configured D_status; it MUST NOT implement it as a post-nextUpdate acceptance tolerance. MaxBackdate does not extend the bound, because thisUpdate <= producedAt and W_max caps nextUpdate - thisUpdate. Cached GOOD state obeys the same bound, because a cache entry expires no later than the nextUpdate of the evidence that created it (Section 14.2). Authenticated revocation received from another source (Section 14.6) can only shorten D_effective at the verifier that receives it.

The bound has three explicit limits. First, it bounds GOOD only. Under a permissive profile, a revoked holder that omits evidence obtains the application state UNCONFIRMED for as long as its certificate and message are otherwise valid; no evidence-based bound applies to that state (Section 18.1). Second, it assumes an honest responder; Section 18.6 covers responder compromise. Third, it excludes application processing after the validator returns.

6. Architecture and Trust Model

pOCSP separates the status authority from the data-plane verifier. The responder generates evidence from authoritative revocation state. The sender obtains evidence over an authenticated management channel or at certificate issuance. The verifier receives evidence only as part of an authenticated V2X message or TLS certificate presentation.

       Authoritative revocation state
                    |
                    v
             +-------------+
             | pOCSP       |
             | Responder R |
             +-------------+
                 |  short-lived signed evidence
                 v
             +-------------+       secured message + evidence
             | Sender V    | -------------------------------->
             +-------------+                        Verifier U
                                    no online query at reception
Figure 1: pOCSP roles and data flow

6.1. Responder Authorization

A verifier MUST verify both the responder signature and the responder authorization for the target certificate. Merely possessing a syntactically valid signature is insufficient.

The verifier first validates the target certificate path and selects the exact issuer certificate that validated the target certificate. It then computes the issuer certificate identifier of Section 2.1. Local trust configuration maps that identifier to exactly one responder authorization domain and its current epoch, and maps the domain to authorized responder keys and profile OIDs. An X.509 issuer name and authorityKeyIdentifier, or an ITS issuer field or HashedId8, MUST NOT be used as the sole domain identifier: those fields help construct a path but do not replace identification of the certificate that successfully validated it. The mapping is independent of evidence, which allows the verifier to consult the status state of Section 14 when evidence is absent. A responder key MAY be authorized for several issuer certificate identifiers, but each authorization MUST be explicit.

For an X.509 target certificate, a baseline authorization MUST meet one of the following conditions, consistently with Section 4.2.2.2 of [RFC6960]:

  • the response is verified with the public key of the exact issuing CA certificate selected above;
  • the response is verified with a delegated responder certificate issued directly under the same issuing key, the responder certificate contains id-kp-OCSPSigning in Extended Key Usage, and local trust configuration authorizes its responderKeyHash for the expected pOCSP profile; or
  • local trust configuration explicitly authorizes the responder key for the issuer certificate identifier and expected profile. A generic certification path to a trusted CA is not sufficient.

For an ITS target certificate, successful validation of a responder credential is likewise insufficient by itself. The applicable ITS profile MUST define an authenticated trust-list entry, application permission, or security-management assertion that binds the responder key to the issuer certificate identifier, domain, epoch, and profile OIDs. Until an ETSI, IEEE, or ecosystem profile defines such an assertion, an explicit locally provisioned mapping is REQUIRED.

The pOCSP response carries no responder certificate chain (Section 9.1). Responder certificates, raw keys, or compact key identifiers and their authorization mappings therefore MUST be available to the verifier through authenticated trust management. C-ITS deployments can use mechanisms of [ETSI-TS-102941], [ETSI-TS-103601], or the SCMS trust infrastructure. A TLS endpoint can use a provisioned responder chain, but MUST apply the same issuer, epoch, and profile checks.

Lookup by responderKeyHash MUST yield exactly one authorized key in the selected domain, epoch, and profile. Zero matches or more than one match is INVALID. A verifier SHOULD record a multiple-match event as a trust-configuration error.

Because the authorization-domain epoch is not carried in the pOCSP object, trust configuration MUST bind each authorized responderKeyHash to exactly one authorization domain and one epoch. Responder key material MUST NOT be reused across epochs. After an epoch transition, evidence signed by a key authorized only for an older epoch is INVALID, whatever its statusVersion, and does not update the certificate status state of the new epoch. A responder key that has been retired or revoked MUST NOT be authorized again, in the same epoch or in any later one; a verifier SHOULD retain the identifiers of retired keys for at least the validity period of the certificates they covered, so that a re-provisioned key is recognized and rejected. When a responder key loses its authorization, every cached good entry derived from evidence signed by that key MUST be discarded (Section 14.2); the certificate status state is not affected. A planned rotation SHOULD include an authorization overlap long enough for the new keys to reach verifiers before the old keys are retired.

A responder MUST NOT return good for a certificate merely because it does not appear in a local revocation list. It returns good only when it is authoritative for the certificate, the certificate is known as issued, and the authoritative state indicates that it is not revoked at producedAt. Lack of authoritative knowledge results in unknown.

All redundant responder keys in one responder authorization domain MUST consume the same authoritative statusVersion sequence and the same committed snapshots, as specified in Section 10.3. Responder-key rotation MUST preserve that sequence. A deployment MUST NOT use independent wall clocks as the sole ordering mechanism for conflicting status assertions.

6.2. Role Separation and Privacy

The certificate issuer already knows the relationship between its issued certificate and the relevant credential-management record. Using the issuer or a tightly coupled delegated responder avoids disclosing the certificate to an unrelated third-party status service. Deployments SHOULD minimize responder logs, avoid retaining requester network identifiers beyond operational need, and obtain evidence over an authenticated confidential management channel.

Evidence retrieval itself can link pseudonyms at the responder: if a vehicle refreshes evidence for successive pseudonyms over one management session or from one network identity, the responder or an observer of the management channel can associate those pseudonyms. Deployments SHOULD prefer delivery of initial evidence at certificate issuance (inside the existing butterfly-key provisioning exchange of [IEEE-1609.2.1], where applicable) and SHOULD structure refresh so that requests for distinct pseudonyms are not trivially attributable to one vehicle, for example by per-pseudonym retrieval through the location-obscuring or anonymizing facilities that the credential-management architecture already provides.

Delivery at certificate issuance applies only when the certificate validity period has begun or will begin within the currently active evidence window. Evidence for pseudonyms whose validity begins later MUST be obtained near activation through a privacy-preserving credential-management mechanism; a responder MUST NOT solve this problem by issuing future-active good evidence.

7. Protocol Overview

  1. The sender and verifier determine a profile object identifier from the application and carriage context.
  2. The sender or issuer obtains a pOCSP response for the target certificate. The response is already active; its thisUpdate is not in the future.
  3. The responder computes the context-specific pID, records good, revoked, or unknown, includes producedAt, thisUpdate, and nextUpdate, and signs the response data.
  4. The sender carries the DER OCSPResponse in a signed V2X secured-message extension or in the TLS 1.3 status_request CertificateEntry extension.
  5. The verifier authenticates and authorizes the target certificate and responder, checks context, pID, and freshness, updates the certificate status state, and returns the decision of Section 14.4, which the profile maps to an application action.

The baseline response contains exactly one certificate status. A responder does not bundle several pseudonyms into one object. This prevents co-occurrence from creating a direct pseudonym-linking channel and bounds parser and matching complexity.

8. Certificate Representation, Context, and pID

8.1. Canonical Certificate Representation

pID derivation requires a unique octet representation. The generic term CertCanonical is defined as follows:

  • For an IEEE 1609.2 [IEEE-1609.2] / ETSI TS 103 097 [ETSI-TS-103097] ITS certificate, CertCanonical is the exact original COER encoding of the certificate, using the Octet Encoding Rules of [X696]. An implementation MUST preserve these octets when it decodes or caches the certificate. If the original octets are unavailable, re-encoding is permitted only when the active profile defines one deterministic COER form and the implementation can establish that the re-encoding is the canonical representation of the same certificate. Otherwise, pID derivation fails. Implementations MUST NOT translate the certificate into DER, JSON, or an implementation-specific object before hashing.
  • For an X.509 certificate, CertCanonical is the complete DER encoding, as specified by [X690], of the Certificate structure defined by RFC 5280 [RFC5280].
  • A profile supporting any additional certificate type MUST define one unique canonical octet representation.

If the full target certificate is not available, the verifier cannot recompute pID and MUST NOT accept new evidence. It may continue to use a previously validated cache entry under the digest-to-certificate association maintained by the underlying V2X stack, subject to Section 14.

8.2. POCSPContext

The signed context prevents use of evidence across profiles that have different issuance, freshness, carriage, or failure semantics. It is an ASN.1 structure encoded with DER, not an unconstrained text string.

POCSPContext ::= SEQUENCE {
    profile          OBJECT IDENTIFIER,
    channelBinding   OCTET STRING (SIZE(32..64)) OPTIONAL
}

The profile OID is mandatory. channelBinding is absent for V2X broadcast and for pOCSP carried in the TLS status_request CertificateEntry extension, because the outer signed message or TLS transcript already supplies binding. channelBinding is mandatory for the exceptional application-layer TLS profile in Section 16.2.

The context MUST NOT contain a VIN, stable vehicle identifier, account identifier, subscriber identifier, position, region trace, or any value that creates a new long-lived tracking handle.

8.3. pID Derivation

Let H be SHA-256 [FIPS180-4]. Let contextDER be the DER encoding of POCSPContext. Let certDigest = SHA-256(CertCanonical). The baseline pID is, for the pID length L_pID selected by the profile:

pID = leftmost_L_pID( SHA-256( "pocsp-id-v1" || certDigest
                               || contextDER ) )

The ASCII domain-separation string is encoded as the 11 octets 70 6f 63 73 70 2d 69 64 2d 76 31. L_pID MUST be either 16 or 32 octets. The profiles defined in this document use 16 octets. A new profile that selects 32 octets uses the same derivation without truncating the SHA-256 output.

Truncation has two different security bounds. Finding a second certificate that matches the pID of one fixed authenticated certificate requires approximately 2^128 hash evaluations under the random-oracle model, whereas finding any pair of certificates with a colliding 128-bit pID has generic birthday cost approximately 2^64. The latter is below a 128-bit collision-security target and MUST NOT be described as providing 128-bit collision resistance.

Protocol correctness does not rely on resolving a certificate from a pID: a verifier always recomputes pID from the exact certificate it has authenticated. In addition, a responder using a 16-octet pID MUST maintain a collision index covering every issued certificate in its authorization domain for each supported context. If two certificates have the same pID under one context, it MUST NOT issue good evidence for either certificate under that context and MUST raise an operational alarm. A profile whose security target or authoritative database cannot accept this collision-management requirement MUST use a 32-octet pID. Profiles using 32 octets obtain the full SHA-256 collision margin and SHOULD be preferred where the additional 16 octets are operationally acceptable.

8.4. Privacy Properties and Limitations of pID

pID is non-invertible only to the extent that SHA-256 is preimage resistant and the certificate is not guessed. It is not unlinkable. An observer that sees or obtains CertCanonical can compute pID. If pID is repeated while the certificate is omitted, pID can become a tracking beacon that is easier to compare than a signature. To avoid additional linkability, the V2X broadcast profiles impose two rules: evidence MUST be single-certificate, and pOCSP evidence MUST NOT be transmitted more frequently than the full target certificate. In the baseline CAM/BSM profile, pOCSP evidence is carried only on full-certificate messages. Digest-only messages rely on a previously validated cache entry.

Context separation changes pID across application profiles and prevents protocol substitution. It does not provide privacy against an observer who knows the certificate and the profile OIDs.

9. Protocol Objects and OCSP Encapsulation

pOCSP uses the OCSPResponse envelope from RFC 6960 [RFC6960]. A successful response uses a new responseType object identifier, id-pkix-ocsp-pocsp, requested in Section 21. The response OCTET STRING contains the DER encoding of POCSPBasicResponse.

OCSPResponse ::= SEQUENCE {
    responseStatus          OCSPResponseStatus,
    responseBytes       [0] EXPLICIT ResponseBytes OPTIONAL
}
ResponseBytes ::= SEQUENCE {
    responseType            OBJECT IDENTIFIER,
    response                OCTET STRING
}
-- For pOCSP:
-- responseType = id-pkix-ocsp-pocsp
-- response     = DER(POCSPBasicResponse)

OCSPResponse, OCSPResponseStatus, and ResponseBytes are exactly the structures of [RFC6960]; this document does not redefine them (see Appendix A).

9.1. pOCSP Response Data

POCSPBasicResponse ::= SEQUENCE {
    tbsResponseData         POCSPResponseData,
    signatureAlgorithm      AlgorithmIdentifier,
    signature               BIT STRING
}
POCSPResponseData ::= SEQUENCE {
    version                 INTEGER (0) DEFAULT 0,
    responderKeyHash        OCTET STRING (SIZE(32)),
    statusVersion           INTEGER (0..9223372036854775807),
    producedAt              GeneralizedTime,
    context                 POCSPContext,
    certID                  POCSPCertID,
    certStatus              POCSPCertStatus,
    thisUpdate              GeneralizedTime,
    nextUpdate              GeneralizedTime,
    responseExtensions  [0] EXPLICIT Extensions OPTIONAL
}
POCSPCertID ::= SEQUENCE {
    hashAlgorithm           AlgorithmIdentifier,
    pID                     OCTET STRING (SIZE(16 | 32))
}
POCSPCertStatus ::= CHOICE {
    good                [0] IMPLICIT NULL,
    revoked             [1] IMPLICIT RevokedInfo,
    unknown             [2] IMPLICIT NULL
}

Because DER requires that fields equal to their DEFAULT value be omitted from the encoding, the version field is absent on the wire in this version of the protocol.

responseExtensions uses the Extensions syntax of [RFC5280]. This document defines no response extension. Evidence for the V2X profiles of Section 15 MUST NOT contain responseExtensions, and a verifier applying those profiles MUST reject evidence that does. Other profiles MAY define extensions; a verifier MUST reject evidence that contains an unrecognized critical extension or more than one instance of a given extension. An extension cannot relax a requirement of this document.

All GeneralizedTime values in pOCSP MUST be expressed in Coordinated Universal Time (UTC), MUST include seconds, MUST NOT include fractional seconds, and MUST end with "Z", following the representation rules of [RFC5280] and the DER rules of [X690]. A verifier MUST reject any other GeneralizedTime form.

hashAlgorithm identifies the hash used in the pID construction and is SHA-256 in the baseline. responderKeyHash is computed as follows:

  • For an X.509 responder certificate, responderKeyHash is SHA-256 over the value octets of the subjectPublicKey BIT STRING of the responder SubjectPublicKeyInfo, excluding the tag, length, and number of unused bits, in the manner of the KeyHash of [RFC6960] with SHA-256 in place of SHA-1.
  • For an ITS responder credential or a raw provisioned key, responderKeyHash is SHA-256 over the COER encoding of the IEEE 1609.2 PublicVerificationKey value. The active profile MUST name the curve, and the elliptic-curve point MUST be encoded in its compressed form, that is, compressed-y-0 or compressed-y-1 as determined by the parity of the point's y-coordinate; the uncompressed and x-only forms MUST NOT be used as hash input. This canonical form is fixed across all conforming deployments; hashing a per-deployment or implementation-specific key serialization is prohibited.

For good and revoked, statusVersion is copied from the version of the authorization-domain-wide authoritative status snapshot. It is positive and advances whenever any committed status change creates a new snapshot. All good or revoked evidence derived from one snapshot carries the same statusVersion. The value survives responder-key rotation and MUST NOT be maintained as a per-certificate, per-vehicle, or per-subscriber counter. For unknown, statusVersion is zero. producedAt remains a response-generation time; it is not a substitute for statusVersion.

statusVersion is limited to the non-negative signed 63-bit range 0..9223372036854775807. Its DER INTEGER content therefore fits in at most 8 octets without requiring a ninth sign-protection octet. A verifier MUST reject a negative value, a value outside this range, or a longer encoding before signature verification. The sequence MUST NOT wrap, be reused, or be reset within one responder authorization-domain epoch. Exhaustion requires authenticated creation of a new epoch and the recovery procedure described in Section 18.6.

Domain-wide snapshot scoping also avoids additional linkability: a finer-grained sequence could become a stable tracking handle linking the pseudonyms of one vehicle or subscriber (Section 19).

nextUpdate is mandatory. The baseline profiles support only terminal revocation. A conforming baseline responder MUST NOT emit certificateHold or removeFromCRL in RevokedInfo. A baseline verifier MUST reject either reason as INVALID and MUST require revocationTime <= producedAt. Other accepted CRLReason values, and an absent reason, are interpreted as terminal for the target certificate. A profile that supports reversible suspension MUST define a separate state transition and recovery procedure and MUST NOT reuse the terminal revokedFlag rules unchanged.

Once a verifier has authenticated a conforming revoked status for a certificate, that certificate remains revoked for the verifier, in every profile, until it is no longer valid under its native validity rules or an authenticated recovery statement authorizes specific state clearing (Sections Section 14 and Section 18.6). Consequently, an honest authorization domain never reports a certificate as good in a snapshot whose version is equal to or greater than that of a snapshot in which the certificate is revoked; Section 14.3 turns this property into a verifier check.

9.2. Algorithm Profile

The baseline uses SHA-256 for certDigest, pID, and responderKeyHash. Signature algorithms are profile-controlled. A V2X profile MUST support ECDSA with the NIST P-256 curve and SHA-256 because it is widely aligned with current ITS security profiles. ECDSA-with-SHA256 AlgorithmIdentifier parameters MUST be absent as required by [RFC5758].

For id-ecdsa-with-SHA256, the signature BIT STRING MUST have zero unused bits and MUST contain the complete DER encoding of ECDSA-Sig-Value, a SEQUENCE of the INTEGER values r and s as defined in Section 2.2.3 of [RFC3279] and required by [RFC5758]. IEEE 1609.2 EccP256Signature encodings and fixed-width r || s encodings MUST NOT be used in this field.

The certID hashAlgorithm MUST be id-sha256 with absent parameters. Deployments MAY additionally support algorithms approved by their trust policy, but algorithm selection MUST NOT be attacker-controlled and verifiers MUST reject unconfigured algorithms before expensive processing.

9.3. Size and Cardinality Limits

The baseline POCSPBasicResponse contains one status only. Profiles MUST define MaxEvidence. The generic upper bound is 4096 octets; the V2X profiles in Section 15 use 1024 octets. A verifier MUST reject an OCSPResponse larger than MaxEvidence before parsing the nested response.

Table 1: Size and cardinality limits
Parameter Generic limit V2X profile
Number of statuses 1 1
pID length 16 or 32 octets 16 octets
statusVersion value 0..2^63-1 0..2^63-1
Context DER length 5..128 octets 5..64 octets
Evidence length <=4096 octets <=1024 octets
Response extensions profile rules absent
Signature algorithms local policy profile-fixed set

The lower bound of 5 octets for the context corresponds to the smallest possible DER SEQUENCE containing one OBJECT IDENTIFIER. For reference, the complete good evidence of Appendix D.4, signed with ECDSA P-256, occupies 256 octets.

10. Responder Processing and Evidence Generation

A responder creates evidence only from authoritative state. The following procedure is normative.

  1. Authenticate the provisioning requester or identify a certificate issuance workflow. This step is outside reception-time validation.
  2. Determine the target certificate, its authorization domain, and the profile OID. Reject if the responder is not authoritative for that domain and profile.
  3. Construct CertCanonical, contextDER, and pID exactly as specified in Section 8. When the profile uses a 16-octet pID, consult the complete collision index required by Section 8.3 before issuing good. A detected collision prevents good evidence for both certificates in that context.
  4. Set producedAt to the responder current time. Set thisUpdate no later than producedAt. Select a candidate nextUpdate after producedAt and no later than thisUpdate plus the profile W_max.
  5. Read the authorization-domain-wide authoritative status snapshot and its statusVersion. Return good only for a known, issued, non-revoked certificate that is currently valid or whose validity period begins before the selected nextUpdate (Section 6.2), and use the positive version of that snapshot; the verifier independently enforces the certificate validity period at use time. Return revoked only for a terminal revocation whose revocationTime is not later than producedAt, and do not emit the certificateHold or removeFromCRL reasons in a baseline profile. Use the positive snapshot version. Return unknown with statusVersion zero when authoritative status cannot be established. Redundant responders in one authorization-domain epoch use the same positive statusVersion for all evidence derived from the same snapshot. When the authoritative decision excludes a device, the authoritative status source MUST record every still-usable certificate of that device, including certificates provisioned for future validity periods, as revoked in the snapshot that records the decision, so that no responder issues replacement good evidence for any of them (assumption A7).
  6. Construct POCSPResponseData, sign its DER encoding, wrap the result in OCSPResponse with responseType id-pkix-ocsp-pocsp, and deliver it to the sender over an authenticated confidential management channel.

10.1. Time Rules and Prohibition of Future-Active Good Evidence

  • thisUpdate MUST be present and MUST NOT be later than producedAt.
  • nextUpdate MUST be present and MUST be later than producedAt.
  • nextUpdate - thisUpdate MUST NOT exceed the profile W_max.
  • producedAt - thisUpdate MUST NOT exceed the profile MaxBackdate.
  • A responder MUST NOT issue a good response whose thisUpdate is in the future.
  • A responder MUST NOT issue a sequence of future-active good responses to bridge a connectivity outage. Such a sequence extends the effective stale-good exposure after revocation.

A sender may refresh evidence early while the replacement evidence is already active. It may store overlapping currently active responses, but it transmits only the freshest acceptable response. Availability during outages is controlled by W_max and the profile failure policy, not by pre-authorizing future good states.

10.2. Status Semantics

good means that the responder is authoritative, recognizes the target certificate as issued, and has no authoritative revocation effective at producedAt. good does not mean that the subject is honest, that the message is plausible, or that the private key is uncompromised.

revoked means that the responder has an authoritative terminal revocation. revocationTime is the effective time known to the responder and revocationReason is included when available and safe to disclose.

revocationTime serves audit and diagnostics. A verifier MUST NOT accept a message on the ground that its generation time precedes revocationTime: generation time is asserted by the sender, and the holder of a compromised key can choose it.

unknown means that the responder cannot make an authoritative good or revoked assertion. An unknown response carries statusVersion zero. A certificate that the responder does not recognize as issued yields unknown; the OCSP convention of answering revoked for a non-issued certificate (Section 2.2 of [RFC6960]) is not used, because revoked is terminal in pOCSP. Verifiers MUST NOT convert unknown into good, and unknown evidence never changes the certificate status state (Section 14.3).

10.3. Snapshot Commit and Redundant Responders

statusVersion is meaningful only if the status snapshot and its version are committed atomically. An authorization domain MUST meet the following requirements:

  • A response is generated only from a committed snapshot. The snapshot identifier and statusVersion MUST be read as one atomic unit.
  • Each committed status change allocates one strictly greater positive statusVersion. A version MUST NOT be published, reused, or reassigned to different snapshot contents.
  • Redundant responders and signers MUST obtain snapshots and versions from the same authoritative replicated log or an equivalent consistency mechanism. A responder MUST NOT allocate versions independently during a network partition.
  • A replica that cannot establish that its snapshot remains within D_status of the authoritative state MUST stop issuing good. It MAY return unknown or stop serving evidence according to the deployment availability policy.
  • Failover, restoration from backup, and responder-key rotation MUST preserve the last committed version and MUST NOT roll the sequence back. Exhaustion or loss of trustworthy sequence state requires a new epoch and a recovery statement (Section 18.6).

This document does not mandate a consensus algorithm. A deployment claiming the bound of Section 5.3 MUST document and test the commit, replication, partition, and recovery mechanism that enforces these requirements.

11. Sender Provisioning, Selection, and Refresh

The provisioning channel is not on the V2X reception critical path. It can be an existing certificate-management channel, an authenticated backend session, or delivery at certificate issuance. This document does not define an interoperable request, authentication, authorization, or delivery protocol for that channel. The evidence object and validation behavior interoperate only when both implementations also share an application profile and responder-trust configuration as specified in Sections Section 6 and Section 15.

  1. For each active certificate and context, store zero or more pOCSP responses indexed by certificate digest, context (profile OID and, where present, channel binding), responder key hash, statusVersion, thisUpdate, and nextUpdate.
  2. Before transmission, discard responses whose nextUpdate has passed, whose target certificate is no longer natively valid, or whose responder is no longer authorized.
  3. Select, among currently active, context-matching responses in the current authorization-domain epoch, the response with the greatest statusVersion and, among those, the one with the latest nextUpdate. A sender that obtains revoked evidence for a certificate MUST stop signing with that certificate.
  4. Never use a response for a different certificate, context, or responder authorization domain.
  5. For a full-certificate V2X message, attach evidence according to the profile. For a digest-only message, do not attach new evidence; rely on receiver cache.
  6. If no acceptable evidence is available, follow the sender-side profile policy. A strict profile prohibits emission under that certificate. A permissive awareness profile may emit without evidence, but receivers treat status as UNCONFIRMED rather than good.

11.1. Refresh Timing

A sender SHOULD begin refresh before nextUpdate by a margin that covers management-channel latency, retries, and clock error. A useful engineering rule is:

refreshStart = nextUpdate - max(RefreshMargin,
                                2*Delta + RTT_management)

RefreshMargin is profile- and deployment-specific. Early refresh does not increase the stale-good bound when the replacement response is already active and has its own short window.

12. Cryptographic Binding and V2X Carriage

pOCSP evidence is security metadata. It MUST be cryptographically bound to the target certificate presentation and the application message. An unsigned sidecar is non-conformant.

12.1. Generic Binding Rules

  • pOCSP evidence MUST NOT be carried in unsecured (unsigned) messages.
  • The exact DER OCSPResponse octets MUST be covered by the sender signature, or a collision-resistant hash of those exact octets MUST be covered by the sender signature and the evidence transported in the same authenticated unit.
  • The target certificate used to verify the sender signature MUST be the certificate used to recompute pID.
  • Removal of evidence MUST be detectable. A profile that allows evidence omission defines an explicit UNCONFIRMED state; an implementation MUST NOT silently treat stripped evidence as good.
  • Application payload schemas remain unchanged unless the relevant SDO defines an application extension.

12.2. ETSI TS 103 097 / IEEE 1609.2 Secured-Envelope Profile

The preferred V2X mapping carries the DER OCSPResponse as an originating secured-header extension within data covered by the IEEE 1609.2 [IEEE-1609.2] SignedData signature, using the contributed-extension mechanism (HeaderInfo contributed extensions) or an equivalent extension point defined by the active ETSI/IEEE profile. The SDO-specific extension identifier is TBD by the relevant SDO. Until such a profile allocates the identifier and defines the exact enclosing type, criticality, unknown-extension behavior, size bound, signed-byte coverage, and a complete encoding vector, this mapping is suitable only for coordinated experiments and closed deployments.

ETSI TS 103 097 [ETSI-TS-103097] provides the header-extension mechanism but allocates no pOCSP extension, and it defines revocation only for authority certificates, through the trust-list and CRL mechanisms of [ETSI-TS-102941]; it specifies no revocation method for authorization tickets. pOCSP therefore does not conflict with an existing ETSI status mechanism for end-entity certificates, but it also cannot claim conformance to one. Carrying octets that an existing decoder tolerates is not the same as having a profiled extension; Section 12.4 and Section 20 describe what remains with the SDO.

Ieee1609Dot2Data / SignedData
  tbsData
    payload                 CAM, DENM, or J2735 bytes (unchanged)
    headerInfo
      signer identifier     full certificate on evidence-bearing
                            messages
      contributedExtensions
        pOCSP extension ID  (SDO allocation)
        extension value     OCTET STRING containing
                            DER(OCSPResponse)
  signature                 covers headerInfo and payload
Figure 2: Preferred secured-envelope carriage

A verifier MUST first establish which certificate is the signer certificate according to the underlying secured-message profile. It then validates the pOCSP object against that exact certificate.

12.3. Signed-Wrapper Fallback

If the deployed secured-envelope profile lacks an interoperable extension point, an SDO MAY define a signed payload wrapper containing the original application payload bytes and the pOCSP evidence. The wrapper MUST preserve the original payload encoding byte-for-byte and MUST itself be inside SignedData. This document does not allocate the wrapper identifier.

12.4. Legacy Receivers

A legacy receiver that does not understand pOCSP can continue to authenticate the underlying signed message if the applicable SDO profile permits unknown extensions to be ignored. Such a receiver has not performed pOCSP validation. Deployments MUST NOT advertise that receiver as pOCSP-conformant and MUST account for mixed-fleet behavior in safety policy.

13. Verifier Processing

A verifier MUST implement the procedure of this section, or one that returns identical results for every input. The procedure separates two concerns. Validation of evidence carried with a message may update the certificate status state of Section 14. The decision is always computed from that state, never from the evidence object alone. In particular, absent, expired, or unknown evidence cannot mask an authenticated revocation.

13.1. Inputs and Outputs

Inputs are the secured message Msg, the target certificate Cert, the exact evidence bytes Evd if present, the expected profile OID, current time now, Delta, local trust configuration, and the status state of Section 14.

The core validator returns one of: GOOD, REVOKED, UNKNOWN, UNAVAILABLE, or INVALID. The application profile maps the core result to accept, reject, degraded processing, or additional validation. UNAVAILABLE or UNKNOWN MUST NOT be mapped to UNCONFIRMED, and the application payload MUST NOT be processed as authenticated, until the secured-message signature, certificate chain, certificate validity, and application permissions have all been successfully validated.

13.2. Ordered Validation Algorithm

  1. Message and certificate: identify the exact signer certificate according to the active V2X or TLS profile, construct CertCanonical, and validate the certificate chain, the certificate validity period using the native certificate-type semantics, the application permissions, and the message signature. On failure, return INVALID. Select the exact issuer certificate that validated the target certificate, compute its issuer certificate identifier, and determine the responder authorization domain and epoch (Section 6.1). If local trust configuration defines none, return INVALID when Evd is present and UNAVAILABLE otherwise.
  2. Absence: if Evd is absent, continue at step 12.
  3. Binding and length: require that Evd is cryptographically bound to Msg (Section 12.1) and that len(Evd) does not exceed MaxEvidence.
  4. Outer parsing: parse OCSPResponse using strict DER [X690]. Require responseStatus=successful, responseBytes present, and responseType=id-pkix-ocsp-pocsp. Reject trailing octets, indefinite lengths, and non-minimal encodings.
  5. Inner parsing and fixed bounds: parse exactly one POCSPBasicResponse. Reject unconfigured algorithms, an AlgorithmIdentifier whose parameters are present where this document requires absence (an explicit NULL is present, not absent), an oversized context or identifier, a statusVersion outside 0..9223372036854775807 or encoded in more than 8 content octets, and responseExtensions where the profile prohibits them.
  6. Responder: locate responder keys by responderKeyHash and require exactly one key authorized for the issuer-certificate identifier, domain, epoch, and expected profile of step 1. Zero or multiple authorized matches are INVALID.
  7. Context: construct the expected POCSPContext and compare its DER encoding to the signed context byte-for-byte.
  8. Identifier: compute pID from CertCanonical and the expected context. Require equality to certID.pID and require the SHA-256 AlgorithmIdentifier parameters to be absent.
  9. Structure of time, status, and version: require thisUpdate <= producedAt < nextUpdate, producedAt - thisUpdate <= MaxBackdate, and nextUpdate - thisUpdate <= W_max. Unless local time is degraded (Section 17.5), also require producedAt <= now + Delta, where now is the monotonic time bound of Section 18.4. Require statusVersion to be zero when certStatus is unknown and strictly positive when it is good or revoked. For revoked, require revocationTime <= producedAt. A baseline profile MUST reject certificateHold and removeFromCRL as INVALID.
  10. Signature and usability: verify the responder signature over DER(tbsResponseData). The evidence is then authenticated. It is usable if and only if thisUpdate - Delta <= now < nextUpdate, where now is the monotonic time bound of Section 18.4 and local time is not degraded (Section 17.5). Delta is not a grace period after nextUpdate.
  11. State update: apply the authenticated evidence to the certificate status state as specified in Section 14.3, whether or not it is usable. Enforce the authenticated-admission, quota, persistence, and fail-closed rules of Section 14.1. A storage failure does not change the decision for the current authenticated revocation and MUST block later GOOD decisions as specified there.
  12. Decision: return the result of Section 14.4 for Cert, the expected context, the domain and epoch of step 1, and the evidence of steps 3 to 11 if any.

A failure in steps 3 to 10 returns INVALID and leaves the status state unchanged.

Implementations MAY perform the inexpensive checks of steps 2 to 9 before the signature verifications of steps 1 and 10, provided that the result is identical. They MUST NOT return GOOD, REVOKED, UNKNOWN, or UNAVAILABLE, and an application MUST NOT produce UNCONFIRMED, before the checks of step 1 have succeeded. They MUST NOT update the status state before the certificate chain of step 1 and the responder signature of step 10 have been verified.

13.3. Failure Semantics

INVALID indicates malformed, unauthenticated, unauthorized, misbound, or policy-violating evidence, or a certificate whose status state records responder equivocation. It is treated as an attack, an implementation error, or a trust failure. REVOKED indicates that the certificate status state records an authenticated revocation, whatever evidence accompanies the current message. UNKNOWN is an authenticated responder assertion that it cannot establish status. UNAVAILABLE indicates that neither usable evidence nor applicable state exists, without evidence of forgery. These states are deliberately distinct. An application profile MAY map UNAVAILABLE or UNKNOWN to the application-level state UNCONFIRMED (Section 2.1) only after successful authentication and authorization of the secured message and target certificate. It MUST NOT map INVALID or REVOKED to UNCONFIRMED.

14. Status State, Caching, and Certificate Omission

Caching is essential for high-rate V2X messages, and verifier state is what makes revocation terminal. This section specifies both. State is keyed by the full certificate digest (SHA-256 of CertCanonical), the responder authorization domain, and the authorization-domain epoch. Good-evidence cache entries are additionally keyed by the complete expected context, that is, the profile OID and, where the profile uses one, the channel binding; a cache entry created under one channel binding therefore never serves another TLS connection. pID alone and responderKeyHash alone are not adequate keys. The signing responderKeyHash is retained with each cache entry so that the entry can be discarded if that key loses its authorization; responder-key rotation within an epoch does not split the state.

14.1. Certificate Status State

For each certificate within one domain epoch, the verifier maintains the following certificate status state:

  • revokedFlag: set when an authenticated revocation of the certificate has been applied, from pOCSP evidence or from a source admitted by Section 14.6.
  • L_rev: the lowest statusVersion among authenticated revoked pOCSP evidence for the certificate, or undefined.
  • H_good: the highest statusVersion among authenticated good pOCSP evidence for the certificate, or undefined.
  • conflictFlag: set when equivocation is detected (Section 14.3).

This state is independent of the application profile, because revocation concerns the certificate, not one of its uses: a revocation learned from awareness-profile evidence applies to strict-profile messages signed with the same certificate. Eviction or expiry of an evidence object MUST NOT by itself clear any element of this state. A verifier MUST create or modify this state only after it has authenticated the exact target certificate and completed the responder-authorization checks of Section 13.2. Thus, unauthenticated pIDs cannot allocate certificate-status state.

The implementation MUST bound this state globally and per authorization domain. The applicable profile MUST specify entry and memory quotas, the behavior at the quota, and a garbage-collection rule. A compact negative-status representation or an authenticated local revocation set MAY be used instead of one record per certificate. State for a certificate MAY be garbage-collected only after the certificate has ceased to be natively valid and any local audit-retention requirement has elapsed.

In a strict profile, revokedFlag and conflictFlag MUST be durable across restarts or restored from an authenticated source before the verifier can return GOOD in the affected domain. If authenticated negative state cannot be recorded, the verifier still applies that evidence to the current decision, MUST invalidate cached good evidence for the certificate, and MUST NOT subsequently return GOOD for the affected certificate, in any profile, until the state has been durably recorded or restored; in a strict profile it MUST NOT return GOOD for the affected domain either. It returns UNAVAILABLE, or suspends strict-profile processing, instead. Storage exhaustion therefore fails closed; it is not permission to evict live negative state. H_good MAY be discarded under the bounded-state policy, at the cost of losing some equivocation-detection history.

14.2. Good-Evidence Cache

For each certificate and context, the verifier MAY keep one cached good entry: the usable good evidence with the latest nextUpdate validated for that certificate, context, domain, and epoch. The entry expires at nextUpdate and MUST NOT be used at or after that instant; Delta does not extend it. Independently, the exact target certificate MUST be natively valid at every use according to Section 2.1. A newly validated usable good evidence object replaces the entry only if its nextUpdate is later. Usable unknown evidence MAY be cached until its nextUpdate to avoid repeated work; it never authorizes acceptance. A cache MUST be bounded by entry count and memory, and eviction SHOULD prefer expired entries, then entries with the earliest expiry.

A cached entry MUST also be discarded, before its expiry, when the responder key that signed it is no longer authorized for the domain and context, when the authorization-domain epoch changes, or when revokedFlag or conflictFlag of the certificate is set. Expiry is evaluated against a monotonic lower bound of the verifier clock: an implementation MUST NOT let a backward adjustment of its clock restore an entry that has expired, and MUST treat an entry as unusable while its time uncertainty exceeds Delta (Section 17.5).

Good evidence carrying a lower statusVersion than H_good is processed normally. Because revocation is terminal, a good assertion derived from an older snapshot is implied by a good assertion derived from a newer one, so accepting it cannot reintroduce a revoked certificate. The only harmful reordering, the presentation of good evidence after a revocation, is excluded by the decision rule of Section 14.4 and detected by the consistency rule of Section 14.3.

14.3. Consistency and Equivocation

Because revocation is terminal and statusVersion orders domain-wide snapshots, an honest authorization domain never signs good evidence for a certificate with a statusVersion equal to or greater than that of revoked evidence for the same certificate. Every honestly produced history therefore satisfies:

   H_good < L_rev     whenever both are defined

Applying authenticated evidence to the state consists of the following updates:

  • revoked: set revokedFlag and set L_rev to the minimum of L_rev and the evidence statusVersion.
  • good: set H_good to the maximum of H_good and the evidence statusVersion. If the evidence is usable, update the cache of Section 14.2.
  • unknown: leave revokedFlag, L_rev, H_good, and conflictFlag unchanged.

If, after an update, L_rev and H_good are both defined and H_good >= L_rev, the verifier MUST set conflictFlag, MUST invalidate every cached good entry for the certificate in all contexts, MUST retain revokedFlag, and SHOULD record the event, with both evidence objects, for audit. Equal-version good and revoked evidence is the special case H_good = L_rev.

The update applies to authenticated evidence whether or not it is usable. An expired revoked response remains an authoritative statement that the certificate was revoked, and an expired good response remains a signed statement that serves equivocation detection. Neither expiry nor a lower statusVersion ever causes authenticated revoked evidence to be rejected.

14.4. Decision

The decision for a certificate, expected context, domain, and epoch is given by the first applicable rule:

  1. If conflictFlag is set, return INVALID.
  2. If revokedFlag is set, or the current message carries authenticated revoked evidence, return REVOKED.
  3. If the evidence of the current message is usable good evidence, or a cached good entry for the expected context has not expired, return GOOD.
  4. If the evidence of the current message, or a cached entry for the expected context, is usable unknown evidence, return UNKNOWN.
  5. Otherwise, return UNAVAILABLE.

These rules make an authenticated revocation dominant. Once revokedFlag is set, neither omitted evidence, nor expired evidence, nor unknown evidence, nor good evidence of any statusVersion can produce a result other than REVOKED or INVALID. Rules 1 and 2 apply equally to a message that carries no evidence.

14.5. Certificate Omission

If the V2X message carries only a certificate digest, the verifier applies Section 14.4 only when its underlying stack has an authenticated mapping from that digest to the exact full certificate. Otherwise the message is processed according to the underlying secured-message profile, which cannot verify it.

The privacy rule in Section 8.4 relies on this mechanism: evidence is carried with full-certificate messages, and intermediate digest-only messages reuse the validated state without broadcasting a stable pID at message frequency.

14.6. Revocation from Other Sources

pOCSP evidence is normally carried by the certificate holder, who has no incentive to present a revoked status. A verifier SHOULD therefore also apply authenticated revocation obtained from sources other than the presenter:

  • Revoked pOCSP evidence delivered by a responder, a roadside unit, or another distribution point. The complete target certificate MUST accompany it unless the verifier already holds that certificate. The verifier MUST validate the target certificate chain as in step 1 of Section 13.2, excluding any message signature, and MUST validate the evidence with steps 4 to 10 of Section 13.2, accepting in step 7 any context without channel binding whose profile OID the responder is authorized for in that domain. Usability is not required, because revocation is terminal. Good and unknown evidence received this way MUST NOT be applied, so that good status remains bound to an authenticated presentation.
  • An authenticated CRL, linkage-based revocation list, or other revocation source accepted by local policy. A revocation of the target certificate from such a source sets revokedFlag; it does not define L_rev. The local mapping MUST admit only terminal revocation under the baseline semantics. In particular, an X.509 certificateHold entry does not set revokedFlag, and removeFromCRL is not a revocation. A deployment that needs reversible suspension requires the separate state machine and recovery semantics of an explicit profile (Section 9.1).

The responder signature already authenticates revoked pOCSP evidence, so the conveying message needs no further signature for authenticity. Deployments SHOULD nevertheless convey it in an authenticated management or infrastructure message and SHOULD rate-limit its processing to bound signature-verification cost. Section 18.1 discusses the effect of this mechanism on revocation enforcement.

15. Application Profiles

The values in this section are interoperability defaults and initial experimental engineering bounds, not universal safety constants or measured recommendations. An SDO or deployment can define stricter values. For an application target D_target on the revocation-effect delay of Section 5.3, a profile choice satisfies:

   W_max <= D_target - D_status - Delta

with D_status configured as specified in Section 5.3. A profile MUST NOT increase a bound without analyzing stale-good exposure, connectivity, message rate, failure policy, and the authoritative status-propagation lag. The numerical defaults below require validation by the applicable ETSI, IEEE, SAE, or deployment safety process.

Every profile MUST satisfy 0 <= MaxBackdate < W_max and 0 <= Delta < W_max. MaxEvidence MUST be at least the largest valid encoding admitted by the profile and MUST be small enough for the enclosing transport and reassembly policy. A profile SHOULD select the smallest MaxEvidence that accommodates its algorithms and extensions. The baseline P-256 test objects in Appendix D are much smaller than the V2X limit; the remaining margin is for algorithm and profile extensibility, not permission for unbounded parsing.

Table 2: Profile carriage
Profile Evidence carriage
v2x-awareness (CAM, BSM) Only with the full certificate; digest messages use the receiver status state
v2x-strict (DENM, SRM, SSM) On each critical message, with the full certificate
v2x-infrastructure (SPaT, MAP) Periodic, with the full infrastructure certificate
tls-status-request TLS 1.3 CertificateEntry status_request
tls-application Application layer, channel-bound
Table 3: Profile time and size parameters
Profile W_max MaxBackdate Delta MaxEvidence
v2x-awareness 600 s 60 s 2 s 1024 octets
v2x-strict 300 s 30 s 1 s 1024 octets
v2x-infrastructure 300 s 30 s 1 s 1024 octets
tls-status-request 600 s 60 s 5 s 4096 octets
tls-application 600 s 60 s 5 s 4096 octets

For the two TLS profiles, Delta is a default that local policy MAY reduce; a deployment that increases it MUST recompute D_effective.

Table 4: Profile failure policy
Profile UNAVAILABLE or UNKNOWN
v2x-awareness UNCONFIRMED; automated safety control SHOULD require GOOD (Section 18.1)
v2x-strict Reject for automated critical processing
v2x-infrastructure Reject or mark unusable per operator policy
tls-status-request TLS certificate-status failure per local policy (Section 16.1)
tls-application TLS certificate-status failure per local policy (Section 16.1)

In every profile, REVOKED and INVALID lead to rejection of the message or certificate for every purpose that relies on its authentication.

15.1. CAM and BSM Awareness Profile

CAM and BSM are high-rate periodic awareness messages. Stapling on every message would create unnecessary radio and signature-processing overhead and can turn pID into a repeated tracking handle. Therefore evidence is carried only on messages that also carry the full pseudonym certificate.

  • The profile OID is id-pocsp-profile-v2x-awareness.
  • The baseline W_max is 600 seconds, MaxBackdate is 60 seconds, Delta is 2 seconds, and MaxEvidence is 1024 octets.
  • The sender SHOULD provide at least one evidence-bearing full-certificate message per second while using a certificate, unless the underlying certificate-inclusion policy is less frequent. This one-second value is an interoperability default; deployments SHOULD derive the repetition period from the loss and cache-warm-up model in Section 17.2. The sender MUST NOT carry pOCSP evidence more frequently than the full certificate.
  • Intermediate digest-only messages use cached status.
  • After successful message and certificate authentication, missing, expired, or unknown evidence results in UNCONFIRMED. A receiver MAY use unconfirmed messages for advisory awareness with plausibility checks, but automated safety control SHOULD require GOOD or an independently authenticated status source.
  • A revoked holder that omits evidence is indistinguishable, at the verifier, from an honest holder whose evidence-bearing messages were lost: both yield UNCONFIRMED. The profile therefore provides revocation enforcement only to applications that require GOOD, and to verifiers that have applied a revocation from another source (Section 14.6).

15.2. DENM, SRM, and SSM Strict Profile

Event-driven hazard and authorization-sensitive messages can have high physical or operational impact. The strict profile requires a self-contained status decision.

  • The profile OID is id-pocsp-profile-v2x-strict.
  • The baseline W_max is 300 seconds, MaxBackdate is 30 seconds, Delta is 1 second, and MaxEvidence is 1024 octets.
  • Each critical message carries the full certificate and evidence.
  • INVALID, UNAVAILABLE, UNKNOWN, or REVOKED results in rejection for automated critical processing. A human-interface deployment may display an unconfirmed warning separately, but MUST NOT present it as verified.

15.3. SPaT and MAP Infrastructure Profile

SPaT and MAP are often produced by infrastructure with longer-lived operational identities and periodic transmissions.

  • The profile OID is id-pocsp-profile-v2x-infrastructure.
  • The baseline W_max is 300 seconds, MaxBackdate is 30 seconds, Delta is 1 second, and MaxEvidence is 1024 octets.
  • Evidence is transmitted periodically with the full infrastructure certificate. Digest-only messages use the receiver status state.
  • The infrastructure operator SHOULD provision redundant responders but MUST preserve one authoritative status state.

15.4. Other Application Profiles

A new profile defines a profile OID registered according to Section 21.2, accepted certificate types, the mapping to responder authorization domains, W_max, MaxBackdate, Delta, MaxEvidence, pID length, evidence repetition rule, full-certificate rule, and application mapping for GOOD, REVOKED, UNKNOWN, UNAVAILABLE, and INVALID. A profile claiming privacy preservation MUST analyze whether evidence creates a more stable observable identifier than the underlying credential presentation and MUST define its issuance-time bucketing, evidence-repetition, and key-cohort policy.

16. TLS 1.3 and RFC 8902 Integration

TLS 1.3 is specified by RFC 9846 [RFC9846], which obsoletes RFC 8446 and updates RFC 6066 [RFC6066]. In TLS 1.3, OCSP status information is carried in the status_request extension of the CertificateEntry associated with the certificate. pOCSP uses this existing carriage mechanism and does not define a new TLS extension. For server certificates, pOCSP response-type capability is negotiated through the RFC 6960 AcceptableResponses request extension carried in the RFC 6066 OCSPStatusRequest.request_extensions field. The presence of status_request alone, or an empty request_extensions field, does not indicate support for id-pkix-ocsp-pocsp.

16.1. Preferred TLS Carriage

  1. For server-certificate status, the client indicates support for status_request according to RFC 6066 [RFC6066] and RFC 9846 [RFC9846]. Its OCSPStatusRequest.request_extensions MUST contain id-pkix-ocsp-response (AcceptableResponses) extension of Section 4.4.3 of [RFC6960], and that extension MUST list id-pkix-ocsp-pocsp. It MAY also list id-pkix-ocsp-basic. A server MUST NOT infer pOCSP support from status_request alone and MUST NOT staple a pOCSP response unless id-pkix-ocsp-pocsp was offered, or an authenticated out-of-band TLS profile establishes equivalent capability.

    Concretely, the extension extnID is id-pkix-ocsp-response and extnValue contains the DER encoding of the RFC 6960 AcceptableResponses value, a SEQUENCE OF OBJECT IDENTIFIER. The extension's critical field is absent or FALSE. List order does not define preference; the TLS profile determines whether basic OCSP is an acceptable fallback.

  2. The server includes a CertificateEntry status_request extension whose CertificateStatus contains the DER OCSPResponse. For mutual authentication, the server requests client stapling by including an empty status_request extension in its CertificateRequest. Because the TLS 1.3 CertificateRequest form is empty and cannot carry AcceptableResponses, the client MUST include pOCSP evidence in its CertificateEntry only when an authenticated TLS profile or out-of-band configuration has established server support for id-pkix-ocsp-pocsp. Otherwise it uses a response type negotiated by that profile or sends no pOCSP response.
  3. The OCSPResponse responseType is id-pkix-ocsp-pocsp.
  4. Because CertificateEntry is transcript-protected, no pOCSP channelBinding is included. The expected context contains id-pocsp-profile-tls-status-request.
  5. The endpoint applies the pOCSP validator in addition to normal TLS certificate validation.

The id-pocsp-profile-tls-status-request profile uses the parameters of Table 3. A client that obtains REVOKED aborts the handshake with a certificate_revoked alert; a client that obtains INVALID, or UNAVAILABLE or UNKNOWN where its policy requires GOOD, aborts with a bad_certificate_status_response alert. A server validating client evidence uses certificate_revoked and bad_certificate respectively. These alerts are defined in [RFC9846].

For X.509 certificates, CertCanonical is DER. For ITS certificates negotiated under RFC 8902 [RFC8902], CertCanonical is the exact COER ITS certificate encoding. RFC 8902 [RFC8902] is Experimental; deployments using it MUST also enforce its certificate permissions and certificate-type negotiation requirements.

Interoperability note: a generic TLS implementation that expects the stapled object to be a BasicOCSPResponse with responseType id-pkix-ocsp-basic may reject or ignore a pOCSP response. pOCSP stapling in TLS therefore requires positive knowledge that both endpoints support the pOCSP profile; offering status_request without the required AcceptableResponses value is not sufficient. pOCSP is not transparently backward compatible with legacy OCSP-stapling peers. Because the pOCSP response carries no responder certificate chain, the responder key MUST be provisioned to the TLS endpoint out of band exactly as in the V2X case (Section 6.1).

16.2. Application-Layer TLS Carriage

Application-layer carriage is NOT RECOMMENDED because it is easier to strip, substitute, or associate with the wrong connection. It is permitted only when the application requires it and implements a channel binding.

The channel binding is computed with the TLS 1.3 exporter interface of [RFC9846]:

channelBinding = TLS-Exporter("EXPORTER-pOCSP-application-binding",
                              "", 32)

The exporter context value is the empty (zero-length) string, and the output length is 32 octets. The label is registered in Section 21.

The expected profile OID is id-pocsp-profile-tls-application, with the parameters of Table 3. channelBinding is placed in POCSPContext and is therefore signed by the responder and included in pID. In this profile the channel binding MUST be exactly 32 octets: the verifier builds the expected context from its own exporter output, so a signed context of any other length or value fails the byte-exact comparison of step 7, and a responder MUST refuse to sign a context whose channel binding does not have the length of the profile. Evidence issued for one TLS connection cannot be used on another, and a cached good entry is keyed by the complete context (Section 14.2), so a cache hit for one connection never authorizes another. Because the responder must know the exporter value, this mode requires an online post-handshake evidence issuance step and is not suitable as pre-produced broadcast evidence.

16.3. TLS PSK, Resumption, and 0-RTT

A resumption PSK derived from a certificate-authenticated connection inherits authorization from that certificate. The ticket or the server-side resumption state MUST therefore be associated, for each peer certificate on which authorization depends, with the authenticated certificate digest, pOCSP profile OID, responder authorization domain and epoch, and a pOCSP freshness deadline equal to:

   freshnessDeadline = nextUpdate

Native certificate validity is a separate predicate and MUST be checked at every resumption attempt using the semantics of Section 2.1. Thus an endpoint never resumes with an expired or not-yet-valid certificate even if freshnessDeadline has not passed.

A deployment has two conforming choices. It either limits the usable resumption lifetime so that resumption cannot succeed after freshnessDeadline, or it obtains fresh authoritative revocation status before accepting certificate-derived authorization through the PSK. If neither condition is met, the endpoint MUST reject resumption or perform a new full certificate-authenticated handshake. Ticket lifetime alone MUST NOT extend a previously established pOCSP GOOD decision.

At every resumption attempt the endpoint MUST consult the certificate status state of Section 14 for the certificate digest, domain, and epoch recorded in the ticket: if revokedFlag or conflictFlag is set, or if the recorded epoch is no longer current, resumption MUST be rejected whatever the freshness deadline. The freshness deadline is compared with the same monotonic time bound as cache expiry (Section 14.2); a backward clock adjustment MUST NOT make an expired ticket acceptable again.

0-RTT data has replay properties independent of pOCSP. Early data MUST NOT be accepted when the associated pOCSP freshness deadline has passed. Applications MUST follow RFC 9846 [RFC9846] anti-replay requirements and MUST NOT use early data for non-idempotent safety control merely because certificate status is GOOD.

16.4. Long-Lived TLS Connections and Status Freshness

An endpoint MUST NOT continue to treat certificate status as GOOD at or after freshnessDeadline, and MUST NOT do so outside the target certificate's native validity interval. Before that deadline, the application MUST obtain fresh connection-bound status evidence, perform a new full certificate-authenticated handshake, or restrict or terminate the connection according to local policy. The application-layer binding of Section 16.2 can refresh status for an existing connection; post-handshake client authentication may also be used where RFC 9846 permits it. TLS 1.3 does not provide post-handshake server authentication, so refreshing server status normally requires connection-bound application evidence or a new handshake.

These rules are in addition to the RFC 8902 [RFC8902] requirement to check ITS certificate expiry and its recommendation to terminate a session when the certificate received in the handshake expires.

17. Operational Engineering Guidance

17.1. Communication Overhead

Let B_e be the encoded evidence size in octets, f the message rate in messages per second, and T the evidence repetition period in seconds. If evidence is attached once every T seconds, the amortized evidence overhead per application message is:

   B_avg = B_e / (f * T)   octets/message

For a 10 Hz awareness stream, the 256-octet evidence of Appendix D.4 sent once per second contributes 256 octets per second, or 25.6 octets per message on average. Sending the same evidence on every message would contribute 2560 octets per second, or 256 octets per message. The exact evidence size depends on signature representation and algorithm profile; implementations MUST measure encoded DER rather than rely on this example.

17.2. Packet Loss and Cache Warm-Up

If evidence-bearing transmissions are independently lost with probability p and a receiver has n opportunities during an observation window, the probability of missing all evidence is approximately p^n. With repetition period T over duration D, n is floor(D/T). Losses are often correlated, so this is an engineering approximation rather than a guarantee.

   P_miss ~= p^floor(D/T)

For a target miss probability P_target, the required number of independent opportunities satisfies:

   n >= ceil( log(P_target) / log(p) )

and a repetition period can be selected as T <= D/n. This derivation is meaningful only for 0<p<1 and independent losses; correlated fading requires trace-driven or measured evaluation. The choice must be evaluated jointly with channel congestion, certificate repetition, and privacy constraints.

17.3. CPU and Energy

pOCSP removes verifier-initiated network exchanges from the reception path and amortizes responder-signature verification through caching. It nevertheless adds bytes to selected messages and adds a second signature validation on cache miss. An implementation SHOULD instrument radio airtime, parse cost, hash cost, responder signature verification, cache hit rate, and memory under realistic vehicle density. Claims of energy savings are deployment-dependent. The protocol provides mechanisms that can reduce online radio use and repeated cryptographic work; it does not guarantee a universal energy reduction when evidence is configured too frequently.

17.4. Responder Scaling and Availability

Responders SHOULD pre-produce currently active responses and use CDN or edge distribution where appropriate. They MAY issue the same currently active response to several authorized retrieval paths. They MUST NOT pre-produce future-active good responses. Responder back ends SHOULD be redundant and share one authoritative status state to avoid split status.

If N_active certificates each require q evidence objects per refresh interval R, the steady-state signing or pre-production rate is approximately:

   Q_responder = N_active * q / R   responses/second

This scales with the active certificate population, not merely with the revoked population as a CRL often does. Capacity planning MUST include peak issuance and refresh bursts, every supported profile, retry amplification, redundant-site operation, and the atomic snapshot-commit mechanism of Section 10.3. The responder MUST shed load by returning unknown or refusing issuance rather than signing good evidence from a stale snapshot outside D_status.

Optional direct diagnostic requests SHOULD be rate-limited and authenticated where possible. A responder MUST avoid providing a public high-amplification service. HTTP caching behavior can follow the principles of RFC 9919 [RFC9919] when evidence is delivered over HTTP.

17.5. Time Sources and Degraded Time

Time can be derived from GNSS, a secure in-vehicle time service, authenticated network time, or a combination. GNSS time alone can be spoofed. A verifier SHOULD track time-quality state and detect implausible jumps. When it cannot establish the error bound of assumption A3, including because local time uncertainty is too large, no evidence and no cache entry is usable. The decision of Section 14.4 can then still return INVALID or REVOKED and otherwise returns UNAVAILABLE; malformed or misbound evidence returns INVALID. After successful message and certificate authentication, an awareness profile may map UNAVAILABLE to UNCONFIRMED, but the validator MUST NOT return GOOD.

18. Security Considerations

18.1. Replay and Stolen-Key Exposure

An attacker that steals a sender private key and obtains a still-valid good response can create valid signed messages until the response expires. This is inherent to pre-signed status evidence. pOCSP bounds, but does not remove, the exposure. The profile W_max, Delta, and D_status therefore form a safety parameter set and must be selected and audited.

Message-level replay protection, generationTime checks, sequence logic, geographic plausibility, and application consistency remain necessary. pOCSP only asserts certificate status. pOCSP is presenter-carried. A malicious revoked holder does not present revoked evidence. Enforcement against such a holder rests on three mechanisms: expiry of the last acceptable good evidence (Section 5.3), the profile policy for omitted evidence, and authenticated revocation from other sources (Section 14.6), which sets the terminal revoked state at the verifiers that receive it.

The profile policy is decisive. Under a strict profile, absence of usable good evidence leads to rejection, and D_effective bounds the exposure. Under a permissive profile, a revoked holder that omits evidence obtains UNCONFIRMED, exactly like an honest holder whose evidence was lost. The verifier cannot distinguish the two cases from the presentation alone, and no evidence-based bound applies. A permissive UNCONFIRMED policy is therefore not equivalent to revocation enforcement and SHOULD restrict automated or high-impact actions. Revocation from other sources is the only pOCSP mechanism that reaches such a holder before the certificate ceases to be natively valid.

18.2. Certificate and Context Substitution

A response can be transplanted only if the target certificate and context checks are omitted or implemented inconsistently. Verifiers must hash the correct canonical certificate, compare DER context exactly, and require the evidence to be within signed bytes. The profile OID prevents a CAM-oriented response from being accepted as a strict DENM or TLS response.

18.3. Stripping and Downgrade

Evidence carried outside authenticated bytes can be removed. Such carriage is prohibited. Even when omission is allowed by an awareness profile, the result can be UNCONFIRMED only after message and certificate authentication; it is never GOOD. A deployment negotiating pOCSP support over TLS SHOULD fail the certificate-status check when negotiated evidence is absent.

18.4. Time-Shift Attacks

A manipulated clock can cause acceptance of expired evidence or rejection of valid evidence. Delta must not be inflated to hide poor synchronization because doing so directly increases stale-good exposure. Implementations MUST maintain a monotonic lower bound of local time for expiry decisions, so that a backward jump cannot resurrect an expired cache entry, resumption ticket, or evidence object (Sections Section 14.2 and Section 16.3), and SHOULD treat an implausible jump as degraded time (Section 17.5).

18.5. Denial of Service and Parser Safety

  • Reject overlength evidence before ASN.1 parsing.
  • Use strict DER and reject indefinite lengths, non-minimal integers, unexpected constructed strings, duplicate fields, trailing data, and unrecognized critical algorithms.
  • Keep one status per response and one bounded context.
  • Resolve configured algorithm and responder key identifiers before public-key verification.
  • Rate-limit repeated invalid evidence from the same radio or network source where the link layer permits.
  • Do not fetch missing certificates or responder chains synchronously on the safety critical path.

Implementation history around OCSP and ASN.1 shows that permissive parsing and missing-field defaults are a recurring source of bypass. nextUpdate and context are mandatory in pOCSP; omission is a hard failure.

18.6. Responder Compromise and Equivocation

Compromise of a responder signing key permits false good or revoked responses. Keys should be protected in an HSM, rotated, audited, and scoped to limited certificate populations and profiles. Trust distribution must support rapid responder-key revocation, and a revoked or retired key is never authorized again (Section 6.1), so that a compromised key cannot be reintroduced as if it were new.

A malicious authorized responder can sign conflicting statuses or can attempt version pinning by issuing good evidence with an extremely high statusVersion. Under Section 14.3, pinning cannot mask a later revocation: revoked evidence is never rejected because of its version, revokedFlag dominates the decision, and pinned good evidence combined with any later authenticated revocation sets conflictFlag. Pinning cannot cause rejection of honest good evidence either, because a lower statusVersion does not invalidate good evidence. What remains is the ability of a compromised key to sign false good statuses, each usable for at most W_max, and false revoked statuses; only responder-key revocation and recovery address them.

statusVersion MUST NOT wrap or be reused within an authorization-domain epoch. Recovery from responder compromise, false revocation, version pinning, or sequence exhaustion requires a recovery statement as defined in Section 2.1. Its authenticated contents MUST identify the issuer-certificate identifier and authorization domain, previous and new epochs, a monotonically increasing recovery sequence, effective time, retired and newly authorized responder-key hashes, the initial snapshot or statusVersion of the new epoch, and the exact certificate-status state that a verifier is permitted to clear. The applicable profile defines its wire encoding and trust anchor.

The recovery statement MUST be authenticated by a recovery authority independent of the affected responder keys; a statement signed only by a compromised or retired responder is invalid. High-assurance deployments SHOULD require threshold or multi-party authorization. Verifiers MUST durably retain the highest recovery sequence per domain and reject replay, rollback, epoch reuse, or an ambiguous clearing scope. The statement MUST revoke the affected responder keys, establish a new epoch, and provision responder keys that were not used in any previous epoch (Section 6.1).

Until a valid recovery statement is authenticated, verifiers MUST NOT clear revokedFlag or conflictFlag, in particular merely because a responder key was rotated. A statement that authorizes a global clear causes strict-profile processing for the domain to remain suspended until the new authoritative snapshot and negative-status state are installed. A narrowly scoped clear affects only the explicitly identified certificate state. These recovery semantics prevent a forged recovery action from silently turning false or true revocations into GOOD decisions.

The baseline detects equivocation only when one verifier observes both conflicting statements; it does not provide ecosystem-wide equivocation detection. Deployments requiring this property can publish signed response digests or status checkpoints to a transparency service, but that extension is outside this document.

18.7. Algorithm Agility

Unbounded algorithm agility creates complexity and downgrade risk. Profiles define a small accepted set. SHA-256 is fixed for identifier derivation in version 0. A future incompatible identifier function requires a new version or profile OID, not silent negotiation.

19. Privacy Considerations

The privacy analysis in this section follows the general guidance of [RFC6973].

pOCSP removes verifier-initiated status queries from the message-reception path. This prevents a third-party responder from learning which remote certificates a vehicle is checking, where, and when. This is a meaningful privacy improvement over online OCSP.

However, pID is a public deterministic function of the certificate and context. It does not provide unlinkability. When the certificate is visible, pID can be recomputed. When the certificate is omitted but pID is repeated, pID can create a new tracking handle. Therefore the broadcast profiles require evidence to be co-carried with the full certificate and prohibit more frequent evidence transmission.

Single-entry evidence avoids linking several pseudonyms by co-occurrence in one responder-signed object. Responders and senders MUST NOT bundle a vehicle's current or future pseudonym statuses in broadcast evidence. Management-channel batching may occur only inside a confidential authenticated channel and each delivered data-plane evidence object remains single-entry. Evidence issuance and refresh are themselves observables. As discussed in Section 6.2, requests for successive pseudonyms made over one management session, from one network identity, or on a predictable schedule can allow the responder or a management-channel observer to link those pseudonyms. Deployments SHOULD deliver initial evidence at issuance and SHOULD decorrelate refresh traffic across pseudonyms.

statusVersion is the version of an authorization-domain-wide authoritative snapshot and MUST NOT be assigned per certificate, vehicle, or subscriber (Section 9.1). A finer scoping would embed a stable quasi-identifier in broadcast evidence and could link the pseudonyms that share the sequence, defeating the single-certificate rule. Domain-wide versions are shared across a sufficiently large certificate population and reveal only the snapshot generation.

The exact values of producedAt, thisUpdate, and nextUpdate can also form a correlation pattern when one vehicle refreshes several pseudonyms at distinctive times. Profiles that claim privacy preservation MUST align these timestamps to common issuance epochs shared by a sufficiently large certificate population, and responders MUST avoid per-vehicle or per-request timestamp patterns. Common issuance epochs also improve response pre-production and cache efficiency.

The profile OID and channel binding must not contain stable vehicle, subscriber, or location identifiers. Responder logs can still expose issuance and refresh behavior and should be minimized. Distribution CDNs should see opaque evidence rather than certificate-to-vehicle mappings when operationally possible.

Revoked evidence distributed under Section 14.6 discloses that a pseudonym certificate is revoked, as a CRL does. Distribution points MUST NOT group such evidence by vehicle, because co-occurrence would link the revoked pseudonyms of one vehicle.

Cross-layer tracking remains possible through positions, timing, radio addresses, certificate repetition, sensor fingerprints, and behavior. pOCSP does not solve those problems. A privacy claim for a deployment must assess the complete V2X stack.

20. Deployment, Migration, and Interoperability

20.1. Incremental Deployment

  1. Provision verifier support and responder trust keys while continuing existing CRL processing.
  2. Deploy pOCSP generation for a limited certificate population and one awareness profile.
  3. Allocate and test the SDO secured-envelope extension identifier; verify that legacy receivers behave as expected.
  4. Measure evidence size, cache hit rate, channel load, CPU, time quality, and failure rates under realistic density.
  5. Enable strict profiles only after availability and time-synchronization objectives are demonstrated.
  6. Retain CRL or linkage mechanisms as a recovery and ecosystem-interoperability path until pOCSP coverage is complete.

20.2. Interoperability Requirements

Two implementations interoperate only if they share the exact profile OID, certificate canonicalization, responder authorization policy, signature algorithm, time bounds, extension carriage, and failure mapping. Textual context aliases or implementation-specific certificate serialization are prohibited.

20.3. Cross-SDO Responsibility

IETF defines the OCSP response type and generic semantics. ETSI and IEEE profiles define the concrete contributed-extension identifiers and secured-envelope mappings. SAE profiles define how J2735 payloads are carried without changing the message dictionary. A deployable profile MUST name the exact enclosing data structure, extension or contributor identifier, criticality and unknown-extension behavior, size limit, and signed-byte coverage, and MUST publish at least one complete encoding vector. The abstract mapping of Section 12 and Appendix G is not, by itself, an interoperable SDO profile. Implementers MUST NOT deploy private numeric identifiers in public interoperability domains.

21. IANA Considerations

21.1. OCSP Response Type

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, as maintained according to [RFC7299] and [RFC8126]:

Table 5: OCSP response-type request
Value Description Reference
TBD1 id-pkix-ocsp-pocsp This document

The resulting object identifier is id-pkix-ocsp-pocsp OBJECT IDENTIFIER ::= { id-pkix-ocsp TBD1 }. The registration policy for this registry is Specification Required. This document uses the arc id-pocsp-profile OBJECT IDENTIFIER ::= { id-pkix-ocsp-pocsp 1 } for profile identifiers, managed as described in Section 21.2.

21.2. pOCSP Profile Identifiers Registry

IANA is requested to create a registry entitled "pOCSP Profile Identifiers" for the values of the arc id-pocsp-profile, that is, 1.3.6.1.5.5.7.48.1.TBD1.1, in the group of SMI Security for PKIX registries. The registration policy is Specification Required [RFC8126]. The designated expert verifies that the specification defines every element listed in Section 15.4, preserves the context, privacy, and failure-semantics requirements of this document, and introduces no stable vehicle, subscriber, or location identifier. The initial contents are:

Table 6: Initial pOCSP profile identifiers
Value Description Reference
0 Reserved This document
1 id-pocsp-profile-v2x-awareness This document
2 id-pocsp-profile-v2x-strict This document
3 id-pocsp-profile-v2x-infrastructure This document
4 id-pocsp-profile-tls-status-request This document
5 id-pocsp-profile-tls-application This document
6 and higher Unassigned

Future documents defining a profile MUST obtain a registry value. Private deployments MUST NOT consume unassigned values in public interoperability domains.

21.3. ASN.1 Module Identifier

IANA is requested to allocate an ASN.1 module identifier from the "SMI Security for PKIX Module Identifier" registry (1.3.6.1.5.5.7.0) for id-mod-pocsp-2026-88, the module of Appendix A. The exact value is TBD2.

21.4. TLS Exporter Label

IANA is requested to add the following entry to the "TLS Exporter Labels" registry defined by [RFC5705] and maintained according to [RFC8447], [RFC9847], and [RFC8126]:

Table 7: TLS exporter label request
Field Requested value
Value EXPORTER-pOCSP-application-binding
DTLS-OK N
Recommended N
Reference This document
Comment TLS 1.3 application-layer binding for pOCSP evidence

DTLS-OK is N because this document defines no DTLS carriage profile. Recommended is N because the label is specific to the exceptional application-layer pOCSP mode rather than general-purpose TLS use.

21.5. No Other Actions

This document makes no request for TLS extension code points. It uses status_request. This document makes no request for ETSI, IEEE, or SAE extension identifiers.

22. Summary of Normative Requirements

23. References

23.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC3279]
Bassham, L., Polk, W., and R. Housley, "Algorithms and Identifiers for the Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 3279, DOI 10.17487/RFC3279, , <https://www.rfc-editor.org/info/rfc3279>.
[RFC5280]
Cooper, D., Santesson, S., Farrell, S., Boeyen, S., Housley, R., and W. Polk, "Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 5280, DOI 10.17487/RFC5280, , <https://www.rfc-editor.org/info/rfc5280>.
[RFC5705]
Rescorla, E., "Keying Material Exporters for Transport Layer Security (TLS)", RFC 5705, DOI 10.17487/RFC5705, , <https://www.rfc-editor.org/info/rfc5705>.
[RFC5758]
Dang, Q., Santesson, S., Moriarty, K., Brown, D., and T. Polk, "Internet X.509 Public Key Infrastructure: Additional Algorithms and Identifiers for DSA and ECDSA", RFC 5758, DOI 10.17487/RFC5758, , <https://www.rfc-editor.org/info/rfc5758>.
[RFC6066]
Eastlake 3rd, D., "Transport Layer Security (TLS) Extensions: Extension Definitions", RFC 6066, DOI 10.17487/RFC6066, , <https://www.rfc-editor.org/info/rfc6066>.
[RFC6960]
Santesson, S., Myers, M., Ankney, R., Malpani, A., Galperin, S., and C. Adams, "X.509 Internet Public Key Infrastructure Online Certificate Status Protocol - OCSP", RFC 6960, DOI 10.17487/RFC6960, , <https://www.rfc-editor.org/info/rfc6960>.
[RFC7299]
Housley, R., "Object Identifier Registry for the PKIX Working Group", RFC 7299, DOI 10.17487/RFC7299, , <https://www.rfc-editor.org/info/rfc7299>.
[RFC8126]
Cotton, M., Leiba, B., and T. Narten, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 8126, DOI 10.17487/RFC8126, , <https://www.rfc-editor.org/info/rfc8126>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8447]
Salowey, J. and S. Turner, "IANA Registry Updates for TLS and DTLS", RFC 8447, DOI 10.17487/RFC8447, , <https://www.rfc-editor.org/info/rfc8447>.
[RFC8902]
Msahli, M., Ed., Cam-Winget, N., Ed., Whyte, W., Ed., Serhrouchni, A., and H. Labiod, "TLS Authentication Using Intelligent Transport System (ITS) Certificates", RFC 8902, DOI 10.17487/RFC8902, , <https://www.rfc-editor.org/info/rfc8902>.
[RFC9654]
Sharma, H., Ed., "Online Certificate Status Protocol (OCSP) Nonce Extension", RFC 9654, DOI 10.17487/RFC9654, , <https://www.rfc-editor.org/info/rfc9654>.
[RFC9846]
Rescorla, E., "The Transport Layer Security (TLS) Protocol Version 1.3", RFC 9846, DOI 10.17487/RFC9846, , <https://www.rfc-editor.org/info/rfc9846>.
[RFC9847]
Salowey, J. and S. Turner, "IANA Registry Updates for TLS and DTLS", RFC 9847, DOI 10.17487/RFC9847, , <https://www.rfc-editor.org/info/rfc9847>.
[FIPS180-4]
National Institute of Standards and Technology, "Secure Hash Standard (SHS)", FIPS PUB 180-4, DOI 10.6028/NIST.FIPS.180-4, , <https://doi.org/10.6028/NIST.FIPS.180-4>.
[X680]
ITU-T, "Information technology - Abstract Syntax Notation One (ASN.1): Specification of basic notation", Recommendation ITU-T X.680, .
[X690]
ITU-T, "Information technology - ASN.1 encoding rules: Specification of Basic Encoding Rules (BER), Canonical Encoding Rules (CER) and Distinguished Encoding Rules (DER)", Recommendation ITU-T X.690, .
[X696]
ITU-T, "Information technology - ASN.1 encoding rules: Specification of Octet Encoding Rules (OER)", Recommendation ITU-T X.696, .
[ETSI-TS-103097]
ETSI, "Intelligent Transport Systems (ITS); Security; Security header and certificate formats", ETSI TS 103 097 V2.2.1, .
[IEEE-1609.2]
IEEE, "IEEE Standard for Wireless Access in Vehicular Environments--Security Services for Application and Management Messages", IEEE Std 1609.2-2025, .

23.2. Informative References

[RFC5612]
Eronen, P. and D. Harrington, "Enterprise Number for Documentation Use", RFC 5612, DOI 10.17487/RFC5612, , <https://www.rfc-editor.org/info/rfc5612>.
[RFC6973]
Cooper, A., Tschofenig, H., Aboba, B., Peterson, J., Morris, J., Hansen, M., and R. Smith, "Privacy Considerations for Internet Protocols", RFC 6973, DOI 10.17487/RFC6973, , <https://www.rfc-editor.org/info/rfc6973>.
[RFC6979]
Pornin, T., "Deterministic Usage of the Digital Signature Algorithm (DSA) and Elliptic Curve Digital Signature Algorithm (ECDSA)", RFC 6979, DOI 10.17487/RFC6979, , <https://www.rfc-editor.org/info/rfc6979>.
[RFC9919]
Ito, T., Wilson, C., Bonnell, C., and S. Turner, "The Lightweight Online Certificate Status Protocol (OCSP) Profile for High-Volume Environments", RFC 9919, DOI 10.17487/RFC9919, , <https://www.rfc-editor.org/info/rfc9919>.
[ETSI-TS-102941]
ETSI, "Intelligent Transport Systems (ITS); Security; Trust and Privacy Management", ETSI TS 102 941 V2.2.1, .
[ETSI-TS-103601]
ETSI, "Intelligent Transport Systems (ITS); Security; Security management messages communication requirements and distribution protocols", ETSI TS 103 601 V2.1.1, .
[ETSI-CAM]
ETSI, "Intelligent Transport Systems (ITS); Vehicular Communications; Basic Set of Applications; Part 2: Cooperative Awareness Basic Service", ETSI EN 302 637-2 V1.4.1, .
[ETSI-DENM]
ETSI, "Intelligent Transport Systems (ITS); Vehicular Communications; Basic Set of Applications; Part 3: Decentralized Environmental Notification Basic Service", ETSI EN 302 637-3 V1.3.1, .
[IEEE-1609.2.1]
IEEE, "IEEE Standard for Wireless Access in Vehicular Environments--Certificate Management Interfaces for End Entities", IEEE Std 1609.2.1-2026, .
[SAE-J2735]
SAE International, "V2X Communications Message Set Dictionary", SAE Standard J2735_202409, DOI 10.4271/J2735_202409, , <https://doi.org/10.4271/J2735_202409>.
[WANG2020]
Wang, Q., Gao, D., and D. Chen, "Certificate Revocation Schemes in Vehicular Networks: A Survey", IEEE Access, Vol. 8, pp. 26223-26234, DOI 10.1109/ACCESS.2020.2970460, , <https://doi.org/10.1109/ACCESS.2020.2970460>.
[PETIT2015]
Petit, J., Schaub, F., Feiri, M., and F. Kargl, "Pseudonym Schemes in Vehicular Networks: A Survey", IEEE Communications Surveys and Tutorials, Vol. 17, No. 1, pp. 228-255, DOI 10.1109/COMST.2014.2345420, , <https://doi.org/10.1109/COMST.2014.2345420>.
[HAAS2011]
Haas, J., Hu, Y-C., and K. Laberteaux, "Efficient Certificate Revocation List Organization and Distribution", IEEE Journal on Selected Areas in Communications, Vol. 29, No. 3, pp. 595-604, DOI 10.1109/JSAC.2011.110309, , <https://doi.org/10.1109/JSAC.2011.110309>.
[KHODAEI2018]
Khodaei, M. and P. Papadimitratos, "Efficient, Scalable, and Resilient Vehicle-Centric Certificate Revocation List Distribution in VANETs", Proc. ACM WiSec 2018, DOI 10.1145/3212480.3212481, , <https://doi.org/10.1145/3212480.3212481>.
[SCMS2018]
Brecht, B., Therriault, D., Weimerskirch, A., Whyte, W., Kumar, V., Hehn, T., and R. Goudy, "A Security Credential Management System for V2X Communications", IEEE Transactions on Intelligent Transportation Systems, Vol. 19, No. 12, pp. 3850-3871, DOI 10.1109/TITS.2018.2797529, , <https://doi.org/10.1109/TITS.2018.2797529>.
[SCOP2024]
Scopelliti, G., Baumann, C., Alder, F., Truyen, E., and J. T. Muehlberg, "Efficient and Timely Revocation of V2X Credentials", Proc. NDSS 2024, DOI 10.14722/ndss.2024.24017, , <https://doi.org/10.14722/ndss.2024.24017>.
[GANAN2015]
Ganan, C., Munoz, J., Esparza, O., Mata-Diaz, J., and J. Alins, "EPA: An Efficient and Privacy-Aware Revocation Mechanism for Vehicular Ad Hoc Networks", Pervasive and Mobile Computing, Vol. 21, pp. 75-91, DOI 10.1016/j.pmcj.2014.01.002, , <https://doi.org/10.1016/j.pmcj.2014.01.002>.
[BONEH2004]
Boneh, D. and H. Shacham, "Group Signatures with Verifier-Local Revocation", Proc. ACM CCS 2004, pp. 168-177, DOI 10.1145/1030083.1030106, , <https://doi.org/10.1145/1030083.1030106>.
[DOLEV1983]
Dolev, D. and A. Yao, "On the Security of Public Key Protocols", IEEE Transactions on Information Theory, Vol. 29, No. 2, pp. 198-208, DOI 10.1109/TIT.1983.1056650, , <https://doi.org/10.1109/TIT.1983.1056650>.
[TAMARIN2013]
Meier, S., Schmidt, B., Cremers, C., and D. Basin, "The TAMARIN Prover for the Symbolic Analysis of Security Protocols", Proc. CAV 2013, DOI 10.1007/978-3-642-39799-8_48, , <https://doi.org/10.1007/978-3-642-39799-8_48>.

Appendix A. Complete ASN.1 Module

The module below uses the 1988 ASN.1 syntax [X680] and is normative except for the TBD object identifier values. DER is used for all pOCSP objects. Following the conventions of the normative OCSP module OCSP-2024-88 of [RFC9654], which replaces the 1988 module of [RFC6960], AlgorithmIdentifier and Extensions are imported from PKIX1Explicit88 [RFC5280], and RevokedInfo and id-pkix-ocsp are imported from OCSP-2024-88. OCSPResponse, OCSPResponseStatus, and ResponseBytes are used exactly as defined in OCSP-2024-88 and are not redefined here.

<CODE BEGINS>
POCSP-2026-88
  { iso(1) identified-organization(3) dod(6) internet(1)
    security(5) mechanisms(5) pkix(7) id-mod(0) TBD2 }

DEFINITIONS EXPLICIT TAGS ::= BEGIN

IMPORTS
  AlgorithmIdentifier, Extensions
    FROM PKIX1Explicit88
      { iso(1) identified-organization(3) dod(6) internet(1)
        security(5) mechanisms(5) pkix(7) id-mod(0)
        id-pkix1-explicit(18) }

  RevokedInfo, id-pkix-ocsp
    FROM OCSP-2024-88
      { iso(1) identified-organization(3) dod(6) internet(1)
        security(5) mechanisms(5) pkix(7) id-mod(0)
        id-mod-ocsp-2024-88(111) } ;

id-pkix-ocsp-pocsp OBJECT IDENTIFIER ::= { id-pkix-ocsp TBD1 }

id-pocsp-profile OBJECT IDENTIFIER ::= { id-pkix-ocsp-pocsp 1 }
id-pocsp-profile-v2x-awareness OBJECT IDENTIFIER ::=
  { id-pocsp-profile 1 }
id-pocsp-profile-v2x-strict OBJECT IDENTIFIER ::=
  { id-pocsp-profile 2 }
id-pocsp-profile-v2x-infrastructure OBJECT IDENTIFIER ::=
  { id-pocsp-profile 3 }
id-pocsp-profile-tls-status-request OBJECT IDENTIFIER ::=
  { id-pocsp-profile 4 }
id-pocsp-profile-tls-application OBJECT IDENTIFIER ::=
  { id-pocsp-profile 5 }

id-sha256 OBJECT IDENTIFIER ::=
  { joint-iso-itu-t(2) country(16) us(840) organization(1)
    gov(101) csor(3) nistAlgorithms(4) hashAlgs(2) sha256(1) }

POCSPContext ::= SEQUENCE {
    profile          OBJECT IDENTIFIER,
    channelBinding   OCTET STRING (SIZE(32..64)) OPTIONAL
}

POCSPCertID ::= SEQUENCE {
    hashAlgorithm    AlgorithmIdentifier,
    pID              OCTET STRING (SIZE(16 | 32))
}

POCSPCertStatus ::= CHOICE {
    good             [0] IMPLICIT NULL,
    revoked          [1] IMPLICIT RevokedInfo,
    unknown          [2] IMPLICIT NULL
}

POCSPResponseData ::= SEQUENCE {
    version            INTEGER (0) DEFAULT 0,
    responderKeyHash   OCTET STRING (SIZE(32)),
    statusVersion      INTEGER (0..9223372036854775807),
    producedAt         GeneralizedTime,
    context            POCSPContext,
    certID             POCSPCertID,
    certStatus         POCSPCertStatus,
    thisUpdate         GeneralizedTime,
    nextUpdate         GeneralizedTime,
    responseExtensions [0] EXPLICIT Extensions OPTIONAL
}

POCSPBasicResponse ::= SEQUENCE {
    tbsResponseData    POCSPResponseData,
    signatureAlgorithm AlgorithmIdentifier,
    signature          BIT STRING
}

END

<CODE ENDS>

Appendix B. Reference Algorithms

B.1. pID Computation

function DerivePID(certType, certBytes, profileOID,
                   channelBinding):
    if certType == ITS_1609DOT2:
        certCanonical = exact_COER_certificate_octets(certBytes)
    else if certType == X509:
        certCanonical = exact_DER_certificate_octets(certBytes)
    else:
        fail(UNSUPPORTED_CERT_TYPE)

    context = POCSPContext(profileOID, channelBinding)
    contextDER = DER_encode(context)
    certDigest = SHA256(certCanonical)
    L_pID = ProfilePIDLength(profileOID)  -- exactly 16 or 32
    return LEFTMOST(L_pID, SHA256(ASCII("pocsp-id-v1") ||
                                  certDigest || contextDER))

B.2. Verifier

function Validate(msg, cert, evd, ctx, now, cfg, state):
    -- ctx = expected context: profile OID and, for the TLS
    --       application profile, the channel binding
    -- Section 13.2, step 1
    issuerCert = AuthenticateMessageAndCertAndReturnIssuer(
                     msg, cert, ctx.profile, now, cfg)
    if issuerCert is FAIL:
        return INVALID
    issuerID = SHA256(issuerCert.canonicalBytes)
    (domain, epoch) = cfg.DomainForIssuerCertificate(issuerID)
    if domain is NONE:
        return INVALID if evd is present else UNAVAILABLE
    key = (SHA256(cert.canonicalBytes), domain, epoch)
    current = NONE
    if evd is present:                         -- step 2
        if not BoundToSignedMessage(msg, evd): -- step 3
            return INVALID
        e = ValidateEvidence(evd, cert, ctx, issuerID, domain, epoch,
                             now, cfg)        -- steps 3 to 10
        if e is FAIL:
            return INVALID
        applyResult = ApplyToState(state, key, ctx, e) -- step 11
        if applyResult == NEGATIVE_STORAGE_FAILURE:
            state.blockGoodUntilRestored(domain, epoch)
        current = e
    return Decide(state, key, ctx, current, now)     -- step 12

function ValidateEvidence(evd, cert, ctx, issuerID, domain, epoch,
                          now, cfg):
    require len(evd) <= cfg.maxEvidence(ctx.profile)
    outer = StrictDERDecodeOCSPResponse(evd)
    require outer.status == successful
    require outer.responseType == id_pkix_ocsp_pocsp
    inner = StrictDERDecodePOCSPBasicResponse(outer.response)
    require no_trailing_bytes and algorithms_allowed(inner)
    require parameters_absent_where_required(inner)
    d = inner.tbsResponseData
    require 0 <= d.statusVersion <= 9223372036854775807
    require extensions_allowed(d, ctx.profile)
    rkeys = cfg.AuthorizedResponderKeys(d.responderKeyHash,
                 issuerID, domain, epoch, ctx.profile)
    require length(rkeys) == 1
    rkey = rkeys[0]
    require DER(d.context) == DER(ctx)
    require constant_time_equal(d.certID.pID,
            DerivePID(cert.type, cert.canonicalBytes,
                      ctx.profile, ctx.channelBinding))
    require d.thisUpdate <= d.producedAt < d.nextUpdate
    require d.producedAt - d.thisUpdate <= cfg.maxBackdate
    require d.nextUpdate - d.thisUpdate <= cfg.wMax
    if not cfg.timeDegraded():
        require d.producedAt <= now + cfg.delta
    if d.status == unknown: require d.statusVersion == 0
    else:                   require d.statusVersion > 0
    if d.status == revoked:
        require d.revocationTime <= d.producedAt
        require d.revocationReason not in
                {certificateHold, removeFromCRL}
    require VerifySignature(rkey, DER(d), inner.signature)
    -- now is the monotonic lower bound of the verifier clock
    usable = (d.thisUpdate - cfg.delta <= now < d.nextUpdate)
             and not cfg.timeDegraded()
    return (d.status, d.statusVersion, d.nextUpdate, usable,
            d.responderKeyHash)
    -- any failed "require" returns FAIL

function ApplyToState(state, key, ctx, e):
    -- admission occurs only here, after certificate and responder
    -- authentication; quotas are enforced before allocating
    s = state.cert.getOrAdmitAuthenticated(key)
    if s is NONE:
        if e.status == revoked:
            state.cache.invalidateGoodForCertificate(key)
            return NEGATIVE_STORAGE_FAILURE
        return POSITIVE_STATE_DROPPED
    if e.status == revoked:
        s.revokedFlag = true
        s.L_rev = min(s.L_rev, e.version)
        state.cache.invalidateGoodForCertificate(key)
    else if e.status == good:
        s.H_good = max(s.H_good, e.version)
        if e.usable and not s.revokedFlag:
            state.cache[key, ctx].offerGood(e.nextUpdate,
                                            e.responderKeyHash)
    else if e.usable:
        state.cache[key, ctx].offerUnknown(e.nextUpdate)
    if defined(s.L_rev) and defined(s.H_good)
       and s.H_good >= s.L_rev:
        s.conflictFlag = true
        state.cache.invalidateGoodForCertificate(key)
        Audit(key, e)
    if (s.revokedFlag or s.conflictFlag)
       and not state.persistRequiredNegativeFields(s):
        return NEGATIVE_STORAGE_FAILURE
    return APPLIED

function OnTrustChange(state, cfg):
    -- called when a responder key loses authorization or the
    -- epoch of a domain changes
    for entry in state.cache:
        if not cfg.ResponderKey(entry.responderKeyHash)
               is authorized for (entry.domain, entry.epoch,
                                  entry.ctx.profile):
            discard entry

function Decide(state, key, ctx, current, now):
    s = state.cert[key]
    if s.conflictFlag: return INVALID
    if s.revokedFlag or (current is authenticated revoked):
        return REVOKED
    if state.goodBlocked(key.domain, key.epoch):
        return UNAVAILABLE
    if (current is usable good) or
       state.cache[key, ctx].goodValid(now):
        return GOOD
    if (current is usable unknown) or
       state.cache[key, ctx].unknownValid(now):
        return UNKNOWN
    return UNAVAILABLE

Appendix C. Detailed Protocol Scenarios

C.1. CAM Cache Warm-Up

PCA/Responder                 Vehicle V                Receiver U
     |                            |                         |
     |-- active good evidence -->|                         |
     |                            |                         |
     |                            |-- Full-cert CAM + Evd ->|
     |                            |                         |
     |                            |          verify and cache
     |                            |-- Digest CAM ---------->|
     |                            |          use cached GOOD
     |                            |-- Digest CAM ---------->|
     |                            |          use cached GOOD
     |                            |-- Full-cert CAM + Evd ->|
     |                            |          refresh cache
Figure 3: CAM profile flow

The evidence is never a higher-frequency identifier than the certificate. If U misses all full-certificate/evidence messages, subsequent digest messages are unconfirmed until U obtains the full certificate and evidence, unless U's status state already records a revocation of that certificate, in which case they are REVOKED.

C.2. Compromise and Revocation

  1. At t0, the responder issues good evidence valid until t0+W.
  2. At t1, the sender key is compromised and an attacker obtains the evidence.
  3. At t2, the revocation authority decides revocation; the responder learns it after D_status.
  4. A verifier that has only the old evidence can accept attacker messages until the old nextUpdate, subject to message-level replay and plausibility controls.
  5. After expiry, the attacker cannot obtain a new good response from an honest responder. New evidence is revoked or unknown.
  6. If the responder also distributes the revoked evidence through roadside units (Section 14.6), every verifier that receives it returns REVOKED for the certificate from that moment on, in every profile and whether or not the attacker attaches evidence.

This scenario is why future-active good evidence is prohibited: a bundle of future responses would let the attacker continue beyond the current W.

C.3. Roaming and Multiple Trust Domains

A roaming verifier can accept evidence only if its trust configuration maps the issuer of the target certificate to a domain and epoch for which the responderKeyHash is authorized for the profile. A common profile OID is not sufficient. Trust-list distribution and cross-domain responder authorization are ecosystem responsibilities.

C.4. TLS with ITS Certificates

Client                                            Server
  | ClientHello + status_request                    |
  |------------------------------------------------>|
  |                                                 |
  |<---------------- ServerHello, EncryptedExtensions
  |<---------------- CertificateEntry {
  |                    ITS Cert (RFC 8902),
  |                    status_request =
  |                        OCSPResponse(pOCSP)
  |                  }
  |<---------------- CertificateVerify, Finished   |
  |                                                 |
  | validate ITS cert + permissions + pOCSP         |
Figure 4: TLS pOCSP carriage

C.5. TLS Resumption and Long-Lived Connection

  1. A full handshake validates certificate C and pOCSP evidence with freshnessDeadline F.
  2. Any resumption ticket derived from that authentication is bound to digest(C), the pOCSP profile, the responder authorization domain and epoch, and F.
  3. Before F, resumption can proceed subject to the normal TLS and application policies.
  4. At or after F, the endpoint either obtains fresh authoritative status, performs a new full certificate-authenticated handshake, or rejects resumption and restricts or terminates the existing connection.
  5. A ticket lifetime or an established connection does not preserve GOOD beyond F.

C.6. Evidence Omission after Revocation

This scenario shows why the decision is computed from the status state rather than from the evidence of the current message.

  1. Verifier U applies revoked evidence for certificate C, received from a roadside unit. revokedFlag is set.
  2. The holder of C, using a compromised key, sends a full-certificate CAM without evidence, then one with its last good evidence, now expired, then one with unknown evidence.
  3. For each message, step 1 of Section 13.2 succeeds and rule 2 of Section 14.4 returns REVOKED. None of the three messages can reach UNCONFIRMED.
  4. A DENM signed with C is also REVOKED, because the status state is independent of the profile.

Appendix D. Test Vectors

The vectors below are self-contained and reproducible from the normative definitions. They use a synthetic certificate octet string (not a real COER or DER certificate) and object identifiers under the enterprise number 32473 reserved for documentation [RFC5612]. They are not production credentials or assigned identifiers. Because the numeric values of id-pkix-ocsp-pocsp (TBD1) and of the profile identifiers of Section 21.2 are not yet assigned, the vectors use documentation OIDs; final interoperability vectors MUST be regenerated with the assigned OIDs.

D.1. Common Values

Domain-separation tag "pocsp-id-v1" (11 octets):

   70 6f 63 73 70 2d 69 64 2d 76 31

Synthetic CertCanonical (32 octets):

   00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
   10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
certDigest = SHA-256(CertCanonical):
   63 0d cd 29 66 c4 33 66 91 12 54 48 bb b2 5b 4f
   f4 12 a4 9c 73 2d b2 c8 ab c1 b8 58 1b d7 10 dd

Example profile OID (documentation only):

   1.3.6.1.4.1.32473.1.1

DER of the profile OBJECT IDENTIFIER (12 octets):

   06 0a 2b 06 01 04 01 81 fd 59 01 01

D.2. Vector 1: Context without channelBinding

POCSPContext = SEQUENCE { profile 1.3.6.1.4.1.32473.1.1 }

contextDER (14 octets):

   30 0c 06 0a 2b 06 01 04 01 81 fd 59 01 01
pID = leftmost_16(SHA-256(tag || certDigest || contextDER)):
   d6 94 9a 7d a3 12 b6 cc 2f 16 02 8a f2 f9 f9 c5

D.3. Vector 2: Context with channelBinding

channelBinding (32 octets):

   ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
   ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
POCSPContext = SEQUENCE { profile 1.3.6.1.4.1.32473.1.1,
                          channelBinding }

contextDER (48 octets):

   30 2e 06 0a 2b 06 01 04 01 81 fd 59 01 01 04 20
   ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
   ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab
pID = leftmost_16(SHA-256(tag || certDigest || contextDER)):
   21 b0 79 d6 c7 73 14 29 45 9a 0c 05 2c 48 eb b8

D.4. Complete Evidence Objects

These objects exercise the complete encoding and signature. The responseType is the documentation OID 1.3.6.1.4.1.32473.1.2, standing for id-pkix-ocsp-pocsp. The context and pID are those of Vector 1. The responder key is an ECDSA P-256 key whose private scalar is the SHA-256 digest, reduced modulo the group order, of the ASCII string "pOCSP documentation responder key". Signatures are deterministic [RFC6979] with SHA-256; verifiers MUST NOT assume determinism, which only makes the vectors reproducible.

Private scalar d:

   b2 5c 31 b9 6f 24 89 21 94 3b 32 da ae 1d e1 8a
   d9 fc cc 53 c9 2b 50 ed a9 07 4c 4d 9b c5 0a 4f

Public key, uncompressed (subjectPublicKey value, 65 octets):

   04 20 5d e9 15 eb 71 97 b7 1a dc cb a5 0b cf 67
   ce 03 a7 1d fa 93 58 4d cc 93 e9 46 94 7c e0 77
   87 00 fc a3 49 42 5b 4f aa 35 fc 52 c4 4d 37 79
   d5 55 b5 fb 45 fc 4c 83 8a 21 57 5c d2 99 99 38
   64
responderKeyHash = SHA-256(public key octets above), X.509 form of
Section 9.1, used in the objects below:
   b2 5d 68 50 42 5e 70 88 81 1c 7e bb 90 85 ee 9c
   e9 e2 b4 e0 80 07 30 7d 83 51 61 bf 1a df 3c 98

For the same key provisioned as an ITS credential, the hash input is the COER encoding of PublicVerificationKey: the context tag 80 of the ecdsaNistP256 alternative, then the EccP256CurvePoint tag 82 (compressed-y-0, the y-coordinate above being even) and the 32 x-coordinate octets, 34 octets in total:

   80 82 20 5d e9 15 eb 71 97 b7 1a dc cb a5 0b cf
   67 ce 03 a7 1d fa 93 58 4d cc 93 e9 46 94 7c e0
   77 87

responderKeyHash, ITS form of Section 9.1:

   d3 d8 a7 69 99 84 03 26 5a 59 1c 74 8a 3e 58 6c
   61 4f ae 78 2b b1 65 d0 49 85 1b cd ce cd 9d df

The two forms identify the same key under two provisioning models and are never mixed within one deployment; a verifier matches the form of its trust configuration.

Good evidence: statusVersion 42, producedAt 20261004120000Z, thisUpdate 20261004115900Z, nextUpdate 20261004120900Z. The window is 600 seconds and the backdating 60 seconds, the limits of the v2x-awareness profile. DER OCSPResponse (256 octets):

   30 81 fd 0a 01 00 a0 81 f7 30 81 f4 06 0a 2b 06
   01 04 01 81 fd 59 01 02 04 81 e5 30 81 e2 30 81
   89 04 20 b2 5d 68 50 42 5e 70 88 81 1c 7e bb 90
   85 ee 9c e9 e2 b4 e0 80 07 30 7d 83 51 61 bf 1a
   df 3c 98 02 01 2a 18 0f 32 30 32 36 31 30 30 34
   31 32 30 30 30 30 5a 30 0c 06 0a 2b 06 01 04 01
   81 fd 59 01 01 30 1f 30 0b 06 09 60 86 48 01 65
   03 04 02 01 04 10 d6 94 9a 7d a3 12 b6 cc 2f 16
   02 8a f2 f9 f9 c5 80 00 18 0f 32 30 32 36 31 30
   30 34 31 31 35 39 30 30 5a 18 0f 32 30 32 36 31
   30 30 34 31 32 30 39 30 30 5a 30 0a 06 08 2a 86
   48 ce 3d 04 03 02 03 48 00 30 45 02 21 00 b4 48
   9d 07 38 fe 0d e3 7d e5 dd 72 6a f3 a2 0b 63 86
   0e 31 07 16 cb 16 68 db 94 3a 83 1e 57 e1 02 20
   68 f5 1b b3 42 b0 95 07 36 76 00 4e ea 37 7a 45
   cb 27 7c 57 41 a7 3f bd 81 9b 3d 7e 83 e9 bf 32

Revoked evidence for the same certificate: statusVersion 43, revocationTime 20261004113000Z, other times as above. DER OCSPResponse (276 octets):

   30 82 01 10 0a 01 00 a0 82 01 09 30 82 01 05 06
   0a 2b 06 01 04 01 81 fd 59 01 02 04 81 f6 30 81
   f3 30 81 9a 04 20 b2 5d 68 50 42 5e 70 88 81 1c
   7e bb 90 85 ee 9c e9 e2 b4 e0 80 07 30 7d 83 51
   61 bf 1a df 3c 98 02 01 2b 18 0f 32 30 32 36 31
   30 30 34 31 32 30 30 30 30 5a 30 0c 06 0a 2b 06
   01 04 01 81 fd 59 01 01 30 1f 30 0b 06 09 60 86
   48 01 65 03 04 02 01 04 10 d6 94 9a 7d a3 12 b6
   cc 2f 16 02 8a f2 f9 f9 c5 a1 11 18 0f 32 30 32
   36 31 30 30 34 31 31 33 30 30 30 5a 18 0f 32 30
   32 36 31 30 30 34 31 31 35 39 30 30 5a 18 0f 32
   30 32 36 31 30 30 34 31 32 30 39 30 30 5a 30 0a
   06 08 2a 86 48 ce 3d 04 03 02 03 48 00 30 45 02
   20 55 bf 25 11 b2 cf 44 1a 86 88 86 a0 08 f7 17
   c9 7f eb a0 6a 3b 4b 49 b2 9d 2d 6c 69 c0 d6 30
   00 02 21 00 d9 15 76 d8 ec 89 26 ea c2 16 2d b8
   34 bc e0 a0 57 b1 57 88 3d 0a 18 e6 6d e1 0d 61
   c6 81 6a 10

A verifier that applies both objects obtains H_good = 42 and L_rev = 43, a consistent history, and returns REVOKED for the certificate in every profile. Re-signing the good object with statusVersion 43 or higher yields an equivocation (Section 14.3).

D.5. Status-State Vectors

Each line gives a sequence of authenticated evidence applied to one certificate, in the form status/statusVersion, with "x" marking evidence that is not usable and "-" a message without evidence, and the result returned for the last message.

   revoked/50, -                        -> REVOKED
   revoked/50, good/40 x                -> REVOKED
   revoked/50, unknown/0                -> REVOKED
   good/101, good/100                   -> GOOD
   good/(2^63-1), revoked/51            -> INVALID (conflict)
   good/(2^63-1), revoked/51, good/(2^63-1)
                                        -> INVALID (conflict)
   revoked/50, good/60                  -> INVALID (conflict)
   revoked/50, good/50                  -> INVALID (conflict)
   good/42 signed by a key of an older epoch
                                        -> INVALID (Section 6.1)
   revoked/50, good/60, -               -> INVALID (conflict)
   revoked/50, then time uncertainty
   exceeding Delta, -                   -> REVOKED (Section 17.5)
   good/42 under TLS-application context
   of connection A, then message of
   connection B without evidence        -> UNAVAILABLE (Section 14.2)
   good/42, then signing key loses
   authorization, -                     -> UNAVAILABLE (Section 14.2)
   good/42, then nextUpdate passes,
   then clock set back, -               -> UNAVAILABLE (Section 18.4)

Lines 1 through 8 exercise revocation dominance, tolerance of benign good-evidence reordering, resistance to version pinning, and equivocation detection. Line 9 requires epoch binding of responder keys (Section 6.1). The last three lines exercise the context-bound cache key, trust-change invalidation, and monotonic time bound; in each case an incorrectly scoped or resurrected cache hit would have produced GOOD.

D.6. Further Vectors

An interoperability suite needs to cover, in addition, malformed and oversized input, non-minimal DER, prohibited extensions, future-active and expired evidence, context substitution, zero and multiple responder-key matches, wrong-issuer authorization, producedAt in the future beyond Delta, revocationTime after producedAt, certificateHold, removeFromCRL, pID collisions in the 16-octet profile, storage exhaustion, stale replicas, recovery-sequence replay, and recovery with an ambiguous clearing scope.

Appendix E. Formal Verification Blueprint

This appendix defines a verification plan; it does not report a completed machine-checked proof. Any later proof claim needs the model source, exact tool version, executable command, assumptions, lemmas, and result log needed for independent reproduction.

A symbolic model, for example in the Tamarin prover [TAMARIN2013], can represent the responder signature as an unforgeable constructor, SHA-256 as a collision-free function, time-window checks as guards, and the network as controlled by a Dolev-Yao adversary [DOLEV1983]. The target properties are:

statusVersion can be modelled with the natural-number support of the prover or with a successor encoding; the properties above need only order comparisons.

The model state SHOULD distinguish the good-evidence cache keyed by complete context, revokedFlag, L_rev, H_good, conflictFlag, the authorization domain, and the authorization-domain epoch. A responder-key authorization fact MUST include the epoch, so that a key of an older epoch cannot relabel old evidence into a recovered epoch. Recovery is modelled as an authenticated transition that changes the epoch and the key authorization before version ordering restarts. The model does not prove unlinkability because pID is deterministic and the certificate can be public. Privacy requires an observational-equivalence model of the complete V2X message and radio behavior; this specification makes no such claim.

Appendix F. Design Rationale and Rejected Alternatives

F.1. Why Retain pID if It Is Not Unlinkable?

pID provides compact matching, hides direct issuer/serial representation, and binds the certificate to a profile. It is retained as a functional identifier, not an anonymity mechanism. The privacy rules ensure that it does not become more observable than the certificate in broadcast operation. The 16-octet form offers about 128 bits against a fixed-target second preimage but only about 64 bits against generic pair collisions; the collision index of Section 8.3 is therefore mandatory. Profiles that cannot maintain it use the 32-octet form.

F.2. Why One Status per Response?

Bundling improves responder and transmission efficiency but directly links all included pseudonyms, increases parsing and matching complexity, and increases the impact of a malformed object. The baseline chooses single-entry determinism. Confidential management channels can batch delivery of separate response objects.

F.3. Why Prohibit Future-Active Good Evidence?

Earlier proposals suggested prefetching several successive 10-minute good responses to survive a 30-minute outage. If the key is compromised immediately after issuance, the attacker can use the entire bundle. The effective stale-good exposure becomes the bundle horizon rather than one response window. The baseline permits early refresh of already active evidence but not future authorization.

F.4. Why Use TLS status_request?

The standard CertificateEntry extension is transcript-bound and already has failure alerts and implementation semantics. A custom application field or side channel requires additional binding, is vulnerable to stripping, and is easier to associate with the wrong connection. Therefore status_request is the default.

F.5. Why DER Inside COER?

The OCSP envelope and PKIX registries are ASN.1/DER-based. V2X secured messages are COER-based. Carrying an opaque DER OCSPResponse in a COER extension preserves each ecosystem's canonical encoding and avoids redefining OCSP in COER. Implementations must treat the DER bytes as an opaque extension value until pOCSP validation.

F.6. Why Add statusVersion in Addition to producedAt?

producedAt is generated by an individual responder clock. Redundant responders, clock skew, and responder-key rotation can otherwise produce inconsistent ordering. statusVersion is the version of the authorization-domain-wide authoritative status snapshot and provides one ordered history for the domain epoch without creating a per-certificate or per-vehicle counter. It is what makes the consistency condition H_good < L_rev checkable. producedAt remains a generation time for audit.

F.7. Why Is status_request Not Sufficient Capability Negotiation?

status_request negotiates carriage of an OCSP CertificateStatus object; it does not advertise support for every responseType carried inside OCSPResponse. A legacy peer can support id-pkix-ocsp-basic without understanding id-pkix-ocsp-pocsp. For server certificates, the RFC 6960 AcceptableResponses extension in the RFC 6066 OCSPStatusRequest explicitly lists id-pkix-ocsp-pocsp. TLS 1.3 CertificateRequest has an empty status_request form and cannot carry that list, so client-certificate pOCSP requires an authenticated profile or out-of-band capability agreement.

F.8. Why Not Reject Lower-Version Good Evidence?

Rejecting good evidence merely because it carries a lower statusVersion than previously accepted evidence for the same certificate protects nothing: because revocation is terminal, lower-version good evidence is implied by higher-version good evidence, and an attacker holding still-valid good evidence presents the highest version it holds. The rule had two harmful effects. It returned INVALID for honest messages reordered or forwarded by the network. Combined with version pinning by a compromised responder key, it rejected authentic revoked evidence of lower version as rollback, so that the pinned good evidence masked the revocation until its expiry.

Applying sticky revoked state only on the evidence-processing path is likewise unsafe. A message without evidence, or with expired evidence, could return UNAVAILABLE before that state is consulted, which an awareness profile maps to UNCONFIRMED. A revoked holder could then leave the REVOKED state simply by omitting evidence. The specified design instead uses revocation dominance (Section 14.4) and the consistency condition H_good < L_rev (Section 14.3).

F.9. Why Is the Status State Independent of the Profile?

Revocation invalidates a certificate, not one of its uses. One pseudonym certificate commonly signs both awareness and event messages. Scoping the revoked state to the profile would let a certificate revoked through awareness evidence continue to sign accepted event messages. Profile scoping remains appropriate for good evidence, whose freshness parameters and failure semantics differ by profile.

F.10. Why Use a New OCSP responseType?

BasicOCSPResponse requires the RFC 6960 ResponseData and SingleResponse structures, including the classical CertID composed of issuer hashes and a certificate serial number. Extensions can add context or version information, but they cannot replace those mandatory fields or the response-list structure. Encoding the pID, signed context, and statusVersion only as extensions would therefore retain identifiers and parsing paths that the single-entry pOCSP design intentionally avoids.

A new responseType permits a fixed one-status schema, exact context binding, and a profile-bounded parser while retaining the OCSPResponse envelope and IANA namespace. The cost is deliberate: generic BasicOCSPResponse implementations are not transparently compatible, and TLS endpoints must negotiate or configure the new response type as specified in Section 16.1. A deployment that values legacy OCSP compatibility more highly can use BasicOCSPResponse, but it is not implementing the pOCSP response defined here.

Appendix G. SDO Mapping Guidance

The following guidance is informative because IETF does not control ETSI, IEEE, or SAE namespaces.

Table 8: SDO mapping guidance
Ecosystem Recommended mapping Application payload change
ETSI TS 103 097 Signed HeaderInfo contributed extension None for CAM/DENM
IEEE 1609.2 Signed secured-header extension None for J2735 bytes
SAE J2735 Keep UPER message unchanged; evidence in the 1609.2 envelope None
TLS 1.3 CertificateEntry status_request None

A concrete ETSI/IEEE profile should allocate: contributor/ extension identifier, maximum extension size, legacy handling, certificate repetition interaction, and profile OID mapping. It should also provide COER wrapper test vectors around the opaque DER evidence.

Appendix H. Experimental Evaluation and Claim Boundaries

H.1. Classification of Claims

This appendix is informative. It distinguishes four classes of statement that must not be conflated in an implementation report, standards proposal, publication, or deployment claim.

  • A specified mechanism is protocol behavior defined normatively in this document, such as signature verification, strict expiry, or revocation dominance. Specification does not demonstrate that an implementation is correct or fast.
  • A conditional analytical bound follows from stated assumptions. The stale-GOOD bound D_status + W_max + Delta in Section 5.3 and the responder-rate estimate in Section 17.4 are examples. Such a bound is invalid when an assumption or input bound is not met.
  • A measured result is an observation from a named implementation, platform, workload, data set, and statistical method. This document reports no measured performance, radio-load, energy, availability, or privacy result.
  • A proved property is established by a published proof or an executable formal model under explicit assumptions. Appendix E is a blueprint only; this document reports no machine-checked security or privacy proof.

Terms such as "bounded", "scalable", "privacy-preserving", "interoperable", "low latency", and "DoS-resistant" must therefore be qualified by the applicable class, metric, assumptions, and evidence when used outside the protocol specification.

H.2. Minimum Evaluation Campaign

A production or scientific evaluation needs to include all of the following work packages. Omitting one limits the corresponding claim and must be reported.

E1, encoding and conformance: at least two independently developed implementations exchange every status and profile that they share. Tests cover canonical certificate input, complete DER encodings, exact signed bytes, all profile parameters, and the negative cases of Appendix D.6. Fuzzing includes length, tag, integer, time, extension, signature, and trailing-data mutations. Assigned OIDs replace the documentation OIDs before a public interoperability claim.

E2, verifier performance: report cache-hit, cache-miss, new-certificate, invalid-input, and signature-flood paths separately. Measure throughput, p50, p95, p99, and p99.9 latency, CPU, memory, allocations, and energy where relevant. Include cold starts, pseudonym changes, concurrent traffic, queueing, and resource saturation. An average warmed-cache measurement is insufficient.

E3, radio and carriage impact: measure complete on-air bytes, fragmentation, channel occupancy, loss, retransmission, and cache warm-up under documented vehicle density and mobility traces. Evaluate correlated loss and congestion rather than relying only on the independent-loss approximation of Section 17.2. Legacy-decoder behavior is tested against named schema and implementation versions.

E4, responder and distribution capacity: evaluate the population and profile factors in Section 17.4, issuance and refresh bursts, CDN or edge caching, retry amplification, partition, failover, key rotation, and a stale replica. Verify that snapshot contents and statusVersion are committed atomically and that a partitioned responder stops issuing good before D_status is exceeded.

E5, verifier state and recovery: test bounded-state admission, pseudonym churn, full storage, restart, rollback of persistent state, corruption, epoch change, key deauthorization, and garbage collection after native certificate invalidity. Demonstrate that a live revokedFlag or conflictFlag cannot become GOOD through eviction, restart, evidence omission, clock rollback, or cache reuse. Exercise recovery statement replay, ambiguous scope, false revocation, global clear, and restoration before strict processing resumes.

E6, time behavior: test the two clock-error contributions assumed in Section 5.3, drift over W_max, a future producedAt, the inclusive X.509 notAfter boundary, the exclusive ITS validity end, degraded time, forward and backward jumps, and expiry during TLS resumption or an established connection.

E7, privacy: define observers, auxiliary information, issuance and refresh channels, timestamp cohorts, responder-key cohorts, radio metadata, and the reference system without pOCSP. Measure or model additional linkability across pseudonym changes. A shorter pID or the absence of online verifier queries alone does not establish unlinkability.

E8, security analysis: execute the model outlined in Appendix E and publish the model and tool logs if a formal claim is made. Separately analyze implementation attacks outside the symbolic model, including parser differentials, algorithm confusion, key-hash ambiguity, storage exhaustion, compromised responders, and recovery-authority compromise.

H.3. Reproducibility Record

Each reported experiment should identify the draft version and profile, implementation commit, compiler and cryptographic library, hardware and accelerators, operating system, responder topology, trust configuration, clock source, data set or trace provenance, workload generator, random seeds, warm-up, run count, exclusions, statistical method, confidence intervals, and raw-result location. Configuration and analysis scripts should accompany the results.

Results should distinguish protocol failures, environmental failures, and implementation defects. Negative and null results should be retained. A derived parameter such as D_status must be measured or justified independently; selecting it to fit an intended conclusion invalidates the bound in Section 5.3.

H.4. Present Scope of Defensible Claims

The draft specifies a single-certificate, presenter-carried status format, its verifier state machine, conditional freshness bounds, and abstract V2X and TLS carriage rules. The cryptographic test objects in Appendix D have reproducible encodings and signatures.

The draft does not by itself establish end-to-end exclusion of a vehicle, completeness of the authority's pseudonym-to-device resolution, a numerical radio or latency target, a production responder capacity, a privacy-equivalence or unlinkability result, ecosystem-wide equivocation detection, or a completed formal proof. It also does not establish public V2X interoperability until the relevant SDO allocates and specifies a concrete secured-envelope mapping, nor public OCSP interoperability until IANA assigns the requested identifiers and final vectors use them.

Deployment claims must therefore name the profile, enforcement policy, external revocation-decision system, credential-coverage assumption, responder and recovery trust model, measured platform, and completed work packages from Section H.2. Unmeasured objectives remain objectives, not properties of pOCSP.

Acknowledgments

The authors thank the colleagues who reviewed earlier drafts of this specification. Their comments on identifier linkability, certificate canonicalization, future-active evidence, TLS binding, and the handling of verifier status state led to corrections incorporated in this document.

Authors' Addresses

Jean-Jacques Grund
Telecom Paris, Institut Polytechnique de Paris
19 place Marguerite Perey
91120 Palaiseau
France
Rida Khatoun
Telecom Paris, Institut Polytechnique de Paris
19 place Marguerite Perey
91120 Palaiseau
France
Guy Pujolle
Sorbonne Universite, CNRS, LIP6
Paris
France
Ahmed Serhrouchni
Telecom Paris, Institut Polytechnique de Paris, and Institut CyberIA
19 place Marguerite Perey
91120 Palaiseau
France