N-PAMP: Native Post-Quantum Agent Messaging Protocol

1.1. Goals

The design goals of N-PAMP are:¶

• Cryptographic agility within a stable wire format. The frame format does not change between profiles; the cryptographic primitives, modes, and operational requirements do.¶

• Defense in depth through hybrid post-quantum and classical key establishment, authenticated encryption, and a forward-secure key schedule.¶

• Channel multiplexing so that a single association can carry several classes of agent traffic with independent sequence spaces and per-channel keying.¶

• Interoperability across profiles, so that an endpoint operating at a higher profile MAY interoperate with a lower-profile peer when local policy permits.¶

1.2. Non-Goals

This document does NOT:¶

• Replace TLS for ordinary web traffic. N-PAMP is purpose-built for autonomous-agent, multi-channel traffic over long-lived associations.¶

• Define application-layer semantics for the data carried on its channels.¶

• Define a general-purpose IP-layer tunneling or VPN protocol.¶

1.3. Terminology

For the purposes of this document:¶

Association:

A long-lived, cryptographically authenticated session between two N-PAMP endpoints, identified by a stable Association ID.¶

Channel:

A semantic multiplexing lane within an association, identified by a 16-bit Channel ID, carrying one class of agent traffic with its own sequence space.¶

Frame:

The atomic unit of transmission, consisting of a fixed 36-octet header, optional extension TLVs, and an AEAD-protected payload.¶

Profile:

One of three negotiated levels of cryptographic strength and operational requirement (Standard, High, Sovereign).¶

4.1. Frame Structure

Every N-PAMP frame has the following structure:¶

+--------+------------------------------------------------+
| Header | Payload                                        |
| 36 B   | (var; frame-type body, then 16-octet AEAD tag) |
+--------+------------------------------------------------+

The 36-octet header is fixed-size. Everything after the header is a single Payload region whose length is the Payload Length field: it carries the frame-type-specific body (which, where a frame type uses them, contains extension TLVs decoded per that frame type) and ends with the 16-octet AEAD tag, which is counted in Payload Length. There is no separate extension-TLV region between the header and the payload; extension TLVs are frame-type payload content (see Extension TLVs). The payload is AEAD-sealed, and the associated data covers the 21-octet header prefix (octets 0-20, through the Payload Length field, the same octets protected by the header CRC32C) so that any modification to those header fields is detected on decryption. The CRC32C (octets 21-24) and the reserved octets (25-35) are OUTSIDE the AEAD associated-data range (octets 0-20); a receiver MUST NOT make any security decision based on them. The CRC32C is a non-cryptographic integrity check (an on-path attacker who alters a header field can recompute it), and the reserved octets carry no meaning beyond the MUST-be-zero rule; only the AEAD tag over the AD-covered header prefix authenticates the header.¶

4.2. Stream Framing

N-PAMP frames are self-delimiting: each frame carries its own length in the Payload Length header field, so no inter-frame delimiter or separate total-length prefix is used. Over a stream transport (TCP with TLS 1.3), a receiver locates each frame boundary by reading the fixed 36-octet header, taking Payload Length (octets 17-20, big-endian), and consuming exactly 36 + Payload Length octets; the next frame begins at the following octet. A receiver that has buffered fewer than 36 octets, or fewer than 36 + Payload Length octets, MUST wait for more input before parsing the frame. Over QUIC a frame MAY additionally align to a stream or datagram boundary, but the same Payload-Length self-delimiting rule applies within any byte run.¶

4.3. Frame Header

The fixed header is 36 octets, laid out as follows. Multi-octet integers are encoded in network byte order (big-endian) unless stated otherwise.¶

 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|     'N'       |     'P'       |     'A'       |     'M'       |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Ver   | Flags |          Frame Type           |  Channel ID   |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                                                               |
+                   Sequence Number (64 bits)                   +
|                                                               |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                   Payload Length (32 bits)                    |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                   CRC32C over octets 0-20                     |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                                                               |
+             Reserved + Padding (11 octets, zero)              +
|                               |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

The fields are:¶

All multi-octet integers are big-endian. The Ver field carries the wire-format version (the frame layout); the value 0x02 is invariant and does not identify the crypto generation. The crypto generation is carried out of band by the negotiated ALPN identifier (currently "n-pamp/3"), or by explicit configuration where frames are exchanged without TLS; a raw frame is not generation-self-describing. A receiver MUST reject any frame whose Ver nibble is not 0x02.¶

4.4. Frame Flags

The low nibble of header octet 4 carries four flag bits:¶

4.5. Extension TLVs

Where a frame type uses Type-Length-Value (TLV) extensions, they appear inside that frame type's payload, decoded per the frame type's grammar; there is no separate extension-TLV region between the header and the payload. Each TLV is encoded as:¶

+---------+---------+-----------+
| Type    | Length  | Value     |
| 16 bits | 16 bits | Length B  |
+---------+---------+-----------+

Type and Length are 16-bit unsigned integers in network byte order; Length is the byte count of Value (0 to 65535). A receiver that encounters an unknown TLV whose Type has the high bit (0x8000) clear MUST ignore that TLV. A receiver that encounters an unknown TLV whose Type has the high bit (0x8000) set MUST treat it as a forward-incompatible extension and reject the frame with the registered error code unknown_critical_tlv (Section 4.9.1). The TLV type registry maintained by this specification is given in Section 10.4.¶

4.6. Payload Encoding

The payload carries a frame-type-specific body. The body MAY be encoded in a binary serialization, in deterministic CBOR [RFC8949] (per the Deterministic Encoding Profile, Section 4.6.1), or as raw octets. The selected encoding is signaled within the channel-local interpretation of the Frame Type field.¶

4.7. Reserved Frame Types

Each channel defines its own frame types in the 0x0000-0xFFFF space. The following frame types are reserved across all channels and have the same meaning on every channel:¶

