Internet-Draft ACME PK Challenge November 2026
Geng, et al. Expires 23 May 2027 [Page]
Workgroup:
Automated Certificate Management Environment Working Group
Internet-Draft:
draft-geng-acme-idp-01
Published:
Intended Status:
Standards Track
Expires:
Authors:
F. Geng
Huawei Technologies
P. Wu
Huawei Technologies
X. Chen
TrustAsia

Automated Certificate Management Environment (ACME) Delegated Identity Control Validation Framework Using Identity Providers

Abstract

This document defines a Delegated Identity Control Validation (Delegated ICV) framework for the ACME protocol [RFC8555]. It addresses a core problem: how an ACME server can obtain proof that "the client controls the identifier" without directly validating the identifier. The solution is for an Identity Provider (IdP) to issue an identity assertion, acmeIdpToken, enabling the ACME server to delegate identifier control validation to a trusted IdP, with the CA validating the IdP's assertion.

The framework defines two trust models: PKI certificate binding (x509-chain), in which the CA pre-configures a trust anchor that anchors the IdP certificate; and dual-PoP public key binding (idp-pop), in which IdP static mapping and ACME-PoP are combined back-to-back. Implementations MUST support at least one model; they are not required to support both.

The normative scope of this document is limited to dedicated trust environments or private CAs. Identity validation rules for publicly trusted certificates are defined by external rules; this document does not define, interpret, or replace those rules. This document composes orthogonally with [I-D.ietf-acme-pop]: the constrained ACME-PoP internalized by idp-pop is used only for identifier binding and does not replace the generic pop-01 authorization.

Status of This Memo

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

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

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

This Internet-Draft will expire on 23 May 2027.

▲

Table of Contents

1. Introduction

1.1. Background

The Automatic Certificate Management Environment (ACME) protocol [RFC8555] provides a standardized mechanism for automated issuance and management of X.509 certificates. ACME's core design is centered on Domain Control Validation (DCV). As ACME use cases extend from web server certificates to S/MIME, code signing, device identity, enterprise identity, and cloud-native workloads, certificate subject identifiers extend from domain names to email addresses, user accounts, private-domain SIP numbers, device identifiers, or SPIFFE IDs. Traditional DCV challenges cannot validate an applicant's control over such identity identifiers.

The ACME community has explored several identity validation paths: [RFC8823] defines email control validation; [RFC9447] defines the tkauth-01 challenge (TNAuthList profile in [RFC9448]); [I-D.ietf-acme-pop] defines the ACME pop authorization; and [I-D.rasmussen-acme-wif] attempts to define a workload identity challenge. The relationship between this framework and these efforts is described in Section 3.4 and Appendix D.

