| Internet-Draft | pOCSP | November 2026 |
| Grund, et al. | Expires 18 May 2027 | [Page] |
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.¶
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.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
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.¶
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.¶
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.¶
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.¶
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].¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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
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]:¶
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.¶
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.¶
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.¶
pID derivation requires a unique octet representation. The generic term CertCanonical is defined as follows:¶
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.¶
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.¶
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.¶
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.¶
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).¶
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 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.¶
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.¶
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.¶
| 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.¶
A responder creates evidence only from authoritative state. The following procedure is normative.¶
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.¶
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).¶
statusVersion is meaningful only if the status snapshot and its version are committed atomically. An authorization domain MUST meet the following requirements:¶
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.¶
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.¶
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.¶
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.¶
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
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
For each certificate within one domain epoch, the verifier maintains the following certificate status state:¶
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.¶
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.¶
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:¶
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.¶
The decision for a certificate, expected context, domain, and epoch is given by the first applicable rule:¶
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.¶
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.¶
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:¶
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.¶
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.¶
| 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 |
| 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.¶
| 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.¶
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.¶
Event-driven hazard and authorization-sensitive messages can have high physical or operational impact. The strict profile requires a self-contained status decision.¶
SPaT and MAP are often produced by infrastructure with longer-lived operational identities and periodic transmissions.¶
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.¶
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.¶
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.¶
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).¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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).¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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]:¶
| 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.¶
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:¶
| 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.¶
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.¶
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]:¶
| 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.¶
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.¶
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>¶
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))
¶
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
¶
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
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.¶
This scenario is why future-active good evidence is prohibited: a bundle of future responses would let the attacker continue beyond the current W.¶
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.¶
Client Server
| ClientHello + status_request |
|------------------------------------------------>|
| |
|<---------------- ServerHello, EncryptedExtensions
|<---------------- CertificateEntry {
| ITS Cert (RFC 8902),
| status_request =
| OCSPResponse(pOCSP)
| }
|<---------------- CertificateVerify, Finished |
| |
| validate ITS cert + permissions + pOCSP |
This scenario shows why the decision is computed from the status state rather than from the evidence of the current message.¶
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.¶
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¶
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¶
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¶
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).¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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).¶
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.¶
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.¶
The following guidance is informative because IETF does not control ETSI, IEEE, or SAE namespaces.¶
| 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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