Frame types are interpreted within the channel on which they appear, as identified by the Channel ID field of the frame header (Section 4). A given frame-type value MAY have a different meaning on different channels, except for the all-channel reserved types above, which have the same meaning on every channel. Each channel's frame-type namespace is partitioned as follows:¶

• 0x0000-0x000A: reserved all-channel frame types (the table above); the same meaning on every channel.¶

• 0x000B-0x002F: unassigned; reserved to this specification for future all-channel or core additions. A frame whose type is in this range and is not defined by this specification MUST be treated as an unknown frame type.¶

• 0x0030-0x00FF: companion-extension band. Frame types in this range are reserved for extensions defined in companion specifications and are scoped to a specific channel; the individual reservations are enumerated in Section 9.¶

• 0x0100-0xFFFF: channel-specific application frame types. Each channel defines its own frame types in this range; the same value on two different channels denotes two unrelated frames. The Control channel's handshake frame types (below) occupy 0x0100-0x0103.¶

The Control channel (0x0000) assigns the following channel-specific frame types for the N-PAMP handshake (Section 8):¶

4.8. CLOSE Frame

An endpoint closes an association with an acknowledged teardown on the Control channel (0x0000). A CLOSE frame (0x0003) is authenticated like any other frame: a receiver MUST verify the AEAD tag before honoring it, and an unauthenticated or forged CLOSE frame MUST be dropped and SHOULD be counted as a security event, so an off-path attacker cannot tear down an association with a forged CLOSE.¶

The exchange is CLOSE then CLOSE_ACK and closes the whole association (every channel):¶

1. The closer seals and sends a CLOSE frame on Control. CLOSE is the closer's final frame: after sending it the closer MUST NOT send any further application frame on any channel, and it moves to the CLOSING state. Because each (channel, direction) is delivered in order (Section 4), every frame the closer sent before CLOSE is delivered ahead of it, so no in-flight frame the closer already sent is lost.¶

2. The peer, on a verified CLOSE, MUST first process any frames it has already received in sequence order up to the CLOSE (in-flight frames are not discarded), then seal and send a CLOSE_ACK frame (0x0004) on Control, then tear down (CLOSED). After sending CLOSE_ACK it MUST NOT send any further frame.¶

3. The closer, in CLOSING, awaits CLOSE_ACK under the CLOSE_ACK-wait timer (its bounds are stated with the other numeric bounds, Section 11). While it waits it MAY continue to receive and process frames the peer had in flight. On CLOSE_ACK it moves to CLOSED; on the timer's expiry it forces teardown and records the outcome as close_incomplete (Section 4.9.1) -- the peer is unresponsive, so no further ERROR is sent.¶

CLOSE and CLOSE_ACK carry no payload; the frame type and its AEAD authentication are the whole of the message. A receiver MUST reject a CLOSE or CLOSE_ACK that carries a non-empty payload with unexpected_message. Once an endpoint reaches CLOSED it processes no further frame, and the association's key schedule -- the master secret and every cached epoch key -- is zeroized (Section 11).¶

4.9. ERROR Frame

Reject conditions have one of two reactions. A fatal condition aborts the connection: after a traffic key is established, an endpoint that aborts on a fatal condition MUST send an ERROR frame (0x0005) on the Control channel (0x0000) carrying the condition's code before it tears the connection down; before any traffic key is established -- an initiator before it has processed SERVER_HELLO -- it aborts WITHOUT an ERROR (so there is no unauthenticated ERROR an off-path attacker could forge), and the peer detects the abort through the transport or the handshake-completion timer. Two fatal codes are triggered by a timer rather than a received frame -- handshake_timeout and close_incomplete -- and force teardown directly: the endpoint MAY send a best-effort ERROR if a traffic key is established, but MAY omit it when the peer is unresponsive, and it records the outcome and tears down regardless. A discard condition is not fatal: the offending frame is dropped and the condition is counted, the connection survives, and no ERROR frame is sent. Each code's reaction is given in the registry below.¶

The ERROR frame is AEAD-protected under the current traffic key. A receiver MUST verify the AEAD tag before reading an ERROR frame and MUST NOT make any security decision based on an unauthenticated or malformed ERROR; an authenticated ERROR frame is advisory -- it reports the sender's reason for aborting and does not itself change the receiver's keys or state beyond letting the receiver surface the reason and close.¶

The ERROR payload is a deterministic-CBOR (Section 4.6.1) map with two integer keys:¶

error-body = {
  1 => code:    0..255,   ; Error/Alert Code Registry value (below)
  2 => context: bstr,     ; diagnostic detail; always present,
                          ; MAY be zero-length
}

The context is an implementation-chosen diagnostic detail (for example, the offending frame type) and carries no normative meaning; it is always present and MAY be zero-length, and a receiver MUST NOT parse context into any security decision.¶

5.1. Core Channel Registry

The following channels are defined and maintained by this specification:¶

The Min Profile column gives the lowest profile at which a channel may be enabled; a channel is available at that profile and at every higher profile (for example, a "High" channel is available at High and Sovereign). The Audit channel is enabled by default only at Sovereign; other profiles MAY enable it. The Control and Immune channels SHOULD be scheduled at higher priority than bulk channels (Memory, Sensory, Telemetry) during congestion.¶

All N-PAMP channels are full-duplex: each peer maintains an independent send and receive sequence space and independent per-direction traffic keys, so both peers MAY transmit on a channel simultaneously. The Direction column classifies each channel as follows:¶

The Stream channel (0x000C) provides general-purpose multiplexed full-duplex streaming, carrying concurrent bidirectional sub-streams (for example token, audio, video, and file-transfer streams), each with independent flow control.¶