Beyond IETF draft work, industry also has deployment practice combining SSO authorization with the ACME certificate lifecycle (for example, related solutions in Cisco's Zero Trust Access architecture [Cisco-Live-BRKSEC-3027]). Such practice typically places user or device identity validation outside the ACME protocol boundary, with a separate Registration Authority (RA) component performing authorization based on SSO assertions, while the ACME protocol itself still executes traditional control challenges. The goal of this document is to standardize such identity control validation capability inside the ACME protocol, making the IdP identity assertion a verifiable input to the CA rather than relying on out-of-band RA logic.

1.2. Motivation

If a new challenge type were defined independently for each class of identity identifier, the result would be protocol fragmentation, increased client implementation complexity, and an inability to reuse existing identity authentication infrastructure. The goal of the Delegated ICV framework is to decouple identity validation from the CA and delegate it to already-deployed IdPs, while preserving the CA's ultimate control over certificate issuance.

This document addresses a core problem: how an ACME server can obtain proof that "the client controls the identifier" without directly validating the identifier.

The solution is to delegate identifier control validation to a trusted IdP, with the CA validating the IdP's assertion. This document defines two trust models to implement this delegation; both serve the same motivation and apply to different deployment scenarios.

This document does not attempt to be a "generic framework for identity validation", nor does it attempt to cover all identity identifier types. It defines only one idp identifier type and two trust models, addressing the single problem of "delegated ICV". [RFC8823] has already registered the email type for email addresses; STIR/telephony telephone number authority is carried by the TNAuthList of [RFC9448]; private-domain SIP identities (for example, an enterprise-internal SIP URI) have no existing ACME type and are carried by the idp type of this document; workload identities are handled by [I-D.rasmussen-acme-wif]. This document does not redefine validation mechanisms for those types. Telephone-number-form SIP URIs and TEL URIs are carried by RFC 9448; the sip: in this document is used only for non-telephone-number AoRs.

1.3. Problem Statement

The standard ACME protocol faces four core challenges in delegated identity identifier validation scenarios:

  • Missing identity identifier type: ACME's dns, ip, and similar types cannot express identity identifiers such as "account", "device identifier", or "SPIFFE ID"; although email addresses have the email type, there is no "asserted by an IdP" validation path.

  • Missing delegation mechanism for identity validation: the CA needs a standardized way to delegate identity validation to an external IdP and to securely validate the identity assertion returned by the IdP.

  • Timeliness of identity revocation: identity state changes occur on the IdP side, while the certificate may already have been issued and is in circulation; the time window between an identity revocation event and certificate revocation needs to be shortened.

  • Certificate subject carriage and relying party parsing: after an idp identifier enters the certificate subject, relying parties must be able to reliably parse, compare, and make security decisions based solely on RFC 5280 and the referenced identifier specification; URI SAN authority constraints and otherName encoding must be addressed head-on.

1.4. Solution Overview

This document defines a Delegated Identity Control Validation framework:

  • An idp identifier type carrying URI-form identity identifiers (spiffe:, urn:, oidc:, sip:/sips:).

  • A base framework (Section 4): idp identifier type, certificate subject mapping rules, IdP routing, and idp_config retrieval framework. Both trust models share this base framework.

  • PKI certificate binding (Section 5): x509-chain, reusing the [RFC9447] and [RFC9448] architecture and extending the atc semantics of tkauth-01 with tkauth-type = "idp".

  • Dual-PoP public key binding (Section 6): idp-pop, defining an independent idp-pop-01 challenge. The challenge response carries a JWK public key and a JWS PoP signature; at finalize, the CA re-checks that the CSR public key matches the bound public key.

  • Trust model selection guidance (Section 7).

The two models have different trust anchors: x509-chain uses a pre-configured certificate trust anchor; idp-pop uses a JWKS obtained through OIDC Discovery under the Web PKI, plus the IdP's static mapping. Both achieve "the CA obtains proof that the client controls the identifier without directly validating the identity identifier".

Implementations MUST support at least one model; they are not required to support both. The CA declares which model it supports via idp_config.supported_models, and the client selects based on the deployment scenario. If the CA and client share no common model, the CA MUST return rejectedIdpId.

1.5. Scope and Positioning

The ICV framework defined in this document applies to dedicated trust environments or private CA deployments that require an identity identifier (rather than a domain name) as the certificate subject identifier, including but not limited to: S/MIME end-entity certificates (private trust environment), code signing certificates (private trust environment), device identity certificates, enterprise identity certificates, private-domain SIP certificates, and cross-organization PKI bridging.

Scope statement by CA type:

Table 1
CA Type Within Normative Scope Notes
Public Web PKI TLS CA No The business model is built around domain control validation and does not include identity validation delegation. This document does not change existing Web PKI rules.
Publicly Trusted S/MIME CA Not in normative scope Certificate validity periods and identity validation rules are defined by CA/B Forum rules. This document provides no compliance guidance.
Publicly Trusted Code Signing CA Not in normative scope As above.
STIR/Telephony Certificate CA No (carried by RFC 9448) Telephone-number-form SIP URIs and TEL URIs are carried by RFC 9448; the sip: in idp is used only for non-telephone-number AoRs.
Dedicated Trust Environment / Private CA In scope The target deployment scenario. Includes private-domain SIP identities: for example, an enterprise-internal sip:alice@internal.example.com, whose authority is asserted by the enterprise IdP. The idp/sip: in this document is used only for such non-telephone-number AoRs and does not assert telephone number authority.

The applicability of publicly trusted certificates is entirely determined by external rules; this document does not define, interpret, or replace CA/B Forum Baseline Requirements or the identity validation rules of any publicly trusted certificate system. If a public trust profile wishes to reference the mechanisms of this document, it MUST define its own identity validation semantics in its external rules; this document does not provide compliance guidance.

This document defines ACME authorization objects and token semantics, as well as the mapping rules the CA MUST follow when a deployment profile has already defined certificate subject carriage. This document does not define a generic otherName OID or ASN.1 module; certificate subject carriage for urn: and oidc: identifiers depends on an independent profile registering an OID. When no profile referencing a registered OID is available, the CA MUST NOT issue certificates containing those identifiers. The URI SAN allowance conditions for spiffe: and sip:/sips: are defined in Section 4.2. Even for a private trust CA, when using urn: or oidc: identifiers, the deployment profile that defines the otherName encoding must still be referenced; issuance is prohibited without such a profile. This rule applies equally to private and public CAs.

This document defines only the two trust models of Delegated ICV. It does not attempt to be a generic registry of identity types, nor does it redefine the validation mechanisms for email control ([RFC8823]), telephone number authority ([RFC9448]), or workload identity ([I-D.rasmussen-acme-wif]).

1.6. Terminology

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD 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.

  • ACME Server: the entity implementing ACME protocol interactions.

  • Certification Authority (CA): the entity issuing and revoking X.509 certificates.

  • Identity Provider (IdP): an identity management service trusted by the CA to validate an applicant's control over the claimed identity.

  • ACME-ICV Client: an ACME client requesting identity-bound certificates.

  • idp identifier: an ACME identifier type whose value is a URI, used to identify a subject in an IdP namespace.

  • Trust model: a technical path implementing delegated ICV; this document defines two, x509-chain and idp-pop.

  • acmeIdpToken: a JWT [RFC7519] issued by the IdP carrying an identity assertion.

  • IdP trust anchor: the trusted public key or key set (such as a JWKS) or IdP certificate trust root used to validate the JWT issued by the IdP.

  • Identifier-mapping IdP: an IdP satisfying the normative requirements of Section 6.4, which is a precondition for deploying the idp-pop model.

  • Bound public key: the public key K identified by idp_assertion.binding in idp-pop; the challenge response carries its JWK, and at finalize the CSR public key must match.

  • Deployment profile: the certificate profile or identifier profile followed by the deployment, defining the OID, ASN.1 encoding, and matching rules for certificate subject carriage.

  • Dedicated trust environment: a trust environment in which the CA explicitly configures the set of trusted identity sources and is not constrained by public trust program rules. Public Web PKI, publicly trusted S/MIME, and publicly trusted code signing are not dedicated trust environments.

  • High-assurance certificate profile: a certificate profile explicitly marked as high-assurance in the deployment policy; its determination criteria are defined by the CA in its CPS or certificate policy. The MUST NOT provisions in this document that reference "high-assurance" apply only to profiles so marked.

2. Design Rationale

2.1. Core Design Decisions

Single motivation, two trust models: the sole motivation of this document is "Delegated ICV". The two trust models are two implementations of the same motivation, applicable to different scenarios; an implementation may support either one.

Base framework independent of trust model: the idp identifier type, certificate subject mapping rules, IdP routing, and idp_config retrieval framework are the base framework shared by both trust models, defined once (Section 4) and referenced, not redefined, by both trust models.

x509-chain references the RFC 9448 architecture without redefining the mechanism: the token acquisition mechanism of x509-chain (dedicated request + certificate private key signature + x5c path validation) follows the same architecture as [RFC9448] Section 5.5. This document normatively references RFC 9448 Section 5.5 and lists the differences; the contribution of this document is to define the atc semantics of the idp identifier under the tkauth-01 framework and the certificate subject mapping rules.

idp-pop replaces tkauth-01 with dual PoP: the standard OIDC authorization request parameter set has no legitimate location to carry an ACME identifier (the identifier conveyance requirement of [RFC9447] Section 3.1 cannot be met). Therefore idp-pop does not reuse tkauth-01, but defines an independent idp-pop-01 challenge, using dual PoP public key binding as the common anchor for both the IdP and ACME:

  • the IdP validates that "the identity identifier is securely bound to public key PK";

  • ACME validates that "the client securely holds the same public key PK";

  • the two PoPs are back-to-back, constituting proof that "the client controls the identity identifier".

This internal PoP is used only to prove that the client holds the bound public key PK, and is not equivalent to the generic ACME pop-01 authorization; if the deployment requires generic key possession proof, the pop-01 challenge must be used separately.

Protocol constraints for idp-pop:

  • the client submits pop_key (JWK) and pop_signature (Flattened JWS) in the idp-pop-01 challenge response;

  • the CA validates the public key thumbprint and PoP signature at the challenge stage, without comparing the CSR;

  • at finalize, the CA enforces that the CSR public key matches the JWK Thumbprint of the bound public key, returning badPublicKey on mismatch;

  • pop_signature uses Flattened JWS with payload being the JSON object {"nonce": ..., "binding": ...}; the protected header MUST contain alg and MUST NOT use b64=false;

  • public key thumbprints use RFC 7638 JWK Thumbprint (SHA-256).

MTI by trust model:

  • a CA implementation MUST support the complete validation flow of at least one of x509-chain or idp-pop;

  • a client implementation MUST support the token acquisition and submission of at least one of x509-chain or idp-pop;

  • implementations are not required to support both. The CA declares via idp_config.supported_models.

2.2. Design Constraints

  1. Single motivation focus: serving only the one problem of Delegated ICV. Not redefining email control [RFC8823], telephone number authority [RFC9448], or workload identity (WIF).

  2. Shared base framework: identifier type, certificate subject mapping, IdP routing, and configuration retrieval framework are defined once and referenced by both trust models.

  3. Reference [RFC9448]: x509-chain normatively references [RFC9448] Section 5.5; this document defines only idp-specific atc semantics, fingerprint encoding, and mapping rules.

  4. CA ultimate control: trust anchors are explicitly configured by the CA (pre-configured trust root or OIDC Discovery), not resolved via external federation chains or the client.

  5. Lifecycle compensation: the timeliness of identity revocation is compensated by short-lived certificates and mandatory re-validation; this document does not promise zero-delay revocation.

  6. Algorithm agility: protocol fields and configuration must be able to express algorithm family migration; specific PQC profiles are defined by external documents, but the ICV framework itself must not hard-code cryptographic constants that cannot be migrated.

  7. Explicit certificate subject carriage scope: this document does not define a generic otherName OID; certificate subject carriage for urn:/oidc: is defined and OID-registered by an independent profile. sip: is used only for non-telephone-number AoRs and does not assert telephone number authority.

3. Architecture Overview

3.1. Trust Models of Delegated ICV

ICV is a validation dimension parallel to DCV in the ACME protocol suite; PoP is an independent key possession validation dimension that can be combined with DCV/ICV. This document defines two trust models of Delegated ICV. The relationship among the three validation dimensions is shown in Table 1 (informative).

Table 2: Three Validation Dimensions and Three Main Protocol Frameworks (Informative)
Validation Dimension Validation Framework Core Question
Domain Control Validation (DCV) RFC 8555 Do you control this domain name?
Proof of Possession (PoP) pop-01 Do you hold this private key?
Delegated Identity Control Validation (Delegated ICV) This document Is this identity asserted by an IdP and controllable by the client?

The correspondence between identifier types and the three validation frameworks is shown in Figure 1.

                  ACME Identifiers (including domain identifiers and identity identifiers)
                      |
         +------------+------------+
         |            |            |
        dns          pk           idp
         |            |            |
        DCV          PoP          ICV (including delegated ICV and direct ICV)
         |  (auxiliary, does not directly validate identifiers) |
         +------------+------------+
         |                         |
     Domain Validation Mode   Identity Validation Mode
    DCV + (optional PoP)     ICV + (optional PoP)
Figure 1: Relationship Between Identifier Types and Validation Frameworks (Informative)

The protocol trust chains of the two trust models are shown in Figure 2.

PKI Certificate Binding (x509-chain):
  The IdP holds a PKI certificate issued by a CA pre-configured trust root.
  IdP --[JWS + atc, signed by certificate private key, x5c=IdP cert chain]--> Client --> CA
  CA validates: certificate chain to the pre-configured trust root + atc semantics

Dual-PoP Public Key Binding (idp-pop):
  The IdP validates "identifier I <-> public key PK" and issues a JWT containing
  idp_assertion.binding = JWK Thumbprint(PK).
  Client --[idp-pop-01: JWT + pop_key(JWK) + pop_signature(JWS)]--> CA
  CA validates: OIDC Discovery + JWK Thumbprint match + PoP signature
  finalize: CA re-checks CSR public key JWK Thumbprint == binding
Figure 2: Protocol Trust Chains of the Two Trust Models (Informative)

3.2. Shared Base Framework

The shared base framework defined in Section 4 is used by both trust models:

  • idp identifier type (Section 4.1): the value is a URI, carrying schemes such as spiffe:, urn:, oidc:, sip:/sips:.

  • Certificate subject mapping rules (Section 4.2): how the identifier value maps to the certificate subjectAltName, including URI SAN allow/prohibit conditions and otherName usage conditions; this document does not define a generic otherName OID.

  • IdP routing (Section 4.3): how the CA determines the validating IdP from the identifier.

  • idp_config retrieval framework (Section 4.4): the CA publishes trust configuration via the directory meta.idp_config_uri pointing to an independent HTTPS resource.

Whether the CA supports x509-chain or idp-pop, the identifier type and mapping rules are the same.

3.3. Component Relationships

The Delegated ICV framework involves four components: the ACME-ICV client, the ACME server/CA, the IdP, and an optional aggregation gateway. The relationships among the four components are shown in Figure 3 (informative).

+----------------+       newOrder / challenge            +----------------+
| ACME-ICV Client | <-----------------------------------> | ACME Server/CA |
+----------------+                                       +----------------+
        |                                                        ^
        | obtain acmeIdpToken                                    | validate token
        v                                                        |
+----------------+                                       +----------------+
| Aggregation     | ---- IdP authentication / token -----> |      IdP       |
| Gateway (opt.)  |        issuance                        |                |
+----------------+                                       +----------------+
Figure 3: Delegated ICV Component Relationships (Informative)
  • ACME-ICV client: initiates newOrder, completes the delegated identity control validation challenge, and submits acmeIdpToken to the CA. The client does not directly validate the identity; it is responsible for obtaining the token from the IdP and presenting it to the CA.

  • ACME server/CA: creates an authorization object for the identifier, generates a challenge nonce, validates the signature, atc or idp_assertion, claims, and binding of acmeIdpToken, and ultimately decides whether to issue the certificate. The CA is the ultimate subject of the trust decision.

  • IdP: the issuer of identity assertions trusted by the CA. The IdP does not need to implement the ACME client/server role, but must construct token claims per this document.

  • Aggregation gateway (optional): located between the client and the IdP, it can convert other identity assertions such as SAML into an acmeIdpToken conforming to this specification, or issue tokens with its own signing key. The aggregation gateway appears to the CA as an IdP.

Normative constraints for the aggregation gateway: when an aggregation gateway is used, the gateway is the trusted IdP from the CA's perspective; the CA has no direct trust in the backend original identity source. The deployment policy MUST record the trust relationship between the gateway and the backend identity source and the audit requirements; the gateway MUST fully retain the original identity authentication evidence for audit. The CA MUST configure the gateway as a separate IdP entry in idp_config, and must not merge the backend identity source and the gateway into the same trust anchor.

A single Delegated ICV interaction can be summarized as: the client obtains an assertion from the IdP, the CA validates the assertion and issues the certificate; the trust relationship between the CA and the IdP is explicitly established by the CA via idp_config, a pre-configured certificate trust root, or OIDC Discovery, without resolution via the client or external federation chains.

3.4. Relationship to Existing ACME Extensions

Table 3
Mechanism Relationship Notes
DCV (RFC 8555 core) Parallel DCV validates domain control; ICV validates identity identifiers. They can coexist in different authorization objects, but MUST NOT be mixed in the same authorization object.
email-reply-00 ([RFC8823]) Orthogonal Email control is handled by RFC 8823; this document does not define an email identifier type.
tkauth-01 ([RFC9447]) Referenced by x509-chain x509-chain references tkauth-01; the token acquisition mechanism normatively references RFC 9448 Section 5.5. idp-pop does not reuse tkauth-01.
TNAuthList ([RFC9448]) Architecturally analogous, different authority model The token acquisition mechanism of x509-chain follows the same architecture as RFC 9448 Section 5.5. Telephone number authority is carried by TNAuthList; the sip: in idp is used only for non-telephone-number AoRs; the mutual exclusion rules are in Section 9.3.
PoP ([I-D.ietf-acme-pop]) Orthogonal composition ICV validates identity; PoP validates key possession. idp-pop internalizes a constrained ACME-PoP for identifier binding and does not replace the generic pop-01 authorization. If the deployment requires generic key possession proof, pop-01 is still needed.
Device attestation ([I-D.ietf-acme-device-attest]) Complementary Device attestation establishes device identity and trusted state; ICV establishes identity identifier validation.
OpenID Federation ([I-D.ietf-acme-openid-federation]) Orthogonal ICV trust anchors are explicitly configured by the CA, not resolved via federation entity chains.
ACME PQC profile ([I-D.ar-acme-pqc-tlsjws] or a later RFC) Orthogonal superposition This document defines identity semantics and algorithm agility requirements; the PQC profile defines PQ/composite algorithm identifiers and migration rules (Sections 9.11, 9.13).
WIF ([I-D.rasmussen-acme-wif]) Parallel WIF (based on aud/ABV) targets workloads and lacks an IdP-enforced identifier-public-key static binding; the risk of a client requesting the wrong identifier is mitigated entirely by CA-local policy. idp-pop adds IdP-managed static mapping and dual PoP, with the IdP deriving the identifier from the authenticated subject, eliminating this class of risk. Deployment selection is by subject type. See Section 6.1 and Appendix C.

4. Base Framework

4.1. idp Identifier Type

The identifier type idp is added to the ACME Identifier Types registry (Section 10.1). Its value is a URI [RFC3986], used to identify a subject in an IdP namespace.

idp carries only URI-form identity identifiers, currently including spiffe:, urn:, oidc:, and sip:/sips:. Email address control validation is handled by [RFC8823]; telephone number authority is handled by [RFC9448]; this document does not define validation paths for those types.

Examples:

spiffe://example.org/ns/prod/sa/backend
urn:example:device:12345
oidc:https://accounts.google.com#1234567890
sip:alice@internal.example.com

The idp identifier value MUST NOT use the mailto: scheme; the CA MUST reject such requests with malformed. urn:example: is for illustrative purposes only and should not be used in production; the CA SHOULD restrict acceptable URN namespaces in the deployment policy and record that restriction in audit logs.

URI normalization and comparison rules: all scenarios involving "compare after normalization" or "URI match" MUST use the following rules:

  • scheme and host are compared case-insensitively in ASCII (converted to lowercase before comparison);

  • default ports (80 for http, 443 for https) are removed before comparison;

  • userinfo comparison follows scheme-specific rules; where no scheme-specific rule exists, it is compared as raw bytes without percent-decoding;

  • path and query are compared as raw bytes: no dot-segment folding, no percent-decoding, no merging of consecutive slashes;

  • a trailing slash is a significant character;

  • the fragment of an oidc: identifier is handled separately: the fragment MUST carry the sub in percent-encoding; before comparison, the fragment is percent-decoded exactly once, and the resulting byte string is compared byte-by-byte with the sub in the token; no Unicode normalization, case folding, or any other equivalence determination may be performed; if decoding fails or the decoded result contains illegal characters, the CA MUST reject the identifier. The decoded sub byte string MUST NOT contain U+0000–U+001F or U+007F control characters; if present, the identifier is rejected.

  • the CA MUST NOT use string prefix or suffix matching not conforming to the above rules.

Applicability conditions for oidc: identifiers: oidc:<issuer-url>#<subject> requires that the sub value from the CA's perspective be known at order creation time. Under the idp-pop model, the IdP derives the sub via static mapping, and the CA knows the target value before order creation. Under the x509-chain model, the IdP sets atc.tkvalue after validation, and the client provides the target identifier to the IdP. Under both models the oidc: identifier is usable, but the oidc: identifier MUST NOT be mapped to a uniformResourceIdentifier SAN (Section 4.2).

Relationship between the issuer URL in an oidc: identifier and the IdP entry: for an oidc: identifier, the <issuer-url>, after normalization per this section's URI rules, MUST equal the idp_config.idp_list[].issuer of the IdP to which the identifier is routed, and MUST equal the issuer of the OIDC Discovery document. On mismatch, the CA MUST reject the identifier or token and return rejectedIdpId. The CA MUST NOT compare only the host part while ignoring the full issuer URL.

Registration status of the oidc: scheme: the oidc: scheme is currently not registered in the IANA URI Scheme registry. This document uses it as internal syntax for idp identifier values and does not seek generic URI registration. When it is mapped to otherName, relying parties parse it according to the OID and ASN.1 encoding defined by the referenced profile; they must not rely on a generic scheme resolver to treat it as a dereferenceable URI.

An order containing an idp identifier must complete at least one associated challenge.

4.2. Certificate Subject Mapping Requirements

This section defines the rules the CA MUST follow when the deployment profile has already defined certificate subject carriage. This document does not define a generic otherName OID or ASN.1 module; the otherName mapping for urn: and oidc: depends on an independent profile registering an OID. When no profile referencing a registered OID is available, the CA MUST NOT use otherName and MUST NOT issue certificates containing the identifier. This document does not require the CA to allocate OIDs itself; OID allocation and ASN.1 encoding are the responsibility of the independent profile.

When mapping an idp identifier to the certificate subject identity, the CA MUST follow these requirements:

  • the CA MUST map the identifier value to the corresponding SAN type in subjectAltName;

  • the CA MUST NOT carry the identity identifier solely in the CN field of the Subject DN. If the certificate profile followed by the deployment cannot express the corresponding SAN type, the CA MUST NOT issue the certificate; there is no CN exception;

  • the CA MUST evaluate the constraints of [RFC5280] Section 4.2.1.6 on the URI authority in a uniformResourceIdentifier SAN. The URI must contain an authority in the form of a DNS-based hostname or IP address; identifiers not meeting this constraint MUST NOT be mapped to uniformResourceIdentifier;

  • this document does not retroactively apply to existing certificates; newly issued certificates MUST follow the requirements of this section.

Allowed and prohibited mappings:

Table 4
URI scheme Allowed SAN Type Prohibition/Condition
spiffe:// uniformResourceIdentifier (full SPIFFE ID) Allowed when the authority is a DNS name satisfying RFC 5280 constraints.
sip:/sips: uniformResourceIdentifier (full SIP URI; semantics per [RFC5922]) Only non-telephone-number AoRs are allowed; when the user part is in telephone-number form, the CA MUST reject with malformed (default identification rules in the body; deployment policy may extend); the client should switch to the TNAuthList profile of RFC 9448. The CA MUST evaluate whether the user part contains structures disallowed by RFC 5280 and RFC 3261; if not satisfied, the CA MUST NOT issue.
urn: otherName only, and only if the referenced profile has defined and registered an OID and ASN.1 encoding MUST NOT be mapped to uniformResourceIdentifier (no authority part). When no registered otherName profile exists, the CA MUST NOT issue.
oidc: otherName only, and only if the referenced profile has defined and registered an OID and ASN.1 encoding MUST NOT be mapped to uniformResourceIdentifier; MUST NOT rely on the URI fragment as the certificate subject parsing path. When no registered otherName profile exists, the CA MUST NOT issue.

Normalization and matching rules for sip:/sips:: the SAN carries the full SIP URI, with semantics per [RFC5922]. sip: and sips: are different schemes and must not be substituted for each other in comparison; the comparison rules for the user part are defined by RFC 3261 and must not degrade to string equality. SAN matching rules follow RFC 5922; the CA and relying parties MUST use the same scheme and host matching rules. When routing per Section 4.3, the CA should extract the host part from the SIP URI for matching, rather than performing suffix comparison on the full URI. The atc.tkvalue (x509-chain) or idp_assertion.identifier (idp-pop) of sip:/sips: carries the full SIP URI, and relying parties parse it per RFC 5922; the certificate uniformResourceIdentifier SAN and the identifier value in the token MUST be equal per the URI comparison rules of Section 4.1. For sip: URIs, the byte-by-byte comparison rules of Section 4.1 apply to the scheme and host; the comparison of the user part follows RFC 3261, but the CA MUST record its normalization and comparison rules in the deployment policy and ensure that the identifier value in the token and the certificate SAN use the same rules.

RFC 5280 compliance argument and authority boundary for sip:/sips:: the authority of a sip:/sips: URI is the host, satisfying RFC 5280 Section 4.2.1.6. The user part MUST conform to the SIP URI character set of RFC 3261; the CA MUST NOT issue SIP URIs containing password-form userinfo or control characters. Example: sip:alice@internal.example.com is allowed; the deployment policy SHOULD prohibit sip:alice:password@internal.example.com (userinfo contains a password); this prohibition is a security policy recommendation, not a mandatory requirement of RFC 5280. The CA MUST record the allowed SIP URI forms in the deployment policy.

The sip:/sips: certificate under the idp framework asserts only that "the IdP considers the AoR controlled by some authenticated subject"; it does not assert telephone number authority and does not replace the STI certificate of STIR/TNAuthList. The CA MUST define telephone-number-form identification rules in the deployment policy and at least use the following default identification rules:

  • if the user part of the SIP URI matches ^\+[0-9]{1,15}$, the CA MUST treat it as telephone-number form and reject;

  • if the user part of the SIP URI matches ^[0-9]{1,15}$ (no +), the CA MUST by default treat it as a suspicious telephone-number form and reject, unless the deployment policy explicitly configures an exception (for example, an enterprise-internal short number range) and records the exception, its justification, and audit requirements;

  • other PSTN-equivalent forms are defined by the deployment policy.

The rationale for this conservative default rule is that a digit-only user part without a leading + may be either an E.164 form or an enterprise-internal short number; when it cannot be reliably distinguished from the TNAuthList authority model, default rejection prevents the idp framework from overstepping to issue telephone-number-form identifiers. If an enterprise private-domain SIP deployment needs to accept digit-only short numbers, it MUST explicitly configure an exception in the deployment policy and record the risk acceptance rationale.

If the user part of the SIP URI is in telephone-number form, the CA MUST NOT issue the certificate via the idp identifier, MUST reject with malformed, and must inform the client that the identifier should be handled by the TNAuthList profile of RFC 9448. For cases that cannot be determined, the CA MUST reject and guide the client to TNAuthList. The deployment policy may extend the default identification rules, but must not relax them to "accept when undetermined". The specific direction of the default rules is listed in Appendix D as an open issue.

uniformResourceIdentifier and name constraints: if the certificate may be covered by nameConstraints, the CA MUST evaluate the expressibility of name constraints on uniformResourceIdentifier (RFC 5280 Section 4.2.1.10). When the conclusion is "no meaningful restriction can be expressed", the CA MUST NOT map the identifier to uniformResourceIdentifier and MUST handle it per the otherName rules; if otherName is also unavailable, the CA MUST NOT issue the certificate. The CA MUST record this evaluation conclusion in the deployment policy.

otherName mapping rules:

  • the CA MAY use otherName to carry a structured identifier only if the certificate profile followed by the deployment has defined the otherName OID and ASN.1 encoding for the scheme and has registered the OID;

  • this document does not define a generic otherName OID; the otherName mapping for oidc: and urn: depends on the referenced profile. When no profile referencing a registered OID is available, the CA MUST NOT use otherName and MUST reject issuance per the preceding paragraph;

  • the CA MUST record the otherName OID, encoding, and matching rules in the certificate policy and publish them in a manner discoverable by relying parties;

  • relying parties MUST parse otherName per the OID and encoding defined by the deployment profile; this document does not define generic parsing rules.

Publication of the mapping table: the CA SHOULD record a "URI scheme → SAN type → expected identifier form" mapping table in the deployment policy and publish it in the CPS or certificate policy, so that auditors can derive the expected identifier value from the certificate SAN.

4.3. IdP Routing

The identity identifier itself does not directly indicate which IdP should validate it. The CA MUST determine the IdP according to the following rules:

  1. Exact match: if the CA has configured domain_suffixes (Section 4.4), and the domain part of the identifier matches a domain suffix declared by an IdP, that IdP is used. Domain extraction rules:

    • oidc:: the host part of the issuer URL (parsed per RFC 3986), not applied to path, query, or fragment; at the same time the CA MUST verify per Section 4.1 that the full <issuer-url> equals the issuer of that IdP entry;

    • sip:/sips:: the host part extracted per RFC 3261, with port and transport parameters removed before matching;

    • other schemes: domain extraction rules defined by the deployment policy, or no domain suffix matching.

    Domain suffix matching MUST be based on full label boundaries: example.com should match sub.example.com and example.com; MUST NOT match example.com.attacker.com; wildcard suffixes are not supported unless the CA explicitly configures and records an exception. If the domain_suffixes of multiple IdPs match simultaneously, the CA MUST use longest suffix matching; if the longest suffix still corresponds to multiple IdPs and the CA has not configured another deterministic selection rule, the CA MUST reject with rejectedIdpId.

  2. Identifier type match: when exact match fails, the CA determines the IdP based on the URI scheme of the identifier and idp_config.idp_list[].supported_identifier_types. If multiple IdPs match and no domain suffix matches, the CA MUST reject with rejectedIdpId, unless the CA has explicitly configured a multi-candidate selection rule.

  3. Rejection: when the IdP cannot be determined, the CA MUST reject with urn:ietf:params:acme:error:rejectedIdpId.

Enterprise private-domain SIP routing restriction: for enterprise private-domain SIP deployments, the CA SHOULD restrict the domain_suffixes of the sip scheme in idp_config to enterprise-owned domains, and MUST NOT list public carrier SIP domains in domain_suffixes. If the host of the identifier belongs to a known PSTN carrier domain, the CA MUST reject the idp order and guide the client to the TNAuthList profile of RFC 9448.

Association with JWKS routing security: for the idp-pop model, the CA SHOULD evaluate IdP routing and the routing security of JWKS retrieval as the same trust decision (Sections 6.6, 9.12).

4.4. idp_config Retrieval Framework

The ACME server MAY provide idp_config_uri in the meta of the directory object. The field is an HTTPS URL pointing to an independent idp_config JSON resource. When provided, the URI MUST accurately reflect the server's current IdP trust configuration and model support, and MUST be TLS-validated.

The integrity of idp_config is part of the trust anchor: tampering with idp_config or its URI is equivalent to replacing the trust anchor; the CA SHOULD audit and alert on changes to idp_config (Section 9.12).

Resource retrieval and caching:

  • the client SHOULD use a cache not exceeding the validity period defined by the deployment policy; re-fetch on cache expiry, on receiving rejectedIdpId, or on CA version identifier change;

  • the client MUST NOT cache idp_config indefinitely; the cache validity period SHOULD be defined by the deployment policy, recommended not exceeding 24 hours;

  • the client library SHOULD provide an API for the caller to inject configuration and MUST provide an API to force refresh;

  • the CA SHOULD support ETag or Last-Modified for the idp_config resource; the client SHOULD use conditional requests;

  • the CA MUST define an upper bound on the size of the idp_config resource in the deployment policy; RECOMMENDED not exceeding 256 KiB. A single x5c_trust_anchors entry SHOULD not exceed 16 KiB; when exceeded, idp_list_ref SHOULD be used to separate it;

  • the CA SHOULD set Cache-Control for the idp_config resource and MUST update the version identifier on change.

idp_config is a JSON object:

  • supported_models: list of supported trust models, with values being at least one of "x509-chain" and "idp-pop".

  • supported_binding_algs (optional): list of binding_alg values accepted by the CA; currently only "jwk-sha256"; when absent, defaults to ["jwk-sha256"]. The CA MUST reject binding_alg values not in the list. binding_alg values are managed by the registry in Section 10.7.

  • idp_list: list of trusted IdPs; each entry contains:

    • issuer: IdP issuer identifier;

    • idp_url (optional): IdP endpoint URL;

    • jwks_uri (optional): JWKS endpoint; used by the idp-pop model;

    • x5c_trust_anchors (optional): IdP certificate trust roots used by the x509-chain model; each element is a base64url-encoded DER certificate or an HTTPS URL pointing to a trust root set. SHOULD use embedded DER; HTTPS URL retrieval MUST be an explicit deployment exception, specifying TLS validation, caching, pinning/audit, and MUST NOT be used for high-assurance certificate profiles.

    • anchor_algs (optional): list of certificate signature algorithms allowed in the IdP's x5c chain, with values being PKIX algorithm OIDs in dotted-decimal form; the CA MUST verify that the signature algorithm OID of each certificate in the x5c chain is in the allowed set; when absent, the CA follows the deployment policy.

    • supported_identifier_types: list of supported URI schemes (spiffe, urn, oidc, sip, sips); mailto MUST NOT appear in the list. If parsing idp_config finds that the list contains mailto, the CA MUST treat that idp_list entry as invalid configuration, refuse to load that IdP, and alert.

    • supported_models (optional): list of models supported by the IdP; when absent, inherits the top-level supported_models;

    • domain_suffixes (optional): list of domain suffix matches;

    • allowed_jwt_algs (optional): list of JWT signature algorithms allowed for the IdP; used as a whitelist only when required_jwt_algs is absent; when absent, inherits supported_jwt_algs. When present, MUST be a subset of the top-level supported_jwt_algs; otherwise the CA configuration is invalid.

    • required_jwt_algs (optional): list of JWT signature algorithms that the IdP must use; when present, the token alg MUST be in it, and required_jwt_algs MUST be a subset of allowed_jwt_algs (if the latter is present) and MUST be a subset of the top-level supported_jwt_algs; otherwise the CA configuration is invalid.

    • recommended_revocation_delay (optional): recommended revocation delay reference value (seconds), used as described in Section 9.4;

    • policy_version (optional, per-IdP): IdP authentication policy version or last review date.

  • idp_list_ref (optional): URL pointing to an independent HTTPS endpoint, used only to retrieve the IdP list. When idp_list_ref is present, idp_list MUST NOT be present. The CA MUST apply TLS validation, caching, and audit to that retrieval, and MUST NOT use it for dynamic retrieval of trust roots for high-assurance profiles. If idp_list and idp_list_ref are both present, the CA MUST judge idp_config as malformed, refuse to load all IdP configuration, and alert.

  • supported_jwt_algs (optional): list of JWT signature algorithms accepted by the CA, using the IANA "JSON Web Signature and Encryption Algorithms" registry; when absent, defaults to ["ES256", "EdDSA"].

  • policy_version (optional, top-level): top-level configuration version or last review date, distinct from the per-IdP policy_version.

Sub-fields and registration: idp_config is an independent HTTPS resource, not a JSON extension of the directory object; the directory object carries only the idp_config_uri pointer. The internal fields of idp_config are defined by this document and are not registered separately; IANA registers only the directory metadata field idp_config_uri (Section 10.6).

Example (transitional configuration; after migration, required_jwt_algs can be added to enforce PQ algorithms):

{
  "supported_models": ["x509-chain", "idp-pop"],
  "supported_binding_algs": ["jwk-sha256"],
  "idp_list": [
    {
      "issuer": "https://idp.company.com",
      "idp_url": "https://idp.company.com/oauth2/v1/authorize",
      "jwks_uri": "https://idp.company.com/oauth2/v1/keys",
      "x5c_trust_anchors": ["MIICEXAMPLEBASE64URLDER"],
      "anchor_algs": ["1.2.840.10045.4.3.2", "1.3.101.112"],
      "supported_identifier_types": ["spiffe", "urn", "oidc", "sip"],
      "domain_suffixes": ["company.com"],
      "allowed_jwt_algs": ["ES256", "EdDSA"],
      "recommended_revocation_delay": 3600,
      "policy_version": "2026-11-01"
    }
  ],
  "supported_jwt_algs": ["ES256", "EdDSA"],
  "policy_version": "2026-11-15"
}

Note: "MIICEXAMPLEBASE64URLDER" in the example is a placeholder and not a valid base64url DER certificate; real certificates must be used in actual configuration.

5. PKI Certificate Binding Trust Model

5.1. Trust Model Overview

x509-chain is the PKI certificate binding model: the IdP signs the JWS of acmeIdpToken with the private key of a PKI certificate anchored by a CA pre-configured trust root; the CA validates trust by verifying the certificate chain to the pre-configured trust root.

Architectural relationship to RFC 9448: the token acquisition mechanism of x509-chain (the client sends a dedicated request to the IdP, the IdP validates and sets claims and signs the JWS with its certificate private key, x5c carries the IdP certificate chain) follows the same architecture as [RFC9448] Section 5.5. This document normatively references RFC 9448 Section 5.5; implementers should refer to that section, substituting the identifier type with idp. The differences between this document and RFC 9448 are as follows:

  • the identifier type is idp, with URI schemes in Section 4.1;

  • tkauth-type = "idp" (Section 10.2);

  • atc.fingerprint uses base64url without padding (Section 5.2), whereas RFC 9448 uses colon-separated hexadecimal;

  • when atc.ca is true, the CA MUST reject.

The contribution of this document: defining the atc semantics of the idp identifier under the tkauth-01 framework (tktype = "idp", tkvalue is the idp identifier value, fingerprint is the SHA-256 digest of the challenge nonce) and the certificate subject mapping rules (Section 4.2).

5.2. Challenge and Token: tkauth-01 + atc

Challenge object: tkauth-type is "idp", and type-specific parameters are placed in the tkauth-params object; tkauth-params contains the idp_methods array (currently only x509-chain). idp_methods is currently used only for x509-chain; idp-pop uses the independent challenge idp-pop-01 and does not appear in idp_methods.

{
  "type": "tkauth-01",
  "url": "https://ca.example.com/acme/chall/WxFJbL",
  "status": "pending",
  "tkauth-type": "idp",
  "tkauth-params": {
    "idp_methods": [
      { "idp_method": "x509-chain", "nonce": "eHl6NDU2..." }
    ]
  }
}

atc claim: acmeIdpToken contains atc per [RFC9447] Section 4:

  • tktype: MUST be "idp";

  • tkvalue: MUST be the idp identifier value; SHOULD store the same byte string as the challenge identifier.value, and the CA validates per the comparison rules of Section 4.1;

  • fingerprint: MUST be "SHA256 " + base64url(SHA-256(UTF-8 bytes of the nonce string)); base64url without padding; the CA MUST recompute and compare exactly per this formula. The prefix "SHA256 " is for future support of other hash algorithms; currently MUST be "SHA256 ".

  • atc.ca: if present and true, the CA MUST reject.

Representation difference from RFC 9448: RFC 9448 uses colon-separated hexadecimal fingerprint. This profile chooses base64url without padding because the input to fingerprint is the challenge nonce, not the ACME account key; this is a profile-level choice, and the normative deviation is declared in Section 5.1. RFC 9447 defines the generic claim framework of atc, and the specific format of fingerprint is defined by the profile corresponding to tkauth-type; this document, as the profile for tkauth-type = "idp", defines that format. The CA implementation MUST dispatch fingerprint parsing logic by tkauth-type.

Mandatory fingerprint format: when tkauth-type is "idp", the CA MUST accept only fingerprint in base64url without padding; if colon-separated hexadecimal is received, the CA MUST reject with badIdpToken. For other tkauth-type values, the CA MUST follow the original parsing rules of RFC 9448 and must not apply the base64url rules of this profile.

Other required claims: iss (IdP identifier), sub (IdP local subject identifier), aud (CA directory URL), iat, exp (SHOULD not exceed 15 minutes), nonce. Optional claims: jti (SHOULD), amr, acr, auth_time; the CA validates per the deployment policy.

IdP token issuance responsibilities (normative): the IdP MUST set atc, iss, aud, exp, jti, nonce, and sub itself, and MUST NOT accept values specified by the client. atc.tkvalue is the identity assertion body of the IdP. The IdP MUST determine atc.tkvalue from its authoritative data or from a statically configured mapping; it MUST NOT accept the identifier value specified by the client as tkvalue. When the IdP cannot validate the binding between the applicant and the target idp identifier, it MUST NOT issue the token. When the IdP serves multiple CAs, it MUST configure aud separately per CA.

5.3. Protocol Flow

  1. The client sends newOrder (with an idp identifier).

  2. The CA returns an authorization object and a tkauth-01 challenge (tkauth-type = "idp", tkauth-params.idp_methods: [{idp_method: "x509-chain", nonce}]).

  3. The client requests acmeIdpToken from the IdP, providing the nonce, the target identifier, and the CA directory URL. The specific format of this request is normatively referenced from RFC 9448 Section 5.5; differences are in Section 5.1.

  4. After validating the applicant's identity and the target identifier binding, the IdP sets atc, iss/aud/exp/jti/nonce, and sub, and signs as a JWS with its PKI certificate private key (the protected header contains x5c and alg).

  5. The client submits {"tkauth": "<JWS>"}.

  6. The CA validates the JWS signature (Section 5.4) and marks the challenge valid.

Field adaptation with RFC 9448 Section 5.5: the dedicated request from the client to the IdP follows the request structure of RFC 9448 Section 5.5, with the target identifier field replaced by the idp identifier value of this document, nonce using the challenge nonce, and aud using the CA directory URL; in the JWS returned by the IdP, atc.tktype, atc.tkvalue, and atc.fingerprint are constructed per Section 5.2, and x5c carries the IdP certificate chain. Fields in RFC 9448 Section 5.5 specific to TNAuthList do not apply to this profile; implementers should reuse only its dedicated request and JWS submission mechanism, not its telephone number authority semantics.

5.4. CA Validation Process

  1. Parse the JOSE protected header, confirm that alg is not none, and satisfy one of the following: if the IdP is configured with allowed_jwt_algs, alg MUST be in it; otherwise alg MUST be in supported_jwt_algs. If the IdP is configured with required_jwt_algs, alg MUST be in it. Confirm that x5c is present.

  2. Build the IdP certificate chain from x5c and validate to the pre-configured trust root: end-entity basicConstraints cA=false, keyUsage.digitalSignature set, revocation status (Section 5.5 fail-closed), chain length limit, alg matching the public key algorithm. If the IdP is configured with anchor_algs, the signature algorithm OID of every certificate in the x5c chain MUST be in the allowed set.

  3. Verify the JWS signature with the end-entity certificate public key.

  4. Validate atc: tktype is "idp"; tkvalue matches identifier.value per the comparison rules of Section 4.1; fingerprint recomputed per Section 5.2 matches; reject when atc.ca is true.

  5. Validate iss, aud, iat, exp, nonce, jti, sub. If amr/acr/auth_time are present, validate per the deployment policy.

  6. Mark the challenge valid.

Authorization expiry validation: after re-checking that the authorization is valid at finalize, the CA MUST, before issuing the certificate, re-confirm that the authorization expires is strictly greater than the current time; use a monotonic clock.

5.5. Trust Establishment: Pre-configured Trust Root

The CA MUST pre-configure the trust root of the IdP certificate, declared via idp_config.idp_list[].x5c_trust_anchors (Section 4.4) or out-of-band deployment configuration. The CA MUST validate the certificate path, end-entity EKU (if required by the deployment), revocation status (OCSP/CRL), and chain length limit.

Revocation status: when the revocation status cannot be determined (OCSP unreachable/unverifiable/unknown/soft-fail; CRL unfetchable/expired/signature unverifiable/certificate not covered; deployment cannot obtain both OCSP and CRL and has no equivalent mechanism), the CA MUST reject with badIdpToken. The deployment policy may explicitly configure an exception and record the risk acceptance rationale, but that exception MUST NOT apply to high-assurance certificate profiles.

Trust anchor constraints: trust roots in x5c_trust_anchors may carry trust anchor constraints (for example, name constraints, policy constraints). The CA MUST apply these constraints during path validation (per the semantics of [RFC5937]).

Algorithm family migration: x5c_trust_anchors may contain trust anchors of multiple algorithms. The CA MUST express per-IdP JWT algorithm constraints via idp_list[].allowed_jwt_algs and required_jwt_algs; during the transition period, classical and PQ algorithms may coexist; after migration, required_jwt_algs MUST enforce PQ algorithms. When x5c contains PQ or composite signatures, the CA's chain validation logic MUST support the corresponding PKIX PQC specification (for example, the LAMPS WG ML-DSA certificate specification), or MUST reject and record the limitation (Section 9.11). The CA SHOULD use idp_list[].anchor_algs to constrain the certificate chain signature algorithms, avoiding a situation where the JWT alg has migrated while the certificate chain remains classical.

The PKI certificate binding (x509-chain) trust model is shown in Figure 4 (informative).

CA pre-configured trust root
      |
      v
+----------------+      issue       +------------------+
| IdP Cert Trust  | --------------> | IdP End-Entity   |
| Root            |                 | Certificate      |
+----------------+                 +-------------------+
                                          |
                                          | sign
                                          v
                                   +----------------+
                                   | acmeIdpToken   |
                                   | (JWS, x5c=IdP) |
                                   +----------------+
Figure 4: x509-chain Pre-configured Trust Chain Trust Model (Informative)

6. Dual-PoP Public Key Binding Trust Model

6.1. Trust Model Overview

idp-pop is the dual-PoP public key binding model. It does not reuse [RFC9447]'s tkauth-01; it defines an independent idp-pop-01 challenge that completes the proof of "the client controls the identity identifier" via two back-to-back PoPs:

Identifier Id  --(IdP-PoP validation)-->  Public Key PK  --(ACME-PoP validation)-->  Client
    |                            |                           |
    +-- IdP assertion: Id belongs to PK --+                           |
                                 |                           |
                                 +-- CA validation: client holds PK --+
                                                             |
                                                             v
                                          Conclusion: client controls Id (certificate can be issued)

Core design: the two PoPs validate the same public key PK. The IdP does not need to know the ACME protocol, and ACME does not need to directly validate the identifier — the public key is the common anchor on both sides.

Different from WIF's threat model:

  • WIF (draft-rasmussen-acme-wif-00) relies on aud/ABV assertions and targets workload scenarios. WIF does not have the IdP establish a static forced binding from identifier to public key. In threat scenarios where the client can influence the requested target identifier, a potential man-in-the-middle risk arises: a client holding a legitimate workload token may attempt to request a certificate for an identifier inconsistent with the token claims. Mitigation of this risk relies entirely on CA-side local policy, checking whether the order content matches the token claims.

  • In contrast, the incremental security property of idp-pop derives from the IdP-maintained static mapping of subject-identifier-public key, superposed with dual PoP possession proof validation. Under the idp-pop model, the target identifier is independently derived by the IdP from the authenticated subject state, rather than accepting the identifier passed in by the client. This eliminates the above risk of "the client inducing the IdP to issue an assertion for an unrelated identifier".

  • WIF and idp-pop target different deployment scenarios. Operators should choose the mechanism based on the requested subject type: WIF may be selected when the workload platform fully controls identifier allocation; idp-pop is selected for interactive human or enterprise identity scenarios that require IdP-side enforcement of the identifier-public-key binding. See Section 6.1 and Appendix C for details.

Relationship to RFC 9447 Section 3.1: idp-pop does not claim to satisfy the requirement of RFC 9447 Section 3.1 that "the identifier type and value be conveyed to the Token Authority via the request protocol" — the IdP obtains the identifier via out-of-band static mapping, not via the request protocol. However, idp-pop achieves a stronger binding via dual PoP: the reliability of identifier binding is guaranteed by "the IdP validating public key possession", not by "protocol conveyance".

Applicability precondition: idp-pop requires the IdP to satisfy the "identifier-mapping IdP" requirements of Section 6.4 — it must be able to validate that the user holds the private key of the certificate public key PK (for example, via a signature challenge or public key registration mechanism) and maintain a static subject → identifier → public key mapping. General-purpose public OIDC IdPs (Google, Entra) typically do not satisfy this requirement, and idp-pop is not applicable to such IdPs. A WebAuthn assertion cannot directly serve as pop_signature; if the IdP uses WebAuthn for internal user authentication, pop_signature must still be generated by the client with the private key of the certificate public key PK. Deployers should confirm IdP capability before selection.

IdP capability evaluation checklist (informative): before selecting idp-pop, deployers should evaluate whether the IdP: supports public key registration or signature challenge; maintains a static subject → identifier → public key mapping; provides audit logs and access control for mapping changes; can compute JWK Thumbprint per RFC 7638; supports the binding_alg required by the idp-pop token; supports the OIDC authorization request parameters idp_pop_key and idp_pop_identifier. Deployers should also confirm that the client platform allows the private key corresponding to the certificate public key to be used for ACME-PoP signing, or that an independent profile defines a hardware-supported signature mapping.

Deployment reality note (informative): from a deployment-reality perspective, x509-chain places lower requirements on the IdP (it only needs to hold a PKI certificate) and may be implemented more widely earlier; idp-pop requires the IdP to support public key registration and static mapping, suitable for scenarios where the IdP is deeply integrated with the CA. The two are not interchangeable.

6.2. Challenge: idp-pop-01

idp-pop-01 is an independent challenge type, registered in the "ACME Validation Methods" registry (Section 10.3). Challenge object:

{
  "type": "idp-pop-01",
  "url": "https://ca.example.com/acme/chall/XyZAbC",
  "status": "pending",
  "idp_url": "https://idp.company.com",
  "nonce": "eHl6Nzg5...",
  "pop_alg": "ES256"
}
  • idp_url: IdP endpoint URL;

  • nonce: random value, ≥128 bits, base64url without padding;

  • pop_alg (optional): expected public key algorithm, using the IANA JOSE Algorithms registry. When set by the CA, the client MUST use that algorithm; when not set, the CA accepts algorithms in its supported_jwt_algs. If pop_alg is present in the challenge and the client does not support it, the client MUST abort the order and report to the upper layer that the pop_alg is unsupported, and should not submit a challenge response.

Client response format:

{
  "idp_token": "<acmeIdpToken JWT>",
  "pop_key": { "kty": "EC", "crv": "P-256", "x": "...", "y": "..." },
  "pop_signature": {
    "protected": "<base64url>",
    "payload": "<base64url>",
    "signature": "<base64url>"
  }
}
  • idp_token: the JWT issued by the IdP, containing idp_assertion;

  • pop_key: the JWK of the bound public key K; its JWK Thumbprint must match idp_assertion.binding;

  • pop_signature: Flattened JWS JSON Serialization. The protected header MUST contain alg; b64 if present MUST be true and MUST NOT be false; SHOULD contain kid or jwk; if it contains jwk, the CA MUST verify it matches pop_key. The payload is the UTF-8 JSON object {"nonce": "<challenge nonce>", "binding": "<idp_assertion.binding>"}; the JSON string values of nonce and binding MUST contain only ASCII visible characters. The client SHOULD use canonical JSON construction; the CA MUST first validate the JWS signature per RFC 7515, then parse the payload as a JSON object and compare the parsed string values field by field; the CA MUST NOT require that the raw payload byte string contain no optional escaping. The signature uses the private key corresponding to pop_key.

6.3. Token: idp_assertion

acmeIdpToken is a JWT signed by the IdP, containing the idp_assertion container:

"idp_assertion": {
  "identifier_type": "idp",
  "identifier": "<idp identifier value>",
  "issuer": "<IdP issuer URL>",
  "method": "idp-pop",
  "binding": "urn:ietf:params:acme:idppop:jwk-sha256:<base64url(JWK Thumbprint)>",
  "binding_alg": "jwk-sha256",
  "subject": "<IdP local subject identifier>",
  "pop_alg": "ES256"
}

idp_assertion MUST be a top-level claim of the JWT payload; unknown members in the object MUST be ignored by the CA; it MUST NOT be nested under other claims.

For tokens of the idp-pop-01 challenge, if the JWT payload also contains atc, the CA MUST ignore atc and process only idp_assertion; it must not judge the token invalid due to the presence of atc.

  • binding: MUST be "urn:ietf:params:acme:idppop:jwk-sha256:" || base64url(JWK Thumbprint(K)), with JWK Thumbprint computed per [RFC7638] using SHA-256; base64url without padding. The algorithm identifier in the binding prefix MUST match binding_alg; on mismatch the CA MUST reject. The URN sub-namespace and binding_alg registration of binding are in Sections 10.7 and 10.8.

  • binding_alg: MUST be "jwk-sha256"; future migration to other hashes or serializations is defined by the profile with new values registered in the registry of Section 10.7. binding_alg MUST be in idp_config.supported_binding_algs; if not, the CA MUST reject.

  • pop_alg (SHOULD): expected public key algorithm, using the IANA JOSE Algorithms registry. If present, MUST match the challenge pop_alg; if the challenge is not set, SHOULD be set to a value matching the pop_key algorithm; on mismatch the CA MUST reject.

Other required claims: iss (IdP identifier), sub (IdP local subject identifier), aud (CA directory URL), iat, exp (SHOULD not exceed 5 minutes). Optional claims: jti (SHOULD), amr, acr, auth_time; the CA validates per the deployment policy.

The upper bound of exp for idp-pop is shorter than for x509-chain because the man-in-the-middle risk surface of static mapping and dual PoP is larger, and a shorter token validity period is needed to limit the attack window.

6.4. Protocol Flow (Including Normative IdP Responsibilities)

The idp-pop model completes the proof of "the client controls the identity identifier" via two back-to-back PoPs:

IdP-PoP (IdP side): the IdP confirms that "identifier Id is controlled by an authenticated user, and that user holds the private key of public key PK"; ACME-PoP (ACME side): the CA confirms that "the client submitting the JWT and pop_signature holds the private key of public key PK".

The two PoPs are connected via idp_assertion.binding in the JWT (the JWK Thumbprint of public key PK).

OIDC Authorization Request Parameters (Normative): when initiating an OIDC authentication request to the IdP, the idp-pop client MUST use the following authorization request parameters to convey public key binding information:

  • idp_pop_key: MUST be a UTF-8 JWK JSON string, transmitted as an OAuth 2.0 authorization request parameter value and encoded by the HTTP layer per application/x-www-form-urlencoded. The parameter value is the JWK JSON string; pop_key in the challenge response is the JSON object representation of the same JWK. The IdP MUST parse the JWK, verify that the authenticated user holds the corresponding private key, and compute the JWK Thumbprint accordingly; the IdP MUST NOT accept a public key without possession validation. The JWK SHOULD contain only required members (kty, crv/n/e, x/y, etc.) and MUST NOT carry kid, use, key_ops, or other fields unrelated to binding. The client and IdP SHOULD evaluate the authorization request URL length limit; if URL length becomes a problem, the deployment profile may consider POST authorization requests (request_uri or PAR), but this document does not mandate it.

  • idp_pop_identifier: the client SHOULD always carry it, with the value being the full URI string of the idp identifier in newOrder. The IdP MUST verify that the value belongs to the static mapping of the authenticated subject; on validation failure it MUST reject. idp_assertion.identifier is still set by the IdP, and the IdP MUST NOT directly copy client input that has not been mapping-validated. If idp_pop_identifier is not provided and the mapping of that subject contains multiple identifiers, the IdP MUST refuse to issue (see responsibility 6). In the single-identifier case, if idp_pop_identifier is not provided, the IdP may still issue, setting identifier to the sole mapped value.

  • If the IdP does not support these parameters, it MUST reject with the OIDC invalid_request error, and must not ignore them and then issue a token.

  • These parameters are OAuth 2.0 authorization request extension parameters defined by this document for idp-pop. OAuth 2.0 permits such extension parameters; this document does not request IANA registration. Deployers should declare support for these two parameters in IdP metadata or deployment documentation.

  • Deployers should confirm that the IdP does not use idp_pop_key and idp_pop_identifier for other purposes; if there is a conflict, use the prefix variant defined by the deployment profile and record it in idp_config or deployment documentation.

Protocol Flow:

  1. The client generates a key pair PK and its private key. PK MUST be the certificate public key in the final CSR; the private key of PK is used for IdP-PoP (step 4b) and ACME-PoP (step 6). If the deployment requires separation of the identity key and the certificate public key, an independent document must define the "public key binding proof" mechanism; this is not defined in this document.

  2. The client sends newOrder (with an idp identifier).

  3. The CA returns an authorization object and an idp-pop-01 challenge (idp_url, nonce, pop_alg).

  4. The client initiates OIDC authentication to the IdP, carrying the JWK JSON string of public key K via idp_pop_key and the target idp identifier value via idp_pop_identifier (SHOULD always carry). The IdP completes IdP-PoP:

    • 4a. Identity authentication: the IdP authenticates the user identity, obtaining subject S. The authentication method is defined by the IdP deployment configuration (WebAuthn, password + MFA, etc.).

    • 4b. Public key binding validation: the IdP validates that "user S holds the private key of public key PK". The source of PK is the idp_pop_key carried by the client in the OIDC authorization request in step 4, or the public key record pre-registered at the IdP. The validation method is defined by the IdP deployment configuration (signature challenge, hardware key registration, or other public key registration mechanism). The IdP MUST verify that the received PK matches the subsequent idp_assertion.binding; on mismatch it MUST NOT issue the token. A WebAuthn assertion cannot directly serve as pop_signature unless an independent profile defines the mapping.

  5. The IdP derives identifier via static mapping and issues the JWT:

    • idp_assertion.identifier is derived by the IdP via the statically configured subject → identifier mapping; the IdP MUST verify that idp_pop_identifier (if provided) belongs to the mapping of the authenticated subject, and sets identifier accordingly; if not provided and the mapping contains multiple identifiers, the IdP MUST refuse to issue; the IdP MUST NOT accept client-specified values that have not been mapping-validated;

    • idp_assertion.binding is "urn:ietf:params:acme:idppop:jwk-sha256:" || base64url(JWK Thumbprint(K));

    • idp_assertion.binding_alg is "jwk-sha256";

    • idp_assertion.subject is S;

    • idp_assertion.method is "idp-pop";

    • idp_assertion.identifier_type is "idp";

    • the JWT top-level claims iss, aud, iat, exp, jti.

  6. The client completes ACME-PoP: constructs the pop_signature Flattened JWS, with payload {"nonce": "<challenge nonce>", "binding": "<binding>"}, signed with the private key of PK; the protected header alg is set per pop_alg or the PK algorithm.

  7. The client submits the challenge response:

{
  "idp_token": "<acmeIdpToken JWT>",
  "pop_key": { "kty": "EC", "crv": "P-256", "x": "...", "y": "..." },
  "pop_signature": {
    "protected": "<base64url>",
    "payload": "<base64url>",
    "signature": "<base64url>"
  }
}
  1. The CA validates (Section 6.5) and marks the challenge valid. The client submits the CSR at finalize; the CA re-checks that the CSR public key matches binding.

IdP normative responsibilities ("identifier-mapping IdP" requirements): when issuing an idp-pop token, the IdP MUST satisfy the following requirements:

  1. idp_assertion.subject MUST be derived by the IdP from its authenticated identity, and MUST NOT accept client specification;

  2. idp_assertion.identifier MUST be derived by the IdP via the statically configured subject → identifier mapping; the IdP MUST verify that the target identifier provided by the client via idp_pop_identifier (if provided) belongs to the mapping of the authenticated subject, and still sets identifier itself; MUST NOT accept client-specified values that have not been mapping-validated;

  3. idp_assertion.binding MUST be computed by the IdP from the public key K it validated, and MUST NOT accept client specification;

  4. the IdP MUST, during authentication, validate that the user holds the private key corresponding to the public key K claimed in binding. The validation method is defined by the IdP deployment configuration (signature challenge, public key registration, etc.);

  5. if the IdP cannot validate public key possession, it MUST NOT issue the idp-pop token;

  6. if the same subject corresponds to multiple identifiers in the IdP mapping, and the client has not provided idp_pop_identifier, the IdP MUST refuse to issue; if provided, the IdP MUST validate per responsibility 2.

An IdP satisfying the above requirements is referred to in this document as an "identifier-mapping IdP". An IdP not satisfying the requirements MUST NOT deploy the idp-pop model.

Why static mapping is security-critical: if the IdP allows the client to influence identifier or subject, an attacker can use their own legitimate identity to have the IdP issue a token with identifier = someone else's identifier, opening the man-in-the-middle attack surface. Static mapping ensures that the identifier issued by the IdP always corresponds to the authenticated identity. WIF does not provide this binding and therefore cannot replace this security property of idp-pop.

6.5. CA Validation Process

  1. Validate JWT base claims: signature, iss, aud, iat, exp, jti (if present). iss MUST exactly match idp_config.idp_list[].issuer; aud MUST equal the CA directory URL. If amr/acr/auth_time are present, validate per the deployment policy.

  2. Validate idp_assertion structure: present, a top-level JSON object of the JWT payload, containing required elements; identifier_type is "idp"; issuer matches iss; method is "idp-pop"; binding is correctly formatted and binding_alg is "jwk-sha256" and in idp_config.supported_binding_algs, and the algorithm identifier in the binding prefix matches binding_alg; identifier matches the challenge identifier.value per the comparison rules of Section 4.1. For oidc: identifiers, the CA MUST also verify that the <issuer-url> in identifier normalizes per Section 4.1 to equal the issuer of that IdP entry; on mismatch it MUST reject with rejectedIdpId.

  3. Validate public key thumbprint match: parse pop_key as JWK; compute the JWK Thumbprint (SHA-256) per [RFC7638], construct binding, and verify equality with idp_assertion.binding. The CA MUST derive the acceptable JWS alg set from pop_key's kty/crv and cross-validate with the challenge pop_alg (if set) and idp_assertion.pop_alg (if set); if pop_key's alg is present it MUST match. Recommended mappings follow; the CA may add constraints in the deployment policy, but MUST NOT accept algorithms mismatched to the key type:

    • EC P-256 → ES256; EC P-384 → ES384; EC P-521 → ES512;

    • Ed25519 → EdDSA;

    • RSA (≥2048 bits) → PS256 or RS256; if pop_key is RSA and the modulus is less than 2048 bits, the CA MUST reject with badIdpToken. The CA MUST accept both PS256 and RS256; if the deployment policy requires accepting only PS256, it MUST express that via idp_config or the challenge pop_alg and reject RS256. The CA MUST NOT reject a valid RS256 signature merely because PS256 is recommended;

    • PQ or composite algorithms are mapped per the ACME PQC profile or JOSE PQ drafts; this document does not define new alg values. On mismatch, the CA MUST reject with badIdpToken.

  4. Validate ACME-PoP: verify that pop_signature is a valid Flattened JWS signature of the payload by the private key corresponding to pop_key. The CA MUST first verify the signature per RFC 7515, then parse the payload; the protected header MUST contain alg; MUST NOT contain b64=false; if it contains jwk, the CA MUST verify it matches pop_key. The payload MUST be a JSON object; the parsed nonce is byte-by-byte equal to the challenge nonce string value, and the parsed binding is byte-by-byte equal to the idp_assertion.binding string value; the CA MUST NOT require that the raw payload byte string contain no optional escaping. The signature algorithm is specified by the protected header alg and MUST be within the algorithms supported by the CA.

  5. Trust the IdP's static mapping: the consistency of subject and identifier is guaranteed by the IdP's "identifier-mapping IdP" responsibilities (Section 6.4); the CA does not compare the two strings unless otherwise required by the deployment policy. The CA has already verified that identifier matches the challenge (step 2), so no additional comparison of subject and identifier is needed.

  6. Mark the challenge valid.

Finalize re-check: after the client submits the CSR, the CA MUST construct a JWK from the CSR public key per the JWK parameters defined in [RFC7517] and [RFC7518] and per the SPKI-to-JWK mapping specification referenced by the deployment; compute the JWK Thumbprint (SHA-256) per [RFC7638], and verify equality with idp_assertion.binding. When the algorithm mapping is unsupported, it MUST reject with badPublicKey and record. For PQ algorithms, reference the JOSE PQ drafts for the mapping. On mismatch, the CA MUST reject with badPublicKey. This re-check prevents the client from substituting the public key after the challenge.

Trust chain closure:

  • IdP-PoP proves "identifier Id is controlled by the authenticated user S, and S holds public key PK" — realized jointly by the IdP's identity authentication (Section 6.4 step 4a), public key possession validation (Section 6.4 step 4b), static mapping (subject S → identifier Id), and JWT signature (Section 6.4 step 5).

  • ACME-PoP proves "the client submitting the JWT holds public key PK" — realized by the validation of pop_signature (step 4 of this section).

  • Back-to-back connection: idp_assertion.binding in the JWT (the JWK Thumbprint of PK) is the anchor connecting the two PoPs. IdP-PoP confirms "PK belongs to the controller of identifier Id", ACME-PoP confirms "the submitter holds PK", and the two together yield "the submitter controls identifier Id".

  • The finalize re-check confirms that the final certificate public key is the already-bound public key PK.

Authorization expiry validation: same as Section 5.4. After re-checking that the authorization is valid at finalize, the CA MUST, before issuing the certificate, re-confirm that the authorization expires is strictly greater than the current time; use a monotonic clock.

6.6. Trust Establishment: OIDC Discovery

The CA obtains the JWKS via OpenID Connect Discovery 1.0 (https://openid.net/specs/openid-connect-discovery-1_0.html); the trust root is the Web PKI.

issuer match: the issuer of the Discovery document MUST exactly match idp_config.idp_list[].issuer; on mismatch it MUST reject. For oidc: identifiers, the issuer URL constraint of Section 4.1 also applies.

jwks_uri constraint: MUST be an HTTPS URL. The CA MUST NOT follow redirects to hosts not configured in idp_config. When both idp_config and Discovery provide jwks_uri, the CA MUST preferentially use the explicit configuration of idp_config and record it.

Routing security of the JWKS retrieval path: the path by which the CA connects to the JWKS endpoint via DNS and TLS may be subject to BGP hijacking. The CA SHOULD incorporate the routing security of this path into the trust decision, and SHOULD implement mechanisms such as DANE TLSA, static fingerprint pinning, multi-perspective retrieval, or RPKI/ROV observability per the deployment policy. On fixed or multi-perspective validation failure, the CA MUST reject the token and alert. The deployment baseline is in Section 9.12. If the JWKS retrieval path cannot satisfy the routing security baseline of Section 9.12, that IdP MUST NOT be used for high-assurance certificate profiles.

Key rotation: the CA should cache the JWKS per Cache-Control/Expires; when kid is not in the cache or signature validation fails, it should refresh the cache and re-validate. After rotation, old public keys SHOULD be retained in the JWKS for at least one token exp window (recommended 30 days). During algorithm family migration, allowed_jwt_algs/required_jwt_algs control the transition and enforcement periods.

Self-referencing chains: the CA MUST be able to detect trust chain self-references and should limit the recursion depth to one hop.

7. Trust Model Selection Guidance

Table 5
Dimension PKI Certificate Binding (x509-chain) Dual-PoP Public Key Binding (idp-pop) WIF (Informative, draft-rasmussen-acme-wif-00)
IdP capabilities required Holds a PKI certificate issued by a CA pre-configured trust root Can validate that the user holds the certificate public key private key (signature challenge/public key registration) + static subject→identifier→public key mapping Produces OIDC-conforming workload JWT; no public key registration or identifier-public key static mapping required
Trust establishment Pre-configured certificate trust root JWKS obtained via OIDC Discovery under Web PKI + IdP static mapping JWKS obtained via OIDC Discovery; trust anchor entirely locally configured by the CA
Identifier conveyance Via dedicated request (normatively referenced from RFC 9448 Section 5.5) Via out-of-band static mapping; the IdP independently derives the target identifier, not accepting client-provided identifiers that have not been mapping-validated Identifier comes from CA validation of order and JWT claims; the identifier may be specified by the client in newOrder, and validation logic resides entirely in CA-side policy
Interactive scenario Not applicable Applicable (signature challenge/hardware key) Not applicable; targets automated workloads
Non-interactive scenario Applicable Not applicable Applicable (CI/CD, cloud-native workloads)
Applicable IdP Enterprise self-built PKI IdP Enterprise self-built OIDC IdP (supporting public key registration/signature challenge) Cloud platforms, K8s SPIFFE/SPIRE and similar native workload IdPs; general-purpose public OIDC IdPs can be used directly
Relationship to RFC 9448 Architecturally analogous, but telephone number authority is still carried by TNAuthList Independent mechanism; non-telephone-number AoRs No relationship; does not reuse the tkauth-01 framework
Man-in-the-middle attack surface Low (pre-configured trust root + IdP binding responsibilities) Low (static mapping + requires possession of the target public key private key) Conditional risk: when the client can manipulate the requested identifier, mitigation relies entirely on CA-local policy validation of order and JWT claim match; risk is lower when the platform fully controls identifier allocation
Certificate lifecycle match Matches the source CA Medium-short recommended; pair with certificate revocation in identity-change scenarios Highly compatible with short-lived certificates; the JWT itself is a short-lived workload credential

Selection guidance references:

8. Client Behavior

8.1. General Constraints

The client must recognize the idp identifier type, the tkauth-01 (tkauth-type = "idp") and the idp-pop-01 challenge. The client should discover the models supported by the CA via the directory meta.idp_config_uri; when the CA does not provide it, equivalent information must be obtained via out-of-band configuration.

Model selection: the client MUST select the model based on the target IdP entry: if that entry is configured with supported_models, the client MUST use that entry; otherwise use the top-level supported_models. If the intersection of those with the models supported by the client is empty, the interaction MUST fail, and the CA returns rejectedIdpId. If the CA returns a challenge unsupported by the client in the same authorization object, the client MUST ignore that challenge and SHOULD re-read idp_config_uri; if there is still no common model, the client MUST fail and report rejectedIdpId.

Identifier pass-through unchanged: the identifier value provided by the client to the IdP MUST be byte-by-byte identical to the identifier.value in newOrder; the client MUST NOT perform normalization, case conversion, or encoding conversion.

8.2. PKI Certificate Binding (x509-chain) Client

The client MUST obtain from the IdP a JWS signed by the IdP certificate private key and submit it in the tkauth field. The client MUST provide the challenge nonce, the target identifier, and the CA directory URL to the IdP. The client MUST NOT construct or modify by itself claims such as x5c, atc, iss, aud, exp, jti, or sub for which the IdP is responsible.

8.3. Dual-PoP Public Key Binding (idp-pop) Client

The client MUST generate a key pair K (or reuse an existing key), and complete public key possession proof via idp_pop_key (JWK JSON string) during IdP authentication; the client SHOULD always carry the target identifier value from newOrder via idp_pop_identifier. The client MUST submit idp_token, pop_key, and pop_signature in the challenge response.

pop_signature MUST be a Flattened JWS with payload {"nonce": "<challenge nonce>", "binding": "<idp_assertion.binding>"}, signed with K's private key. The client MUST verify that idp_assertion.binding in the IdP token corresponds to the public key K it holds; on mismatch it MUST refuse to submit.

Error handling:

Table 6
CA Error Order/Authorization State Client Behavior
badIdpToken Authorization remains pending Re-perform IdP authentication; after retries per the count defined by the deployment policy, report the error
badPublicKey Authorization is valid but finalize failed The client MUST create a new order; MUST NOT reuse an already-valid challenge or the same CSR
rejectedIdpId The order SHOULD be marked by the CA as not continuable Report a configuration error, do not retry; SHOULD re-read idp_config_uri; the client MUST NOT retry the same order, and must create a new order or contact the CA
malformed Authorization remains pending or is invalidated per the CA policy Report an implementation error, do not retry

9. Security Considerations

9.1. Adversary Model

  • Network adversary: can observe, inject, drop, and replay ACME and IdP traffic; can hijack DNS/BGP. Mitigation: TLS, nonce, atc.fingerprint/idp_assertion.binding, aud, routing security baseline (Section 9.12).

  • Malicious client: holds a legitimate ACME account and attempts to obtain a certificate for an identifier not belonging to it. Mitigation: account specificity of the challenge nonce, IdP-side applicant validation and static mapping, idp-pop public key thumbprint match + JWS PoP signature + finalize re-check.

  • Malicious IdP operator: can issue assertions for any identifier. The trust models of this document explicitly trust the IdP; this threat is out of mitigation scope.

  • Malicious CA operator: can directly issue certificates without going through ICV. This document does not claim to defend against a malicious CA.

  • End user holding legitimate IdP credentials: an inherent limitation of ICV, out of mitigation scope; the CA can only reduce impact via amr/acr/auth_time and short-lived certificates.

Deployment warning: deployers must fully understand that the security foundation of Delegated ICV rests entirely on the trustworthiness of the IdP; a compromised IdP can generate legitimate cryptographic assertions for any identity identifier, and the CA cannot detect it. High-assurance deployments need security auditing of the IdP, access control, and audit of changes to the idp-pop subject → identifier → public key mapping.

9.2. Security Properties of the Two Trust Models

Table 7
Threat/Property PKI Certificate Binding (x509-chain) Dual-PoP Public Key Binding (idp-pop) WIF (Informative, draft-rasmussen-acme-wif-00) Notes
Attacker holds legitimate IdP credentials Requires the IdP certificate private key Requires the target public key private key Requires obtaining a legitimate workload JWT credential Out of mitigation scope
IdP key compromise Handled via certificate trust root revocation Handled via JWKS rotation + public key validation history Handled via JWKS key rotation of the compromised signing key The CA should retain acmeIdpToken as audit evidence
IdP static mapping tampering Not applicable (no static mapping) Medium: mapping tampering can lead to tokens issued for the wrong identifier Not applicable; no IdP-side static subject-identifier mapping The CA cannot detect IdP internal mapping errors; relies on IdP audit (Section 9.6)
Identifier binding reliability Relies on IdP authoritative data and dedicated request conveyance Relies on IdP validation of public key possession + static mapping No IdP-side identifier-public-key binding; identifier match validation entirely delegated to CA-local policy The reliability of idp-pop is guaranteed cryptographically
Client inducing the IdP to issue for another identifier Possible if the IdP does not fulfill its Section 5.2 responsibilities; the IdP controls the identifier in the assertion Static mapping prevents this attack; the IdP independently derives the target identifier Conditional risk: the client may specify the identifier in newOrder; mitigation relies entirely on CA validation of order identifier and JWT claims Risk precondition: the client can influence the requested target identifier
DNS/BGP hijacking Low (pre-configured trust root) Medium-high (JWKS retrieval path) Medium-high (JWKS retrieval path) Deployment baseline in Section 9.12
Cross-CA replay atc.fingerprint + nonce + aud idp_assertion.binding + nonce + aud Relies solely on JWT aud and short validity; there is no ACME challenge nonce binding Account specificity of the challenge nonce provides isolation (WIF does not use ACME challenge)
Trust anchor retrieval Pre-configured OIDC Discovery + JWKS cache OIDC Discovery + JWKS cache The latter can be cached
Implementation complexity Low Medium (requires public key registration/signature challenge and JWK handling) Low; no IdP public key registration capability required —

Security property notes: acmeIdpToken proves "the IdP's assertion about the identifier", not "the applicant currently controls the identity". The dual PoP of idp-pop provides a stronger binding and internalizes a constrained ACME-PoP; if the identity public key and the certificate public key differ, pop-01 is still required.

SIP message layer boundary: a sip: certificate issued under the idp framework does not provide PASSporT signature or SIP message layer identity validation guarantees; if the deployment uses the certificate for SIP message signing (for example, the x5u of PASSporT), the binding of From/AoR to the certificate SAN, replay protection, and orig/dest validation are handled by SIP layer security mechanisms and are outside the scope of this document. An idp certificate does not replace PASSporT or STI certificates.

9.3. Limitations of Identity Control Validation and Downgrade Protection

ICV cannot distinguish a legitimate user from an attacker who has stolen IdP credentials. The CA should accept cautiously and reduce risk via short-lived certificates.

The CA MUST NOT provide ICV and DCV challenges in the same authorization object simultaneously. When simultaneous validation is required, create different authorization objects, and the order enters ready only after both are valid.

Mixed restriction with WIF: the same ACME order MUST NOT use both the WIF identity token mechanism and Delegated ICV challenges (tkauth-01 with tkauth-type="idp", or idp-pop-01); if an implementation allows a single authorization object to carry multiple identifier types, mixing is likewise MUST NOT within the same authorization object. If the deployment needs to validate both workload identity and delegated ICV, create different authorization objects, and the order enters ready only after both are valid. If the WIF document has defined stricter mixing rules, the stricter ones prevail, and the cross-reference is recorded in the deployment policy.

Mixed restriction with TNAuthList: the same authorization object MUST NOT contain both an idp identifier (sip: scheme) and a TNAuthList identifier. Telephone number authority MUST use RFC 9448; the sip: of the idp framework is used only for non-telephone-number AoRs and does not assert TNAuthList semantics.

9.4. Trust Chain, Liability, and Revocation

The CA should clarify responsibility allocation; the IdP is advised to undergo independent audit. Handling of IdP key compromise or trust failure: x509-chain handles it via certificate trust root revocation, CRL/OCSP, and trusted root updates; idp-pop handles it via JWKS rotation, pinning alerts, and trusted IdP list updates.

Use of idp_config.idp_list[].recommended_revocation_delay: the CA SHOULD use the value as a recommended delay reference for propagation of IdP identity revocation to certificate revocation, for designing certificate validity periods, re-validation cycles, and revocation strategy; the client MAY use it for caching and retry policy. The value is not a mandatory revocation deadline, and the CA MUST record the revocation propagation assumptions it actually adopts in the deployment policy.

Issuance evidence retention: the CA SHOULD retain acmeIdpToken evidence sufficient to independently validate the issuance decision (full token, or cryptographic binding digest + validation result). The retention period SHOULD at least cover the certificate validity period plus the post-revocation retention period required by the PKI system in which the deployment resides. The CA MUST record its choice in the deployment policy.

In the event of a liability dispute between the CA and the IdP, the acmeIdpToken retained by the CA can serve as audit evidence; its probative value depends on the IdP's key management, signing key lifecycle, and CA log integrity. OIDC ID Tokens and generic JWS assertions are not designed for non-repudiation; this document does not claim that they constitute non-repudiable cryptographic evidence.

9.5. Token Replay and Cross-CA Isolation

Multi-layer protection: atc.fingerprint/idp_assertion.binding (the SHA-256 of the challenge nonce, or the public key JWK Thumbprint), nonce, aud, jti/exp, and the iat threshold (defined by the deployment policy, RECOMMENDED not exceeding 60 seconds). The jti deduplication cache is a SHOULD-level protection for multi-instance deployments: if the token contains jti, when the CA deploys multiple directory instances, it should ensure that all instances share the deduplication cache or use a unified aud.

Cross-CA isolation: atc.fingerprint/idp_assertion.binding is based on the challenge nonce/public key of each CA, so cross-CA replay is necessarily rejected; aud restricts the token to a specific CA. The CA MUST use the challenge nonce of the current authorization object during validation and MUST NOT accept binding values from other sources.

Account isolation: the challenge nonce is generated by the server for that account's authorization object.

9.6. IdP Key Compromise, Administrative Privileges, and Audit

Key compromise: impact is limited to identifier forgery. High-value IdPs are recommended to use multi-signature and threshold schemes, and are advised to accept the same audit standard as the CA (WebTrust or SOC 2).

IdP-side administrative privilege attacks: the CA should evaluate the IdP's administrative privilege controls (dual confirmation, audit logs, batch change rate limiting). Under high-assurance certificate profiles, the CA should require auth_time and at least one strong authentication amr (RECOMMENDED).

Audit of IdP static mapping (idp-pop-specific): the CA SHOULD require the idp-pop IdP to provide audit evidence of its subject → identifier → public key mapping table, including logs of creation, modification, and deletion of mappings and access control. For high-assurance certificate profiles, the CA SHOULD require mapping changes to undergo dual approval. This is a key precondition for the security of the idp-pop model.

IdP authentication policy changes: the CA SHOULD establish a periodic re-evaluation mechanism and track it via policy_version (Section 4.4); re-evaluation conclusions SHOULD be recorded in audit logs.

9.7. Privacy, Pseudonymity, and Protection of IdP Source Attributes

Pairwise pseudonymity and sub minimization are basic requirements. The IdP should generate sub using the pairwise pseudonymity mechanism defined by OIDC; the CA should treat sub as an opaque string. The static mapping of idp-pop requires sub to be predictable (stable sub), which weakens the privacy protection of pairwise pseudonymity; deployments should evaluate this privacy impact in idp_config or the CPS.

Assertion content minimization: the IdP SHOULD NOT include attributes unrelated to identity validation in acmeIdpToken. The CA SHOULD retain only the cryptographic hash of sub and the identifier value in audit logs.

The privacy impact of writing email addresses into the SAN and CT should be evaluated by the CA in the deployment policy ([RFC6962]).

Enumeration risk of low-entropy identifiers (informative): predictable identifiers may be enumerated to probe identities that the IdP has validated. When publishing domain_suffixes and the trusted IdP list, the CA SHOULD evaluate this risk and apply account-level rate limiting to newOrder.

9.8. Nonce and PoP Signature Generation

CSPRNG, ≥128 bits, at most 256 bits. In a distributed CA, each instance should use a CSPRNG seeded independently.

jti deduplication cache lifetime: if the token contains jti, the deduplication cache MUST retain at least until one skew window after the token exp.

pop_signature construction: the client MUST construct a Flattened JWS with payload {"nonce": "<challenge nonce>", "binding": "<binding>"}, signed with PK's private key; the signature algorithm is specified by pop_alg or the protected header alg. The client SHOULD use canonical JSON construction. The CA MUST first verify the JWS signature, then parse the payload as a JSON object and compare the parsed string values field by field; the CA MUST NOT require that the raw payload byte string contain no optional escaping. The signature base string of pop_signature is the payload serialization submitted by the client; the CA's validation covers both "the JWS signature is valid" and "the parsed nonce/binding field values match", but does not claim that the signature covers canonicalized field values.

9.9. Layered Proof of Possession and Defense in Depth

PoP can be performed at two layers: IdP-PoP (the IdP validates during authentication that the applicant holds the public key) and ACME-PoP (the CA directly validates that the applicant holds the certificate private key).

  • x509-chain: signed by the IdP certificate private key, providing the IdP's strong signature over the assertion, but not proving that the applicant holds the final certificate private key; applicant PoP must be handled independently (pop-01).

  • idp-pop: internalizes IdP-PoP (the IdP validates public key possession) and a constrained ACME-PoP (the CA validates a JWS PoP signature of the same public key). If the identity public key = the certificate public key, idp-pop simultaneously completes identity validation and constrained key possession proof; but this constrained PoP does not replace the generic pop-01 authorization. If the deployment requires generic key possession proof, pop-01 is still required. If the identity public key ≠ the certificate public key, an independent document must still define the public key binding proof and pop-01.

Recommendation: idp-pop deployments SHOULD use identity public key = certificate public key, simplifying the protocol and internalizing the constrained ACME-PoP.

9.10. Certificate Lifecycle and Authentication Strength (Informative)

Table 8
Authentication Method Certificate Lifetime (Example) Additional PoP
Low entropy (password) Hours to days Recommended
Hardware-bound two-factor authentication Months to one year Optional
PKI certificate chain (x509-chain) Matches the source CA Recommended
Dual-PoP public key binding (idp-pop) Short to medium (examples in body) Recommended if the identity public key differs from the certificate public key; constrained PoP does not replace pop-01
Publicly trusted S/MIME / code signing Defined by CA/B Forum rules Per profile; not in normative scope of this document

The CA should apply differentiated policy based on amr/acr, and SHOULD reference recommended_revocation_delay (Section 9.4) when designing re-validation and revocation propagation assumptions.

For idp-pop access certificates (for example, EAP-TLS device onboarding, mTLS client authentication), the CA SHOULD use short or medium validity periods (for example, days to months) and pair them with IdP account status checks and revocation; it should not issue multi-year access certificates merely because the identity identifier is stable. The mapping of network-layer identity to policy is defined by the deployment profile.

9.11. Algorithm Agility and PQC Boundary

This document remains algorithm-neutral, but algorithm neutrality is not PQ security. The default algorithm set ES256 and EdDSA is a classical cryptography security baseline. Deployments using ICV MUST evaluate classical algorithm risk in their quantum threat analysis.

Algorithm namespace: supported_jwt_algs, pop_alg, and the JWS protected header alg MUST use the IANA "JSON Web Signature and Encryption Algorithms" registry [RFC7518]. PQ or composite algorithm identifiers are defined by the ACME PQC profile or JOSE PQ drafts; this document does not define new JOSE alg values.

Per-IdP algorithm constraints: idp_config.idp_list[].allowed_jwt_algs and required_jwt_algs allow the CA to express transition and enforcement periods. When required_jwt_algs is present, the token's alg MUST be in it; allowed_jwt_algs serves as a whitelist only when required_jwt_algs is absent. When both are present, required_jwt_algs MUST be a subset of allowed_jwt_algs, and both MUST be subsets of the top-level supported_jwt_algs; otherwise the CA configuration is invalid. After migration, the CA SHOULD set required_jwt_algs to PQ algorithms and remove classical algorithms. The coexistence and phase-out rules for classical and PQ roots in x5c_trust_anchors MUST be recorded in the CA deployment policy; idp_list[].anchor_algs is used to constrain certificate chain signature algorithms. The CA MUST verify anchor_algs (constraining x5c chain certificate signature algorithms) and allowed_jwt_algs/required_jwt_algs (constraining JWT alg) separately, and MUST NOT infer that one constraint implies the other.

binding_alg migration: idp_config.supported_binding_algs allows the CA to accept multiple binding_alg values simultaneously; old values may be removed after the transition period. The binding_alg in the IdP token MUST be in the list, and the algorithm identifier in the binding prefix MUST match it. The CA MUST extract the <binding_alg> segment from the binding string and interpret the encoding of <binding-value> per the registry of Section 10.7, and MUST NOT rely solely on the binding_alg field while ignoring the URN prefix. Future migration to other hashes or serializations is defined by the profile with new values added to supported_binding_algs; new binding_alg values MUST be registered in the registry of Section 10.7 to avoid proliferation of private values. Future registered values may define non-URN binding forms, but must also define coexistence and phase-out rules with the existing URN form.

PQC risk of x509-chain: if the IdP certificate is RSA or ECDSA, its lifetime is several years. An attacker recording a signature today could, after CRQC emerges, forge that IdP's assertions for any identifier, while the CA's pre-configured trust root still trusts that key. Therefore:

  • when the deployment plans to still use x509-chain within the example timeline (2030–2035), the IdP certificate SHOULD use composite or PQ signatures, or the deployment policy MUST record the quantum risk acceptance rationale for classical certificates;

  • the CA MUST NOT conclude that the whole process is PQ-secure merely because the ICV end-entity certificate uses PQ algorithms;

  • PQ certificate path validation MUST reference a specific PKIX PQC specification (for example, the LAMPS WG ML-DSA certificate specification), and must not merely state "supports the corresponding algorithm".

PQC risk of idp-pop: it involves three algorithm layers — the IdP's JWT signing algorithm, the bound public key K's algorithm, and the pop_signature JWS algorithm. The three have different risks, and the deployment's quantum threat analysis should cover each separately:

  • the quantum risk of the IdP JWT signing key is the same as x509-chain; the pre-collected signature and post-quantum forgery risk also applies to the idp-pop model IdP's JWT signing key; high-assurance deployments should shorten the IdP JWT signing key lifetime or use PQ/composite signature algorithms;

  • the algorithm risk of the bound public key PK is jointly constrained by IdP-PoP and the finalize re-check;

  • the JWS algorithm risk of pop_signature is constrained by pop_alg and supported_jwt_algs;

  • binding_alg = "jwk-sha256" uses SHA-256; high-assurance deployments SHOULD evaluate whether 128-bit effective security is sufficient, and future profiles may define new binding_alg values.

Interface boundary with the ACME PQC profile: the PQC profile defines the specific identifiers, token validity periods, and certificate lifecycle rules for PQ/composite algorithms; this document defines identity semantics and algorithm agility requirements; the two compose orthogonally. The PQC profile MAY declare its algorithm identifiers in supported_jwt_algs. Until the PQC profile defines a client-side algorithm negotiation field, the CA selects algorithms per supported_jwt_algs, allowed_jwt_algs, and required_jwt_algs, and the client cannot express algorithm preferences; this is a known limitation of the current version.

Store-now-decrypt-later (also known as harvest-now-decrypt-later): when the CA retains acmeIdpToken as audit evidence, it SHOULD evaluate the long-term confidentiality of identity attributes and public key thumbprints in the token; for high-assurance deployments, it SHOULD use short-lived tokens, minimize retained content, or encrypt the retained content. When retaining tokens, the CA SHOULD also retain the algorithm identifiers, binding_alg, and trust anchor version at validation time, so that the token's trustworthiness under CRQC can be evaluated in the future.

9.12. Configuration Integrity and Routing Security

The integrity of idp_config_uri and the idp_config resource is part of the trust anchor. The CA MUST provide this resource over TLS, SHOULD support ETag or Last-Modified, SHOULD set Cache-Control, and MUST audit and alert on changes. The CA SHOULD incorporate the generation of idp_config into configuration management and audit processes, and MUST NOT allow manual ad hoc editing. The CA SHOULD monitor the idp_config resource for unexpected content changes (for example, hash pinning + alerting). When revoking an IdP, the CA SHOULD pair short Cache-Control with an active invalidation mechanism and record the client cache window in the deployment policy.

JWKS and idp_list_ref retrieval path: the CA SHOULD incorporate DNS/BGP routing security into the trust decision, and SHOULD implement mechanisms such as DANE TLSA, static fingerprint pinning, multi-perspective retrieval, or RPKI/ROV observability. On fixed or multi-perspective validation failure, the CA MUST reject the token and alert. If the JWKS retrieval path cannot satisfy the above routing security baseline, that IdP MUST NOT be used for high-assurance certificate profiles.

High-assurance restriction: HTTPS URL retrieval of x5c_trust_anchors and dynamic retrieval of idp_list_ref MUST NOT be used for trust roots of high-assurance certificate profiles.

9.13. Priority with the PQC Profile

When the server policy of the ACME PQC profile conflicts with supported_jwt_algs, allowed_jwt_algs, required_jwt_algs, or supported_binding_algs of this document, the CA MUST adopt the stricter one and record the conflict resolution rule in the deployment policy. The PQC profile must not relax the IdP binding responsibilities, binding integrity, or finalize re-check requirements of this document.

Example: if the PQC profile requires required_jwt_algs = ["ML-DSA-44"], while this document configures allowed_jwt_algs = ["ES256", "ML-DSA-44"], the CA must adopt the mandatory set of required_jwt_algs, i.e., accept only tokens signed with ML-DSA-44. If the PQC profile requires supported_binding_algs = ["jwk-sha384"] while this document configures ["jwk-sha256"], the CA must support both, or reject tokens not meeting the stricter requirement per the deployment policy.

10. IANA Considerations

10.1. New ACME Identifier Type

IANA is requested to register the following in the "ACME Identifier Types" registry ([RFC8555] Section 9.7.7):

Table 9
Label Reference
idp This document

Registration policy is "Specification Required"; Change Controller is the IETF.

10.2. New ACME Authority Token Challenge Types

IANA is requested to register the following in the "ACME Authority Token Challenge Types" registry ([RFC9447] Section 6.3):

Table 10
Label Description Reference
idp The tkauth-type used by the x509-chain model; the token is a JWS containing an atc claim, signed by the IdP's PKI certificate private key. Type-specific parameters are located in tkauth-params, containing idp_methods. This document

Registration policy is "Specification Required"; Change Controller is the IETF.

Differences from RFC 9447: the idp type of this document reuses the tkauth-01 challenge and retains the atc claim, but does not reuse the token transfer model of RFC 9447. atc.fingerprint is defined by this profile as the SHA-256 digest of the challenge nonce (base64url without padding), differing from the colon-separated hexadecimal representation of RFC 9448; RFC 9447 defines the generic claim framework of atc, and the specific format of fingerprint is defined by the profile corresponding to tkauth-type; this document, as the profile for tkauth-type = "idp", defines that format. The CA implementation MUST dispatch fingerprint parsing logic by tkauth-type. The tkauth-01 challenge itself is registered by RFC 9447, and this document does not re-register it.

10.3. ACME Validation Methods Registration

IANA is requested to register the following in the "ACME Validation Methods" registry:

Table 11
Label Identifier Type ACME Reference
idp-pop-01 idp Y This document (idp-pop model)

Note: the tkauth-01 challenge itself is defined by [RFC9447], and tkauth-type = "idp" is registered in Section 10.2; idp-pop-01 is a new challenge type defined by this document.

10.4. New ACME Error Types

IANA is requested to register the following in the "ACME Error Types" registry:

Table 12
Error Type Description Reference
badIdpToken Delegated ICV validation failure, including IdP token invalid, signature validation failed, or (idp-pop) bound public key/PoP signature validation failed This document
rejectedIdpId Identifier or IdP selection rejected; including inability to determine the IdP, multiple IdPs matching with no deterministic rule, oidc: issuer URL mismatch, etc. This document
badPublicKey CSR public key does not match the public key pre-bound in idp_assertion.binding This document

Registration policy is "Specification Required"; Change Controller is the IETF.

Client behavior after receiving badPublicKey is defined in Section 8.3; the IANA registration entry describes only the error semantics and does not include client implementation requirements. The CA SHOULD provide a distinguishable rejection reason in the detail field of the problem document (for example, "IdP not in the trust list", "issuer URL mismatch", "multiple IdPs matched with no deterministic rule") and SHOULD record the specific reason in audit logs; this document does not define sub-error codes.

10.5. idp_method Registry

IANA is requested to create the "ACME idp_method Values" registry with registration policy "Specification Required". The registry title is "ACME idp_method Values"; entry fields are: method name (string), description (string), status (Required or Optional), reference (RFC).

Table 13
Method Name Description Status Reference
x509-chain PKI certificate binding Optional This document

The status column takes values Required or Optional. x509-chain is marked Optional because implementations MUST support at least one model but are not required to support both. idp-pop is the independent challenge idp-pop-01 and is not registered as an idp_method.

10.6. ACME Directory Metadata Field Registration

IANA is requested to register the following in the "ACME Directory Metadata Fields" registry:

Table 14
Field Name Field Type Description Reference
idp_config_uri string HTTPS URL pointing to an independent idp_config JSON resource This document

Sub-field note: idp_config is an independent HTTPS resource, not a JSON extension of the directory object; the directory object carries only the idp_config_uri pointer. The internal fields of idp_config are defined by this document and, as components of an independent resource, are not registered separately. Change Controller is the IETF.

10.7. ACME idp-pop Binding Algorithms Registry

IANA is requested to create the "ACME idp-pop Binding Algorithms" registry with registration policy "Specification Required". Entry fields are: binding_alg value (string), description (string), reference (RFC).

Table 15
binding_alg Description Reference
jwk-sha256 JWK Thumbprint (SHA-256), base64url without padding This document

Future new values MUST be registered through this registry and define the corresponding binding URN prefix and encoding rules. The URN form of binding is urn:ietf:params:acme:idppop:<binding_alg>:<binding-value>, where <binding_alg> must be a value in this registry. Future registered values may define non-URN binding forms, but must also define coexistence and phase-out rules with the existing URN form.

10.8. urn:ietf:params:acme:idppop URN Sub-namespace

IANA is requested to register urn:ietf:params:acme:idppop in the "IETF URN Sub-namespace for Registered Protocol Parameters", referencing this document. This sub-namespace is used for the binding URN of idp-pop; the <binding_alg> values under it are managed by the registry of Section 10.7.

10.9. Registrations Not Requested and Conflict Handling

This document does not request registration of atc (already registered by RFC 9447); it does not request registration of nonce or acr (already registered by OpenID Core) or amr (already registered by RFC 8176). idp_assertion is a JWT top-level container defined by this document; this document does not request registration in the IANA "JSON Web Token Claims" registry; implementations MUST parse idp_assertion only when the iss of the same JWT is a configured IdP. If a claim with the same name is registered by IANA in the future, the CA MUST process it per the registered definition; if the registered definition is incompatible with this document, the deployment policy MUST explicitly choose which definition to use, record it in audit logs, and reject idp-pop or upgrade per the registered definition, avoiding silent inconsistency. The idp_assertion parsing of this document applies only to JWTs whose iss is a configured IdP. otherName OIDs are registered by the referenced profile; this document does not define a generic OID.

11. Implementation Status

This version contains no implementation statements. Per the convention of [RFC7942], after WG adoption this document should add: CAs and clients that have implemented the x509-chain model, CAs and IdPs that have implemented the idp-pop model, and interoperability results with RFC 8823/RFC 9448.

Until then, this document does not claim the existence of any specific implementation.

12. References

12.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC3986]
Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, DOI 10.17487/RFC3986, , <https://www.rfc-editor.org/info/rfc3986>.
[RFC5280]
Cooper, D., Santesson, S., Farrell, S., Boeyen, S., Housley, R., and W. Polk, "Internet X.509 Public Key Infrastructure Certificate and Certificate Revocation List (CRL) Profile", RFC 5280, DOI 10.17487/RFC5280, , <https://www.rfc-editor.org/info/rfc5280>.
[RFC5922]
Gurbani, V., Lawrence, S., and A. Jeffrey, "Domain Certificates in the Session Initiation Protocol (SIP)", RFC 5922, DOI 10.17487/RFC5922, , <https://www.rfc-editor.org/info/rfc5922>.
[RFC7515]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, , <https://www.rfc-editor.org/info/rfc7515>.
[RFC7517]
Jones, M., "JSON Web Key (JWK)", RFC 7517, DOI 10.17487/RFC7517, , <https://www.rfc-editor.org/info/rfc7517>.
[RFC7518]
Jones, M., "JSON Web Algorithms (JWA)", RFC 7518, DOI 10.17487/RFC7518, , <https://www.rfc-editor.org/info/rfc7518>.
[RFC7519]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token (JWT)", RFC 7519, DOI 10.17487/RFC7519, , <https://www.rfc-editor.org/info/rfc7519>.
[RFC7638]
Jones, M. and N. Sakimura, "JSON Web Key (JWK) Thumbprint", RFC 7638, DOI 10.17487/RFC7638, , <https://www.rfc-editor.org/info/rfc7638>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8555]
Barnes, R., Hoffman-Andrews, J., McCarney, D., and J. Kasten, "Automatic Certificate Management Environment (ACME)", RFC 8555, DOI 10.17487/RFC8555, , <https://www.rfc-editor.org/info/rfc8555>.
[RFC8725]
Sheffer, Y., Hardt, D., and M. Jones, "JSON Web Token Best Current Practices", BCP 225, RFC 8725, DOI 10.17487/RFC8725, , <https://www.rfc-editor.org/info/rfc8725>.
[RFC9447]
Peterson, J., Barnes, M., Hancock, D., and C. Wendt, "Automated Certificate Management Environment (ACME) Challenges Using an Authority Token", RFC 9447, DOI 10.17487/RFC9447, , <https://www.rfc-editor.org/info/rfc9447>.
[RFC9448]
Wendt, C., Hancock, D., Barnes, M., and J. Peterson, "TNAuthList Profile of Automated Certificate Management Environment (ACME) Authority Token", RFC 9448, DOI 10.17487/RFC9448, , <https://www.rfc-editor.org/info/rfc9448>.
[OpenID]
Sakimura, N., Bradley, J., Jones, M., Medeiros, B. de., and C. Mortimore, "OpenID Connect Core 1.0", n.d..

12.2. Informative References

[RFC5937]
Ashmore, S. and C. Wallace, "Using Trust Anchor Constraints during Certification Path Processing", RFC 5937, DOI 10.17487/RFC5937, , <https://www.rfc-editor.org/info/rfc5937>.
[RFC6943]
Thaler, D., Ed., "Issues in Identifier Comparison for Security Purposes", RFC 6943, DOI 10.17487/RFC6943, , <https://www.rfc-editor.org/info/rfc6943>.
[RFC6962]
Laurie, B., Langley, A., and E. Kasper, "Certificate Transparency", RFC 6962, DOI 10.17487/RFC6962, , <https://www.rfc-editor.org/info/rfc6962>.
[RFC7942]
Sheffer, Y. and A. Farrel, "Improving Awareness of Running Code: The Implementation Status Section", BCP 205, RFC 7942, DOI 10.17487/RFC7942, , <https://www.rfc-editor.org/info/rfc7942>.
[RFC8126]
Cotton, M., Leiba, B., and T. Narten, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 8126, DOI 10.17487/RFC8126, , <https://www.rfc-editor.org/info/rfc8126>.
[RFC8823]
Melnikov, A., "Extensions to Automatic Certificate Management Environment for End-User S/MIME Certificates", RFC 8823, DOI 10.17487/RFC8823, , <https://www.rfc-editor.org/info/rfc8823>.
[I-D.ietf-acme-pop]
Geng, F., Wu, P., Xia, L., and C. 陈鑫, "Automated Certificate Management Environment (ACME) Extension for Proof-of-Possession", Work in Progress, Internet-Draft, draft-ietf-acme-pop-01, , <https://datatracker.ietf.org/doc/html/draft-ietf-acme-pop-01>.
[I-D.ietf-acme-telephone]
Peterson, J. and R. Barnes, "ACME Identifiers and Challenges for Telephone Numbers", Work in Progress, Internet-Draft, draft-ietf-acme-telephone-01, , <https://datatracker.ietf.org/doc/html/draft-ietf-acme-telephone-01>.
[I-D.biggs-acme-sso]
Biggs, A., Barnes, R., and R. Moynihan, "Automated Certificate Management Environment (ACME) Extension for Single Sign On Challenges", Work in Progress, Internet-Draft, draft-biggs-acme-sso-01, , <https://datatracker.ietf.org/doc/html/draft-biggs-acme-sso-01>.
[I-D.ietf-acme-client]
Moriarty, K., "ACME End User Client and Code Signing Certificates", Work in Progress, Internet-Draft, draft-ietf-acme-client-14, , <https://datatracker.ietf.org/doc/html/draft-ietf-acme-client-14>.
[I-D.ietf-acme-openid-federation]
De Marco, G., Pitman, B., Geoghegan, T., Cook, D., and J. Jones, "Automatic Certificate Management Environment (ACME) with OpenID Federation 1.0", Work in Progress, Internet-Draft, draft-ietf-acme-openid-federation-00, , <https://datatracker.ietf.org/doc/html/draft-ietf-acme-openid-federation-00>.
[I-D.ietf-acme-device-attest]
Weeks, B., Mallaya, G., Rajala, S., Bonnell, C., and R. Hurst, "Automatic Certificate Management Environment (ACME) Device Attestation Extension", Work in Progress, Internet-Draft, draft-ietf-acme-device-attest-10, , <https://datatracker.ietf.org/doc/html/draft-ietf-acme-device-attest-10>.
[I-D.rasmussen-acme-wif]
Rasmussen, S., "Workload Identity Tokens in Automated Certificate Management Environment (ACME) Orders", Work in Progress, Internet-Draft, draft-rasmussen-acme-wif-01, , <https://datatracker.ietf.org/doc/html/draft-rasmussen-acme-wif-01>.
[I-D.ar-acme-pqc-tlsjws]
Banerjee, A. and T. Reddy.K, "Quantum-Ready ACME Mechanism", Work in Progress, Internet-Draft, draft-ar-acme-pqc-tlsjws-01, , <https://datatracker.ietf.org/doc/html/draft-ar-acme-pqc-tlsjws-01>.
[I-D.ietf-jose-pq-composite-sigs]
Prabel, L., Shuzhou, S., Gray, J., and T. Reddy.K, "PQ/T Hybrid Composite Signatures for JOSE and COSE", Work in Progress, Internet-Draft, draft-ietf-jose-pq-composite-sigs-06, , <https://datatracker.ietf.org/doc/html/draft-ietf-jose-pq-composite-sigs-06>.
[Cisco-Live-BRKSEC-3027]
"Deep Dive into Cisco's Use of QUIC, MASQUE and OS Native Capabilities to Deliver Frictionless Zero Trust Access", Cisco Live BRKSEC-3027, .

Appendix A. PKI Certificate Binding (x509-chain) Interaction Example (Informative)

The example in this appendix does not involve telephone-number-form SIP URIs; the sip: of the idp framework is used only for non-telephone-number AoRs.

Client                      CA                         IdP
  |                          |                          |
  |-- newOrder ------------->|                          |
  |   identifiers: [{idp, "spiffe://..."}]              |
  |<-- tkauth-01 challenge --|                          |
  |   tkauth-type: idp                                  |
  |   tkauth-params.idp_methods: [{x509-chain, nonce:N}]|
  |                          |                          |
  |------ token request (dedicated, normatively RFC 9448 Section 5.5) ----> |
  |   identifier + nonce + CA directory URL              |
  |                          | IdP validates identity and target identifier binding |
  |                          |  sets atc/iss/aud/...     |
  |<-- JWS (contains atc, x5c=IdP cert chain) ------------|
  |                          |                          |
  |-- POST challenge ------->|                          |
  |   {"tkauth": "<JWS>"}    |                          |
  |                          | validate x5c chain to trust root |
  |                          | validate atc.tktype/tkvalue/ |
  |                          | fingerprint              |
  |<-- valid ----------------|                          |

Appendix B. Dual-PoP Public Key Binding (idp-pop) Interaction Example (Informative)

The example in this appendix does not involve telephone-number-form SIP URIs; the sip: of the idp framework is used only for non-telephone-number AoRs.

Client                        CA                                 IdP
  |                          |                                   |
  |-- newOrder ------------->|                                   |
  |   identifiers: [{idp, "oidc:https://idp#alice"}]             |
  |<-- idp-pop-01 challenge -|                                   |
  |   idp_url + nonce + pop_alg                                  |
  |                          |                                   |
  |----- OIDC auth + idp_pop_key + idp_pop_identifier + key possession proof --->|
  |   (IdP validates user holds private key of PK)               |
  |                          |   IdP static mapping derivation   |
  |                          |   identifier                      |
  |<----- JWT (contains idp_assertion, binding=JWK Thumbprint)  |
  |                          |                                   |
  | (K = CSR public key)     |                                   |
  |  construct pop_signature JWS = Sign(K_priv, {"nonce","binding"}) |
  |-- POST challenge ------->|                                   |
  |   {"idp_token":"<JWT>",  |                                   |
  |    "pop_key":{...},      |                                   |
  |    "pop_signature":{...}}|                                   |
  |                          | validate JWT signature + idp_assertion |
  |                          | validate pop_key thumbprint == binding |
  |                          | validate pop_signature JWS        |
  |<-- valid ----------------|                                   |
  |                          |                                   |
  |-- finalize (CSR) ------->|                                   |
  |                          | re-check CSR public key thumbprint == binding |
  |<-- certificate ----------|                                   |

Appendix C. Mobile OIDC + idp-pop + EAP-TLS Deployment Example (Informative)

This example describes an enterprise employee logging into an enterprise OIDC account on a mobile phone, then automatically obtaining a client certificate via idp-pop for EAP-TLS access to enterprise WiFi/LAN. This example is informative and does not define network access policy or platform key APIs.

  1. The employee logs into the enterprise OIDC account on the mobile phone.

  2. The IdP validates, via passkey, device key, or platform key attestation, that the user/device holds the private key of public key K.

  3. The IdP derives identifier via static mapping (for example, oidc:https://idp.example.com#employee-123) and issues idp_assertion.

  4. The mobile ACME client completes pop_signature with K's private key; after validation, the CA issues the client certificate.

  5. The certificate is used for EAP-TLS access to enterprise WiFi/LAN.

Deployment preconditions and boundaries:

Appendix D. Open Issues (Informative)

The WG is invited to consider the following questions:

  1. Parallel relationship with WIF: whether the WG endorses the WIF/idp-pop motivation split in Section 6.1, and agrees to cross-reference Sections 6.1 and 9.3 in the WIF document. Lifecycle matching is a deployment selection heuristic, not a basis for security division; the security division still depends on the identity identifier and public key static binding, and on CA policy validation.

  2. Whether the WG agrees that this document uses the currently unregistered oidc: scheme as internal idp syntax without seeking generic URI registration.

  3. Whether the OIDC authorization request parameters idp_pop_key and idp_pop_identifier of idp-pop need to be defined in an independent document or registered by an OpenID Foundation registry, and whether the WG considers the normative definition in this document sufficiently interoperable.

  4. One-to-many static mapping in idp-pop: this document allows indicating the target identifier via idp_pop_identifier with IdP mapping validation; whether the WG considers this mechanism sufficient to cover multi-identifier subjects, or whether a more structured mapping discovery mechanism is needed.

  5. Whether rejectedIdpId should be renamed to rejectedIdentifier or rejectedIdpIdentifier to more accurately express the semantics of "identifier or IdP selection rejected".

  6. Whether SIP URI user parts in digit-only form without a leading + (for example, enterprise-internal short numbers) should be by default treated as telephone-number form and rejected, or left to the deployment policy to explicitly configure exceptions; this document currently adopts conservative default rejection with deployment policy exceptions, and the WG is invited to consider this direction.

Appendix E. Document Revision History (Informative)

Table 16
Version Date Revision
-01 2026-11-15 Major revision. Defines the Delegated ICV framework, proposes two trust models, and gives the relationship between this document and draft-rasmussen-acme-wif-00.
-00 2026-05-19 Initial version.

Acknowledgments

Over time, the motivation and design of this document have benefited from exploratory work by many experts in the ACME Working Group on non-DCV authentication methods.

The authors thank [I-D.biggs-acme-sso] for pioneering the concept of third-party identity providers participating in ACME validation. Thanks to [RFC8823] for its contribution to defining email identifiers and automated issuance of end-user S/MIME certificates. We acknowledge [I-D.ietf-acme-client] for first identifying the automation needs of end-user, device, and code signing certificates. Thanks to [I-D.ietf-acme-telephone] for exploring the applicability of non-domain identifiers validated via external authoritative entities. We thank [I-D.ietf-acme-device-attest] for leveraging trusted hardware roots to validate device identity. Finally, thanks to [RFC9447] and [I-D.ietf-acme-openid-federation] as core references for the generic authority token challenge framework and multi-layer trust chain mechanism design.

The authors also thank all members of the ACME Working Group for their valuable feedback during discussions of ACME identity-related proposals.

Authors' Addresses

Feng Geng
Huawei Technologies
Panyu Wu
Huawei Technologies
Xin Chen
TrustAsia