Skip to main content

Post-Quantum Authentication for the Resource Public Key Infrastructure
draft-li-sidrops-pqrpki-00

Document Type Active Internet-Draft (individual)
Authors Weitong Li , Tijay Chung
Last updated 2026-07-20
RFC stream (None)
Intended RFC status (None)
Formats
Stream Stream state (No stream defined)
Consensus boilerplate Unknown
RFC Editor Note (None)
IESG IESG state I-D Exists
Telechat date (None)
Responsible AD (None)
Send notices to (None)
draft-li-sidrops-pqrpki-00
SIDROPS                                                            W. Li
Internet-Draft                                                  T. Chung
Updates: 9286 (if approved)                                Virginia Tech
Intended status: Standards Track                            20 July 2026
Expires: 21 January 2027

 Post-Quantum Authentication for the Resource Public Key Infrastructure
                       draft-li-sidrops-pqrpki-00

Abstract

   The Resource Public Key Infrastructure (RPKI) authenticates Internet
   number resource holdings and routing authorizations with classical
   (RSA) signatures.  Because every relying party repeatedly fetches and
   validates the complete global repository, replacing each per-object
   signature with a larger post-quantum signature would multiply
   repository size and validation cost.

   This document specifies pqRPKI, an additive post-quantum
   authentication layer for the RPKI.  Instead of re-signing every
   object, each Certification Authority (CA) authenticates its complete
   published state with a single post-quantum signature over a Merkle
   Tree Ladder whose leaf order and leaf commitments are taken directly
   from the CA's existing Manifest.  A new signed object, the pqRPKI
   Ladder Object (PQLO), carries the ladder root, the Manifest binding,
   an optional aggregate binding the CA's children, and -- for a Trust
   Anchor or a CA holding its own post-quantum key -- the post-quantum
   signature; a CA operated by its parent is authenticated through the
   parent's aggregate instead.  Existing RPKI objects are unchanged and
   legacy relying parties are unaffected by the PQLO, which no Manifest
   lists, while upgraded relying parties validate the same repository
   contents with post-quantum authentication.  This document updates RFC
   9286 to permit index-preserving placeholder Manifest entries and the
   pqRPKI file-name extension.

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/.

Li & Chung               Expires 21 January 2027                [Page 1]
Internet-Draft                   pqRPKI                        July 2026

   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 21 January 2027.

Copyright Notice

   Copyright (c) 2026 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents (https://trustee.ietf.org/
   license-info) in effect on the date of publication of this document.
   Please review these documents carefully, as they describe your rights
   and restrictions with respect to this document.  Code Components
   extracted from this document must include Revised BSD License text as
   described in Section 4.e of the Trust Legal Provisions and are
   provided without warranty as described in the Revised BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3
     1.1.  Relationship to Other Post-Quantum RPKI Work  . . . . . .   5
     1.2.  Requirements Language . . . . . . . . . . . . . . . . . .   5
   2.  Terminology . . . . . . . . . . . . . . . . . . . . . . . . .   5
   3.  Design Overview . . . . . . . . . . . . . . . . . . . . . . .   7
     3.1.  Manifest-Centered Authentication  . . . . . . . . . . . .   7
     3.2.  Ladders, Rungs, and Metadata Rungs  . . . . . . . . . . .   8
     3.3.  Per-CA Ladders, Aggregation, and Update Decoupling  . . .   8
     3.4.  Design Goals  . . . . . . . . . . . . . . . . . . . . . .   9
   4.  Cryptographic Construction  . . . . . . . . . . . . . . . . .  10
     4.1.  Domain-Separation Tags  . . . . . . . . . . . . . . . . .  10
     4.2.  Object Leaf Commitments . . . . . . . . . . . . . . . . .  11
     4.3.  Leaf Order, Indexing, and Exclusions  . . . . . . . . . .  11
     4.4.  Rungs and Rung Roots  . . . . . . . . . . . . . . . . . .  12
     4.5.  Metadata Rungs  . . . . . . . . . . . . . . . . . . . . .  13
     4.6.  Ladder Root . . . . . . . . . . . . . . . . . . . . . . .  13
     4.7.  Worked Example (K = 14 object leaves) . . . . . . . . . .  14
   5.  The pqRPKI Ladder Object (PQLO) . . . . . . . . . . . . . . .  14
     5.1.  Signed-Object Profile . . . . . . . . . . . . . . . . . .  14
     5.2.  Publication, Naming, and Discovery  . . . . . . . . . . .  15
     5.3.  ASN.1 Module  . . . . . . . . . . . . . . . . . . . . . .  16
     5.4.  Post-Quantum Signing Input  . . . . . . . . . . . . . . .  20
   6.  Aggregation and Delegation  . . . . . . . . . . . . . . . . .  20
     6.1.  Hosted Mode . . . . . . . . . . . . . . . . . . . . . . .  22
     6.2.  Delegated Mode  . . . . . . . . . . . . . . . . . . . . .  22

Li & Chung               Expires 21 January 2027                [Page 2]
Internet-Draft                   pqRPKI                        July 2026

     6.3.  Trust Chain . . . . . . . . . . . . . . . . . . . . . . .  23
   7.  Manifest Use and Updates to RFC 9286  . . . . . . . . . . . .  23
     7.1.  Deriving Leaf Indices and Commitments . . . . . . . . . .  23
     7.2.  Placeholder Entries . . . . . . . . . . . . . . . . . . .  23
     7.3.  Update to RFC 9286: File-Name Extension . . . . . . . . .  24
     7.4.  Update to RFC 9286: Publication of Unlisted Ladder
           Objects . . . . . . . . . . . . . . . . . . . . . . . . .  25
     7.5.  Update to RFC 9286: Placeholder Fetch Semantics . . . . .  25
   8.  Post-Quantum Trust Anchor Distribution  . . . . . . . . . . .  26
   9.  Algorithm Profile and Agility . . . . . . . . . . . . . . . .  27
   10. Issuer Behavior . . . . . . . . . . . . . . . . . . . . . . .  27
   11. Relying Party Behavior  . . . . . . . . . . . . . . . . . . .  29
   12. Migration Modes . . . . . . . . . . . . . . . . . . . . . . .  31
     12.1.  Dual-Stack Mode  . . . . . . . . . . . . . . . . . . . .  31
     12.2.  Post-Quantum-Required Mode . . . . . . . . . . . . . . .  31
     12.3.  Router Interface . . . . . . . . . . . . . . . . . . . .  32
   13. Operational Considerations  . . . . . . . . . . . . . . . . .  32
   14. Security Considerations . . . . . . . . . . . . . . . . . . .  33
   15. IANA Considerations . . . . . . . . . . . . . . . . . . . . .  37
     15.1.  SMI Security for S/MIME CMS Content Type . . . . . . . .  37
     15.2.  SMI Security for S/MIME Module Identifier  . . . . . . .  37
     15.3.  RPKI Repository Name Scheme  . . . . . . . . . . . . . .  37
     15.4.  Media Type . . . . . . . . . . . . . . . . . . . . . . .  38
     15.5.  Post-Quantum Algorithm Identifiers . . . . . . . . . . .  38
   16. Normative References  . . . . . . . . . . . . . . . . . . . .  38
   17. Informative References  . . . . . . . . . . . . . . . . . . .  39
   Implementation Status . . . . . . . . . . . . . . . . . . . . . .  41
   Acknowledgements  . . . . . . . . . . . . . . . . . . . . . . . .  41
   Open Issues for Working Group Review  . . . . . . . . . . . . . .  42
   Authors' Addresses  . . . . . . . . . . . . . . . . . . . . . . .  43

1.  Introduction

   The RPKI [RFC6480] secures Internet routing by binding Internet
   number resources (IP address prefixes and Autonomous System numbers)
   to the entities authorized to use them, and by letting those entities
   publish signed objects such as Route Origin Authorizations (ROAs)
   [RFC9582].  A Relying Party (RP) fetches the contents of publication
   points, validates certificate and signed-object chains up to one or
   more preconfigured Trust Anchors (TAs), and emits validated payloads
   (for example, Validated ROA Payloads) that routers consume.

   Unlike handshake-driven public-key infrastructures, RPKI validation
   is inherently _bulk_: an RP periodically retrieves and validates
   essentially the complete global corpus across all trust anchors and
   delegated publication points, on an operational cadence (commonly 20
   to 60 minutes, and at least every 24 hours).  Each publication point
   is anchored by two mandatory, frequently reissued artifacts: the