A channel's frames for a given direction form a single ordered sequence carried over one transport byte run (one QUIC stream, or the TCP-with-TLS byte stream); the per-(channel, direction) sequence number is assigned by a single writer (Section 8.5), and nonce uniqueness and the replay window depend on that single monotonic sequence. This revision therefore does NOT define a channel opening multiple concurrent transport-layer streams: the frame header carries no per-transport-stream identifier, and splitting one channel's frames across independently ordered transport streams would break the single-writer sequence and risk nonce reuse. "Multi-stream" accordingly denotes payload-layer sub-stream multiplexing (for example the NPAMP-STREAM sub_stream_id), never transport-stream multiplexing; an implementation MUST carry each (channel, direction) as one ordered sequence. A future revision that adds concurrent transport-stream operation MUST also define the per-transport-stream correlation and the corresponding sequence and nonce separation, and negotiates a new ALPN generation.¶

Channel IDs not listed in Section 5.1, and in particular the ranges enumerated in Section 9, are reserved for extensions defined in companion specifications.¶

7.1. Key Encapsulation Mechanisms

Both are hybrid KEMs combining an elliptic-curve ECDH with ML-KEM [FIPS203], per [RFC10024]. The concatenation order is per-group: for each group the FIPS-approved component leads the HKDF input as that group's defining construction requires (see [SP800-56C]), so the two groups differ.¶

X25519MLKEM768 (0x11ec) combines X25519 with ML-KEM-768 and is ML-KEM-first: the shared secret is (ML-KEM-768 SS || X25519 SS); KEMShare is (ML-KEM-768 ek (1184) || X25519 pub (32)) = 1216 octets; KEMCiphertext is (ML-KEM-768 ct (1088) || server X25519 pub (32)) = 1120 octets. The suite name lists X25519 first, but the bytes are ML-KEM-first ([RFC10024] records this reversed order as historical).¶

SecP384r1MLKEM1024 (0x11ed) combines secp384r1 (P-384) with ML-KEM-1024 and is ECDHE-first (P-384 first): the shared secret is (ECDHE SS (48) || ML-KEM-1024 SS (32)) = 80 octets; KEMShare is (secp384r1 pub (97) || ML-KEM-1024 ek (1568)) = 1665 octets; KEMCiphertext is (server secp384r1 pub (97) || ML-KEM-1024 ct (1568)) = 1665 octets. The secp384r1 share is the uncompressed point encoding of [RFC9846] Section 4.3.8.2; the ECDHE shared secret is the shared-point x-coordinate.¶

Both feed the concatenation raw to HKDF-Extract [RFC5869] as input keying material. The Sovereign profile MUST NOT accept X25519MLKEM768.¶

7.2. Authenticated Encryption

AES-256-GCM is used as specified for AEAD ciphers in [RFC5116]; ChaCha20-Poly1305 is used as specified in [RFC8439]. AES-256-GCM (0x0001) is Mandatory-To-Implement in every profile, so two conformant endpoints always share at least one AEAD -- a non-empty MUST-support intersection for every profile x algorithm class (the Danvers Doctrine, BCP 61). Endpoints operating at the Standard profile MUST support AES-256-GCM and MAY additionally support ChaCha20-Poly1305. Endpoints operating at the High and Sovereign profiles MUST support both AEAD suites because per-frame AEAD diversification at those profiles selects between them.¶

At High and Sovereign, per-frame AEAD diversification selects each frame's AEAD suite deterministically from the sequence number, with no per-frame wire flag: the suite is AEADSelect[seq mod N], where AEADSelect is the negotiated ordered list of selectable suites (primary first) and N is its length. Both peers derive the same suite from the shared per-(channel, direction) sequence number. Consequently AEADSelect (TLV 0x0D) carries the ordered list of selectable suites (2 octets per suite, primary first): one suite at Standard, both at High and Sovereign. The former fixed 2-octet encoding does not stand while two suites are selectable.¶

7.3. Signatures

The ML-DSA code points reference the IANA TLS SignatureScheme registry ([I-D.ietf-tls-mldsa]): 0x0904 = ML-DSA-44, 0x0905 = ML-DSA-65, 0x0906 = ML-DSA-87. Ed25519 is used as specified in [RFC8032]. ML-DSA-87 is the module-lattice-based digital signature algorithm standardized in [FIPS204]. N-PAMP negotiates only ML-DSA-87 (0x0906) at High and Sovereign; 0x0904 and 0x0905 are listed so N-PAMP's namespace does not shadow the IANA values. The Sovereign profile uses ML-DSA-87 for identity and audit signatures.¶

The hybrid-KEM construction authority [RFC10024] (formerly the Internet-Draft draft-ietf-tls-ecdhe-mlkem, published August 2026) is cited directly as a published RFC. The ML-DSA SignatureScheme code points [I-D.ietf-tls-mldsa] remain an active Internet-Draft at the time of writing; on its publication as an RFC, this citation is to be updated to the assigned RFC number.¶

7.4. Key Derivation and Hashing

All key derivation uses HKDF [RFC5869]. The KDF hash is SHA-256 at the Standard profile and SHA-384 at the High and Sovereign profiles. The HKDF-Expand-Label construction follows TLS 1.3 [RFC9846], with the literal label prefix "n-pamp " (with the trailing space) in place of TLS 1.3's "tls13 ", providing domain separation from TLS 1.3, from QUIC, and from earlier N-PAMP versions. A conforming implementation MUST use the "n-pamp " prefix; use of the "tls13 " prefix is non-conformant. The full key-schedule ladder is specified in Section 8.5.¶

7.5. Key Schedule and Nonces

Traffic secrets are derived per (direction, epoch, AEAD suite, channel) tuple, so that no two distinct contexts share a key. Each traffic secret yields an AEAD key and an AEAD initialization vector by HKDF-Expand-Label; N-PAMP derives no separate header-protection key, because header protection is provided by the secure transport. The per-frame nonce is the AEAD IV exclusive-ORed with the left-zero-padded sequence number, identical in form to the construction used in TLS 1.3 [RFC9846] and QUIC [RFC9001]. This namespace partitioning prevents cross-direction, cross-suite, and cross-channel nonce reuse, and supports forward secrecy: on key update, traffic secrets for the new epoch are derived afresh and the prior epoch's secrets are zeroized.¶

Within a single (direction, epoch, AEAD suite, channel) key, sequence-number assignment MUST be atomic and single-writer: each frame MUST be sealed under exactly the sequence number it was assigned, so that a multi-threaded sender cannot reuse a sequence number, and therefore a nonce, under one key. An endpoint MUST perform a key update before the negotiated AEAD's usage limit is reached, and MUST NOT let the sequence space wrap within an epoch; a key update begins a new epoch with fresh secrets (see the key-update procedure). Cross-(direction, epoch, suite, channel) reuse is structurally prevented by the key separation above; this rule covers the remaining intra-key case.¶

7.6. Random Number Generation

All randomness that participates in security MUST come from a cryptographically secure random number generator. Implementations MUST NOT use a non-cryptographic source for any field that participates in security.¶

8.1. Message Flow

There is no separate Finished frame; the Finished MAC is a TLV inside each AUTH frame. Each frame is a standard 36-octet N-PAMP frame (Section 4) on channel 0x0000 with sequence 0; the AUTH frames set FlagENC and are AEAD-sealed (Section 8.6.3). A server reaches the Established state only after it has verified CLIENT_AUTH; the master secret is derived at the client-authentication boundary.¶

All four handshake frames use sequence number 0 -- the exception to the general per-(channel, direction) monotonic sequence rule (Section 4). Each direction AEAD-seals at most one handshake frame (SERVER_AUTH server-to-client and CLIENT_AUTH client-to-server; the HELLO frames are cleartext), so sequence 0 is sealed at most once per direction under the handshake key and no (key, nonce) pair repeats. The monotonic per-(channel, direction) sequence space of the keyed session begins at sequence 0 of epoch 0, which starts when the handshake completes.¶

8.2. State Machine

The handshake and the keyed session form one state machine per endpoint. The per-state transition rules and the total default in this section are normative; the diagram is informative (following the [RFC9293] Section 3.10 model, in which the event-by-state processing rules bind and a summary diagram does not). Each state is named for what the endpoint is waiting for. Every frame that can arrive in a state is either listed with its transition below or is covered by the total default; there is no state in which an unexpected frame is silently ignored.¶

An endpoint plays one role, fixed when the connection is set up: the initiator sends CLIENT_HELLO first, and the responder waits for it. The two roles have distinct handshake states and converge on the shared keyed-session states ESTABLISHED, CLOSING, and CLOSED.¶

(informative)
initiator: START --send CLIENT_HELLO-->
           WAIT_SH --recv SERVER_HELLO--> WAIT_SA
           WAIT_SA --recv+verify SERVER_AUTH;
           send CLIENT_AUTH; key master--> ESTABLISHED
responder: LISTEN --recv CLIENT_HELLO;
           send SERVER_HELLO, SERVER_AUTH--> WAIT_CA
           WAIT_CA --recv+verify CLIENT_AUTH--> ESTABLISHED
both:      ESTABLISHED --KEY_UPDATE-->
           ESTABLISHED (epoch advances in place)
           ESTABLISHED --send/recv CLOSE--> CLOSING
           --CLOSE_ACK / timeout--> CLOSED

Normative transitions -- initiator:¶

• START: the endpoint sends CLIENT_HELLO and moves to WAIT_SH. No frame is legal to receive in START.¶

• WAIT_SH: on SERVER_HELLO, the endpoint checks that every selection is one it offered (a stripped or downgraded selection is additionally caught by the transcript binding of the Finished MAC and CertVerify, Downgrade Protection), derives the handshake traffic keys, and moves to WAIT_SA.¶

• WAIT_SA: on SERVER_AUTH -- which MUST carry exactly IdentityKey, CertVerify, and Finished, in that order -- the endpoint verifies the CertVerify signature and the Finished MAC; on success it sends CLIENT_AUTH, derives the master secret, and moves to ESTABLISHED. There is no CLIENT_AUTH acknowledgement frame; the initiator is ESTABLISHED once CLIENT_AUTH is sent.¶

Normative transitions -- responder:¶

• LISTEN: on CLIENT_HELLO, the endpoint selects the profile and algorithms from the offer, sends SERVER_HELLO and the AEAD-sealed SERVER_AUTH, and moves to WAIT_CA. No other frame is legal in LISTEN.¶

• WAIT_CA: on CLIENT_AUTH -- exactly IdentityKey, CertVerify, Finished, in that order -- the endpoint verifies the CertVerify signature and the Finished MAC; on success it reaches ESTABLISHED. The responder reaches ESTABLISHED only after it has verified CLIENT_AUTH.¶

A failed AEAD open, CertVerify signature, or Finished MAC at either WAIT_SA or WAIT_CA is a fatal handshake authentication failure: the endpoint MUST abort with the registered code decrypt_failed (error registry) and derive no session keys.¶

Normative transitions -- keyed session (both roles):¶