Li & Chung               Expires 21 January 2027                [Page 3]
Internet-Draft                   pqRPKI                        July 2026

   Manifest [RFC9286], which enumerates every current file and its
   SHA-256 hash, and the Certificate Revocation List (CRL); RPKI
   validation rejects any file that is not listed on the current
   Manifest with a matching hash.

   This bulk model makes the post-quantum transition both urgent and
   difficult.  Post-quantum signature algorithms have substantially
   larger public keys and signatures than RSA-2048; even the most
   compact standardized option (FN-DSA / Falcon) has signatures and
   public keys roughly three times the size of RSA-2048.  A per-object
   substitution multiplies that penalty across hundreds of thousands of
   objects that every RP downloads and validates every cycle, and
   inflates the frequent reissuance of Manifests, CRLs, and their one-
   time-use end-entity (EE) certificates.  A direct substitution is
   poorly matched to RPKI for four reasons:

   *  RPKI repositories contain many objects (CA certificates, CRLs,
      Manifests, and large numbers of signed routing-policy objects);
      any per-object size increase is multiplied across the complete
      global repository.

   *  RPs repeatedly synchronize and validate complete repositories, so
      a larger object format affects every validation cycle, not only
      occasional certificate-issuance events.

   *  Manifests and CRLs are refreshed far more frequently than routing
      objects; a design that couples routine metadata refreshes to broad
      object re-signing would greatly increase publication-point churn
      and RP work.

   *  Deployment must support a long transition in which upgraded and
      non-upgraded RPs coexist; a flag-day replacement of today's RSA-
      authenticated objects is not operationally realistic.

   pqRPKI exploits RPKI's repository structure instead of fighting it.
   It applies an RPKI-specific Merkle Tree Ladder (MTL)
   [I-D.harvey-cfrg-mtl-mode] per CA: many objects are hashed into a
   ladder of bounded-depth Merkle trees ("rungs"), and a single post-
   quantum signature protects the compact ladder root.  The ladder
   reuses two things the Manifest already provides: the file-list order
   (which induces each leaf's index) and each file's existing SHA-256
   hash (which serves as that leaf's commitment).  No per-object Merkle
   authentication paths are attached to objects; an upgraded RP
   reconstructs the shared internal nodes once per cycle and reuses them
   across all objects of a CA.

Li & Chung               Expires 21 January 2027                [Page 4]
Internet-Draft                   pqRPKI                        July 2026

   This document specifies the cryptographic construction to the byte
   level (Section 4), the pqRPKI Ladder Object (Section 5), and parent
   aggregation and delegation (Section 6).  It further specifies the
   updates to RFC 9286 that make the Manifest-derived leaf semantics and
   placeholder entries interoperable (Section 7), post-quantum trust-
   anchor distribution (Section 8), and the algorithm profile
   (Section 9).  Issuer and RP behavior are specified in Section 10 and
   Section 11.

   This document updates [RFC9286] in three ways.  It extends the
   Manifest file-name grammar to admit the pqRPKI file-name extension
   (Section 7.3).  It admits one deliberate exception to the rule that
   every published signed object is listed on a Manifest (Section 7.4).
   Finally, it defines index-preserving placeholder Manifest entries and
   their processing (Section 7.5).  It does not change the Manifest
   ASN.1 syntax, and it does not define or require any X.509 certificate
   extension.

1.1.  Relationship to Other Post-Quantum RPKI Work

   Post-quantum migration of the RPKI has two largely independent
   dimensions: which algorithm produces each signature, and how many
   objects one signature covers.  [I-D.yoshikawa-sidrops-pqc-rpki]
   addresses the first, profiling a composite post-quantum suite for
   RPKI certificates, CRLs, certification requests, and CMS signed
   objects, introduced at CA boundaries and retaining today's one-
   signature-per-object model.  This document addresses the second: it
   leaves the signature on each existing object untouched and adds one
   post-quantum signature per CA over that CA's complete published
   state, so the number of post-quantum signatures an RP verifies scales
   with the number of CAs rather than the number of objects.

   The two are therefore complementary rather than alternatives and can
   be deployed together.  Which combination is appropriate, and in which
   order the two are deployed, is a question for the Working Group.

1.2.  Requirements Language

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

2.  Terminology

   This document uses the RPKI terminology of [RFC6480], [RFC6487],
   [RFC6488], and [RFC9286].  It additionally defines:

Li & Chung               Expires 21 January 2027                [Page 5]
Internet-Draft                   pqRPKI                        July 2026

   CA Ladder  The Merkle Tree Ladder that authenticates the complete set
      of files published by a single RPKI CA at its publication point
      during one signing epoch.

   Object leaf  A depth-0 ladder leaf corresponding to an ordinary
      published object (for example, a ROA or a subordinate certificate)
      or to a placeholder entry (Section 7.2).

   Metadata leaf / metadata rung  A depth-0 single-leaf rung appended
      after all object rungs, used to represent the frequently reissued
      Manifest and CRL without perturbing object-leaf indices
      (Section 4.5).

   Leaf index  The zero-based position of an object leaf in the Manifest
      fileList wire order, after removing the CRL entry (Section 4.3).
      Because the exact Manifest byte order is authenticated by the
      signed manifestHash, this position is itself authenticated; no
      separate index field is carried.

   Leaf commitment  The depth-0 value H0[i] committed to leaf index i.
      For object leaves derived from a Manifest, it is the file's
      SHA-256 hash as it already appears in the Manifest FileAndHash
      entry (Section 4.2).

   Rung  A perfect (fully balanced) binary Merkle tree over a power-of-
      two run of consecutive leaves.  A CA Ladder is a sequence of rungs
      (Section 4.4).

   Rung root / ladder root  The root of an individual rung; and the
      single value that binds all rung roots of a ladder (Section 4.6).

   PQLO  The pqRPKI Ladder Object defined in Section 5: an RFC 6488
      signed object, published at the authenticated CA's own publication
      point but never listed on any Manifest, carrying that CA's ladder
      root, rung descriptors, Manifest binding, optional aggregate, and
      (for a Trust Anchor or delegated CA) post-quantum signature.

   pqRPKI-aware CA  A CA that is bound, as a hosted or delegated child,
      in its parent's aggregate (Section 6), or a Trust Anchor for which
      a pqTAL is configured.  A pqRPKI-aware CA MUST publish a PQLO.

   Aggregate  A ladder, carried in a parent CA's PQLO, whose leaves bind
      the parent's pqRPKI-aware child CAs: a hash of the child's PQLO
      TBS for a hosted child, or the child's post-quantum public key for
      a delegated child (Section 6).

   Hosted child (pqRPKI)  A pqRPKI-aware CA that holds no post-quantum

Li & Chung               Expires 21 January 2027                [Page 6]
Internet-Draft                   pqRPKI                        July 2026

      key of its own; its PQLO carries no post-quantum signature and its
      TBS is authenticated through the parent's aggregate (Section 6.1).
      This typically coincides with hosted RPKI operation, in which the
      parent registry operates the CA.

   Delegated child (pqRPKI)  A pqRPKI-aware CA that holds its own post-
      quantum key and signs its own PQLO; the parent's aggregate binds
      only that key (Section 6.2).

   pqTAL  The Post-Quantum Trust Anchor Locator of Section 8: an out-of-
      band file, distributed like a TAL, that conveys a Trust Anchor's
      post-quantum public key and the location of its PQLO.

   Placeholder entry  A Manifest FileAndHash entry with a reserved,
      unique deleted (D) or hidden (H) file name that occupies a fixed
      fileList slot and whose retained hash preserves a leaf index
      without a fetchable object (Section 7.2).

   Signing epoch  The interval between two rebuilds of a CA Ladder that
      reassign object leaf indices (typically bounded by CA key rollover
      or a planned compaction), during which the issuer holds fileList
      slots stable (appending new leaves and replacing removed leaves in
      place with placeholders) so leaf indices do not shift.

3.  Design Overview

   pqRPKI adds authentication; it removes nothing.  During migration a
   CA continues to publish ordinary RPKI certificates, CRLs, Manifests,
   and signed objects exactly as today, and additionally publishes
   exactly one PQLO at its own publication point, beside its Manifest.
   The PQLO is produced together with each Manifest, but -- like the
   Manifest itself, which no fileList names -- it is never listed on any
   Manifest (Section 5.2).  Keeping the PQLO off the fileList is what
   lets it commit to the Manifest without a circular dependency, and
   keeps its reissuance from rippling into any other object.  Legacy RPs
   disregard it entirely (Section 12); upgraded RPs validate the
   ordinary object set and, in addition, the pqRPKI authentication
   state.  A Trust Anchor's PQLO is additionally referenced from the
   pqTAL (Section 8).

3.1.  Manifest-Centered Authentication

   The Manifest is pqRPKI's shared verification channel.  It already
   lists every file an RP must consider for a CA and already carries a
   SHA-256 hash for each listed file.  pqRPKI therefore derives the CA
   Ladder's object-leaf order from the Manifest FileAndHash sequence and
   uses each Manifest hash directly as the corresponding leaf
   commitment.  No new per-object data structure is introduced, and

Li & Chung               Expires 21 January 2027                [Page 7]
Internet-Draft                   pqRPKI                        July 2026

   ordinary objects (ROAs, ASPAs, certificates, CRLs) are unchanged on
   the wire.

3.2.  Ladders, Rungs, and Metadata Rungs

   A single fixed-depth Merkle tree supports only a fixed number of
   leaves and must be rebuilt once exhausted.  A ladder instead links a
   sequence of bounded-depth trees (rungs): as leaves accumulate,
   smaller rungs merge into larger ones (for example, 14 object leaves
   occupy rungs of sizes 8, 4, and 2, which merge into a single rung of
   size 16 when the 16th object leaf appears).  Appending or changing a
   small number of leaves touches only a short suffix of the ladder and
   its upward hash path.

   The Manifest and CRL are reissued far more often than routing
   objects.  Placing them inside object rungs would make every routine
   refresh propagate through Merkle roots and force widespread
   recomputation and re-authentication even when no routing object
   changed.  pqRPKI therefore models the Manifest and CRL as single-
   leaf, depth-0 _metadata rungs_ appended after all object rungs
   (Section 4.5).  This isolates metadata churn to a short ladder
   suffix, keeping every object leaf, index, and cached subtree stable
   across metadata refreshes.

3.3.  Per-CA Ladders, Aggregation, and Update Decoupling

   Each pqRPKI-aware CA has its own CA Ladder whose root authenticates
   that CA's published state.  A parent CA authenticates its children by
   carrying an _aggregate_ ladder in its own PQLO (Section 6).  For a
   hosted child -- a CA operated by the parent, with no post-quantum key
   of its own -- the aggregate binds a hash of the child's entire PQLO
   TBS.  For a delegated child -- a CA holding its own post-quantum key
   -- the aggregate binds only that public key, so the child refreshes
   its Manifest and PQLO on its own cadence without any parent
   involvement, and the parent's aggregate changes only when the child's
   key rolls.

   The two binding modes give pqRPKI its operational shape.  A registry
   operating a large hosted population updates its members' ladders and
   aggregates bottom-up and re-signs once, at the nearest CA holding a
   post-quantum key, per coalesced batch of changes -- one post-quantum
   signature amortized over the whole batch.  Delegated subtrees are
   fully decoupled from their parents.  At the top, the Trust Anchor's
   post-quantum public key is preconfigured at RPs through the pqTAL
   (Section 8) and transitively authenticates every PQLO beneath it.

Li & Chung               Expires 21 January 2027                [Page 8]
Internet-Draft                   pqRPKI                        July 2026

   Trust Anchor post-quantum public key     (preconfigured via pqTAL)
         | verifies
         v
   TA PQLO: pqSignature over TBS
     TBS = ladderRoot + Manifest binding + aggregate
         |
         |    aggregate leaves bind children:
         |      hosted:    SHA-256 of child PQLO TBS
         |      delegated: child post-quantum public key
         v
   Child CA PQLO: TBS  (hosted: bound by parent aggregate;
         |              delegated: signed with child's own PQ key)
         v
   ladderRoot ---> Manifest FileAndHash order and hashes
         |           induce indices i and commitments H0[i]
         v
   Object leaves (ROAs, ASPAs, certs, placeholders)
         + CRL and Manifest metadata rungs

                 Figure 1: pqRPKI Trust and Validation Flow

3.4.  Design Goals

   Post-quantum authentication  Authenticate CA repository state with a
      post-quantum signature whose cost is amortized across many
      objects.

   Object compatibility  Preserve existing RPKI object encodings so
      ordinary validation remains available throughout migration.

   Manifest-centered verification  Reuse the Manifest file-list order
      and SHA-256 hashes as the leaf index and leaf commitment source;
      add no per-object authentication paths.

   Efficient bulk validation  Let RPs reconstruct each shared internal
      node at most once per cycle and reuse it across objects.

   Localized updates  Support object addition, deletion, revocation, and
      Manifest/CRL refresh without reissuing unrelated objects or
      reindexing leaves.  For a delegated CA this extends to
      independence from ancestors: no ancestor's publication point is
      touched.  For a hosted CA, changes propagate upward to the nearest
      ancestor holding a post-quantum key (Section 6.1).

   Incremental deployment  Allow publication points and RPs to upgrade
      independently, with an RSA fallback during dual-stack operation.

Li & Chung               Expires 21 January 2027                [Page 9]
Internet-Draft                   pqRPKI                        July 2026

4.  Cryptographic Construction

   This section defines the CA Ladder and its root exactly, so that
   independent implementations produce byte-identical results.  All
   values in this section are octet strings; all hashing is SHA-256
   ([RFC6234]) producing 32-octet outputs; and every multi-octet integer
   is encoded big-endian.  The hash algorithm is carried explicitly in
   the PQLO (field hashAlgorithm, Section 5.3) so a future profile may
   substitute a stronger hash; SHA-256 is the only value defined by this
   document because it is already the Manifest hash algorithm.

4.1.  Domain-Separation Tags

   Four fixed 16-octet domain-separation tags distinguish the hash
   inputs of different construction steps so that a hash computed for
   one purpose can never be reinterpreted as another.  They are protocol
   constants; implementations MUST use exactly these octets and MUST NOT
   derive them at runtime.

   +=============+==========================+=========================+
   | Name        | ASCII (NUL-padded to 16) | Hex                     |
   +=============+==========================+=========================+
   | DSEP_LEAF   | "pqRPKI/leaf/v0\0\0"     | 70 71 52 50 4b 49 2f 6c |
   |             |                          | 65 61 66 2f 76 30 00 00 |
   +-------------+--------------------------+-------------------------+
   | DSEP_NODE   | "pqRPKI/node/v0\0\0"     | 70 71 52 50 4b 49 2f 6e |
   |             |                          | 6f 64 65 2f 76 30 00 00 |
   +-------------+--------------------------+-------------------------+
   | DSEP_LROOT  | "pqRPKI/lroot/v0\0"      | 70 71 52 50 4b 49 2f 6c |
   |             |                          | 72 6f 6f 74 2f 76 30 00 |
   +-------------+--------------------------+-------------------------+
   | DSEP_LADDER | "pqRPKI/ladder/v0"       | 70 71 52 50 4b 49 2f 6c |
   |             |                          | 61 64 64 65 72 2f 76 30 |
   +-------------+--------------------------+-------------------------+

             Table 1: Domain-Separation Tags (16 octets each)

   DSEP_NODE tags internal Merkle nodes (Section 4.4).  DSEP_LROOT tags
   the ladder-root reduction (Section 4.6).  DSEP_LADDER tags the TBS
   byte string that is signed or, for a hosted CA, hashed into the
   parent's binding (Section 5.4).  DSEP_LEAF tags aggregate leaves that
   commit to a child's TBS hash or public key (Section 6).  Object-
   ladder leaves derived from the Manifest are NOT re-hashed and carry
   no tag (Section 4.2).

Li & Chung               Expires 21 January 2027               [Page 10]
Internet-Draft                   pqRPKI                        July 2026

4.2.  Object Leaf Commitments

   For an object leaf derived from a Manifest FileAndHash entry, the
   leaf commitment is the entry's hash value used verbatim:

     H0[i] = FileAndHash[i].hash      ; 32 octets, from the Manifest

   The file name is NOT included in the commitment (it governs ordering
   only, Section 4.3); the index i is NOT included (it is implicit in
   position); and no domain-separation tag is applied at the object-leaf
   level.  Reusing the Manifest hash as the commitment is what makes
   pqRPKI additive: for every ordinary object, the value an RP needs is
   already present in the Manifest and is verified against the object
   bytes by ordinary RPKI validation.  Consequently, an RP MUST have
   verified, as part of ordinary RPKI validation, that a fetched
   object's SHA-256 hash equals its Manifest hash before using that hash
   as a leaf commitment; a mismatch is a Manifest validation failure for
   both ordinary and pqRPKI validation.  This applies to every object
   leaf other than a placeholder entry (Section 7.2), which corresponds
   to no fetchable file and whose commitment is therefore not checked
   against any object.

   The 32 octets committed by a metadata leaf and by an aggregate leaf
   are defined in Section 4.5 and Section 6 respectively.

4.3.  Leaf Order, Indexing, and Exclusions

   Let the validated Manifest fileList be the DER wire-order sequence of
   FileAndHash entries.  The fileList of a pqRPKI-aware CA MUST contain
   exactly one entry whose file name carries the ".crl" extension
   ([RFC6481]); if it contains none or several, pqRPKI validation of
   that CA fails.  The CA Ladder's object leaves are obtained by
   processing the sequence in order and separating the two metadata
   entries:

   1.  The entry naming the CRL is removed from the object-leaf sequence
       and retained as the CRL metadata leaf (Section 4.5).  The
       Manifest does not list itself ([RFC9286]); its metadata leaf
       value is defined in Section 4.5.

   2.  Every remaining entry -- ordinary objects (ROAs, ASPAs,
       subordinate CA certificates, ...) and placeholder entries
       (Section 7.2) alike -- is an object leaf.  Its leaf index is its
       zero-based position in this filtered sequence.

   A CA's own PQLO is published at this same publication point but is
   never listed on any Manifest (Section 5.2), so it never appears in
   the fileList and is not an object leaf.  This is deliberate: the PQLO

Li & Chung               Expires 21 January 2027               [Page 11]
Internet-Draft                   pqRPKI                        July 2026

   commits to the Manifest (through manifestHash and the Manifest
   metadata rung), so listing it on that Manifest would make the
   Manifest bytes depend on the PQLO's hash and the PQLO's content
   depend on the Manifest bytes -- an unresolvable cycle.  Keeping the
   PQLO outside the fileList breaks the cycle and keeps routine PQLO
   reissuance from perturbing any leaf.

   Leaf order is the Manifest wire order, taken verbatim.  Because the
   exact DER byte sequence of the Manifest eContent is hashed into
   manifestHash, which is post-quantum authenticated (Section 5.4), the
   order -- and hence every leaf index -- is authenticated directly; no
   lexicographic ordering is required and no per-leaf index field is
   carried.  An RP MUST use the wire order it validated and MUST NOT re-
   sort.  To keep leaf indices stable across reissues within a signing
   epoch, an issuer SHOULD hold fileList slots stable: new leaves are
   appended, and a removed or hidden leaf is replaced _in its existing
   slot_ by a placeholder (Section 7.2) rather than dropped, subject to
   the legacy-compatibility constraint of Section 7.5.  An issuer that
   does not do so MUST rebuild the affected object rungs; index shifts
   are not visible to an RP, because Section 11 rederives every leaf
   index from the current Manifest on each cycle.  Holding slots stable
   is therefore an issuer-side optimization that bounds rebuild cost,
   not an interoperability requirement.  Reassigning indices
   (compaction) then happens only at an epoch boundary (Section 10).

4.4.  Rungs and Rung Roots

   Let K be the number of object leaves.  The object leaves are
   partitioned into consecutive rungs whose sizes are the binary
   decomposition of K, largest first: writing K in binary, each set bit
   contributes one rung of that power-of-two size, from the most-
   significant set bit down to the least-significant.  For example, K =
   14 = 8 + 4 + 2 yields rung sizes [8, 4, 2]; K = 1 yields [1]; K = 3
   yields [2, 1]; K = 0 yields no object rungs at all (the ladder then
   consists of the two metadata rungs alone).  The rung sizes are
   strictly decreasing powers of two, and the first rung consumes object
   leaves [0, s0), the next [s0, s0+s1), and so on.

   Each rung is a perfect binary Merkle tree over its consecutive
   leaves.  An internal node combining a left child L and a right child
   R (each 32 octets) is:

     node(L, R) = SHA-256( DSEP_NODE || L || R )   ; 80-octet input

   The rung root is computed bottom-up: pair consecutive nodes (leaf 0
   with leaf 1, leaf 2 with leaf 3, ...) using node() to form the next
   level, and repeat until one node remains.  Because every rung size is
   a power of two, each level always has an even node count and halves

Li & Chung               Expires 21 January 2027               [Page 12]
Internet-Draft                   pqRPKI                        July 2026

   cleanly; there is never a lone node to promote or duplicate.  A rung
   of size 1 has a rung root equal to its single leaf, with no hashing
   applied.  No index, depth, or level counter is mixed into node();
   separation across rungs and ladders is provided by the ladder-root
   and signing steps below.

4.5.  Metadata Rungs

   After the object rungs, a CA Ladder appends exactly two single-leaf,
   depth-0 metadata rungs, in this order:

   1.  the _CRL rung_, whose rung root is the CRL metadata leaf: the
       32-octet SHA-256 hash carried in the CRL's Manifest FileAndHash
       entry (equivalently, SHA-256 of the published CRL file); and

   2.  the _Manifest rung_, whose rung root is the Manifest metadata
       leaf: SHA-256 of the DER-encoded Manifest eContent ([RFC9286]).
       Because the Manifest never lists itself, this value is not taken
       from the fileList; it is the same value carried in the PQLO
       manifestHash field (Section 5.3).  Hashing the eContent rather
       than the complete file keeps the post-quantum layer independent
       of the CMS envelope, which a future post-quantum-only profile may
       change.

   Modeling the Manifest and CRL as trailing depth-0 rungs means a
   routine Manifest or CRL refresh changes only these two rung roots and
   the ladder-root reduction, while every object leaf, object index, and
   cached object subtree is unchanged.  This yields O(1) ladder work per
   metadata refresh regardless of repository size.

4.6.  Ladder Root

   Let the ordered rung roots be R[0], R[1], ..., R[k-1] for the object
   rungs (largest first), followed by R_crl and R_mft for the two
   metadata rungs.  The ladder root is a single SHA-256 over the tag,
   the object-leaf count K as an 8-octet big-endian integer, and the
   concatenation of all rung roots in that order:

     ladderRoot = SHA-256( DSEP_LROOT
                        || uint64_be(K)     ; 8 octets, K = leaf count
                        || R[0] || ... || R[k-1]    ; object rungs
                        || R_crl            ; CRL metadata rung
                        || R_mft )          ; Manifest metadata rung

   The input length is 16 + 8 + 32*(k + 2) octets, where k =
   popcount(K).  Folding K into the reduction ensures that two ladders
   with coincidentally equal rung roots but different object-leaf counts
   cannot collide.  A CA Ladder always has the two metadata rungs, so

Li & Chung               Expires 21 January 2027               [Page 13]
Internet-Draft                   pqRPKI                        July 2026

   k+2 rung roots always appear.  The parent _aggregate_ ladder
   (Section 6) uses the same reduction over its child rungs but has no
   metadata rungs; its distinct structure and its placement in a
   separate signed TBS field prevent confusion between an aggregateRoot
   and a ladderRoot.

4.7.  Worked Example (K = 14 object leaves)

   Suppose a CA's Manifest lists 14 ordinary objects (any mix of ROAs,
   ASPAs, and subordinate certificates), one CRL, and nothing else (the
   Manifest never lists itself, and the CA's PQLO is never listed).
   Removing the CRL entry as the CRL metadata leaf leaves K = 14 object
   leaves with commitments H0[0..13] taken verbatim from the Manifest.
   The object rung sizes are decompose(14) = [8, 4, 2]:

     Object rung 0 (size 8): perfect tree over H0[0..7]   -> R[0]
     Object rung 1 (size 4): perfect tree over H0[8..11]  -> R[1]
     Object rung 2 (size 2): perfect tree over H0[12..13] -> R[2]

       where, e.g., R[2] = node( H0[12], H0[13] )
                         = SHA-256( DSEP_NODE || H0[12] || H0[13] )
       and    R[1] = node( node(H0[8],H0[9]), node(H0[10],H0[11]) )

     Metadata rungs:
       R_crl = SHA-256(CRL file)          (= the CRL's Manifest hash)
       R_mft = SHA-256(Manifest eContent) (= manifestHash)

     ladderRoot = SHA-256( DSEP_LROOT || uint64_be(14)
                        || R[0] || R[1] || R[2] || R_crl || R_mft )

   When the 16th object appears, rungs [8,4,2] plus two new leaves
   reorganize into a single object rung of size 16 (decompose(16) =
   [16]); the metadata rungs are re-appended unchanged in structure.
   Reference leaf/rung/root test vectors are maintained with the
   reference implementations (Appendix "Implementation Status").

5.  The pqRPKI Ladder Object (PQLO)

5.1.  Signed-Object Profile

   The PQLO is an RPKI signed object conforming to [RFC6488].  Per RFC
   6488 Section 4, this document defines the three elements a new
   signed-object type must define: the eContentType OID (Section 5.3),
   the eContent syntax (Section 5.3), and the additional validation
   steps (Section 11).  As for every RPKI signed object, the PQLO is a
   CMS SignedData with CMSVersion 3, a single SHA-256
   DigestAlgorithmIdentifier, and exactly one embedded one-time-use EE
   certificate whose SubjectKeyIdentifier equals the SignerInfo sid.

Li & Chung               Expires 21 January 2027               [Page 14]
Internet-Draft                   pqRPKI                        July 2026

   The crls field is omitted.  The single SignerInfo carries the
   content-type and message-digest signed attributes (and optionally
   signing-time and/or binary-signing-time, and no others), and
   unsignedAttrs is omitted.

   The EE certificate is an ordinary RPKI EE certificate ([RFC6487])
   issued by the CA that the PQLO authenticates -- the same CA that
   issues the EE certificate of its Manifest.  Its Subject Information
   Access id-ad-signedObject accessLocation points at the published
   PQLO, and its resources are set to inherit.  The CMS signature (RSA
   during dual-stack) provides ordinary RPKI integrity for the file;
   pqRPKI authentication comes from the post-quantum signature carried
   _inside_ the eContent (Section 5.4) or, for a hosted CA, from the
   parent's aggregate binding (Section 6.1).

   Exactly one PQLO exists per pqRPKI-aware CA.  A PQLO carries the
   authenticated CA's own ladder (ladderRoot, rungDescriptors); if that
   CA has pqRPKI-aware children it additionally carries an aggregate
   over them (aggregate, Section 6).

5.2.  Publication, Naming, and Discovery

   A CA's PQLO is published at that CA's own publication point -- the
   repository directory referenced by the caRepository SIA
   accessLocation of the CA's certificate -- beside the CA's Manifest.
   It MUST be published in the same repository update as the Manifest it
   commits to, so that an RP never observes one without the other; a
   publication server reached through the publication protocol [RFC8181]
   can carry both in a single atomic exchange, and an RRDP delta
   [RFC8182] then delivers them together.

   The PQLO's file name is the file name of the CA's Manifest with the
   extension replaced by the pqRPKI extension of Section 7.3 (written
   ".pq" in this document).  An RP already learns the Manifest's URI
   from the rpkiManifest SIA accessLocation of the CA certificate
   ([RFC6487]); it derives the PQLO's URI from that URI by substituting
   the extension.  No new certificate field or access method is needed.
   If the Manifest file name changes, the rules of [RFC9981] apply and
   the PQLO file name follows the new Manifest name.

   The PQLO MUST NOT be listed on any Manifest (Section 7.4).  Listing
   it on the CA's own Manifest would create the circular dependency
   described in Section 4.3 -- the same dependency that, as [RFC9286]
   notes, is why a Manifest cannot list itself.  Listing it on the
   parent's Manifest instead would couple every child Manifest refresh
   to a reissue of the parent's Manifest -- and, transitively, of every
   ancestor's Manifest and PQLO up to the Trust Anchor -- turning
   routine per-CA refreshes into global churn.  Like the Manifest

Li & Chung               Expires 21 January 2027               [Page 15]
Internet-Draft                   pqRPKI                        July 2026

   itself, which no fileList names, the PQLO exists outside Manifest-
   based validation.  [RFC9286] Section 6 requires that files not listed
   on a Manifest not be used to validate certificates, ROAs, and CRLs,
   but provides that such files MAY be employed to validate other signed
   objects where the profile of the object type explicitly states that
   this is allowed.  This document is that profile for the PQLO, and so
   states: a pqRPKI-aware RP MUST retrieve and validate a PQLO as
   specified in Section 11 even though no Manifest lists it
   (Section 7.4).  RFC 9286 further notes that relying on unlisted files
   may permit substitution attacks against them; Section 14 describes
   how PQLO substitution and suppression are detected.

   An RP learns that a CA is pqRPKI-aware -- and therefore that a PQLO
   exists to fetch -- from the ChildBinding for that CA in its parent's
   authenticated aggregate (Section 6) or, for a Trust Anchor, from the
   presence of a configured pqTAL (Section 8).  For a pqRPKI-aware CA, a
   missing, stale, or mismatching PQLO is a pqRPKI validation failure
   for that CA (Section 11); because awareness is asserted post-quantum
   authentically above the CA, an adversary cannot downgrade a CA out of
   pqRPKI by withholding its PQLO (Section 14).

   A Trust Anchor's PQLO follows the same publication and naming rule at
   the Trust Anchor's own publication point; in addition, the pqTAL
   carries its retrieval URIs explicitly (Section 8).

5.3.  ASN.1 Module

   The following ASN.1 module defines the PQLO eContent, importing
   CONTENT-TYPE from the CMS module of [RFC6268] and the algorithm-
   identifier machinery and SubjectPublicKeyInfo from [RFC5912].  Object
   identifiers marked TBD are assigned by IANA (Section 15).  The
   eContent of the PQLO CMS SignedData is a PqRPKILadder value, DER-
   encoded.

   PQRPKI-2026
     { iso(1) member-body(2) us(840) rsadsi(113549)
       pkcs(1) pkcs9(9) smime(16) mod(0)
       id-mod-pqrpki-2026(TBD) }

   DEFINITIONS EXPLICIT TAGS ::=
   BEGIN

   IMPORTS
     CONTENT-TYPE
       FROM CryptographicMessageSyntax-2010  -- in [RFC6268]
         { iso(1) member-body(2) us(840) rsadsi(113549)
           pkcs(1) pkcs-9(9) smime(16) modules(0)
           id-mod-cms-2009(58) }

Li & Chung               Expires 21 January 2027               [Page 16]
Internet-Draft                   pqRPKI                        July 2026

     AlgorithmIdentifier{}, ALGORITHM
       FROM AlgorithmInformation-2009        -- RFC 5912
         { iso(1) identified-organization(3) dod(6) internet(1)
           security(5) mechanisms(5) pkix(7) id-mod(0)
           id-mod-algorithmInformation-02(58) }
     SubjectPublicKeyInfo
       FROM PKIX1Explicit-2009               -- RFC 5912
         { iso(1) identified-organization(3) dod(6) internet(1)
           security(5) mechanisms(5) pkix(7) id-mod(0)
           id-mod-pkix1-explicit-02(51) };

   -- Algorithm sets are placeholders pending the RPKI post-quantum
   -- algorithm profile (Section 9): id-sha256 for hashAlgorithm;
   -- FN-DSA-512 / ML-DSA-65 identifiers for pqSignatureAlgorithm.
   HashAlgorithms   ALGORITHM ::= { ... }
   PqSigAlgorithms  ALGORITHM ::= { ... }

   -- The PQLO eContentType.
   id-ct-pqrpkiLadder OBJECT IDENTIFIER ::= { iso(1) member-body(2)
       us(840) rsadsi(113549) pkcs(1) pkcs-9(9) id-smime(16)
       id-ct(1) TBD }

   ct-pqrpkiLadder CONTENT-TYPE ::=
     { TYPE PqRPKILadder IDENTIFIED BY id-ct-pqrpkiLadder }

   -- The signed-object payload (eContent).
   -- pqSignature is present for a Trust Anchor and for any delegated
   -- CA (a CA holding its own post-quantum key); it is absent for a
   -- hosted CA, whose TBS is authenticated through the parent's
   -- aggregate (Section 6).
   PqRPKILadder ::= SEQUENCE {
     tbs               PqRPKILadderTBS,
     pqSignature       PqSignature OPTIONAL }

   PqRPKILadderTBS ::= SEQUENCE {
     version              INTEGER DEFAULT 0,
     caKeyIdentifier      KeyIdentifier,      -- SKI of CA certificate
     manifestHash         Digest32,           -- R_mft, Section 4.5
     manifestNumber       INTEGER (0..MAX),   -- equals the Manifest's
     thisUpdate           GeneralizedTime,    -- equals the Manifest's
     nextUpdate           GeneralizedTime,    -- equals the Manifest's
     hashAlgorithm        AlgorithmIdentifier{{HashAlgorithms}},
                                              -- id-sha256 here
     pqSignatureAlgorithm [1] AlgorithmIdentifier{{PqSigAlgorithms}}
                                OPTIONAL,
                          -- present iff pqSignature is present
     ladderRoot           Digest32,           -- Section 4.6
     rungDescriptors      SEQUENCE SIZE (2..MAX) OF RungDescriptor,

Li & Chung               Expires 21 January 2027               [Page 17]
Internet-Draft                   pqRPKI                        July 2026

                          -- >= 2: the two metadata rungs always appear
     aggregate            [0] Aggregate OPTIONAL }

   RungDescriptor ::= SEQUENCE {
     kind             RungKind,
     firstLeafIndex   INTEGER (0..MAX),   -- 0 for metadata rungs;
                                          -- first child if aggregate
     leafCount        INTEGER (1..MAX),   -- 1 for metadata rungs
     depth            INTEGER (0..MAX),   -- log2(leafCount)
     rungRoot         Digest32 }

   RungKind ::= ENUMERATED {
     object(0), crlMetadata(1), manifestMetadata(2), aggregate(3) }

   -- Carried by a parent CA that authenticates pqRPKI children
   -- (Section 6).  aggregateRungs descriptors use kind aggregate(3);
   -- aggregateRoot reduces the child rungs only (no metadata rungs).
   Aggregate ::= SEQUENCE {
     aggregateVersion  INTEGER DEFAULT 0,
     aggregateRoot     Digest32,          -- Section 6, over children
     aggregateRungs    SEQUENCE SIZE (1..MAX) OF RungDescriptor,
     children          SEQUENCE SIZE (1..MAX) OF ChildBinding }

   -- Exactly one of childTBSHash (hosted) and childPQPublicKey
   -- (delegated) is present, matching childMode.
   ChildBinding ::= SEQUENCE {
     childKeyIdentifier    KeyIdentifier,     -- child CA cert SKI
     childMode             ChildMode,
     childCertificateHash  Digest32,          -- SHA-256, child .cer
     childTBSHash          [0] Digest32 OPTIONAL,
                           -- hosted: SHA-256 of DSEP_LADDER ||
                           -- DER(child PqRPKILadderTBS), Section 5.4
     childPQPublicKey      [1] SubjectPublicKeyInfo OPTIONAL }
                           -- delegated: child's post-quantum key

   ChildMode ::= ENUMERATED { hosted(0), delegated(1) }

   PqSignature   ::= BIT STRING              -- PQ signature value
   KeyIdentifier ::= OCTET STRING (SIZE(20)) -- RFC 6487 SHA-1 SKI
   Digest32      ::= OCTET STRING (SIZE(32)) -- SHA-256 output

   END

   Field constraints and cross-checks (all normative):

   version  MUST be 0 for this specification.

   caKeyIdentifier  MUST equal the SubjectKeyIdentifier of the CA

Li & Chung               Expires 21 January 2027               [Page 18]
Internet-Draft                   pqRPKI                        July 2026

      certificate whose publication point this PQLO authenticates (the
      160-bit SHA-1 of the CA's subjectPublicKey BIT STRING, [RFC6487]).

   manifestHash  MUST equal SHA-256 of the DER-encoded eContent of the
      CA's current Manifest, and MUST equal the Manifest metadata leaf
      R_mft (Section 4.5).  Because it covers the Manifest's exact byte
      order, it authenticates every leaf index (Section 4.3).

   manifestNumber, thisUpdate, nextUpdate  MUST equal the corresponding
      fields of the current Manifest; see [RFC9286] and [RFC9981].

   hashAlgorithm  MUST be id-sha256 in this version.

   pqSignatureAlgorithm  MUST be present if and only if the outer
      pqSignature is present (that is, for a Trust Anchor or a delegated
      CA), and identifies its algorithm (Section 9).  A delegated
      child's key algorithm is carried self-descriptively in the
      childPQPublicKey SubjectPublicKeyInfo of its ChildBinding and need
      not match the parent's.

   ladderRoot  MUST equal the value computed in Section 4.6.

   rungDescriptors  MUST describe, in ladder order, the object rungs
      followed by the CRL metadata rung and the Manifest metadata rung.
      Each descriptor's rungRoot MUST equal the corresponding rung root,
      and each descriptor's depth MUST equal log2(leafCount); the
      sequence MUST be consistent with an object-leaf count K whose
      binary decomposition equals the object rung sizes.  An RP MUST
      verify that the sequence corresponds exactly to the rung sequence
      it reconstructs, including its length, and MUST reject the PQLO
      otherwise.  Descriptors are redundant with the Manifest-derived
      reconstruction and exist so an RP can cross-check and so metadata
      rung roots are conveyed explicitly; an RP MUST NOT rely on them in
      place of reconstruction.

   aggregate  Present if and only if the CA has pqRPKI-aware children
      (Section 6).

   children  MUST be sorted by increasing childKeyIdentifier octet value
      and MUST NOT contain two bindings with the same
      childKeyIdentifier.  In each ChildBinding, childTBSHash MUST be
      present and childPQPublicKey absent when childMode is hosted, and
      the reverse when childMode is delegated; childCertificateHash is
      SHA-256 of the child's CA certificate as published.

Li & Chung               Expires 21 January 2027               [Page 19]
Internet-Draft                   pqRPKI                        July 2026

5.4.  Post-Quantum Signing Input

   The post-quantum signature pqSignature, when present, is computed
   over the domain-separated DER encoding of the TBS:

     signingInput = DSEP_LADDER || DER( PqRPKILadderTBS )
     pqSignature  = PQ-Sign( signerPrivateKey, signingInput )

   An implementation MUST compute this input, and the hosted
   childTBSHash, over the exact octets of the tbs field as they appear
   in the PQLO it fetched, and MUST independently verify that those
   octets are valid DER; it MUST NOT re-encode a parsed value for this
   purpose.  A PQLO whose eContent is not valid DER MUST be rejected.
   The same rule applies to DER(childPQPublicKey) in an aggregate leaf
   (Section 6).

   For a hosted CA the identical byte string is hashed instead of
   signed: its SHA-256 is the childTBSHash that the parent binds in its
   aggregate (Section 6.1).  In both cases the value authenticated is
   the entire TBS.

   Authenticating the whole DER-encoded PqRPKILadderTBS means the post-
   quantum layer binds not only ladderRoot but also the freshness fields
   (manifestHash, manifestNumber, thisUpdate, nextUpdate), the algorithm
   identifiers, the rung structure, and any child aggregate.  This is
   essential in post-quantum-required mode, where the surrounding RSA
   CMS signature is no longer relied upon and the post-quantum layer is
   the sole integrity guarantee over those fields.  The 16-octet
   DSEP_LADDER prefix domain-separates this input from any other use of
   the same post-quantum key.  Where a signature algorithm accepts a
   separate context-string input (for example, ML-DSA), the context is
   empty; domain separation is provided uniformly by the DSEP_LADDER
   prefix so that the same signing-input rule applies to every
   algorithm.  Signature values may be randomized; implementations MUST
   NOT assume two signatures over the same input are byte-identical.

6.  Aggregation and Delegation

   A parent CA authenticates its pqRPKI-aware children through an
   aggregate ladder carried in the parent's own PQLO.  The aggregate is
   a ladder (Section 4.4, Section 4.6) whose leaves are the parent's
   children.  Its root, aggregateRoot, is part of the parent's TBS and
   is therefore authenticated exactly as the rest of the parent's TBS
   is: by the parent's own post-quantum signature, or -- if the parent
   is itself hosted -- through the grandparent's aggregate.  Unlike
   object leaves, aggregate leaves ARE domain-separated and hashed:

Li & Chung               Expires 21 January 2027               [Page 20]
Internet-Draft                   pqRPKI                        July 2026

     hosted child:     childLeaf = SHA-256( DSEP_LEAF
                                         || childTBSHash )
     delegated child:  childLeaf = SHA-256( DSEP_LEAF
                                         || DER(childPQPublicKey) )

   Here DER(childPQPublicKey) is the DER encoding of the
   SubjectPublicKeyInfo value itself (universal SEQUENCE tag), not of
   the context-tagged field as it appears inside ChildBinding; the
   computation of childTBSHash is defined in Section 5.4.

   Aggregate leaves are ordered by increasing childKeyIdentifier octet
   value (lexicographic over the 20-octet SKI), the same order as the
   children sequence.  The leaf list is packed into rungs whose sizes
   are the binary decomposition of the child count Kc, and each rung
   root Rc[j] is computed exactly as in Section 4.4 (perfect binary
   trees using node()).  Unlike a CA Ladder, an aggregate has no
   metadata rungs; its descriptors carry kind = aggregate(3), and its
   root reduces only the child rungs:

     aggregateRoot = SHA-256( DSEP_LROOT
                        || uint64_be(Kc)    ; Kc = number of children
                        || Rc[0] || ... || Rc[kc-1] )  ; child rungs

   The input length is 16 + 8 + 32*kc octets, kc = popcount(Kc).  This
   is the CA-Ladder reduction (Section 4.6) with the two metadata rung
   roots absent; folding Kc keeps counts distinct, and the absence of
   metadata rungs plus the value's placement in the dedicated aggregate
   TBS field distinguish an aggregateRoot from a ladderRoot.  Each
   ChildBinding also carries childCertificateHash (SHA-256 of the
   child's CA certificate), binding the aggregate to the RPKI
   certificate identity that an RP independently validates.

   A hosted binding covers the hash of the child's _entire TBS_ rather
   than the child's ladder root alone.  The TBS contains the ladder
   root, but also the child's Manifest freshness fields, its rung
   descriptors, and -- crucially -- the child's own aggregate if the
   child in turn has pqRPKI-aware children.  Binding the whole TBS
   therefore authenticates arbitrarily deep chains of hosted CAs with no
   additional mechanism (registry deployments commonly interpose an
   operator-run intermediate CA between the Trust Anchor and member
   CAs), and leaves nothing in a hosted PQLO outside the post-quantum
   trust chain.

Li & Chung               Expires 21 January 2027               [Page 21]
Internet-Draft                   pqRPKI                        July 2026

6.1.  Hosted Mode

   In hosted mode the parent (typically a registry) operates the child
   CA: it holds the child's RPKI key, issues the child's Manifest, and
   runs the child's publication point.  It equally produces the child's
   PQLO and publishes it at the child's publication point (Section 5.2).
   A hosted PQLO carries no pqSignature and no pqSignatureAlgorithm: the
   child holds no post-quantum key.  Instead, the parent's aggregate
   carries a hosted ChildBinding whose childTBSHash is the SHA-256 of
   DSEP_LADDER || DER(tbs) of the child's current PQLO TBS
   (Section 5.4).

   Omitting pqSignature does not make the PQLO an unsigned or malformed
   object: it remains a well-formed [RFC6488] signed object whose CMS
   signature is present and valid.  An RP authenticates a hosted child
   in two steps: it hashes the TBS it fetched and requires the matching
   childTBSHash in an already-authenticated parent aggregate, and it
   independently reconstructs the child's ladder from the child's own
   Manifest and objects and requires the reconstruction to equal the
   TBS's ladderRoot and rungDescriptors.  It never trusts the values in
   a hosted PQLO on their own.

   Because one operator runs the entire hosted chain, it updates leaf-CA
   state, recomputes the affected childTBSHash values and aggregates
   bottom-up, and re-signs once, at the nearest ancestor holding a post-
   quantum key (the Trust Anchor, or a delegated intermediate CA).  The
   result is one post-quantum signature per coalesced batch of changes,
   regardless of how many hosted CAs changed in the batch.

6.2.  Delegated Mode

   In delegated mode the child operates its own CA, holds its own post-
   quantum key, and signs and publishes its own PQLO at its own
   publication point (Section 5.2).  The parent's aggregate carries a
   delegated ChildBinding whose childPQPublicKey is the child's post-
   quantum SubjectPublicKeyInfo, thereby authenticating the child's
   _key_; the child authenticates its own TBS with that key.  The
   parent's aggregate changes only when the child's key rolls or the
   child's CA certificate is reissued (childCertificateHash), fully
   decoupling parent and child update cadences: a delegated child
   refreshes its Manifest and PQLO with no parent interaction at all.
   Carrying one FN-DSA-512 public key per delegated child adds on the
   order of 1 KB per child to the parent's PQLO.

   How a delegated child conveys its post-quantum public key to its
   parent, and how the parent authenticates that conveyance, is an
   enrollment step of the existing parent-child relationship -- the same
   relationship over which the provisioning protocol [RFC6492] is

Li & Chung               Expires 21 January 2027               [Page 22]
Internet-Draft                   pqRPKI                        July 2026

   established today.  A protocol binding for this step (for example, an
   extension to RFC 6492) is out of scope for this document
   (Appendix "Open Issues for Working Group Review").

6.3.  Trust Chain

   Authentication of any CA's PQLO proceeds upward until it terminates
   at a Trust Anchor whose post-quantum public key is preconfigured at
   the RP through the pqTAL (Section 8).  At each step the RP verifies
   one of two bindings.  For a Trust Anchor or a delegated CA, it
   verifies a pqSignature with a key it has already authenticated: the
   pqTAL key for a Trust Anchor, or the childPQPublicKey bound in the
   parent's aggregate for a delegated CA.  For a hosted CA, it requires
   the hash of the CA's TBS as the childTBSHash of a matching
   ChildBinding in the parent's aggregate.  The parent's aggregate is
   part of the parent's TBS and is authenticated the same way,
   recursively.  The chain of PQLOs mirrors the RPKI certificate
   hierarchy, and each PQLO is located from the corresponding CA
   certificate by the discovery rule of Section 5.2.  The complete
   procedure is specified in Section 11.

7.  Manifest Use and Updates to RFC 9286

7.1.  Deriving Leaf Indices and Commitments

   For a pqRPKI-aware CA, an RP derives object leaf indices and
   commitments from the Manifest it has validated for that CA, using the
   metadata separation and wire-order indexing of Section 4.3 and the
   verbatim-hash rule of Section 4.2.  This document does not change the
   Manifest ASN.1 structure of [RFC9286].

7.2.  Placeholder Entries

   To preserve object leaf indices when an object is removed or must not
   be published, a pqRPKI-aware CA MAY include placeholder entries in
   its Manifest fileList.  A placeholder is an ordinary FileAndHash
   entry that occupies the fileList slot of the entry it replaces, so
   wire-order indices (Section 4.3) are unchanged.  Its file uses a
   reserved, fileList-unique placeholder name (Section 7.3).  Its hash
   is the 32-octet commitment that was, or would be, at that leaf index.
   Because the leaf index derives from the slot position and not from
   the file name, the placeholder name is free to differ from the name
   it replaces without perturbing any index.  Two placeholder name
   families are defined:

   Deleted (D)  The object is no longer published, but its prior leaf

Li & Chung               Expires 21 January 2027               [Page 23]
Internet-Draft                   pqRPKI                        July 2026

      commitment is retained so indices and the ladder reconstruct
      unchanged for the remainder of the signing epoch.  Deletion of an
      object that had an EE certificate MUST also be reflected by
      revocation on the CRL; a placeholder does not by itself revoke
      anything.

   Hidden (H)  The artifact is intentionally not published (for example,
      an RPKI Signed Checklist [RFC9323] held privately), but its
      commitment is retained so the ladder reconstructs and public
      leaves verify without revealing the hidden file name or content.

   A pqRPKI-aware RP MUST NOT attempt to fetch a placeholder entry, MUST
   treat its hash as the object leaf commitment at that index, and MUST
   include it in ladder reconstruction.  Multiple deleted or hidden
   leaves within an epoch each keep a distinct placeholder entry in its
   original slot; because several deletions would otherwise collide on
   one reserved basename, each placeholder name MUST be unique within
   the fileList (Section 7.3).

7.3.  Update to RFC 9286: File-Name Extension

   [RFC9286] Section 4.2.2 constrains Manifest file names to one or more
   characters from [a-zA-Z0-9_-] followed by "." and a three-letter
   extension drawn from the IANA "RPKI Repository Name Schemes"
   registry.  This document updates that section to register and permit
   the pqRPKI file-name extension used by placeholder entries (and by
   the PQLO file, which shares the extension but is never listed), and
   to permit the two reserved placeholder basenames.  The concrete
   registry entries are in Section 15.

   Deployments MUST use whatever extension IANA assigns (Section 15);
   throughout this document that extension is written ".pq" for
   readability.  A placeholder file name is one of the two reserved-
   prefix families, a "D" (deleted) or "H" (hidden) followed by a
   fileList-unique decimal disambiguator, with this extension;
   editorially they are written "D<n>.pq" and "H<n>.pq" (for example
   "D1.pq", "D2.pq", "H1.pq").  The disambiguator carries no semantics
   beyond making the name unique within the fileList; a leaf's index
   comes from its slot (Section 4.3), never from the disambiguator.
   Formally a placeholder base name matches ("D" / "H") 1*DIGIT.  The
   PQLO uses this extension with the base name of the CA's Manifest
   (Section 5.2) and is fetchable but never listed; a placeholder name
   is listed but never fetchable.

Li & Chung               Expires 21 January 2027               [Page 24]
Internet-Draft                   pqRPKI                        July 2026

7.4.  Update to RFC 9286: Publication of Unlisted Ladder Objects

   [RFC9286] Section 7 states that every published signed object in the
   RPKI is published at the publication point of the CA that issued its
   EE certificate and is listed in the Manifest associated with that CA
   certificate.  This document creates one deliberate exception: the
   PQLO is published at the CA's publication point but is not listed on
   that CA's Manifest, nor on any other (Section 5.2).  The exception is
   analogous to the Manifest itself, which RFC 9286 also requires to be
   published without any fileList naming it, and for the same reason: an
   object cannot carry the hash of a file whose content depends on that
   object.

   RFC 9286 Section 6 anticipates this case.  It requires that files not
   listed on a Manifest not be used to validate certificates, ROAs, and
   CRLs, and then provides that such files "MAY be employed to validate
   other signed objects, if the profile of the object type explicitly
   states that such behavior is allowed (or required)".  This document
   is the profile of the PQLO and explicitly states it: a pqRPKI-aware
   RP MUST retrieve and validate a CA's PQLO by the discovery rule of
   Section 5.2, and MUST NOT treat the absence of a fileList entry for
   it as a reason to disregard it.

   Manifest processing itself is unaffected.  The acquisition and hash-
   verification rules of RFC 9286 Section 6 apply to files a Manifest
   lists, so a legacy RP neither fetches nor evaluates the PQLO.  This
   document does not otherwise relax the property that RPKI objects an
   RP validates for routing purposes are enumerated by a Manifest: the
   PQLO carries no Internet Number Resources and makes no routing
   assertion, and ordinary RPKI validation disregards it entirely.  RFC
   9286 Section 6 cautions that relying on unlisted files may allow
   substitution attacks against them; the countermeasure here is that a
   PQLO's TBS is authenticated by the parent's aggregate or by the pqTAL
   key rather than by its presence at a location (Section 14).

7.5.  Update to RFC 9286: Placeholder Fetch Semantics

   [RFC9286] Section 6.4 requires that an RP acquire ALL files
   enumerated in the Manifest fileList and treat any listed file that
   cannot be retrieved as a failed fetch for the entire publication
   point.  Under that rule alone, a placeholder entry (which has no
   fetchable object) would cause a conformant RP to fail the CA.  This
   document updates RFC 9286 Section 6.4 as follows:

Li & Chung               Expires 21 January 2027               [Page 25]
Internet-Draft                   pqRPKI                        July 2026

   *  A Manifest fileList entry whose file matches a reserved pqRPKI
      placeholder name family (Section 7.3) is an index-preserving
      marker, not a repository object.  A conformant RP MUST NOT attempt
      to retrieve it and MUST NOT treat its absence from the repository
      as a failed fetch.  All other Section 6 processing (including hash
      checks for genuinely published files) is unchanged.

   A pqRPKI-aware RP implements this exemption directly.  A legacy RP
   that has not been updated to this document remains, by RFC 9286
   Section 6.4, entitled to treat an unretrievable placeholder as a
   failed fetch.  Therefore, in a public dual-stack deployment where
   legacy-RP compatibility is required, an issuer MUST NOT publish
   placeholder entries unless it has confirmed that the relevant legacy
   RP implementations tolerate them.  A deployment can avoid
   placeholders entirely by rebuilding the ladder from the compacted
   fileList whenever an object is removed, at the cost of re-hashing the
   affected object rungs on every removal rather than only at planned
   boundaries.  The PQLO itself never interacts with this rule: it is
   not listed on any Manifest (Section 5.2), so RFC 9286 fetch
   processing never considers it.

8.  Post-Quantum Trust Anchor Distribution

   A Trust Anchor Locator (TAL, [RFC8630]) conveys exactly one
   subjectPublicKeyInfo and provides no field for a second key or an
   extension.  It therefore cannot, unmodified, distribute a Trust
   Anchor's post-quantum public key alongside its RSA key.  An RP
   validating pqRPKI MUST be configured with the authentic post-quantum
   public key of each Trust Anchor it recognizes.  This document defines
   a companion Post-Quantum Trust Anchor Locator (pqTAL) that a Trust
   Anchor operator publishes and distributes alongside its existing TAL:

   *  an optional comment section, as in RFC 8630 Section 2.2;

   *  a URI section: one or more URIs (rsync or HTTPS) at which the
      Trust Anchor's PQLO can be retrieved, one per line.  These URIs
      point at the same object that the discovery rule of Section 5.2
      names at the Trust Anchor's own publication point;

   *  a single blank line; and

   *  the base64 encoding ([RFC4648]) of the DER-encoded Trust Anchor
      post-quantum SubjectPublicKeyInfo, using an algorithm identifier
      of Section 9.

   The post-quantum public key in a pqTAL MUST be stable across Trust
   Anchor certificate reissuance for as long as that key authenticates
   the Trust Anchor's PQLO, and MUST match the key used to verify that

Li & Chung               Expires 21 January 2027               [Page 26]
Internet-Draft                   pqRPKI                        July 2026

   PQLO's pqSignature.  Distribution and out-of-band verification of the
   pqTAL are subject to the same operational trust assumptions as the
   TAL ([RFC8630] Sections 2.1 and 5).  Whether the long-term mechanism
   is a companion pqTAL, an update to RFC 8630 permitting multiple keys,
   or a separate SIDROPS document, is an open question (Appendix "Open
   Issues for Working Group Review"); a companion file is specified here
   so the mechanism is complete and implementable.

9.  Algorithm Profile and Agility

   The RPKI algorithm profile [RFC7935] mandates RSA-2048 with SHA-256
   and provides no in-band algorithm negotiation; algorithm transitions
   in RPKI are performed by replacing the profile and following the
   transition procedure of [RFC6916].  pqRPKI does not alter [RFC7935]
   for existing RSA-authenticated objects.  Instead, it confines the
   post-quantum algorithm choice to the PQLO: the TBS names the hash
   algorithm (hashAlgorithm) and, when the CA signs its own PQLO, the
   signature algorithm (pqSignatureAlgorithm), while a delegated child's
   algorithm is carried self-descriptively in the SubjectPublicKeyInfo
   of its ChildBinding.  Algorithms can therefore differ, and roll, per
   CA.

   The mandatory-to-implement post-quantum signature algorithm for this
   version is FN-DSA-512 (Falcon-512, [Falcon]), chosen for its compact
   public keys and signatures relative to other standardized options;
   standardization of FN-DSA as NIST FIPS 206 is in progress.  ML-DSA-65
   ([FIPS204]) is defined as an additional permitted algorithm.  The
   object identifiers for these algorithms and their AlgorithmIdentifier
   parameter conventions are to be assigned and profiled in coordination
   with the RPKI algorithm profile and the PKIX/LAMPS post-quantum work
   (Section 15, Appendix "Open Issues for Working Group Review"); until
   an RPKI post-quantum algorithm profile exists, these identifiers are
   provisional.  The hashAlgorithm field is id-sha256 in this version.

10.  Issuer Behavior

   A CA that supports pqRPKI MUST, for each publication point:

   1.  Maintain the Manifest fileList in a stable slot order within a
       signing epoch (Section 4.3): the CRL and the Manifest are handled
       as metadata (Section 4.5), and the CA's PQLO is never listed
       (Section 5.2).  No lexicographic ordering is required; the wire
       order is authenticated by manifestHash.

Li & Chung               Expires 21 January 2027               [Page 27]
Internet-Draft                   pqRPKI                        July 2026

   2.  Preserve object leaf indices within a signing epoch by holding
       slots stable: append new objects, and replace a removed or hidden
       object in its existing slot with a uniquely named placeholder
       (Section 7.2) rather than dropping it, until a planned compaction
       or key-rollover boundary.  Placeholder publication is subject to
       the legacy-compatibility constraint of Section 7.5.

   3.  Compute the CA Ladder and ladderRoot per Section 4 using the
       algorithm named in hashAlgorithm, and populate rungDescriptors to
       match.

   4.  If the CA has pqRPKI-aware children, compute the aggregate and
       aggregateRoot per Section 6 and populate children: for each
       hosted child, the current childTBSHash; for each delegated child,
       its childPQPublicKey.

   5.  Populate the remaining TBS fields, ensuring caKeyIdentifier,
       manifestHash, manifestNumber, thisUpdate, and nextUpdate equal
       the corresponding CA-certificate and Manifest values, and DER-
       encode the TBS.

   6.  If the CA holds its own post-quantum key (a Trust Anchor or any
       delegated CA), set pqSignatureAlgorithm and compute pqSignature
       over DSEP_LADDER || DER(PqRPKILadderTBS) (Section 5.4).  A hosted
       CA omits both fields; its operator instead feeds the new TBS hash
       into the parent aggregate (Section 6.1).

   7.  Wrap the PqRPKILadder as an RFC 6488 signed object with a fresh
       one-time-use EE certificate issued by this CA, name the file
       after the CA's Manifest with the pqRPKI extension (Section 5.2),
       and publish it at this CA's publication point.

   8.  Publish the changed objects, the CRL, the Manifest, and the PQLO
       in one repository update, so that RPs observe them atomically
       (for example, in a single [RFC8181] exchange and hence a single
       RRDP delta).  A PQLO MUST be reissued whenever the Manifest it
       commits to is reissued, MUST be published in the same repository
       update as that Manifest, and its thisUpdate/nextUpdate/
       manifestNumber MUST track that Manifest ([RFC9981]).

   Within a hosted chain, the operator propagates childTBSHash updates
   bottom-up and re-signs once per coalesced batch at the nearest
   ancestor holding a post-quantum key.  A parent MUST update its
   aggregate whenever a hosted child's TBS changes, a delegated child's
   key rolls, or a bound child certificate changes.  A Trust Anchor
   signs with the post-quantum key published in its pqTAL (Section 8).

Li & Chung               Expires 21 January 2027               [Page 28]
Internet-Draft                   pqRPKI                        July 2026

11.  Relying Party Behavior

   An upgraded RP MUST first perform ordinary RPKI validation
   (certificate path, Manifest, CRL, and signed objects).  pqRPKI never
   makes an otherwise-invalid RPKI object valid; it is an additional
   authentication check over already-valid repository state.

   pqRPKI authentication proceeds _top-down_, so that no value is used
   before it has been authenticated.  An RP starts at each Trust Anchor
   for which it holds a pqTAL, authenticates that Trust Anchor's TBS
   with the preconfigured post-quantum key, and then descends: a CA C
   below a Trust Anchor is authenticated only after C's parent's TBS has
   been authenticated, using the aggregate carried in that already-
   authenticated parent TBS.  An RP MUST perform the checks of step 5
   below and the authentication of the parent over the identical octets
   of a single fetched parent PQLO.  For each CA C reached this way, the
   RP MUST:

   1.  Establish that C is pqRPKI-aware: C is a Trust Anchor for which
       the RP has a pqTAL, or C has a ChildBinding in the aggregate of a
       parent whose own TBS this RP has already authenticated.  Derive
       the URI of C's PQLO from C's rpkiManifest SIA accessLocation
       (Section 5.2) -- or, for a Trust Anchor, use the pqTAL URIs --
       and fetch it.  If no valid PQLO can be obtained, pqRPKI
       validation of C fails (see below).  Validate the PQLO as an RFC
       6488 signed object, including its EE-certificate path and CRL
       check.

   2.  Check that the PQLO's caKeyIdentifier, manifestHash,
       manifestNumber, thisUpdate, and nextUpdate match the validated CA
       certificate and the Manifest state selected by [RFC9286]
       processing.  An RP SHOULD cache a CA's Manifest and PQLO as one
       unit, so that when RFC 9286 processing falls back to a previously
       validated Manifest state, the PQLO retained with that state is
       used.

   3.  Derive object leaves from C's Manifest in wire order
       (Section 4.3, Section 4.2), including placeholder entries and
       separating the CRL and Manifest metadata leaves; use the wire-
       order position as the leaf index and do not re-sort.  The order
       needs no lexicographic check: it is authenticated by the
       manifestHash verified in the previous step.

Li & Chung               Expires 21 January 2027               [Page 29]
Internet-Draft                   pqRPKI                        July 2026

   4.  Reconstruct the CA Ladder bottom-up (Section 4), reusing internal
       nodes across objects, and verify that the reconstructed
       ladderRoot and rung roots equal the PQLO's ladderRoot and
       rungDescriptors.  If the PQLO carries an aggregate, recompute
       aggregateRoot from children (Section 6) and verify it equals the
       carried value.

   5.  Authenticate C's TBS against the already-authenticated parent:

       *  If C's PQLO has a pqSignature, obtain C's post-quantum public
          key from its authenticated source.  For a Trust Anchor, that
          source is the preconfigured pqTAL key (Section 8).  Otherwise
          it is the childPQPublicKey of the delegated ChildBinding for C
          in the parent's aggregate, whose childKeyIdentifier and
          childCertificateHash MUST match C's validated CA certificate.
          Verify pqSignature over DSEP_LADDER || DER(tbs) with that key.
          The ChildBinding's childMode MUST be delegated.

       *  If C's PQLO has no pqSignature (hosted), compute SHA-256 of
          DSEP_LADDER || DER(tbs); there MUST be a hosted ChildBinding
          for C in the parent's aggregate whose childTBSHash equals that
          value and whose childKeyIdentifier and childCertificateHash
          match C's validated CA certificate.  The ChildBinding's
          childMode MUST be hosted.

       The parent is the CA that issued C's certificate, and its PQLO is
       located by the discovery rule of Section 5.2; by the top-down
       order above, its TBS has already been authenticated when this
       step runs, and the RP MUST use those same octets here.  Where a
       CA holds valid certificates from more than one parent, pqRPKI
       validation is performed per certificate path.

   pqRPKI awareness MUST form a contiguous subtree rooted at a Trust
   Anchor for which the RP holds a pqTAL.  If any ancestor of C on the
   certificate path to that Trust Anchor lacks a PQLO, or lacks a
   ChildBinding for its child on that path, then no authenticated pqRPKI
   path to C exists and pqRPKI validation of C fails.

Li & Chung               Expires 21 January 2027               [Page 30]
Internet-Draft                   pqRPKI                        July 2026

   An RP MAY use authenticated ladder and aggregate roots for top-down
   synchronization.  Comparing a parent's aggregateRoot against cache
   identifies which children changed without fetching unchanged
   children's Manifests; comparing a CA's ladderRoot against cache
   identifies whether any object changed; and comparing the Manifest
   FileAndHash sequence against cache localizes exactly which objects to
   fetch.  The RP then fetches only missing or changed files and
   recomputes only the affected leaves and internal nodes.  This is
   compatible with RRDP [RFC8182] and with hash-comparison
   synchronization such as the Erik protocol
   [I-D.ietf-sidrops-rpki-erik-protocol], which can reuse the Manifest
   H0[i] commitments directly.

   If ordinary RPKI validation succeeds but pqRPKI validation fails
   (including a missing or stale PQLO at a pqRPKI-aware CA), an RP in
   dual-stack mode SHOULD report the pqRPKI failure and MAY continue
   emitting payloads from ordinary RPKI validation per local policy
   (Section 12.1).  An RP in post-quantum-required mode MUST treat
   pqRPKI validation failure as failure of the affected CA subtree
   (Section 12.2).

12.  Migration Modes

12.1.  Dual-Stack Mode

   CAs publish existing RSA-authenticated objects unchanged and
   additionally publish PQLOs; the Manifest continues to carry all
   legacy fields.  Legacy RPs are unaffected by the PQLO itself, which
   no Manifest lists; placeholder entries do affect them, and an issuer
   publishing placeholders is subject to the constraint of Section 7.5.
   Upgraded RPs validate pqRPKI in parallel and can report discrepancies
   before operators rely on pqRPKI for routing decisions.  Reusing the
   Manifest's SHA-256 hashes as leaf commitments means the added post-
   quantum authentication data is a small, fixed per-CA overhead (the
   PQLO, including any aggregate) rather than per-object growth.

12.2.  Post-Quantum-Required Mode

   In post-quantum-required mode, an RP treats pqRPKI validation failure
   as validation failure for the affected CA subtree.  An RP in this
   mode MUST also treat a CA for which no authenticated pqRPKI path to a
   configured pqTAL exists as a validation failure for that CA's
   subtree: absence of pqRPKI awareness is a failure in this mode, not
   an exemption.  Without this rule, suppressing the evidence that a CA
   is pqRPKI-aware would silently return that subtree to RSA-only
   authority (Section 14).  This mode is for a later phase, after
   publication points, RPs, and trust-anchor material are upgraded.  A
   CA can at that point stop relying on RSA and let pqRPKI authenticate

Li & Chung               Expires 21 January 2027               [Page 31]
Internet-Draft                   pqRPKI                        July 2026

   the existing object bytes; the post-quantum authentication of the TBS
   binds the freshness fields with no RSA fallback (Section 5.4).  The
   object profile for operating entirely without RSA material --
   including the CMS envelope of the PQLO itself -- is not defined by
   this document (Appendix "Open Issues for Working Group Review").

12.3.  Router Interface

   pqRPKI does not change the RP-to-router protocol or the payload
   format.  Routers consume RP output as they do today.

13.  Operational Considerations

   Because a PQLO is reissued with every Manifest reissue,
   implementations SHOULD apply the Manifest-number guidance of
   [RFC9981] and avoid unnecessary high-frequency Manifest reissuance.
   On a change of Manifest file name, the RFC 9981 rules for resetting
   the stored Manifest number apply equally to the PQLO's
   manifestNumber, and the PQLO's file name follows the Manifest's
   (Section 5.2).

   In a fully hosted registry, every coalesced batch of hosted-CA
   changes results in one post-quantum signature by the Trust Anchor
   key, giving that key an online signing cadence comparable to the
   Trust Anchor's existing Manifest and CRL reissuance.  A registry that
   prefers to keep its Trust Anchor post-quantum key offline SHOULD
   operate its production intermediate CA as a delegated pqRPKI child:
   the Trust Anchor's aggregate then binds only that CA's stable public
   key, and the Trust Anchor key signs only on its own Manifest cadence
   and at production-key rollover.

   An aggregate carries one ChildBinding per pqRPKI-aware child.  At a
   registry with tens of thousands of hosted member CAs, the parent PQLO
   grows to megabytes and changes with each batch.  RRDP deltas do not
   soften this: [RFC8182] delta files carry complete replacement objects
   rather than byte-level differences, so a single-child change
   republishes the entire aggregate to every RP.  Republication volume
   therefore scales with aggregate size multiplied by batch rate and RP
   population, and an adversary able to induce frequent hosted-child
   changes amplifies load across the whole RP population.  Whether very
   large registries need per-child authentication paths instead of the
   full child list is an open issue (Appendix "Open Issues for Working
   Group Review").

Li & Chung               Expires 21 January 2027               [Page 32]
Internet-Draft                   pqRPKI                        July 2026

   RPs SHOULD cache reconstructed ladder and aggregate nodes and
   reconstruct each internal node at most once per validation cycle;
   reusing internal nodes across a CA's objects is a principal
   efficiency benefit over per-object authentication paths.  The depth-0
   metadata rungs make routine Manifest and CRL refreshes O(1) in ladder
   work.

   Deleted-leaf placeholders accumulate within a signing epoch and are
   cleared at the next reindexing (typically a daily rebuild); their
   storage overhead is bounded and small relative to repository size,
   but CAs SHOULD rate-limit revocation bursts and MAY cap the number of
   retained placeholders per rebuild window.  Publication services
   SHOULD present a coherent fetch view of all files in a CA update; the
   guidance of [I-D.ietf-sidrops-publication-server-bcp] applies.

   Rung sizes are not configurable; they follow from the object-leaf
   count (Section 4.4).  What an issuer controls is the signing-epoch
   length and compaction cadence, which trade rebuild cost against
   placeholder accumulation.  Operators SHOULD monitor PQLO issuance
   rate and PQLO/Manifest consistency.

14.  Security Considerations

   pqRPKI adds post-quantum authentication to RPKI repository state; it
   does not replace ordinary RPKI certificate, Manifest, CRL, or signed-
   object validation.  An RP MUST NOT accept an otherwise-invalid RPKI
   object solely because it appears in a valid CA Ladder.  Every object
   remains independently validatable via the CA certificate and the
   Manifest, which carries all leaf commitments; a missing or withheld
   leaf does not create an attack on other objects.

   *What the post-quantum layer covers.* Authenticating a TBS -- by a
   Trust Anchor or delegated CA signature, or by a hosted childTBSHash
   binding -- transitively authenticates the CA's complete published
   state.  Via ladderRoot, it covers the Manifest ordering and every
   object commitment H0[i].  Via manifestHash and the metadata rungs, it
   covers the current Manifest and CRL.  Via the freshness fields, it
   covers the epoch.  Via aggregateRoot and children, it covers each
   child's entire TBS (hosted) or public key (delegated).  Because the
   full TBS is covered -- including any aggregate -- these bindings hold
   recursively for arbitrarily deep hosted chains, and they hold even in
   post-quantum-required mode where the RSA CMS signature is no longer
   relied upon.

   *Domain separation and key reuse.* The four domain-separation tags
   separate every tagged construction step, so a hash produced for one
   such step cannot be reinterpreted as another.  Object leaves are
   deliberately untagged; see below.  DSEP_LADDER prefixes the TBS bytes

Li & Chung               Expires 21 January 2027               [Page 33]
Internet-Draft                   pqRPKI                        July 2026

   both when they are signed (Trust Anchor, delegated CA) and when they
   are hashed into a hosted childTBSHash; in both cases the
   authenticated semantics are the same TBS, so no cross-interpretation
   arises, while the prefix separates these bytes from any other use of
   the same post-quantum key.  Implementations MUST NOT reuse a pqRPKI
   signing key for unrelated MTL instantiations or protocols, and MUST
   protect signer state against rollback and against reusing stale
   ladder state across epochs.

   *Replay and rollback.* pqRPKI authenticates, but does not refresh,
   the RPKI freshness fields; it adds no replay defense of its own.  A
   (Manifest, PQLO) pair remains internally consistent and post-quantum
   valid until nextUpdate, so an adversary able to serve stale
   repository content -- a publication point, a mirror or cache, or an
   on-path attacker where rsync or non-post-quantum TLS is in use -- can
   replay that pair for the remainder of its validity interval.
   Transport integrity does not prevent this: [RFC8182] Section 4.3
   observes that an on-path attacker cannot produce validly signed RPKI
   data but can still perform withhold and replay attacks.  Within the
   validity window the defenses are those of [RFC9286] and [RFC9981]:
   the thisUpdate/nextUpdate interval, which pqRPKI binds into the TBS
   and which therefore cannot be extended without the authenticating
   post-quantum key, and relying-party retention of the highest
   manifestNumber observed per CA.  The latter is relying-party local
   state: it is unavailable at first contact or after a cache reset, and
   RFC 9981 requires it to be reset when a CA changes its Manifest file
   name.  RPs SHOULD persist per-CA manifestNumber state across restarts
   and SHOULD report any decrease.  A hosted child's parent aggregate
   does constrain rollback, because a current parent PQLO pins the
   child's exact current TBS hash (Section 10); a delegated child's
   parent binds only a long-lived public key, so a delegated subtree has
   no cross-CA freshness coupling.  Retaining the commitment of a
   deleted leaf under a D placeholder does not enlarge this surface.  A
   stale object is rejected because its file name no longer appears in
   the current fileList.  The retained commitment sits at a placeholder
   name an RP never fetches (Section 7.5), and revocation is signalled
   on the CRL, which is bound into the same ladder.

Li & Chung               Expires 21 January 2027               [Page 34]
Internet-Draft                   pqRPKI                        July 2026

   *Withholding and downgrade.* The PQLO is not listed on any Manifest,
   so ordinary Manifest processing does not notice its absence; an
   adversary controlling transport or a publication point can strip it.
   Stripping a PQLO is detectable by an upgraded RP that holds an
   authenticated ancestor assertion for that CA: pqRPKI-awareness is
   asserted post-quantum authentically above the CA, through a
   ChildBinding in the parent's aggregate or through the pqTAL for a
   Trust Anchor.  A missing, stale, or mismatching PQLO at a pqRPKI-
   aware CA is therefore a pqRPKI validation failure, handled per
   migration mode (Section 12): reported, and by local policy tolerated,
   in dual-stack mode; fatal for the subtree in post-quantum-required
   mode.

   The residual attack is therefore not to make a CA fail but to make an
   RP believe the CA was never pqRPKI-aware.  An adversary who can serve
   an RP a stale but still-valid ancestor PQLO issued before the CA was
   added to that ancestor's aggregate suppresses the awareness assertion
   itself.  Two rules bound this: pqRPKI awareness MUST form a
   contiguous subtree rooted at a configured pqTAL (Section 11), and in
   post-quantum-required mode a CA with no authenticated pqRPKI path to
   a pqTAL fails (Section 12.2), so the adversary must suppress
   awareness for an entire subtree up to a Trust Anchor rather than for
   one CA.  Beyond that, the defence is the replay bound above: per-CA
   manifestNumber retention and the ancestor's nextUpdate.  As in any
   dual-stack cryptographic migration, protection against a quantum-
   capable adversary begins when RPs enforce post-quantum-required mode.

   *Untagged object leaves.* Object-leaf commitments are Manifest hashes
   used verbatim, with no leaf-level domain-separation tag
   (Section 4.2), and a rung of size 1 has a rung root equal to its leaf
   (Section 4.4).  Leaf commitments and internal-node values are
   therefore drawn from the same 32-octet space and are not
   distinguishable by value.  A repository object whose file content is
   exactly 80 octets of the form DSEP_NODE || L || R has a Manifest hash
   equal to the internal-node value node(L, R).  A placeholder entry
   (Section 7.2) may carry any 32-octet value at all, since it
   corresponds to no file and is exempt from fetch and hash checking
   (Section 7.5).

Li & Chung               Expires 21 January 2027               [Page 35]
Internet-Draft                   pqRPKI                        July 2026

   This is safe for the procedure of Section 11 for a reason stronger
   than domain separation.  manifestHash is SHA-256 over the entire
   Manifest eContent and therefore already binds every file name, every
   leaf commitment, and their exact order.  ladderRoot is a
   deterministic function of data that manifestHash already
   authenticates, and the leaf count K is folded into the ladder-root
   reduction.  pqRPKI carries no per-object authentication paths, so no
   verification step infers a value's position in the tree from the
   value itself.  An RP performing the full reconstruction of Section 11
   cannot be induced to accept a leaf as a subtree or a subtree as a
   leaf.

   That guarantee is conditional on full reconstruction.  An RP using
   the incremental and cached-node optimizations permitted by Section 11
   and Section 13 MUST ensure the optimization is equivalent to full
   reconstruction.  Cached ladder and aggregate nodes MUST be keyed by
   position: the CA, the ladder or aggregate, the rung index, the level,
   and the offset within the level.  They MUST NOT be keyed by node
   value alone, and MUST NOT be reused at any other position.  An
   implementation that memoizes verified subtrees by value is
   vulnerable, because a CA controls the 32-octet commitments in its own
   fileList, including placeholder commitments that correspond to no
   published file.

   *Hash strength.* pqRPKI's collision and second-preimage security rest
   on the leaf/node hash, SHA-256, reused from the Manifest.  SHA-256
   provides 128-bit collision resistance, which bounds the post-quantum
   security level of the ladder authentication irrespective of the
   signature algorithm's strength.  If a deployment requires a larger
   long-term margin, a future profile can substitute a stronger hash via
   the hashAlgorithm field; this would also require the Manifest hash
   algorithm to change, since the leaf commitments are the Manifest
   hashes (Appendix "Open Issues for Working Group Review").

   *Trust anchor dependency.* pqRPKI's guarantees reduce to the
   authenticity of the preconfigured Trust Anchor post-quantum keys
   (Section 8).  Distribution and out-of-band verification of the pqTAL
   are as security-critical as the TAL and share its trust model; a
   compromised or substituted pqTAL key defeats pqRPKI for that Trust
   Anchor.

   *New cross-CA dependency.* In today's RPKI a stale or unfetchable
   parent Manifest does not invalidate a child's objects.  Under pqRPKI
   a hosted CA's validity depends on its parent's PQLO carrying a
   childTBSHash matching that CA's current TBS (Section 6.1), so in
   post-quantum-required mode an adversary who can stall, strip, or
   stale a single PQLO invalidates every hosted descendant beneath it --
   at a large registry, potentially its entire membership.  The set of

Li & Chung               Expires 21 January 2027               [Page 36]
Internet-Draft                   pqRPKI                        July 2026

   entities that can affect a CA's subtree therefore now includes those
   who can affect its ancestors' publication points and transport paths.
   The same coupling produces a benign race: nothing orders a child's
   repository update against its parent's, so during a hosted batch an
   RP can observe a new child (Manifest, PQLO) against an old parent
   PQLO.  Within a hosted batch an operator SHOULD publish ancestor
   PQLOs after descendant PQLOs; an RP encountering a childTBSHash
   mismatch SHOULD re-fetch the parent's PQLO before declaring failure,
   and MAY apply a bounded grace interval before failing a subtree in
   post-quantum-required mode.  Any such grace interval is a deliberate
   rollback-versus-availability trade-off.

   *Out of scope.* pqRPKI authenticates repository content after
   retrieval.  It does not by itself provide post-quantum protection for
   the transport and naming layers (for example, RRDP over HTTPS, or
   publication-point host naming via DNSSEC); those require their own
   post-quantum migrations and are orthogonal to this document.  pqRPKI
   does not change the RPKI trust model or an adversarial publication
   point's existing (unchanged) ability to withhold or stall its own
   content; it does add the cross-CA dependency described above.

15.  IANA Considerations

15.1.  SMI Security for S/MIME CMS Content Type

   IANA is requested to assign an object identifier for id-ct-
   pqrpkiLadder in the "SMI Security for S/MIME CMS Content Type
   (1.2.840.113549.1.9.16.1)" registry, referencing this document, and
   to record the eContentType in the RPKI-relevant signed-object listing
   analogous to existing RPKI signed objects.

15.2.  SMI Security for S/MIME Module Identifier

   IANA is requested to assign an object identifier for id-mod-
   pqrpki-2026 in the "SMI Security for S/MIME Module Identifier
   (1.2.840.113549.1.9.16.0)" registry, referencing this document.

15.3.  RPKI Repository Name Scheme

   IANA is requested to register the pqRPKI file-name extension in the
   "RPKI Repository Name Schemes" registry (created by [RFC6481]), with
   this document as the reference.  If the registry's three-letter
   constraint is retained, a three-letter extension is required; the
   value ".pq" used editorially in this document is a placeholder
   pending that assignment (Appendix "Open Issues for Working Group
   Review").  The registration MUST also reserve the two placeholder
   basename families ("D" and "H" followed by digits, with the assigned
   extension) as non-fetchable index-preserving markers per Section 7.5.

Li & Chung               Expires 21 January 2027               [Page 37]
Internet-Draft                   pqRPKI                        July 2026

15.4.  Media Type

   IANA is requested to register the media type application/rpki-pqlo
   for the PQLO, following the RPKI signed-object media-type template.

15.5.  Post-Quantum Algorithm Identifiers

   Object identifiers and AlgorithmIdentifier parameter conventions for
   FN-DSA-512 and ML-DSA-65, as used in the PQLO pqSignatureAlgorithm
   field and in childPQPublicKey, are to be assigned in coordination
   with the applicable PKIX/LAMPS and RPKI algorithm-profile work.  This
   document does not itself allocate these values (Appendix "Open Issues
   for Working Group Review").

16.  Normative References

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC4648]  Josefsson, S., "The Base16, Base32, and Base64 Data
              Encodings", RFC 4648, DOI 10.17487/RFC4648, October 2006,
              <https://www.rfc-editor.org/info/rfc4648>.

   [RFC5912]  Hoffman, P. and J. Schaad, "New ASN.1 Modules for the
              Public Key Infrastructure Using X.509 (PKIX)", RFC 5912,
              DOI 10.17487/RFC5912, June 2010,
              <https://www.rfc-editor.org/info/rfc5912>.

   [RFC6234]  Eastlake 3rd, D. and T. Hansen, "US Secure Hash Algorithms
              (SHA and SHA-based HMAC and HKDF)", RFC 6234,
              DOI 10.17487/RFC6234, May 2011,
              <https://www.rfc-editor.org/info/rfc6234>.

   [RFC6268]  Schaad, J. and S. Turner, "Additional New ASN.1 Modules
              for the Cryptographic Message Syntax (CMS) and the Public
              Key Infrastructure Using X.509 (PKIX)", RFC 6268,
              DOI 10.17487/RFC6268, July 2011,
              <https://www.rfc-editor.org/info/rfc6268>.

   [RFC6481]  Huston, G., Loomans, R., and G. Michaelson, "A Profile for
              Resource Certificate Repository Structure", RFC 6481,
              DOI 10.17487/RFC6481, February 2012,
              <https://www.rfc-editor.org/info/rfc6481>.

Li & Chung               Expires 21 January 2027               [Page 38]
Internet-Draft                   pqRPKI                        July 2026

   [RFC6487]  Huston, G., Michaelson, G., and R. Loomans, "A Profile for
              X.509 PKIX Resource Certificates", RFC 6487,
              DOI 10.17487/RFC6487, February 2012,
              <https://www.rfc-editor.org/info/rfc6487>.

   [RFC6488]  Lepinski, M., Chi, A., and S. Kent, "Signed Object
              Template for the Resource Public Key Infrastructure
              (RPKI)", RFC 6488, DOI 10.17487/RFC6488, February 2012,
              <https://www.rfc-editor.org/info/rfc6488>.

   [RFC6916]  Gagliano, R., Kent, S., and S. Turner, "Algorithm Agility
              Procedure for the Resource Public Key Infrastructure
              (RPKI)", BCP 182, RFC 6916, DOI 10.17487/RFC6916, April
              2013, <https://www.rfc-editor.org/info/rfc6916>.

   [RFC7935]  Huston, G. and G. Michaelson, "The Profile for Algorithms
              and Key Sizes for Use in the Resource Public Key
              Infrastructure", RFC 7935, DOI 10.17487/RFC7935, August
              2016, <https://www.rfc-editor.org/info/rfc7935>.

   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
              2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
              May 2017, <https://www.rfc-editor.org/info/rfc8174>.

   [RFC8630]  Huston, G., Weiler, S., Michaelson, G., Kent, S., and T.
              Bruijnzeels, "Resource Public Key Infrastructure (RPKI)
              Trust Anchor Locator", RFC 8630, DOI 10.17487/RFC8630,
              August 2019, <https://www.rfc-editor.org/info/rfc8630>.

   [RFC9286]  Austein, R., Huston, G., Kent, S., and M. Lepinski,
              "Manifests for the Resource Public Key Infrastructure
              (RPKI)", RFC 9286, DOI 10.17487/RFC9286, June 2022,
              <https://www.rfc-editor.org/info/rfc9286>.

   [RFC9981]  Harrison, T., Michaelson, G., and J. Snijders, "Resource
              Public Key Infrastructure (RPKI) Manifest Number
              Handling", RFC 9981, DOI 10.17487/RFC9981, May 2026,
              <https://www.rfc-editor.org/info/rfc9981>.

17.  Informative References

   [Falcon]   Fouque, P-A., Hoffstein, J., Kirchner, P., Lyubashevsky,
              V., Pornin, T., Prest, T., Ricosset, T., Seiler, G.,
              Whyte, W., and Z. Zhang, "Falcon: Fast-Fourier Lattice-
              based Compact Signatures over NTRU - Specification v1.2",
              October 2020, <https://falcon-sign.info/>.

Li & Chung               Expires 21 January 2027               [Page 39]
Internet-Draft                   pqRPKI                        July 2026

   [FIPS204]  National Institute of Standards and Technology, "Module-
              Lattice-Based Digital Signature Standard", NIST FIPS 204,
              August 2024, <https://doi.org/10.6028/NIST.FIPS.204>.

   [I-D.harvey-cfrg-mtl-mode]
              Harvey, J., Kaliski, B., Fregly, A., Sheth, S., and D.
              McVicker, "Merkle Tree Ladder (MTL) Mode Signatures", Work
              in Progress, Internet-Draft, draft-harvey-cfrg-mtl-mode-
              09, 24 March 2026, <https://datatracker.ietf.org/doc/
              draft-harvey-cfrg-mtl-mode/>.

   [I-D.ietf-sidrops-publication-server-bcp]
              Bruijnzeels, T., de Kock, T., Hill, F., Harrison, T., and
              J. Snijders, "Best Practices for Operating Resource Public
              Key Infrastructure (RPKI) Publication Services", Work in
              Progress, Internet-Draft, draft-ietf-sidrops-publication-
              server-bcp-09, 29 May 2026,
              <https://datatracker.ietf.org/doc/draft-ietf-sidrops-
              publication-server-bcp/>.

   [I-D.ietf-sidrops-rpki-erik-protocol]
              Snijders, J., Bruijnzeels, T., Harrison, T., and W. Ohgai,
              "The Erik Synchronization Protocol for use with the
              Resource Public Key Infrastructure (RPKI)", Work in
              Progress, Internet-Draft, draft-ietf-sidrops-rpki-erik-
              protocol-05, 6 July 2026,
              <https://datatracker.ietf.org/doc/draft-ietf-sidrops-rpki-
              erik-protocol/>.

   [I-D.yoshikawa-sidrops-pqc-rpki]
              Yoshikawa, T., "Post-Quantum Signature Algorithm Profile
              and Migration Considerations for the Resource Public Key
              Infrastructure (RPKI)", Work in Progress, Internet-Draft,
              draft-yoshikawa-sidrops-pqc-rpki-01, 4 July 2026,
              <https://datatracker.ietf.org/doc/draft-yoshikawa-sidrops-
              pqc-rpki/>.

   [RFC6480]  Lepinski, M. and S. Kent, "An Infrastructure to Support
              Secure Internet Routing", RFC 6480, DOI 10.17487/RFC6480,
              February 2012, <https://www.rfc-editor.org/info/rfc6480>.

   [RFC6492]  Huston, G., Loomans, R., Ellacott, B., and R. Austein, "A
              Protocol for Provisioning Resource Certificates",
              RFC 6492, DOI 10.17487/RFC6492, February 2012,
              <https://www.rfc-editor.org/info/rfc6492>.

Li & Chung               Expires 21 January 2027               [Page 40]
Internet-Draft                   pqRPKI                        July 2026

   [RFC8181]  Weiler, S., Sonalker, A., and R. Austein, "A Publication
              Protocol for the Resource Public Key Infrastructure
              (RPKI)", RFC 8181, DOI 10.17487/RFC8181, July 2017,
              <https://www.rfc-editor.org/info/rfc8181>.

   [RFC8182]  Bruijnzeels, T., Muravskiy, O., Weber, B., and R. Austein,
              "The RPKI Repository Delta Protocol (RRDP)", RFC 8182,
              DOI 10.17487/RFC8182, July 2017,
              <https://www.rfc-editor.org/info/rfc8182>.

   [RFC9323]  Snijders, J., Harrison, T., and B. Maddison, "A Profile
              for RPKI Signed Checklists (RSCs)", RFC 9323,
              DOI 10.17487/RFC9323, November 2022,
              <https://www.rfc-editor.org/info/rfc9323>.

   [RFC9582]  Snijders, J., Maddison, B., Lepinski, M., Kong, D., and S.
              Kent, "A Profile for Route Origin Authorizations (ROAs)",
              RFC 9582, DOI 10.17487/RFC9582, May 2024,
              <https://www.rfc-editor.org/info/rfc9582>.

Implementation Status

   This section is to be removed before publication.  The core
   cryptographic construction of Section 4 (the domain-separated leaves,
   rungs, and ladder root) has been implemented in a signer and in a
   relying party that reconstructs ladders and verifies FN-DSA-512
   signatures; the two interoperate at the byte level against a shared
   set of leaf/rung/ladder test vectors.  An operational trial under a
   production Regional Internet Registry confirmed that current
   unmodified relying parties validate the accompanying legacy objects
   without error.

   The prototype predates parts of this specification.  It conveys the
   ladder root in an X.509 certificate extension on the CA certificate
   rather than in the PQLO signed object of Section 5.  It does not
   implement the placeholder entries of Section 7.2, and it predates the
   trust-chain encoding of Section 6 (hosted TBS-hash bindings and per-
   child SubjectPublicKeyInfo).  The PQLO encoding, discovery rule, and
   placeholder processing are therefore normatively defined by this
   document but have not yet been exercised for byte-level
   interoperability.

Acknowledgements

   The authors thank the members of the SIDROPS Working Group for
   discussions of this work at IETF 123, IETF 124, and IETF 125.

Li & Chung               Expires 21 January 2027               [Page 41]
Internet-Draft                   pqRPKI                        July 2026

Open Issues for Working Group Review

   *  File-name extension: RFC 9286 Section 4.2.2 currently requires a
      three-letter, registered extension.  Confirm the concrete
      extension to register (the document uses ".pq" editorially) and
      whether to instead relax the grammar.

   *  PQLO discovery: this version derives the PQLO URI from the
      rpkiManifest SIA accessLocation by substituting the extension
      (Section 5.2).  Alternatives are a new SIA accessMethod on the CA
      certificate (which RFC 6487 profile strictness may not admit) or
      listing the PQLO on a Manifest, which was rejected: listing on the
      CA's own Manifest is circular, and listing on the parent's
      Manifest couples every child Manifest refresh to reissues at every
      ancestor.  Confirm the derived-name rule.

   *  Trust-anchor key distribution: confirm the companion pqTAL
      (Section 8) versus an update to RFC 8630 permitting a second key
      versus a separate SIDROPS document.

   *  Delegated key enrollment: how a delegated child conveys its post-
      quantum public key to its parent, and how that conveyance is
      authenticated -- for example, through an extension to [RFC6492]
      (Section 6.2).

   *  Algorithm identifiers: coordinate FN-DSA-512 and ML-DSA-65 OIDs
      and AlgorithmIdentifier parameter conventions with the RPKI
      algorithm profile and PKIX/LAMPS ([RFC7935], [RFC6916]).

   *  Signed-root object structure: confirm carrying the ladder root,
      rung descriptors, and aggregate in one signed object versus
      splitting a minimal signed root from a descriptor object.

   *  Leaf-index model: this version derives each leaf index from the
      Manifest wire-order position (authenticated by manifestHash) and
      requires issuers to hold fileList slots stable within an epoch
      (Section 4.3).  An alternative is an explicit per-leaf index field
      in the PQLO, which removes the stable-slot requirement at the cost
      of re-listing leaves; confirm the preferred approach.

   *  Post-quantum-only object profile: the encoding of RPKI objects,
      Manifests, and the PQLO itself once RSA material is no longer
      published (Section 12.2).

   *  Hash strength: confirm whether SHA-256 leaf commitments (inherited
      from the Manifest) suffice for the desired long-term post-quantum
      margin, or whether a future Manifest hash profile is needed.

Li & Chung               Expires 21 January 2027               [Page 42]
Internet-Draft                   pqRPKI                        July 2026

   *  Aggregate scaling: confirm the flat child-binding ladder is
      adequate at registries with tens of thousands of children, or
      whether an RP needs per-child authentication paths rather than the
      full child list (see also the size discussion in Section 13).

   *  Parent PQLO freshness: a parent's aggregate changes whenever a
      hosted child's TBS changes, even though the parent's own Manifest
      has not.  This version requires a PQLO to be reissued with the
      Manifest it commits to (Section 10), which leaves two parent PQLO
      revisions able to carry identical manifestNumber, thisUpdate, and
      nextUpdate over different aggregates, so an RP cannot order them.
      The candidate fixes are a monotonic pqloNumber field in the TBS
      with RFC 9981-style handling, or requiring a parent to reissue its
      Manifest whenever its aggregate changes.  This is the most
      significant open design question in this document.

   *  Trust Anchor post-quantum key rollover: a pqTAL key is
      preconfigured out of band and cannot roll in band, so pqRPKI is
      least agile exactly where a compromise is most costly.  A rollover
      and algorithm-transition procedure, analogous to RFC 6489 for RPKI
      keys, is needed.

   *  Mandatory-to-implement algorithm: FN-DSA-512 is specified here for
      its compactness, but FIPS 206 is not yet published and Falcon-512
      is NIST security category 1.  Confirm whether the MTI should
      instead be ML-DSA-65 (FIPS 204, published) with FN-DSA-512
      permitted, and whether Trust Anchor and delegated-intermediate
      keys need a higher minimum security category or a hash-based
      algorithm.

   *  Placeholder entries reduce the completeness property that
      Manifests provide: a CA may list entries no RP will ever fetch or
      check, and legacy and upgraded RPs may compute different results
      for the same repository state (Section 7.5).  Confirm whether the
      H (hidden) family belongs in this version, and whether a D
      placeholder should be normatively required to retain the exact
      commitment previously published at that index so that a warm-cache
      RP can verify it.

   *  Identity binding: the TBS binds the CA it speaks for only through
      a 20-octet SHA-1 SubjectKeyIdentifier, while ChildBindings already
      carry a SHA-256 childCertificateHash.  Confirm whether to add a
      self caCertificateHash and to pair the pqTAL cryptographically
      with the TAL.

Authors' Addresses

Li & Chung               Expires 21 January 2027               [Page 43]
Internet-Draft                   pqRPKI                        July 2026

   Weitong Li
   Virginia Tech
   Email: weitongli@vt.edu

   Taejoong Chung
   Virginia Tech
   Email: tijay@vt.edu

Li & Chung               Expires 21 January 2027               [Page 44]