• ESTABLISHED: application frames on any open channel are processed in place. A KEY_UPDATE is processed as in the Forward Secrecy and Key Update section (the epoch advances and a KEY_UPDATE_ACK is sent; the endpoint remains ESTABLISHED). The record-layer control frames MASTER_RATCHET and REKEM on the Control channel (the master-ratchet and re-KEM sub-protocol; registered in the frame-type registry) are processed in place in the same way -- each advances the ratchet, is acknowledged, and the endpoint remains ESTABLISHED. These REQUEST frames (KEY_UPDATE, MASTER_RATCHET, REKEM) are legal in ESTABLISHED and are not unexpected_message. The corresponding ACKNOWLEDGEMENT frames -- KEY_UPDATE_ACK, MASTER_RATCHET_ACK, and REKEM_ACK -- are legal in ESTABLISHED ONLY as the confirmation of an exchange THIS endpoint initiated: an endpoint that has sent the matching KEY_UPDATE (correlated per (channel, epoch)), MASTER_RATCHET (per generation), or REKEM processes the acknowledgement in place with no reaction and remains ESTABLISHED. An UNSOLICITED acknowledgement -- one for which the endpoint has no outstanding corresponding request -- is NOT exempt from the total default: it MUST be rejected with unexpected_message and the connection MUST be torn down, exactly as an unsolicited CLOSE_ACK is; an endpoint MUST NOT silently ignore it. Sending or receiving an authenticated CLOSE moves the endpoint to CLOSING (Authenticated Close).¶

• CLOSING: the endpoint awaits CLOSE_ACK under the CLOSE_ACK-wait timer; on CLOSE_ACK, or on that timer's expiry, it moves to CLOSED.¶

• CLOSED: terminal; no frame is processed.¶

Total default (normative): in any state, a frame not listed above for that state -- a handshake frame arriving out of order, a frame from a later or earlier flight, a repeated frame, an application frame before ESTABLISHED, or any frame of an unknown or unexpected type -- MUST be treated as a fatal error with the registered code unexpected_message (error registry), and the connection MUST be torn down. The record-layer REQUEST frames listed above as legal for ESTABLISHED -- KEY_UPDATE and the master-ratchet / re-KEM requests -- are "listed above for that state" and are therefore not caught by this default; the acknowledgement frames (KEY_UPDATE_ACK, MASTER_RATCHET_ACK, REKEM_ACK) are exempt ONLY when they confirm an exchange this endpoint initiated -- an unsolicited acknowledgement IS caught by this default, as stated in the ESTABLISHED transition above. The full state transitions of the master-ratchet and re-KEM sub-protocol are given in that sub-protocol's own specification rather than in this core state machine. An endpoint MUST NOT silently ignore an unexpected frame and MUST NOT attempt to recover by skipping it; "ignore" is never the reaction to an unexpected message. This is what closes the skip / hop / repeat deviant-trace family, and the deviant-trace conformance suite is generated from these rules.¶

Every named code used above -- unexpected_message, decrypt_failed, replay_detected (Replay), unknown_critical_tlv (an unknown must-understand extension TLV), handshake_timeout (the handshake-completion timer), and close_incomplete (teardown) -- is defined in the core error/alert registry (Section 4.9.1), which classifies each as fatal or discard: a fatal code appears on the wire in an ERROR frame so that a conformance test can assert the exact code, while a discard code (replay_detected) names a silently-dropped frame that produces no ERROR. The negotiated profilexKEMxAEADxsignature mode fixes exactly one legal required-message set for the AUTH frames -- there is no "mixed-mode" transition -- and the composite negotiation machine together with the distinct bound read-only/discovery state are specified in the negotiation state rules that follow.¶

8.3. Negotiation and the Read-Only State

The negotiable dimensions -- profile, KEM, AEAD, and signature algorithm -- are selected together at exactly one point, the server's SERVER_HELLO. That selection fixes one composite mode for the connection, and the mode fixes exactly one legal required-message set for the AUTH frames and one keyed-session behaviour. There is no transition in which two modes are mixed, and no point after SERVER_HELLO at which a negotiable dimension is renegotiated within the connection. Because the ProfileSelect, KEMSelect, SigSelect, and AEADSelect TLVs of SERVER_HELLO -- and the ProfileOffer, KEMOffer, SigOffer, and AEADOffer of CLIENT_HELLO -- are absorbed into the transcript that both the Finished MAC and CertVerify cover (Section 8.6.4), an attacker cannot splice one mode's messages into another mode's handshake without invalidating the MAC. This is the composite-state-machine discipline whose absence produced the cross-protocol downgrade attacks on earlier negotiated protocols: N-PAMP standardizes the single mode-selection point and cryptographically binds it, rather than leaving the multiplexer for each implementation to compose differently.¶

A High or Sovereign endpoint that accepts a lower selected profile under the read-only / capability-discovery policy exception (Section 6) does NOT enter the full ESTABLISHED state. It enters a distinct ESTABLISHED_READONLY state whose legal event set is restricted to capability-discovery frames (the Discovery channel, 0x0010) and to operations the endpoint's local policy classifies as read-only. A frame that would effect a state change -- any frame the endpoint's policy does not classify as read-only -- MUST be rejected in ESTABLISHED_READONLY with the registered code unexpected_message (error registry) and MUST NOT be honored. The restriction is cryptographically bound: the selected profile is carried in SERVER_HELLO and covered by the transcript that Finished and CertVerify authenticate, so a peer cannot strip the read-only restriction, nor escalate a downgraded, discovery-only association into an effecting one, without breaking the handshake authentication. An endpoint that requires effecting operations MUST NOT accept the downgrade; it refuses it per the profile invariants (Section 6). The precise mapping of channels and operations to read-only versus effecting is a matter of local and companion-defined policy; the Discovery channel (0x0010) is always read-only, and the core requirement here is that ESTABLISHED_READONLY is a distinct, transcript-bound state that admits no effecting frame.¶

8.4. Transcript

The handshake transcript is a running byte buffer; a transcript hash is H over all bytes absorbed so far. Unlike TLS 1.3 [RFC9846] Section 4.1, which hashes whole handshake messages, N-PAMP absorbs at per-TLV granularity and absorbs only the 2-octet big-endian frame type of each frame: the remaining 34 header octets and the AEAD tag are NOT absorbed. For each frame, the 2-octet frame type is absorbed, followed by each of that frame's TLVs in canonical Type(2) || Length(2) || Value form, in order. Five transcript hashes are named:¶

Because both peers absorb the identical decoded on-wire TLV bytes, their transcripts are byte-identical.¶

8.5. Key Schedule

The key schedule is a single HKDF-Extract [RFC5869] followed by sibling HKDF-Expand-Label derivations (simpler than TLS 1.3 [RFC9846] Section 7.1's three-stage chain; N-PAMP defines no PSK or 0-RTT in this binding). HKDF-Expand-Label is as in TLS 1.3 Section 7.1 with the N-PAMP label prefix "n-pamp " (with the trailing space) in place of "tls13 ":¶

HKDF-Expand-Label(Secret, Label, Context, Length) =
    HKDF-Expand(Secret, HkdfLabel, Length)
HkdfLabel = uint16(Length) || opaque("n-pamp " || Label)
                           || opaque(Context)

The KEM output (Section 7) -- the per-group combined shared secret (64 octets for X25519MLKEM768, 80 octets for SecP384r1MLKEM1024, in the per-group order defined there) -- is fed directly as input keying material. That combined KEM shared secret is the only secret input to the schedule: the HKDF-Extract below is itself the hybrid combiner (a dual-PRF), and there is no separate multi-field combiner value. The KEM public material (encapsulation keys, ciphertexts, and the classical public key) is bound into the schedule through the transcript hash TH_kem -- the context of the c_hs/s_hs derivations -- rather than by folding it into the Extract input:¶

handshake_secret = HKDF-Extract(salt = HashLen zero octets,
                                IKM = per-group combined KEM
                                shared secret)
c_hs_secret = HKDF-Expand-Label(handshake_secret,
                                "c hs", TH_kem, HashLen)
s_hs_secret = HKDF-Expand-Label(handshake_secret,
                                "s hs", TH_kem, HashLen)
master      = HKDF-Expand-Label(handshake_secret,
                                "master", TH_cCV, HashLen)

The Extract salt is HashLen zero octets (the [RFC5869] default). The master secret is derived only at the client-authentication boundary, from TH_cCV. Handshake-phase traffic keys descend from c_hs_secret and s_hs_secret; application-phase traffic keys descend from master, using the traffic-secret construction of Section 7. Because the parents differ, an identical (direction, epoch, suite, channel) tuple yields different (key, iv) across the handshake and application phases, so no (key, nonce) pair is shared across phases.¶

8.6. Authentication

signing_input = (0x20 x 64) || context || 0x00 || transcript_hash
context (server) = "N-PAMP/3, server CertificateVerify"
context (client) = "N-PAMP/3, client CertificateVerify"

finished_key = HKDF-Expand-Label(BaseKey, "finished", "", HashLen)
verify_data  = HMAC(finished_key, transcript_hash)

9.1. Reserved Frame-Type Ranges

All companion frame-type reservations lie within the companion-extension band 0x0030-0x00FF defined in Section 4.7, and each is scoped to a specific channel. The following per-channel frame-type code points are reserved for extensions defined in companion specifications:¶

9.2. Reserved TLV Tags

The TLV types 0x0010, 0x0012, and 0x0013 are reserved for extension TLVs defined in companion specifications; all three are assigned (0x0010 BridgeEnvelope, 0x0012 OpaqueContentType, 0x0013 SafetyLabel -- Section 10.4). TLV type 0x0014 remains reserved for a companion specification but is fixed at 32 octets and handshake-only, so it cannot carry a variable-length extension value. TLV types in the range 0x8000-0xFFFF remain reserved as forward-incompatible extension points per Section 4.¶

9.3. Reserved Channel-ID Range

Channel IDs in the range 0x0014-0xFFFF are reserved. Channels 0x0014-0x001F are reserved for future core additions by this specification; 0x0020-0xEFFF are reserved for extension channels defined in companion specifications; 0xF000-0xFFFE are GREASE values that receivers MUST ignore; and 0xFFFF MUST NOT appear on the wire. The specific extension assignments are out of scope for this document.¶

No algorithms, parameters, or semantics for any reserved range are defined in this document.¶

10.1. ALPN Protocol Identifier

IANA is requested to register the following value in the "TLS Application-Layer Protocol Negotiation (ALPN) Protocol IDs" registry established by [RFC7301]:¶

The identification sequence is the 8-octet UTF-8 string "n-pamp/3". The trailing digit "3" is the N-PAMP crypto generation -- the cryptographic construction (hybrid combiner order, KEM and signature code points). It is an axis independent of the wire-format version: the Ver nibble 0x2 in the frame header (Section 4) identifies the frame layout and is invariant across generations. A raw frame is not generation-self-describing; the generation is fixed by ALPN negotiation, or by explicit configuration where frames are exchanged without TLS. The registration policy for the ALPN registry is Expert Review [RFC8126].¶

The earlier identifiers "n-pamp/1" and "n-pamp/2" are deprecated. Implementations SHOULD NOT negotiate them for new associations. "n-pamp/2" is the prior crypto generation, defined by an earlier revision of this document and superseded by generation 3. Each new crypto generation uses a distinct ALPN identifier (a future generation would use "n-pamp/4").¶

10.2. URI Scheme Registration

The "npamp" URI scheme has been provisionally registered in the "Uniform Resource Identifier (URI) Schemes" registry, following the template and the provisional-registration procedure (First Come First Served) of [RFC7595], under an earlier version of this document; IANA is requested to update its reference to the current version. The registration template follows:¶

Scheme name: npamp¶

Status: Provisional¶

Applications/protocols that use this scheme: The protocol defined in this document (N-PAMP). An "npamp" URI names an N-PAMP endpoint and an optional resource path within that endpoint.¶

URI scheme syntax: The "npamp" scheme uses the generic URI syntax of [RFC3986]:¶

npamp-URI = "npamp://" authority path-abempty [ "?" query ]

where "authority", "path-abempty", and "query" are as defined in [RFC3986]. The "authority" component identifies the N-PAMP endpoint (host and optional port). N-PAMP does not reserve a fixed default port; the underlying transport is negotiated as described in Section 3.¶

Encoding considerations: "npamp" URIs are processed as defined in [RFC3986]; non-ASCII characters in the path or query components are percent-encoded UTF-8 octets.¶

Interoperability considerations: None beyond those of [RFC3986]. The scheme carries no protocol semantics of its own; all behavior is defined by N-PAMP.¶

Security considerations: See Section 11. An "npamp" URI is only an identifier. Connecting to an "npamp" endpoint invokes the N-PAMP handshake and its authentication, confidentiality, and downgrade protections; dereferencing an "npamp" URI MUST NOT bypass the security profile negotiated by N-PAMP.¶

Contact: Shawn Sammartano, BubbleFish Technologies, Inc.¶

Change controller: Shawn Sammartano, BubbleFish Technologies, Inc.¶

Reference: This document.¶

10.3. Registries Maintained by This Specification

The N-PAMP channel registry (Section 5.1), the frame-type registry (Section 4.7), the TLV type registry (Section 10.4), and the error/alert code registry (Section 4.9.1) are defined and maintained within this specification. Because this document is published through the Independent Submission stream, it does not request the creation of new IANA-hosted registries for these code points; the registries are normative within this document and are extended by companion specifications and by future revisions of this document, not by IANA registration actions.¶

10.4. TLV Type Registry

The following TLV tags are defined by this specification. Tags marked "reserved" are described in Section 9.¶

11.1. Hybrid Key Establishment

Every profile uses a hybrid KEM that concatenates an ML-KEM shared secret with an X25519 shared secret [FIPS203] (ML-KEM first) before key derivation. The confidentiality of an association is preserved as long as at least one of the two components remains unbroken; an adversary must defeat both the classical and the post-quantum component to recover traffic keys. N-PAMP makes no claim of unconditional or "quantum-proof" security; it provides post-quantum hybrid security against the adversaries addressed by its component primitives.¶

11.2. Downgrade, Unknown-Key-Share, and Identity Substitution

The negotiated profile, KEM, signature algorithm, AEAD suite(s), and both peer identities are bound into the handshake transcript and confirmed by the Finished MAC (Section 3, Section 6). Altering any negotiated parameter, stripping a profile from the offer, or substituting a peer identity invalidates the Finished MAC and aborts the handshake. The High and Sovereign profiles additionally refuse to complete at a profile below their configured minimum.¶

11.3. Authenticated Encryption and Nonce Management

All payloads are protected by AEAD [RFC5116]. Traffic keys are partitioned per (direction, epoch, suite, channel), which structurally prevents nonce reuse across directions, AEAD suites, and channels. AEAD tag verification MUST be performed before any payload is processed, and equality comparisons of authentication values MUST be constant-time to avoid timing side channels.¶

11.4. Replay

Each (channel, direction) pair maintains a sliding replay window over sequence numbers. The window width SHALL be at least 64 (a floor grounded in the min-32 / preferred-64 precedent of RFC 4303); the RECOMMENDED default is 1024 for multi-core receivers, and a receiver MAY choose a larger window. A frame whose sequence number is below the window, or already recorded within it, MUST be dropped as a replay (the frame is discarded and counted, the connection survives) with the registered error code (replay_detected); in-window out-of-order arrival is NOT a replay and MUST be accepted. The window check-and-record -- testing whether a sequence number has been seen and marking it seen -- MUST be atomic per (channel, direction), so that a duplicate cannot slip through under concurrent receive.¶

This binding defines no 0-RTT / early-data mechanism: there is no PSK or 0-RTT stage in the key schedule (Section 8.5), and no frame, TLV, or key derivation carries early data. There is therefore no early-data replay surface; all application data is protected under the post-handshake epoch keys and covered by the replay window above.¶

11.5. Forward Secrecy and Key Update

Endpoints MUST perform key updates within profile-specific bounds on elapsed time, frames sent, and bytes protected, with the tightest bounds at the Sovereign profile; the concrete per-profile numeric bounds are given in the numeric-bounds section. On key update, the prior epoch's traffic secrets MUST be zeroized so that compromise of the current epoch does not expose previously protected traffic. Key update rotates only the per-epoch traffic secrets derived from the existing master secret; rotation of the master secret itself requires a fresh handshake.¶

11.6. Connection-Level Flow Control

A receiver bounds how much a peer may send it, connection-wide, with the FLOW_UPDATE control frame (0x000A). This is the connection-level tier of a two-level flow-control model that a Multi-stream channel companion composes with its own per-sub-stream credit (for example NPAMP-STREAM's STREAM_WINDOW_UPDATE): the credit a sender may consume at any instant is the smaller of the connection-level limit defined here and any per-sub-stream limit a companion defines.¶

FLOW_UPDATE is an all-channel control frame carried on the Control channel (0x0000). Its body is exactly one 8-octet big-endian unsigned integer -- the sender's new connection-level receive limit: the maximum cumulative count of frame-payload octets (the octets after each 36-octet header, i.e. the frame body and its 16-octet AEAD tag) that the FLOW_UPDATE recipient MAY have transmitted across all application channels since the connection was established. Frames on the Control channel (0x0000) -- the handshake, KEY_UPDATE, FLOW_UPDATE, CLOSE, PING, and the master ratchet -- are exempt and never count against the limit, so a full application-data window can never starve the essential control exchange (a sender can always send a KEY_UPDATE, a CLOSE, or a FLOW_UPDATE of its own). The body is AEAD-sealed like any keyed frame; a FLOW_UPDATE whose body is not exactly 8 octets is malformed and is rejected with unexpected_message.¶

The limit only increases. A FLOW_UPDATE whose value is less than or equal to the current effective limit does not lower it and has no other effect (it MAY be re-sent to re-assert a limit). A limit is never reduced on the wire; to slow a peer, a receiver withholds further FLOW_UPDATE frames.¶

The limit is per direction: each peer advertises its own receive limit and independently tracks the other peer's advertised limit against its own cumulative send total. Before the first FLOW_UPDATE in a direction, the effective limit is the fixed initial connection window in Section 11.7.¶

A sender MUST NOT transmit an application-channel frame that would push its cumulative sent-payload total above the current limit; it waits for a FLOW_UPDATE that raises the limit (a transfer larger than the current window, including a single large frame, therefore requires the receiver to grant credit first). A receiver that observes a peer's cumulative received-payload total exceed the limit it advertised MUST treat it as flow_control_error (fatal, Section 4.9.1) and tear the connection down -- the violation is computable by both sides from the same sealed frames. Flow control bounds volume only; sequence numbers, the replay window, and frame ordering are unaffected.¶

This revision defines the connection-level mechanism and its wire frame. A reference implementation of FLOW_UPDATE emission and enforcement, with conformance vectors, is tracked for the implementation-completeness phase.¶

11.7. Numeric Bounds and Timers

This section collects the operational limits an implementation MUST enforce so that two builds agree on accept/reject and no length or count is a resource-exhaustion surface. Every bound carries a named rejection.¶

The maximum frame size is a receiver-side hardening applied before a frame is opened: because the Payload Length field is a 32-bit value (up to roughly 4 GiB), a receiver MUST reject a frame whose declared total size exceeds 16 MiB before waiting to buffer it, so a hostile length cannot pin the reader.¶

Key-update triggers are per profile. An endpoint MUST perform a key update before the earliest of these bounds is reached, and always before the negotiated AEAD's usage limit (Section 7); the bounds tighten with the profile:¶

These are ceilings; an implementation MAY update sooner. They sit within the AEAD confidentiality and integrity limits ([RFC9846] Section 5.5), so a key is retired well before its safety margin.¶

Each timer is a normative block with all six slots plus an explicit clock granularity. The granularity is 1 ms for every timer, so two implementations differ by at most one tick on any comparison.¶

Handshake completion:¶

• Initial: profile-set (e.g. 10 s). Floor: 1 s. Ceiling: 60 s.¶

• Start: on CLIENT_HELLO. Stop / restart: on ESTABLISHED.¶

• On expiry: abort with handshake_timeout.¶

Idle / liveness:¶

• Initial: profile-set. Floor: none. Ceiling: none.¶

• Start: last frame sent or received. Stop / restart: any frame (restart).¶

• On expiry: send a keepalive (PING) or CLOSE.¶

Key-update-due:¶

• Initial: per-profile bounds above. Floor: none. Ceiling: tightest at Sovereign.¶

• Start: epoch start. Stop / restart: on completing a KEY_UPDATE.¶

• On expiry: trigger a key update.¶

CLOSE_ACK-wait:¶

• Initial: profile-set. Floor: 1 s. Ceiling: 60 s.¶

• Start: on sending CLOSE. Stop / restart: on receiving CLOSE_ACK.¶

• On expiry: force teardown, record close_incomplete.¶

(Protocol timers; clock granularity 1 ms for every timer.)¶

11.8. Anti-Amplification and Reflection

N-PAMP's post-quantum handshake is large and asymmetric: a server's first authentication flight carries the KEMCiphertext (up to 1665 octets at the Sovereign profile), the server IdentityKey (an ML-DSA-87 public key is 2592 octets), and the CertVerify signature (an ML-DSA-87 signature is 4627 octets), so it can be several times the size of the client's opening HELLO. An attacker that spoofs a victim's source address could therefore attempt to use an N-PAMP responder as a reflection/amplification vector against that victim.¶

N-PAMP does not define its own address-validation mechanism; it relies on the address validation of its underlying transport, and MUST NOT be deployed over an unvalidated datagram transport that provides none.¶

• Over QUIC [RFC9000], the transport's anti-amplification limit applies before N-PAMP's authentication flight can reach an unvalidated peer: prior to validating the client address, a server MUST NOT send more than three times as many bytes as it has received from that address ([RFC9000], Section 8.1). Because a Sovereign-profile authentication flight can exceed that budget, QUIC's own address validation (a Retry token, [RFC9000] Section 8.1) gates the large response: it flows only to an address that has already been validated.¶

• Over TCP with TLS 1.3, the peer's address is validated by the TCP three-way handshake before any N-PAMP frame is exchanged, so a responder never sends an authentication flight to an unvalidated address.¶

Deployments therefore rely on the transport's address validation rather than on the first flight fitting within an unvalidated-address budget; an operator MUST NOT carry N-PAMP over a transport that omits address validation.¶

11.9. Connection Migration

When carried over QUIC, an endpoint MUST validate a peer's new path with a challenge-response exchange before accepting an address change, to prevent off-path migration spoofing. The exchange uses the PATH_CHALLENGE (0x0008) and PATH_RESPONSE (0x0009) control frames; path validation is carried by these frames only, never by a TLV.¶

11.10. Authenticated Close

The acknowledged CLOSE / CLOSE_ACK teardown, its timer, and in-flight-frame disposition are specified in the CLOSE Frame section. CLOSE and CLOSE_ACK are AEAD-protected and MUST be verified before being honored, so that an off-path attacker cannot tear down an association with a forged CLOSE.¶

11.11. Extension Points

The reserved code-point ranges in Section 9 carry no algorithms or semantics in this document. Any security properties of extensions occupying those ranges are the responsibility of the companion specifications that define them and are out of scope here.¶

11.12. Implementation Considerations

Where the wire format requires deterministic encoding, implementations MUST follow the Deterministic Encoding Profile (Section 4.6.1) so that identical inputs produce byte-identical output; non-deterministic or non-conformant encodings can invalidate transcript and integrity computations across peers.¶