Skip to main content

hyprstream_rpc/transport/
moql_admission.rs

1//! Inside-carrier challenge/response admission for the iroh `moql` ALPN (#1027).
2//!
3//! # Why this exists
4//!
5//! [`crate::transport::iroh_moq::IrohMoqProtocolHandler`] accepts raw iroh
6//! connections. The carrier handshake authenticates only the **NodeId**, which
7//! is reach evidence and never identity (D3/#895, #1031). Without fresh
8//! inside-carrier proof the accept path must serve an anonymous peer, and the
9//! handler correctly refuses — which means positive native streaming is
10//! impossible by construction. This module is the smallest closed-staging
11//! completion: a challenge/response exchange on the **first bidirectional
12//! stream** of the `moql` connection, run before the connection is wrapped as a
13//! `web_transport_iroh::Session` and handed to `moq_net::Server`.
14//!
15//! # Protocol (one bi stream, length-prefixed frames)
16//!
17//! 1. **Hello** (client → server): wire version, the peer's `did:at9p` DID, its
18//!    Ed25519 verifying key, and a fresh random `client_nonce`.
19//! 2. **Challenge** (server → client): a fresh random `server_nonce` plus the
20//!    client's current accepted-state `epoch` and `head_digest`, and the
21//!    server identity pinned by the signed `StreamInfo` response.
22//! 3. **Response** (client → server): a nested composite signature over the
23//!    transcript — the inner Ed25519 layer signs the transcript `T`, the outer
24//!    ML-DSA-65 layer signs `T ‖ ed_sig` (the same inner→outer nesting the at9p
25//!    record composite uses, `hyprstream-pds::at9p_sign`).
26//! 4. **Confirmation** (server → client, success only): a nested server
27//!    Ed25519 + ML-DSA-65 signature covers every previous frame, including the
28//!    server accepted-state witness and the client's complete hybrid response.
29//!    Only after verifying it may the client start the MoQ handshake. Any
30//!    rejection instead closes the connection.
31//!
32//! The transcript binds domain, ALPN, DID, both nonces, and the accepted-state
33//! epoch/head digest:
34//!
35//! ```text
36//! T = "hyprstream/moql-admission/v1" ‖ 0x00 ‖ "moql" ‖ 0x00
37//!   ‖ u16be(did_len) ‖ did ‖ client_nonce ‖ server_nonce
38//!   ‖ u64be(epoch) ‖ head_digest
39//! ```
40//!
41//! # Admission decision (every step fail-closed)
42//!
43//! - The DID must be a `did:at9p` accepted-state identity; any other DID method
44//!   (including a `did:key` encoding of the carrier NodeId) is rejected.
45//! - The authority must hold a **current** accepted state for the DID, unexpired
46//!   at decision time (expiry class).
47//! - The presented Ed25519 key must be one of the accepted current subject keys
48//!   (`subjectKeys` is a published SET, #1188/#1183); the ML-DSA-65 half verified
49//!   against is the one bound to *that* Ed25519 key by the same entry. A key
50//!   rotated out by a state advance is simply absent (rotation class).
51//! - The state is re-read after the response arrives; an epoch/head change
52//!   mid-handshake rejects (state-advance invalidation).
53//! - Both signature layers must verify; a classical-only or stripped composite
54//!   is a downgrade and rejects.
55//! - A transcript digest already consumed by a prior admission rejects
56//!   (replay class); a replayed response on a new connection additionally fails
57//!   signature verification because the server nonce is fresh per challenge.
58//! - The tenant is resolved server-side from the verified subject by the
59//!   operator-controlled resolver; an unresolvable or malformed tenant rejects
60//!   (never a wildcard, never caller-supplied — the #1153 rule).
61//!
62//! The carrier NodeId is recorded in [`AdmittedMoqPeer::carrier_node_id`] as
63//! metadata only. It is never an admission input.
64//!
65//! # What this module does NOT do
66//!
67//! Open/dynamic federation contract rules remain #1536 (deferred for this
68//! closed, fixed-peer staging claim). Per-track/public-relay policy remains
69//! #276; after admission the existing `tenant_scoped_consumer` structural
70//! narrowing applies unchanged.
71
72use std::collections::HashMap;
73use std::sync::Arc;
74use std::time::Duration;
75
76use ed25519_dalek::{Signature, Signer as _, SigningKey, Verifier as _, VerifyingKey};
77use iroh::endpoint::Connection;
78use parking_lot::Mutex;
79use rand::RngCore as _;
80use sha2::Digest as _;
81use tokio::io::{AsyncRead, AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _};
82
83use crate::crypto::pq::{
84    ml_dsa_sign, ml_dsa_sk_to_vk_bytes, ml_dsa_verify, ml_dsa_vk_from_bytes, MlDsaSigningKey,
85};
86use crate::identity::DID_AT9P_PREFIX;
87use crate::moq_authz::{is_valid_tenant_segment, PeerIdentity};
88use crate::transport::iroh_moq::PeerTenantResolver;
89
90/// Domain separation tag at the head of every admission transcript.
91pub const MOQL_ADMISSION_DOMAIN: &[u8] = b"hyprstream/moql-admission/v1";
92
93/// Wire format version byte. Version 3 binds both locally-observed Iroh
94/// endpoint IDs into the hybrid proof and mutual server confirmation.
95const WIRE_VERSION: u8 = 3;
96
97/// Maximum DID length accepted on the wire (DIDs are short identifiers; a
98/// longer field is a parse error, not a truncation).
99const MAX_DID_BYTES: usize = 256;
100
101/// Maximum admission frame size. The largest legitimate frame is the Response,
102/// dominated by the ML-DSA-65 signature (~3.3 KiB); 8 KiB leaves headroom
103/// without offering an unbounded read.
104const MAX_FRAME_BYTES: usize = 8 * 1024;
105
106/// Default bound on the whole admission exchange. A peer that opens a `moql`
107/// connection and never proves is a slowloris on the accept path; the exchange
108/// must not wait indefinitely.
109pub const DEFAULT_ADMISSION_TIMEOUT: Duration = Duration::from_secs(10);
110
111/// Retention ceiling for consumed transcript digests (replay cache). Recording
112/// costs an attacker a full valid admission, so this grows slowly; at the
113/// ceiling, entries older than the horizon are pruned.
114const REPLAY_CACHE_MAX: usize = 4096;
115
116/// How long a consumed transcript digest is remembered. Far longer than any
117/// admission timeout; bounded so the cache cannot grow without limit.
118const REPLAY_HORIZON: Duration = Duration::from_secs(60 * 60);
119
120/// Why an admission attempt was rejected. Each rejection class named by the
121/// #1027 contract maps to a distinct variant so negative evidence can name the
122/// exact failing check.
123#[derive(Debug, thiserror::Error)]
124pub enum MoqlAdmissionError {
125    /// Carrier-level I/O failure during the exchange.
126    #[error("carrier I/O during moql admission: {0}")]
127    Carrier(String),
128    /// The exchange did not complete within the admission timeout.
129    #[error("moql admission exchange timed out")]
130    Timeout,
131    /// A frame failed to parse (bad version, truncation, oversize, bad UTF-8).
132    #[error("malformed moql admission frame: {0}")]
133    Malformed(String),
134    /// The presented DID is not a `did:at9p` accepted-state identity. A NodeId
135    /// or a `did:key` of it lands here: carrier reach is never identity.
136    #[error("identity {0:?} is not a did:at9p accepted-state identity")]
137    NotAcceptedIdentity(String),
138    /// The daemon-owned authority holds no accepted state for this DID.
139    #[error("no current accepted state for {0:?}")]
140    UnknownIdentity(String),
141    /// The accepted state exists but lapsed before the admission decision.
142    #[error("accepted state for {did:?} expired at {expired_at_unix_ms} (now {now_unix_ms})")]
143    Expired {
144        /// The identity whose accepted state lapsed.
145        did: String,
146        /// The recorded expiry (unix ms).
147        expired_at_unix_ms: i64,
148        /// Decision time (unix ms).
149        now_unix_ms: i64,
150    },
151    /// The presented Ed25519 key is not among the accepted current subject
152    /// keys — e.g. it was rotated out by a state advance.
153    #[error("presented Ed25519 key is not a current accepted subject key of {0:?}")]
154    KeyNotCurrent(String),
155    /// The accepted state advanced (epoch/head changed) while the handshake was
156    /// in flight; the proof was made against a superseded currentness claim.
157    #[error("accepted state for {0:?} advanced during admission")]
158    StateAdvanced(String),
159    /// Ed25519 or ML-DSA-65 layer failed to verify, or a layer was stripped.
160    #[error("hybrid Ed25519 + ML-DSA-65 proof verification failed")]
161    BadSignature,
162    /// The exact transcript digest was already consumed by a prior admission.
163    #[error("moql admission transcript replayed")]
164    Replay,
165    /// The subject verified, but the operator resolver maps it to no tenant.
166    #[error("admitted subject {0:?} has no tenant scope")]
167    TenantUnresolved(String),
168    /// The resolver returned a tenant that is not one MoQ path segment.
169    #[error("resolved tenant {0:?} is not a valid single MoQ path segment")]
170    InvalidTenant(String),
171    /// An admission-enabled server did not have the local private identity
172    /// required to prove possession to the client.
173    #[error("moql server has no accepted-state signing identity")]
174    ServerIdentityUnavailable,
175    /// The server's configured private keys do not match its public,
176    /// resolver-verified accepted-state witness.
177    #[error("moql server signing identity does not match its accepted-state witness")]
178    ServerIdentityMismatch,
179    /// The local server witness expired, advanced, or lost its published key
180    /// pair after startup. It cannot be used to confirm a new or live tunnel.
181    #[error("moql server accepted-state identity is no longer current")]
182    ServerIdentityNotCurrent,
183    /// The remote server's challenge did not carry precisely the witness that
184    /// the signed StreamInfo authenticated for this dial.
185    #[error("moql challenge server identity does not match resolver witness")]
186    WrongServer,
187    /// The server did not provide a valid hybrid signature over the completed
188    /// admission exchange. The client must never proceed to MoQ in this case.
189    #[error("moql server did not mutually confirm the full admission transcript")]
190    ServerUnconfirmed,
191}
192
193/// One accepted current subject key: an atomic Ed25519 ↔ ML-DSA-65 pair as
194/// published in the accepted `subjectKeys` set.
195#[derive(Clone, Debug, PartialEq, Eq)]
196pub struct AcceptedSubjectKey {
197    /// Ed25519 verifying key (32 bytes).
198    pub ed25519: [u8; 32],
199    /// ML-DSA-65 verifying key (encoded form, 1952 bytes).
200    pub ml_dsa_65: Vec<u8>,
201}
202
203/// The accepted current state for one `did:at9p` identity, projected for
204/// admission decisions. This is the admission-relevant slice of the daemon's
205/// `AcceptedAt9pState` (`hyprstream-pds::at9p_duplicity`); the projection lives
206/// at the daemon boundary so this crate keeps no pds dependency.
207#[derive(Clone, Debug, PartialEq, Eq)]
208pub struct AcceptedIdentityState {
209    /// Accepted chain epoch.
210    pub epoch: u64,
211    /// `H512` over the canonical accepted head record.
212    pub head_digest: [u8; 64],
213    /// The accepted current subject keys (a published SET, not positional).
214    pub subject_keys: Vec<AcceptedSubjectKey>,
215    /// The accepted capsule's `#<name>` service entry ids, projected verbatim
216    /// so admission-side DID → deployment-service-name derivation (#1652)
217    /// needs zero extra store reads. Empty when the capsule carries no service
218    /// entries; foreign records may carry ids that match no deployment service
219    /// (consumers apply their own factory-roster membership filter).
220    pub service_ids: Vec<String>,
221    /// Successor expiry (unix ms). `None` = genesis, current until a successor
222    /// is accepted (mirrors `AcceptedAt9pState::ensure_fresh`).
223    pub expires_at_unix_ms: Option<i64>,
224}
225
226impl AcceptedIdentityState {
227    /// The published subject key whose Ed25519 half equals `ed25519`, if any.
228    /// Set membership, never positional (#1188/#1183).
229    pub fn subject_key_for(&self, ed25519: &[u8; 32]) -> Option<&AcceptedSubjectKey> {
230        self.subject_keys.iter().find(|k| &k.ed25519 == ed25519)
231    }
232
233    /// Whether the state is live at `now_unix_ms` (genesis never lapses).
234    pub fn is_live(&self, now_unix_ms: i64) -> bool {
235        match self.expires_at_unix_ms {
236            Some(exp) => now_unix_ms < exp,
237            None => true,
238        }
239    }
240}
241
242/// The daemon-owned accepted-state/currentness authority.
243///
244/// Queried at admission time — never snapshotted into the authenticator — so a
245/// state advance (rotation) or lapse between admissions takes effect
246/// immediately. Implemented by the daemon over its accepted-state store
247/// (`DiscoveryService` / `DuplicityGuard` in the `hyprstream` crate); the
248/// blanket `Fn` impl covers closed-staging fixtures and simple adapters.
249pub trait AcceptedStateAuthority: Send + Sync {
250    /// The current accepted state for `did`, or `None` if the identity is
251    /// unknown or has no accepted head.
252    fn accepted_state(&self, did: &str) -> Option<AcceptedIdentityState>;
253}
254
255impl<F> AcceptedStateAuthority for F
256where
257    F: Fn(&str) -> Option<AcceptedIdentityState> + Send + Sync,
258{
259    fn accepted_state(&self, did: &str) -> Option<AcceptedIdentityState> {
260        self(did)
261    }
262}
263
264/// The outcome of a successful admission: a typed admitted subject and tenant
265/// from current accepted Ed25519 + ML-DSA-65 evidence.
266#[derive(Debug, Clone)]
267pub struct AdmittedMoqPeer {
268    /// The authenticated application subject (the `did:at9p` DID).
269    pub peer: PeerIdentity,
270    /// Server-resolved tenant for the verified subject (authoritative
271    /// server-side state, never caller-supplied).
272    pub tenant: String,
273    /// Accepted-state epoch the proof was verified against.
274    pub epoch: u64,
275    /// Accepted-state head digest the proof was verified against.
276    pub head_digest: [u8; 64],
277    /// The accepted current Ed25519 key that proved possession. Retained with
278    /// the tunnel witness so an active session can be invalidated if that key
279    /// is rotated out without changing the tenant mapping.
280    pub subject_ed25519: [u8; 32],
281    /// The carrier NodeId, recorded as metadata only. Never an identity input.
282    pub carrier_node_id: [u8; 32],
283}
284
285// ────────────────────────────────────────────────────────────────────────────
286// Wire frames (the `moql` admission wire contract; public so peers and tests
287// can construct/parse them without private access)
288// ────────────────────────────────────────────────────────────────────────────
289
290/// Hello (client → server): claimed identity + freshness contribution.
291#[derive(Clone, Debug, PartialEq, Eq)]
292pub struct AdmissionHello {
293    /// The peer's `did:at9p` DID.
294    pub did: String,
295    /// The peer's Ed25519 verifying key; must be a current accepted subject key.
296    pub ed25519_pub: [u8; 32],
297    /// Fresh random client nonce.
298    pub client_nonce: [u8; 32],
299}
300
301/// Challenge (server → client): server freshness + currentness claim.
302#[derive(Clone, Debug, PartialEq)]
303pub struct AdmissionChallenge {
304    /// Fresh random server nonce, single-use per connection.
305    pub server_nonce: [u8; 32],
306    /// The server's current accepted-state epoch for the DID.
307    pub epoch: u64,
308    /// The server's current accepted-state head digest for the DID.
309    pub head_digest: [u8; 64],
310    /// The server accepted-state identity expected by this client from the
311    /// signed StreamInfo response. It is signed in the final confirmation.
312    pub server_identity: crate::stream_info::MoqlServerIdentity,
313}
314
315/// Response (client → server): the nested composite proof.
316#[derive(Clone, Debug, PartialEq, Eq)]
317pub struct AdmissionResponse {
318    /// Ed25519 signature over the transcript `T`.
319    pub ed_sig: [u8; 64],
320    /// ML-DSA-65 signature over `T ‖ ed_sig` (inner→outer nesting).
321    pub pq_sig: Vec<u8>,
322}
323
324/// Server → client mutual confirmation. Both signature halves cover every
325/// admission frame: hello, challenge (including the server accepted-state
326/// witness), and the client's nested hybrid response.
327#[derive(Clone, Debug, PartialEq, Eq)]
328pub struct AdmissionConfirmation {
329    /// Ed25519 signature over [`mutual_confirmation_transcript`].
330    pub ed_sig: [u8; 64],
331    /// ML-DSA-65 signature over the transcript followed by `ed_sig`.
332    pub pq_sig: Vec<u8>,
333}
334
335/// Verdict (server → client), sent only on success: the session is admitted
336/// and the moq handshake may proceed. Rejection closes the connection without
337/// a verdict — the failure detail stays server-side (fail-closed, no oracle).
338pub const VERDICT_ADMITTED: u8 = 1;
339
340/// Encode the admission verdict frame payload.
341pub fn encode_verdict() -> Vec<u8> {
342    vec![WIRE_VERSION, VERDICT_ADMITTED]
343}
344
345/// Decode and check a verdict frame payload.
346pub fn decode_verdict(bytes: &[u8]) -> Result<(), MoqlAdmissionError> {
347    if bytes == encode_verdict() {
348        Ok(())
349    } else {
350        Err(MoqlAdmissionError::Malformed(
351            "verdict: not an admission verdict".to_owned(),
352        ))
353    }
354}
355
356/// Canonical public encoding of a resolver-verified server identity. It is
357/// deliberately included in both the challenge and the signed confirmation so
358/// a carrier peer cannot substitute a server between RPC resolution and MoQ.
359fn encode_server_identity(identity: &crate::stream_info::MoqlServerIdentity) -> Vec<u8> {
360    let mut out =
361        Vec::with_capacity(2 + identity.did.len() + 8 + 64 + 8 + 32 + 2 + identity.ml_dsa65.len());
362    out.extend_from_slice(&(identity.did.len() as u16).to_be_bytes());
363    out.extend_from_slice(identity.did.as_bytes());
364    out.extend_from_slice(&identity.epoch.to_be_bytes());
365    out.extend_from_slice(&identity.head_digest);
366    out.extend_from_slice(&identity.expires_at_unix_ms.to_be_bytes());
367    out.extend_from_slice(&identity.ed25519);
368    out.extend_from_slice(&(identity.ml_dsa65.len() as u16).to_be_bytes());
369    out.extend_from_slice(&identity.ml_dsa65);
370    out
371}
372
373fn decode_server_identity(
374    bytes: &[u8],
375) -> Result<crate::stream_info::MoqlServerIdentity, MoqlAdmissionError> {
376    let malformed = |why: &str| MoqlAdmissionError::Malformed(format!("server identity: {why}"));
377    if bytes.len() < 2 {
378        return Err(malformed("truncated DID length"));
379    }
380    let did_len = u16::from_be_bytes([bytes[0], bytes[1]]) as usize;
381    if did_len == 0 || did_len > MAX_DID_BYTES || bytes.len() < 2 + did_len + 8 + 64 + 8 + 32 + 2 {
382        return Err(malformed("invalid DID length or truncated fields"));
383    }
384    let did = std::str::from_utf8(&bytes[2..2 + did_len])
385        .map_err(|_| malformed("DID is not UTF-8"))?
386        .to_owned();
387    let offset = 2 + did_len;
388    let mut epoch = [0u8; 8];
389    epoch.copy_from_slice(&bytes[offset..offset + 8]);
390    let mut head_digest = vec![0u8; 64];
391    head_digest.copy_from_slice(&bytes[offset + 8..offset + 72]);
392    let mut expiry = [0u8; 8];
393    expiry.copy_from_slice(&bytes[offset + 72..offset + 80]);
394    let mut ed25519 = [0u8; 32];
395    ed25519.copy_from_slice(&bytes[offset + 80..offset + 112]);
396    let pq_len = u16::from_be_bytes([bytes[offset + 112], bytes[offset + 113]]) as usize;
397    let pq = &bytes[offset + 114..];
398    if pq_len == 0 || pq_len != pq.len() {
399        return Err(malformed("ML-DSA-65 length mismatch or empty"));
400    }
401    Ok(crate::stream_info::MoqlServerIdentity {
402        did,
403        epoch: u64::from_be_bytes(epoch),
404        head_digest,
405        expires_at_unix_ms: i64::from_be_bytes(expiry),
406        ed25519,
407        ml_dsa65: pq.to_vec(),
408    })
409}
410
411/// The signed transcript both sides reconstruct byte-identically.
412pub fn admission_transcript(
413    did: &str,
414    client_nonce: &[u8; 32],
415    server_nonce: &[u8; 32],
416    epoch: u64,
417    head_digest: &[u8; 64],
418    client_carrier_node_id: &[u8; 32],
419    server_carrier_node_id: &[u8; 32],
420) -> Vec<u8> {
421    let mut t = Vec::with_capacity(
422        MOQL_ADMISSION_DOMAIN.len() + 1 + 4 + 1 + 2 + did.len() + 32 + 32 + 8 + 64 + 32 + 32,
423    );
424    t.extend_from_slice(MOQL_ADMISSION_DOMAIN);
425    t.push(0);
426    t.extend_from_slice(crate::transport::iroh_substrate::ALPN_MOQ_LITE);
427    t.push(0);
428    t.extend_from_slice(&(did.len() as u16).to_be_bytes());
429    t.extend_from_slice(did.as_bytes());
430    t.extend_from_slice(client_nonce);
431    t.extend_from_slice(server_nonce);
432    t.extend_from_slice(&epoch.to_be_bytes());
433    t.extend_from_slice(head_digest);
434    t.extend_from_slice(client_carrier_node_id);
435    t.extend_from_slice(server_carrier_node_id);
436    t
437}
438
439/// The complete mutually-confirmed admission transcript. Unlike the client
440/// proof's preface, this includes the advertised server accepted-state witness
441/// and the client's two signature layers, so the server cannot be substituted
442/// after the client proves possession.
443pub fn mutual_confirmation_transcript(
444    hello: &AdmissionHello,
445    challenge: &AdmissionChallenge,
446    response: &AdmissionResponse,
447    client_carrier_node_id: &[u8; 32],
448    server_carrier_node_id: &[u8; 32],
449) -> Vec<u8> {
450    let client = admission_transcript(
451        &hello.did,
452        &hello.client_nonce,
453        &challenge.server_nonce,
454        challenge.epoch,
455        &challenge.head_digest,
456        client_carrier_node_id,
457        server_carrier_node_id,
458    );
459    let server = encode_server_identity(&challenge.server_identity);
460    let response = encode_response(response);
461    let mut out = Vec::with_capacity(
462        MOQL_ADMISSION_DOMAIN.len() + 1 + client.len() + 4 + server.len() + 4 + response.len(),
463    );
464    out.extend_from_slice(MOQL_ADMISSION_DOMAIN);
465    out.extend_from_slice(b"/mutual-confirm/v1\0");
466    out.extend_from_slice(&(client.len() as u32).to_be_bytes());
467    out.extend_from_slice(&client);
468    out.extend_from_slice(&(server.len() as u32).to_be_bytes());
469    out.extend_from_slice(&server);
470    out.extend_from_slice(&(response.len() as u32).to_be_bytes());
471    out.extend_from_slice(&response);
472    out
473}
474
475/// The replay-cache key for a transcript.
476fn transcript_digest(t: &[u8]) -> [u8; 32] {
477    let mut h = sha2::Sha256::new();
478    h.update(MOQL_ADMISSION_DOMAIN);
479    h.update(t);
480    h.finalize().into()
481}
482
483/// Encode a Hello frame payload.
484pub fn encode_hello(hello: &AdmissionHello) -> Vec<u8> {
485    let mut out = Vec::with_capacity(1 + 2 + hello.did.len() + 32 + 32);
486    out.push(WIRE_VERSION);
487    out.extend_from_slice(&(hello.did.len() as u16).to_be_bytes());
488    out.extend_from_slice(hello.did.as_bytes());
489    out.extend_from_slice(&hello.ed25519_pub);
490    out.extend_from_slice(&hello.client_nonce);
491    out
492}
493
494/// Decode a Hello frame payload.
495pub fn decode_hello(bytes: &[u8]) -> Result<AdmissionHello, MoqlAdmissionError> {
496    let malformed = |why: &str| MoqlAdmissionError::Malformed(format!("hello: {why}"));
497    let (version, rest) = bytes.split_first().ok_or_else(|| malformed("empty"))?;
498    if *version != WIRE_VERSION {
499        return Err(malformed("unsupported wire version"));
500    }
501    if rest.len() < 2 {
502        return Err(malformed("missing did length"));
503    }
504    let did_len = u16::from_be_bytes([rest[0], rest[1]]) as usize;
505    if did_len == 0 || did_len > MAX_DID_BYTES {
506        return Err(malformed("did length out of range"));
507    }
508    let rest = &rest[2..];
509    if rest.len() != did_len + 32 + 32 {
510        return Err(malformed("trailing bytes or truncation"));
511    }
512    let did = std::str::from_utf8(&rest[..did_len])
513        .map_err(|_| malformed("did is not UTF-8"))?
514        .to_owned();
515    let mut ed25519_pub = [0u8; 32];
516    ed25519_pub.copy_from_slice(&rest[did_len..did_len + 32]);
517    let mut client_nonce = [0u8; 32];
518    client_nonce.copy_from_slice(&rest[did_len + 32..]);
519    Ok(AdmissionHello {
520        did,
521        ed25519_pub,
522        client_nonce,
523    })
524}
525
526/// Encode a Challenge frame payload.
527pub fn encode_challenge(challenge: &AdmissionChallenge) -> Vec<u8> {
528    let identity = encode_server_identity(&challenge.server_identity);
529    let mut out = Vec::with_capacity(1 + 32 + 8 + 64 + 2 + identity.len());
530    out.push(WIRE_VERSION);
531    out.extend_from_slice(&challenge.server_nonce);
532    out.extend_from_slice(&challenge.epoch.to_be_bytes());
533    out.extend_from_slice(&challenge.head_digest);
534    out.extend_from_slice(&(identity.len() as u16).to_be_bytes());
535    out.extend_from_slice(&identity);
536    out
537}
538
539/// Decode a Challenge frame payload.
540pub fn decode_challenge(bytes: &[u8]) -> Result<AdmissionChallenge, MoqlAdmissionError> {
541    let malformed = |why: &str| MoqlAdmissionError::Malformed(format!("challenge: {why}"));
542    let (version, rest) = bytes.split_first().ok_or_else(|| malformed("empty"))?;
543    if *version != WIRE_VERSION {
544        return Err(malformed("unsupported wire version"));
545    }
546    if rest.len() < 32 + 8 + 64 + 2 {
547        return Err(malformed("bad length"));
548    }
549    let mut server_nonce = [0u8; 32];
550    server_nonce.copy_from_slice(&rest[..32]);
551    let mut epoch = [0u8; 8];
552    epoch.copy_from_slice(&rest[32..40]);
553    let mut head_digest = [0u8; 64];
554    head_digest.copy_from_slice(&rest[40..104]);
555    let identity_len = u16::from_be_bytes([rest[104], rest[105]]) as usize;
556    let identity = &rest[106..];
557    if identity_len != identity.len() {
558        return Err(malformed("server identity length mismatch"));
559    }
560    Ok(AdmissionChallenge {
561        server_nonce,
562        epoch: u64::from_be_bytes(epoch),
563        head_digest,
564        server_identity: decode_server_identity(identity)?,
565    })
566}
567
568/// Encode a Response frame payload.
569pub fn encode_response(response: &AdmissionResponse) -> Vec<u8> {
570    let mut out = Vec::with_capacity(1 + 64 + 2 + response.pq_sig.len());
571    out.push(WIRE_VERSION);
572    out.extend_from_slice(&response.ed_sig);
573    out.extend_from_slice(&(response.pq_sig.len() as u16).to_be_bytes());
574    out.extend_from_slice(&response.pq_sig);
575    out
576}
577
578/// Decode a Response frame payload.
579pub fn decode_response(bytes: &[u8]) -> Result<AdmissionResponse, MoqlAdmissionError> {
580    let malformed = |why: &str| MoqlAdmissionError::Malformed(format!("response: {why}"));
581    let (version, rest) = bytes.split_first().ok_or_else(|| malformed("empty"))?;
582    if *version != WIRE_VERSION {
583        return Err(malformed("unsupported wire version"));
584    }
585    if rest.len() < 64 + 2 {
586        return Err(malformed("truncated"));
587    }
588    let mut ed_sig = [0u8; 64];
589    ed_sig.copy_from_slice(&rest[..64]);
590    let pq_len = u16::from_be_bytes([rest[64], rest[65]]) as usize;
591    let pq_sig = &rest[66..];
592    if pq_sig.len() != pq_len || pq_len == 0 {
593        return Err(malformed("pq signature length mismatch or empty"));
594    }
595    Ok(AdmissionResponse {
596        ed_sig,
597        pq_sig: pq_sig.to_vec(),
598    })
599}
600
601/// Encode a hybrid server confirmation frame.
602pub fn encode_confirmation(confirmation: &AdmissionConfirmation) -> Vec<u8> {
603    encode_response(&AdmissionResponse {
604        ed_sig: confirmation.ed_sig,
605        pq_sig: confirmation.pq_sig.clone(),
606    })
607}
608
609/// Decode a hybrid server confirmation frame.
610pub fn decode_confirmation(bytes: &[u8]) -> Result<AdmissionConfirmation, MoqlAdmissionError> {
611    let response = decode_response(bytes)?;
612    Ok(AdmissionConfirmation {
613        ed_sig: response.ed_sig,
614        pq_sig: response.pq_sig,
615    })
616}
617
618async fn write_frame<W: AsyncWrite + Unpin>(
619    w: &mut W,
620    payload: &[u8],
621) -> Result<(), MoqlAdmissionError> {
622    if payload.len() > MAX_FRAME_BYTES {
623        return Err(MoqlAdmissionError::Malformed(
624            "outbound frame exceeds the size cap".to_owned(),
625        ));
626    }
627    w.write_all(&(payload.len() as u32).to_be_bytes())
628        .await
629        .map_err(|e| MoqlAdmissionError::Carrier(e.to_string()))?;
630    w.write_all(payload)
631        .await
632        .map_err(|e| MoqlAdmissionError::Carrier(e.to_string()))
633}
634
635async fn read_frame<R: AsyncRead + Unpin>(r: &mut R) -> Result<Vec<u8>, MoqlAdmissionError> {
636    let mut len = [0u8; 4];
637    r.read_exact(&mut len)
638        .await
639        .map_err(|e| MoqlAdmissionError::Carrier(format!("frame length read: {e}")))?;
640    let len = u32::from_be_bytes(len) as usize;
641    if len == 0 || len > MAX_FRAME_BYTES {
642        return Err(MoqlAdmissionError::Malformed(format!(
643            "frame length {len} out of range"
644        )));
645    }
646    let mut buf = vec![0u8; len];
647    r.read_exact(&mut buf)
648        .await
649        .map_err(|e| MoqlAdmissionError::Carrier(format!("frame body read: {e}")))?;
650    Ok(buf)
651}
652
653fn fresh_nonce() -> [u8; 32] {
654    let mut n = [0u8; 32];
655    rand::thread_rng().fill_bytes(&mut n);
656    n
657}
658
659// ────────────────────────────────────────────────────────────────────────────
660// Server side: the authenticator
661// ────────────────────────────────────────────────────────────────────────────
662
663/// Inside-carrier admission authenticator for the `moql` accept path.
664///
665/// Constructed with the daemon-owned [`AcceptedStateAuthority`] and the
666/// operator-controlled subject→tenant resolver, then installed on the handler
667/// via
668/// [`crate::transport::iroh_moq::MoqAuthzConfig::with_admission`]. With no
669/// authenticator installed the accept path keeps its pre-#1027 posture
670/// (anonymous ⇒ refused).
671#[derive(Clone)]
672pub struct MoqlServerIdentityProof {
673    /// The public resolver-verified state this server must prove possession of.
674    pub identity: crate::stream_info::MoqlServerIdentity,
675    /// Private Ed25519 half corresponding to `identity.ed25519`.
676    pub ed25519: SigningKey,
677    /// Private ML-DSA-65 half corresponding to `identity.ml_dsa65`.
678    pub ml_dsa_65: MlDsaSigningKey,
679}
680
681impl MoqlServerIdentityProof {
682    /// Construct the server confirmation material from the same checkpointed
683    /// local identity already used for native client admission. This does not
684    /// create a credential: both public keys must exactly match the accepted
685    /// witness captured by the native announcement.
686    pub fn from_local_admission_proof(
687        proof: &MoqlAdmissionProof,
688    ) -> Result<Self, MoqlAdmissionError> {
689        let identity = proof.expected_server.clone();
690        if !identity.did.starts_with(DID_AT9P_PREFIX)
691            || identity.did.len() > MAX_DID_BYTES
692            || identity.epoch == 0
693            || identity.head_digest.len() != 64
694            || identity.ml_dsa65.is_empty()
695            || identity.ml_dsa65.len() > u16::MAX as usize
696            || identity.expires_at_unix_ms <= crate::envelope::current_timestamp()
697            || identity.ed25519 != proof.ed25519.verifying_key().to_bytes()
698            || identity.ml_dsa65 != ml_dsa_sk_to_vk_bytes(&proof.ml_dsa_65)
699        {
700            return Err(MoqlAdmissionError::ServerIdentityMismatch);
701        }
702        Ok(Self {
703            identity,
704            ed25519: proof.ed25519.clone(),
705            ml_dsa_65: proof.ml_dsa_65.clone(),
706        })
707    }
708
709    fn sign(
710        &self,
711        hello: &AdmissionHello,
712        challenge: &AdmissionChallenge,
713        response: &AdmissionResponse,
714        client_carrier_node_id: &[u8; 32],
715        server_carrier_node_id: &[u8; 32],
716    ) -> AdmissionConfirmation {
717        let transcript = mutual_confirmation_transcript(
718            hello,
719            challenge,
720            response,
721            client_carrier_node_id,
722            server_carrier_node_id,
723        );
724        let ed_sig: [u8; 64] = self.ed25519.sign(&transcript).to_bytes();
725        let mut outer = transcript;
726        outer.extend_from_slice(&ed_sig);
727        AdmissionConfirmation {
728            ed_sig,
729            pq_sig: ml_dsa_sign(&self.ml_dsa_65, &outer),
730        }
731    }
732}
733
734pub struct MoqlAdmissionAuthenticator {
735    authority: Arc<dyn AcceptedStateAuthority>,
736    tenant_resolver: PeerTenantResolver,
737    timeout: Duration,
738    /// Consumed transcript digests → the unix-ms after which the record may be
739    /// dropped. Makes each accepted transcript single-use.
740    used: Mutex<HashMap<[u8; 32], i64>>,
741    /// The server's private accepted identity for the mutual confirmation.
742    /// Absence is fail-closed on every admission exchange.
743    server_identity: Mutex<Option<MoqlServerIdentityProof>>,
744    /// Locally observed Iroh endpoint ID for this server. This is carrier
745    /// binding only, never application identity or policy authority.
746    server_carrier_node_id: Mutex<Option<[u8; 32]>>,
747}
748
749impl std::fmt::Debug for MoqlAdmissionAuthenticator {
750    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
751        f.debug_struct("MoqlAdmissionAuthenticator")
752            .field("timeout", &self.timeout)
753            .finish_non_exhaustive()
754    }
755}
756
757impl MoqlAdmissionAuthenticator {
758    /// Build with the accepted-state authority and subject→tenant resolver.
759    pub fn new(
760        authority: Arc<dyn AcceptedStateAuthority>,
761        tenant_resolver: PeerTenantResolver,
762    ) -> Self {
763        Self {
764            authority,
765            tenant_resolver,
766            timeout: DEFAULT_ADMISSION_TIMEOUT,
767            used: Mutex::new(HashMap::new()),
768            server_identity: Mutex::new(None),
769            server_carrier_node_id: Mutex::new(None),
770        }
771    }
772
773    /// Share live authority, isolating each service's carrier identity and replay cache.
774    pub fn for_server(&self) -> Self {
775        Self::new(
776            Arc::clone(&self.authority),
777            Arc::clone(&self.tenant_resolver),
778        )
779        .with_timeout(self.timeout)
780    }
781
782    /// Install the local accepted-state identity that signs server confirmation
783    /// frames. A bare authenticator remains useful for unit decision tests but
784    /// cannot admit a network tunnel.
785    #[must_use]
786    pub fn with_server_identity_and_carrier(
787        mut self,
788        server_identity: MoqlServerIdentityProof,
789        server_carrier_node_id: [u8; 32],
790    ) -> Self {
791        self.server_identity = Mutex::new(Some(server_identity));
792        self.server_carrier_node_id = Mutex::new(Some(server_carrier_node_id));
793        self
794    }
795
796    /// Attach the local confirmation proof at the service-spawner boundary.
797    /// A caller that already supplied one must agree on the same public
798    /// accepted-state identity; silently replacing it would make configuration
799    /// order an authentication decision.
800    pub fn install_server_identity(
801        &self,
802        server_identity: MoqlServerIdentityProof,
803        server_carrier_node_id: [u8; 32],
804    ) -> Result<(), MoqlAdmissionError> {
805        let mut installed = self.server_identity.lock();
806        match installed.as_ref() {
807            Some(existing) if existing.identity != server_identity.identity => {
808                Err(MoqlAdmissionError::ServerIdentityMismatch)
809            }
810            Some(_) => Ok(()),
811            None => {
812                *installed = Some(server_identity);
813                *self.server_carrier_node_id.lock() = Some(server_carrier_node_id);
814                Ok(())
815            }
816        }
817    }
818
819    /// Override the admission exchange timeout (bounded slowloris window).
820    #[must_use]
821    pub fn with_timeout(mut self, timeout: Duration) -> Self {
822        self.timeout = timeout;
823        self
824    }
825
826    /// Run the challenge/response on `conn`'s first bi stream. On success,
827    /// returns the typed admitted peer; on any failure the caller MUST close
828    /// the connection (fail-closed) and serve nothing.
829    pub async fn accept(&self, conn: &Connection) -> Result<AdmittedMoqPeer, MoqlAdmissionError> {
830        match tokio::time::timeout(self.timeout, self.exchange(conn)).await {
831            Ok(res) => res,
832            Err(_) => Err(MoqlAdmissionError::Timeout),
833        }
834    }
835
836    async fn exchange(&self, conn: &Connection) -> Result<AdmittedMoqPeer, MoqlAdmissionError> {
837        let carrier_node_id = *conn.remote_id().as_bytes();
838        let server_carrier_node_id = self
839            .server_carrier_node_id
840            .lock()
841            .as_ref()
842            .copied()
843            .ok_or(MoqlAdmissionError::ServerIdentityUnavailable)?;
844        let server_identity = self
845            .server_identity
846            .lock()
847            .clone()
848            .ok_or(MoqlAdmissionError::ServerIdentityUnavailable)?;
849        if !self.is_server_identity_current(&server_identity) {
850            return Err(MoqlAdmissionError::ServerIdentityNotCurrent);
851        }
852        // Advertise the CURRENT accepted epoch/head in the challenge, not the
853        // startup-pinned snapshot — see [`Self::project_server_identity`].
854        let advertised_identity = self.project_server_identity(&server_identity)?;
855        let (mut send, mut recv) = conn
856            .accept_bi()
857            .await
858            .map_err(|e| MoqlAdmissionError::Carrier(format!("accept_bi: {e}")))?;
859
860        // ── Hello ────────────────────────────────────────────────────────────
861        let hello = decode_hello(&read_frame(&mut recv).await?)?;
862        let state = self.check_hello(&hello)?;
863
864        // ── Challenge ────────────────────────────────────────────────────────
865        let challenge = AdmissionChallenge {
866            server_nonce: fresh_nonce(),
867            epoch: state.epoch,
868            head_digest: state.head_digest,
869            server_identity: advertised_identity,
870        };
871        write_frame(&mut send, &encode_challenge(&challenge)).await?;
872
873        // ── Response ─────────────────────────────────────────────────────────
874        let response = decode_response(&read_frame(&mut recv).await?)?;
875        let now = crate::envelope::current_timestamp();
876        self.verify_response_bound(
877            &hello,
878            &challenge,
879            &response,
880            now,
881            &carrier_node_id,
882            &server_carrier_node_id,
883        )?;
884        // The server witness is a live authorization fact too. Re-read it
885        // after the client response so an expiry or state advance while this
886        // exchange was in flight cannot receive a valid confirmation.
887        if !self.is_server_identity_current(&server_identity) {
888            return Err(MoqlAdmissionError::ServerIdentityNotCurrent);
889        }
890
891        // ── Tenant binding (server-side, from the verified subject) ──────────
892        let peer = PeerIdentity::authenticated(hello.did.clone());
893        let tenant = (self.tenant_resolver)(&peer)
894            .ok_or_else(|| MoqlAdmissionError::TenantUnresolved(hello.did.clone()))?;
895        if !is_valid_tenant_segment(&tenant) {
896            return Err(MoqlAdmissionError::InvalidTenant(tenant));
897        }
898        // Only after client proof verification does the server prove possession
899        // of the resolver-pinned server identity over the *entire* exchange.
900        // A bare verdict would be forgeable by an on-path wrong server.
901        let confirmation = server_identity.sign(
902            &hello,
903            &challenge,
904            &response,
905            &carrier_node_id,
906            &server_carrier_node_id,
907        );
908        write_frame(&mut send, &encode_confirmation(&confirmation)).await?;
909        send.finish()
910            .map_err(|e| MoqlAdmissionError::Carrier(format!("finish: {e}")))?;
911        Ok(AdmittedMoqPeer {
912            peer,
913            tenant,
914            epoch: state.epoch,
915            head_digest: state.head_digest,
916            subject_ed25519: hello.ed25519_pub,
917            carrier_node_id,
918        })
919    }
920
921    /// Whether a previously admitted tunnel remains bound to the same live
922    /// accepted state. This deliberately re-reads the daemon-owned authority:
923    /// session admission is not a permanent capability after a state advance,
924    /// key rotation, expiry, or withdrawal.
925    pub fn is_still_current(&self, admitted: &AdmittedMoqPeer) -> bool {
926        let server_identity = self.server_identity.lock().clone();
927        let Some(current) = admitted
928            .peer
929            .subject
930            .as_deref()
931            .and_then(|did| self.authority.accepted_state(did))
932        else {
933            return false;
934        };
935        current.is_live(crate::envelope::current_timestamp())
936            && current.epoch == admitted.epoch
937            && current.head_digest == admitted.head_digest
938            && current.subject_key_for(&admitted.subject_ed25519).is_some()
939            // Tenant assignment is live deployment authority: removal or
940            // reassignment closes a previously admitted scoped session.
941            && (self.tenant_resolver)(&admitted.peer).as_deref() == Some(admitted.tenant.as_str())
942            && server_identity
943                .as_ref()
944                .is_some_and(|server| self.is_server_identity_current(server))
945    }
946
947    fn is_server_identity_current(&self, server: &MoqlServerIdentityProof) -> bool {
948        let Some(current) = self.authority.accepted_state(&server.identity.did) else {
949            return false;
950        };
951        if server.identity.head_digest.len() != 64 {
952            return false;
953        }
954        // Possession of the still-accepted subject keys IS the currency
955        // property. The in-daemon at9p renewal timer advances epoch/head
956        // while carrying the SAME subject keys forward, so a proof installed
957        // at process start stays current across routine renewals; a genuine
958        // key rotation removes those keys from the accepted set and still
959        // fails here, fail-closed. The monotonic epoch guard rejects any
960        // authority regression (a proof from an epoch the store no longer
961        // reaches).
962        current.is_live(crate::envelope::current_timestamp())
963            && server.identity.epoch <= current.epoch
964            && current
965                .subject_key_for(&server.identity.ed25519)
966                .is_some_and(|key| key.ml_dsa_65 == server.identity.ml_dsa65)
967    }
968
969    /// The server identity to advertise in the admission challenge: the
970    /// installed proof's keys projected onto the CURRENT accepted epoch,
971    /// head digest, and expiry. Clients re-project their expected server
972    /// identity from the live accepted state on their link-refresh loop, so
973    /// advertising a startup-pinned epoch after a renewal would mismatch
974    /// every refreshed client forever; advertising the current state
975    /// converges with them. The signing keys never change across renewals
976    /// (the same on-volume key carries forward), so the proof's signatures
977    /// remain valid over the projected identity.
978    fn project_server_identity(
979        &self,
980        server: &MoqlServerIdentityProof,
981    ) -> Result<crate::stream_info::MoqlServerIdentity, MoqlAdmissionError> {
982        let current = self
983            .authority
984            .accepted_state(&server.identity.did)
985            .ok_or(MoqlAdmissionError::ServerIdentityNotCurrent)?;
986        if !self.is_server_identity_current(server) {
987            return Err(MoqlAdmissionError::ServerIdentityNotCurrent);
988        }
989        Ok(crate::stream_info::MoqlServerIdentity {
990            did: server.identity.did.clone(),
991            epoch: current.epoch,
992            head_digest: current.head_digest.to_vec(),
993            // Genesis never lapses; successors always carry a bounded expiry
994            // that both sides project from the same accepted state.
995            expires_at_unix_ms: current.expires_at_unix_ms.unwrap_or(i64::MAX),
996            ed25519: server.identity.ed25519,
997            ml_dsa65: server.identity.ml_dsa65.clone(),
998        })
999    }
1000
1001    /// The hello-time decision: identity class, currentness, expiry, and
1002    /// subject-key membership (including that the bound ML-DSA-65 key
1003    /// decodes). Returns the accepted state the challenge will bind.
1004    fn check_hello(
1005        &self,
1006        hello: &AdmissionHello,
1007    ) -> Result<AcceptedIdentityState, MoqlAdmissionError> {
1008        if !hello.did.starts_with(DID_AT9P_PREFIX) {
1009            return Err(MoqlAdmissionError::NotAcceptedIdentity(hello.did.clone()));
1010        }
1011        let state = self
1012            .authority
1013            .accepted_state(&hello.did)
1014            .ok_or_else(|| MoqlAdmissionError::UnknownIdentity(hello.did.clone()))?;
1015        let now = crate::envelope::current_timestamp();
1016        if !state.is_live(now) {
1017            return Err(MoqlAdmissionError::Expired {
1018                did: hello.did.clone(),
1019                expired_at_unix_ms: state.expires_at_unix_ms.unwrap_or_default(),
1020                now_unix_ms: now,
1021            });
1022        }
1023        let subject = state
1024            .subject_key_for(&hello.ed25519_pub)
1025            .ok_or_else(|| MoqlAdmissionError::KeyNotCurrent(hello.did.clone()))?;
1026        if ml_dsa_vk_from_bytes(&subject.ml_dsa_65).is_err() {
1027            return Err(MoqlAdmissionError::Malformed(format!(
1028                "accepted state for {:?} carries an undecodable ML-DSA-65 key",
1029                hello.did
1030            )));
1031        }
1032        Ok(state)
1033    }
1034
1035    /// The response-time decision: currentness re-check, replay, then the
1036    /// hybrid signature. Factored from the I/O path so each rejection class is
1037    /// unit-testable without a carrier. The unbound shim is only for those
1038    /// unit decision tests; the I/O path always uses `verify_response_bound`.
1039    #[cfg(test)]
1040    fn verify_response(
1041        &self,
1042        hello: &AdmissionHello,
1043        challenge: &AdmissionChallenge,
1044        response: &AdmissionResponse,
1045        now_unix_ms: i64,
1046    ) -> Result<(), MoqlAdmissionError> {
1047        self.verify_response_bound(hello, challenge, response, now_unix_ms, &[0; 32], &[1; 32])
1048    }
1049
1050    fn verify_response_bound(
1051        &self,
1052        hello: &AdmissionHello,
1053        challenge: &AdmissionChallenge,
1054        response: &AdmissionResponse,
1055        now_unix_ms: i64,
1056        client_carrier_node_id: &[u8; 32],
1057        server_carrier_node_id: &[u8; 32],
1058    ) -> Result<(), MoqlAdmissionError> {
1059        // Currentness re-check: the authority must still report exactly the
1060        // epoch/head the challenge bound. A state advance mid-handshake
1061        // invalidates the proof even if both signatures verify.
1062        let current = self
1063            .authority
1064            .accepted_state(&hello.did)
1065            .ok_or_else(|| MoqlAdmissionError::UnknownIdentity(hello.did.clone()))?;
1066        if current.epoch != challenge.epoch || current.head_digest != challenge.head_digest {
1067            return Err(MoqlAdmissionError::StateAdvanced(hello.did.clone()));
1068        }
1069        if !current.is_live(now_unix_ms) {
1070            return Err(MoqlAdmissionError::Expired {
1071                did: hello.did.clone(),
1072                expired_at_unix_ms: current.expires_at_unix_ms.unwrap_or_default(),
1073                now_unix_ms,
1074            });
1075        }
1076        let subject = current
1077            .subject_key_for(&hello.ed25519_pub)
1078            .ok_or_else(|| MoqlAdmissionError::KeyNotCurrent(hello.did.clone()))?;
1079        let pq_vk = ml_dsa_vk_from_bytes(&subject.ml_dsa_65).map_err(|_| {
1080            MoqlAdmissionError::Malformed(format!(
1081                "accepted state for {:?} carries an undecodable ML-DSA-65 key",
1082                hello.did
1083            ))
1084        })?;
1085
1086        let t = admission_transcript(
1087            &hello.did,
1088            &hello.client_nonce,
1089            &challenge.server_nonce,
1090            challenge.epoch,
1091            &challenge.head_digest,
1092            client_carrier_node_id,
1093            server_carrier_node_id,
1094        );
1095        let digest = transcript_digest(&t);
1096        if self.is_consumed(&digest, now_unix_ms) {
1097            return Err(MoqlAdmissionError::Replay);
1098        }
1099
1100        // Inner Ed25519 layer over T.
1101        let ed_vk = VerifyingKey::from_bytes(&hello.ed25519_pub)
1102            .map_err(|_| MoqlAdmissionError::BadSignature)?;
1103        ed_vk
1104            .verify(&t, &Signature::from_bytes(&response.ed_sig))
1105            .map_err(|_| MoqlAdmissionError::BadSignature)?;
1106        // Outer ML-DSA-65 layer over T ‖ ed_sig (inner→outer nesting).
1107        let mut outer = t;
1108        outer.extend_from_slice(&response.ed_sig);
1109        ml_dsa_verify(&pq_vk, &outer, &response.pq_sig)
1110            .map_err(|_| MoqlAdmissionError::BadSignature)?;
1111
1112        self.mark_consumed(digest, now_unix_ms);
1113        Ok(())
1114    }
1115
1116    fn is_consumed(&self, digest: &[u8; 32], now_unix_ms: i64) -> bool {
1117        let used = self.used.lock();
1118        used.get(digest)
1119            .is_some_and(|discard_after| now_unix_ms < *discard_after)
1120    }
1121
1122    fn mark_consumed(&self, digest: [u8; 32], now_unix_ms: i64) {
1123        let horizon_ms = REPLAY_HORIZON.as_millis() as i64;
1124        let mut used = self.used.lock();
1125        if used.len() >= REPLAY_CACHE_MAX {
1126            used.retain(|_, discard_after| now_unix_ms < *discard_after);
1127        }
1128        // A sustained stream of valid, distinct admissions can fill the whole
1129        // replay horizon without making any entry expired. Bound resident state
1130        // in that case too: retain the newest horizon of transcripts, evicting
1131        // the entry that will expire first before admitting the new transcript.
1132        while used.len() >= REPLAY_CACHE_MAX {
1133            let Some(oldest) = used
1134                .iter()
1135                .min_by_key(|(_, discard_after)| *discard_after)
1136                .map(|(digest, _)| *digest)
1137            else {
1138                break;
1139            };
1140            used.remove(&oldest);
1141        }
1142        used.insert(digest, now_unix_ms.saturating_add(horizon_ms));
1143    }
1144}
1145
1146// ────────────────────────────────────────────────────────────────────────────
1147// Client side: the prover
1148// ────────────────────────────────────────────────────────────────────────────
1149
1150/// Client-side proof material for `moql` admission: the peer's accepted
1151/// `did:at9p` identity and both private halves of one of its accepted current
1152/// subject keys. The carrier (iroh secret key / NodeId) plays no part.
1153#[derive(Clone)]
1154pub struct MoqlAdmissionProof {
1155    /// The peer's `did:at9p` DID.
1156    pub did: String,
1157    /// Ed25519 signing key of an accepted current subject key.
1158    pub ed25519: SigningKey,
1159    /// ML-DSA-65 signing key bound to that Ed25519 key in the accepted state.
1160    pub ml_dsa_65: MlDsaSigningKey,
1161    /// Public accepted-state witness expected from the Iroh server during
1162    /// mutual admission. The service bootstrap holds its own checkpointed
1163    /// witness here for server-confirmation construction; the shared reach
1164    /// resolver replaces it with the remote RPC-authenticated `StreamInfo`
1165    /// witness for every client dial. Empty/default is never accepted.
1166    pub expected_server: crate::stream_info::MoqlServerIdentity,
1167}
1168
1169impl std::fmt::Debug for MoqlAdmissionProof {
1170    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1171        f.debug_struct("MoqlAdmissionProof")
1172            .field("did", &self.did)
1173            .finish_non_exhaustive()
1174    }
1175}
1176
1177fn verify_server_challenge(
1178    expected: &crate::stream_info::MoqlServerIdentity,
1179    challenge: &AdmissionChallenge,
1180) -> Result<(), MoqlAdmissionError> {
1181    if !expected.did.starts_with(DID_AT9P_PREFIX)
1182        || expected.did.len() > MAX_DID_BYTES
1183        || expected.epoch == 0
1184        || expected.head_digest.len() != 64
1185        || expected.ml_dsa65.is_empty()
1186        || expected.ml_dsa65.len() > u16::MAX as usize
1187        || expected.expires_at_unix_ms <= crate::envelope::current_timestamp()
1188        || &challenge.server_identity != expected
1189    {
1190        return Err(MoqlAdmissionError::WrongServer);
1191    }
1192    Ok(())
1193}
1194
1195fn verify_server_confirmation(
1196    expected: &crate::stream_info::MoqlServerIdentity,
1197    hello: &AdmissionHello,
1198    challenge: &AdmissionChallenge,
1199    response: &AdmissionResponse,
1200    confirmation: &AdmissionConfirmation,
1201    client_carrier_node_id: &[u8; 32],
1202    server_carrier_node_id: &[u8; 32],
1203) -> Result<(), MoqlAdmissionError> {
1204    let ed_vk = VerifyingKey::from_bytes(&expected.ed25519)
1205        .map_err(|_| MoqlAdmissionError::ServerUnconfirmed)?;
1206    let pq_vk = ml_dsa_vk_from_bytes(&expected.ml_dsa65)
1207        .map_err(|_| MoqlAdmissionError::ServerUnconfirmed)?;
1208    let transcript = mutual_confirmation_transcript(
1209        hello,
1210        challenge,
1211        response,
1212        client_carrier_node_id,
1213        server_carrier_node_id,
1214    );
1215    ed_vk
1216        .verify(&transcript, &Signature::from_bytes(&confirmation.ed_sig))
1217        .map_err(|_| MoqlAdmissionError::ServerUnconfirmed)?;
1218    let mut outer = transcript;
1219    outer.extend_from_slice(&confirmation.ed_sig);
1220    ml_dsa_verify(&pq_vk, &outer, &confirmation.pq_sig)
1221        .map_err(|_| MoqlAdmissionError::ServerUnconfirmed)
1222}
1223
1224/// Run the client half of the admission exchange on `conn`, consuming its
1225/// first bi stream. On success the connection is ready to be wrapped as a
1226/// `web_transport_iroh::Session` for the moq handshake; on failure the server
1227/// has closed (or will close) the connection and the caller MUST NOT proceed.
1228pub async fn prove_moql_admission(
1229    conn: &Connection,
1230    proof: &MoqlAdmissionProof,
1231    client_carrier_node_id: [u8; 32],
1232    timeout: Duration,
1233) -> Result<(), MoqlAdmissionError> {
1234    match tokio::time::timeout(timeout, prove_exchange(conn, proof, client_carrier_node_id)).await {
1235        Ok(res) => res,
1236        Err(_) => Err(MoqlAdmissionError::Timeout),
1237    }
1238}
1239
1240async fn prove_exchange(
1241    conn: &Connection,
1242    proof: &MoqlAdmissionProof,
1243    client_carrier_node_id: [u8; 32],
1244) -> Result<(), MoqlAdmissionError> {
1245    let (mut send, mut recv) = conn
1246        .open_bi()
1247        .await
1248        .map_err(|e| MoqlAdmissionError::Carrier(format!("open_bi: {e}")))?;
1249    let hello = AdmissionHello {
1250        did: proof.did.clone(),
1251        ed25519_pub: proof.ed25519.verifying_key().to_bytes(),
1252        client_nonce: fresh_nonce(),
1253    };
1254    write_frame(&mut send, &encode_hello(&hello)).await?;
1255
1256    let challenge = decode_challenge(&read_frame(&mut recv).await?)?;
1257    verify_server_challenge(&proof.expected_server, &challenge)?;
1258    let t = admission_transcript(
1259        &hello.did,
1260        &hello.client_nonce,
1261        &challenge.server_nonce,
1262        challenge.epoch,
1263        &challenge.head_digest,
1264        &client_carrier_node_id,
1265        conn.remote_id().as_bytes(),
1266    );
1267    let ed_sig: [u8; 64] = proof.ed25519.sign(&t).to_bytes();
1268    let mut outer = t;
1269    outer.extend_from_slice(&ed_sig);
1270    let pq_sig = ml_dsa_sign(&proof.ml_dsa_65, &outer);
1271    write_frame(
1272        &mut send,
1273        &encode_response(&AdmissionResponse {
1274            ed_sig,
1275            pq_sig: pq_sig.clone(),
1276        }),
1277    )
1278    .await?;
1279    send.finish()
1280        .map_err(|e| MoqlAdmissionError::Carrier(format!("finish: {e}")))?;
1281    // Do not hand an unconfirmed carrier to the MoQ handshake. The server's
1282    // hybrid confirmation binds its resolver-pinned identity, the challenge,
1283    // and this client's full hybrid response into one transcript.
1284    let confirmation = decode_confirmation(&read_frame(&mut recv).await?)?;
1285    verify_server_confirmation(
1286        &proof.expected_server,
1287        &hello,
1288        &challenge,
1289        &AdmissionResponse { ed_sig, pq_sig },
1290        &confirmation,
1291        &client_carrier_node_id,
1292        conn.remote_id().as_bytes(),
1293    )
1294}
1295
1296#[cfg(test)]
1297#[allow(clippy::expect_used, clippy::unwrap_used)]
1298mod tests {
1299    use super::*;
1300    use crate::crypto::pq::ml_dsa_generate_keypair;
1301
1302    const DID: &str = "did:at9p:testsubject";
1303
1304    fn keypair(seed: u8) -> (SigningKey, MlDsaSigningKey) {
1305        let ed = SigningKey::from_bytes(&[seed; 32]);
1306        let pq = crate::crypto::pq::ml_dsa_sk_from_seed(&[seed.wrapping_add(1); 32]);
1307        (ed, pq)
1308    }
1309
1310    fn state_with(
1311        ed: &SigningKey,
1312        pq: &MlDsaSigningKey,
1313        epoch: u64,
1314        tag: u8,
1315    ) -> AcceptedIdentityState {
1316        AcceptedIdentityState {
1317            epoch,
1318            head_digest: [tag; 64],
1319            subject_keys: vec![AcceptedSubjectKey {
1320                ed25519: ed.verifying_key().to_bytes(),
1321                ml_dsa_65: crate::crypto::pq::ml_dsa_sk_to_vk_bytes(pq),
1322            }],
1323            service_ids: vec![],
1324            expires_at_unix_ms: None,
1325        }
1326    }
1327
1328    fn fixture_authenticator(
1329        state: AcceptedIdentityState,
1330    ) -> (MoqlAdmissionAuthenticator, SigningKey, MlDsaSigningKey) {
1331        let (ed, pq) = keypair(7);
1332        let authority: Arc<dyn AcceptedStateAuthority> =
1333            Arc::new(move |did: &str| (did == DID).then(|| state.clone()));
1334        let resolver: PeerTenantResolver =
1335            Arc::new(|peer: &PeerIdentity| peer.subject.as_deref().map(|_| "alice".to_owned()));
1336        (MoqlAdmissionAuthenticator::new(authority, resolver), ed, pq)
1337    }
1338
1339    fn sign_response(
1340        ed: &SigningKey,
1341        pq: &MlDsaSigningKey,
1342        hello: &AdmissionHello,
1343        challenge: &AdmissionChallenge,
1344    ) -> AdmissionResponse {
1345        let t = admission_transcript(
1346            &hello.did,
1347            &hello.client_nonce,
1348            &challenge.server_nonce,
1349            challenge.epoch,
1350            &challenge.head_digest,
1351            &[0; 32],
1352            &[1; 32],
1353        );
1354        let ed_sig: [u8; 64] = ed.sign(&t).to_bytes();
1355        let mut outer = t;
1356        outer.extend_from_slice(&ed_sig);
1357        AdmissionResponse {
1358            ed_sig,
1359            pq_sig: ml_dsa_sign(pq, &outer),
1360        }
1361    }
1362
1363    fn hello_for(ed: &SigningKey) -> AdmissionHello {
1364        AdmissionHello {
1365            did: DID.to_owned(),
1366            ed25519_pub: ed.verifying_key().to_bytes(),
1367            client_nonce: [0xAA; 32],
1368        }
1369    }
1370
1371    fn challenge_for(state: &AcceptedIdentityState) -> AdmissionChallenge {
1372        AdmissionChallenge {
1373            server_nonce: [0xBB; 32],
1374            epoch: state.epoch,
1375            head_digest: state.head_digest,
1376            server_identity: Default::default(),
1377        }
1378    }
1379
1380    #[test]
1381    fn frame_roundtrips() {
1382        let hello = AdmissionHello {
1383            did: DID.to_owned(),
1384            ed25519_pub: [1; 32],
1385            client_nonce: [2; 32],
1386        };
1387        assert_eq!(decode_hello(&encode_hello(&hello)).unwrap(), hello);
1388
1389        let challenge = AdmissionChallenge {
1390            server_nonce: [3; 32],
1391            epoch: 42,
1392            head_digest: [4; 64],
1393            server_identity: crate::stream_info::MoqlServerIdentity {
1394                did: "did:at9p:test-server".to_owned(),
1395                epoch: 7,
1396                head_digest: vec![5; 64],
1397                expires_at_unix_ms: crate::envelope::current_timestamp() + 60_000,
1398                ed25519: [6; 32],
1399                ml_dsa65: vec![7; 1952],
1400            },
1401        };
1402        assert_eq!(
1403            decode_challenge(&encode_challenge(&challenge)).unwrap(),
1404            challenge
1405        );
1406
1407        let response = AdmissionResponse {
1408            ed_sig: [5; 64],
1409            pq_sig: vec![6; 3309],
1410        };
1411        assert_eq!(
1412            decode_response(&encode_response(&response)).unwrap(),
1413            response
1414        );
1415
1416        let confirmation = AdmissionConfirmation {
1417            ed_sig: [8; 64],
1418            pq_sig: vec![9; 3309],
1419        };
1420        assert_eq!(
1421            decode_confirmation(&encode_confirmation(&confirmation)).unwrap(),
1422            confirmation
1423        );
1424    }
1425
1426    #[test]
1427    fn malformed_frames_reject() {
1428        assert!(matches!(
1429            decode_hello(&[]),
1430            Err(MoqlAdmissionError::Malformed(_))
1431        ));
1432        assert!(matches!(
1433            decode_hello(&[2]),
1434            Err(MoqlAdmissionError::Malformed(_))
1435        ));
1436        assert!(matches!(
1437            decode_challenge(&[1, 2, 3]),
1438            Err(MoqlAdmissionError::Malformed(_))
1439        ));
1440        assert!(matches!(
1441            decode_response(&[1]),
1442            Err(MoqlAdmissionError::Malformed(_))
1443        ));
1444        // did length exceeding the cap
1445        let mut bad = vec![1u8];
1446        bad.extend_from_slice(&(MAX_DID_BYTES as u16 + 1).to_be_bytes());
1447        assert!(matches!(
1448            decode_hello(&bad),
1449            Err(MoqlAdmissionError::Malformed(_))
1450        ));
1451    }
1452
1453    #[test]
1454    fn positive_proof_verifies_and_records_transcript() {
1455        let (ed, pq) = keypair(7);
1456        let state = state_with(&ed, &pq, 3, 9);
1457        let (auth, _, _) = fixture_authenticator(state.clone());
1458        let hello = hello_for(&ed);
1459        let challenge = challenge_for(&state);
1460        let response = sign_response(&ed, &pq, &hello, &challenge);
1461        let now = crate::envelope::current_timestamp();
1462        auth.verify_response(&hello, &challenge, &response, now)
1463            .expect("valid hybrid proof must verify");
1464    }
1465
1466    #[test]
1467    fn replayed_transcript_rejects() {
1468        let (ed, pq) = keypair(7);
1469        let state = state_with(&ed, &pq, 3, 9);
1470        let (auth, _, _) = fixture_authenticator(state.clone());
1471        let hello = hello_for(&ed);
1472        let challenge = challenge_for(&state);
1473        let response = sign_response(&ed, &pq, &hello, &challenge);
1474        let now = crate::envelope::current_timestamp();
1475        auth.verify_response(&hello, &challenge, &response, now)
1476            .unwrap();
1477        let err = auth
1478            .verify_response(&hello, &challenge, &response, now)
1479            .expect_err("the same transcript must be single-use");
1480        assert!(matches!(err, MoqlAdmissionError::Replay), "{err}");
1481    }
1482
1483    #[test]
1484    fn replay_cache_never_exceeds_capacity_when_horizon_is_full() {
1485        let (ed, pq) = keypair(7);
1486        let state = state_with(&ed, &pq, 3, 9);
1487        let (auth, _, _) = fixture_authenticator(state);
1488        let now = crate::envelope::current_timestamp();
1489        for index in 0..=REPLAY_CACHE_MAX {
1490            let mut digest = [0u8; 32];
1491            digest[..8].copy_from_slice(&(index as u64).to_be_bytes());
1492            auth.mark_consumed(digest, now.saturating_add(index as i64));
1493        }
1494        assert_eq!(auth.used.lock().len(), REPLAY_CACHE_MAX);
1495    }
1496
1497    #[test]
1498    fn wrong_nonce_or_epoch_rejects_as_bad_signature() {
1499        let (ed, pq) = keypair(7);
1500        let state = state_with(&ed, &pq, 3, 9);
1501        let (auth, _, _) = fixture_authenticator(state.clone());
1502        let hello = hello_for(&ed);
1503        let challenge = challenge_for(&state);
1504        let response = sign_response(&ed, &pq, &hello, &challenge);
1505        let now = crate::envelope::current_timestamp();
1506
1507        // A replay over a FRESH challenge (different server nonce) is a
1508        // signature failure: the transcript bound the original nonce.
1509        let fresh_challenge = AdmissionChallenge {
1510            server_nonce: [0xCC; 32],
1511            ..challenge.clone()
1512        };
1513        let err = auth
1514            .verify_response(&hello, &fresh_challenge, &response, now)
1515            .expect_err("a response is bound to its challenge nonce");
1516        assert!(matches!(err, MoqlAdmissionError::BadSignature), "{err}");
1517
1518        // A response minted against a superseded epoch/head fails likewise.
1519        let stale_challenge = AdmissionChallenge {
1520            epoch: state.epoch - 1,
1521            head_digest: [8; 64],
1522            ..challenge.clone()
1523        };
1524        let stale_response = sign_response(&ed, &pq, &hello, &stale_challenge);
1525        let err = auth
1526            .verify_response(&hello, &challenge, &stale_response, now)
1527            .expect_err("a proof over a stale epoch/head must not verify");
1528        assert!(matches!(err, MoqlAdmissionError::BadSignature), "{err}");
1529    }
1530
1531    #[test]
1532    fn classical_only_proof_rejects_as_downgrade() {
1533        let (ed, pq) = keypair(7);
1534        let state = state_with(&ed, &pq, 3, 9);
1535        let (auth, _, _) = fixture_authenticator(state.clone());
1536        let hello = hello_for(&ed);
1537        let challenge = challenge_for(&state);
1538        let mut response = sign_response(&ed, &pq, &hello, &challenge);
1539        // Strip the ML-DSA-65 layer: present a classical-only signature.
1540        let (rogue_ed, _) = keypair(21);
1541        let t = admission_transcript(
1542            &hello.did,
1543            &hello.client_nonce,
1544            &challenge.server_nonce,
1545            challenge.epoch,
1546            &challenge.head_digest,
1547            &[0; 32],
1548            &[1; 32],
1549        );
1550        let mut outer = t.clone();
1551        outer.extend_from_slice(&response.ed_sig);
1552        // A valid ML-DSA signature from a NON-accepted key is still a failure.
1553        let (rogue_pq_sk, _) = ml_dsa_generate_keypair();
1554        response.pq_sig = ml_dsa_sign(&rogue_pq_sk, &outer);
1555        let err = auth
1556            .verify_response(
1557                &hello,
1558                &challenge,
1559                &response,
1560                crate::envelope::current_timestamp(),
1561            )
1562            .expect_err("ML-DSA layer from a non-accepted key must reject");
1563        assert!(matches!(err, MoqlAdmissionError::BadSignature), "{err}");
1564        let _ = rogue_ed;
1565    }
1566
1567    #[test]
1568    fn state_advance_mid_handshake_rejects() {
1569        let (ed, pq) = keypair(7);
1570        let old_state = state_with(&ed, &pq, 3, 9);
1571        // Authority flips to a newer epoch between challenge and response.
1572        let new_state = AcceptedIdentityState {
1573            epoch: 4,
1574            head_digest: [10; 64],
1575            ..old_state.clone()
1576        };
1577        let authority: Arc<dyn AcceptedStateAuthority> =
1578            Arc::new(move |did: &str| (did == DID).then(|| new_state.clone()));
1579        let resolver: PeerTenantResolver = Arc::new(|_| Some("alice".to_owned()));
1580        let auth = MoqlAdmissionAuthenticator::new(authority, resolver);
1581        let hello = hello_for(&ed);
1582        let challenge = challenge_for(&old_state); // bound to epoch 3
1583        let response = sign_response(&ed, &pq, &hello, &challenge);
1584        let err = auth
1585            .verify_response(
1586                &hello,
1587                &challenge,
1588                &response,
1589                crate::envelope::current_timestamp(),
1590            )
1591            .expect_err("a state advance mid-handshake must reject");
1592        assert!(matches!(err, MoqlAdmissionError::StateAdvanced(_)), "{err}");
1593    }
1594
1595    #[test]
1596    fn expired_state_rejects_at_hello() {
1597        let (ed, pq) = keypair(7);
1598        let mut state = state_with(&ed, &pq, 3, 9);
1599        state.expires_at_unix_ms = Some(crate::envelope::current_timestamp() - 1);
1600        let (auth, _, _) = fixture_authenticator(state);
1601        let err = auth
1602            .check_hello(&hello_for(&ed))
1603            .expect_err("expired accepted state must reject");
1604        assert!(matches!(err, MoqlAdmissionError::Expired { .. }), "{err}");
1605    }
1606
1607    #[test]
1608    fn rotated_out_key_rejects_at_hello() {
1609        let (ed, _pq) = keypair(7);
1610        // Accepted state now publishes a DIFFERENT key set (rotation).
1611        let (new_ed, new_pq) = keypair(30);
1612        let state = state_with(&new_ed, &new_pq, 4, 10);
1613        let (auth, _, _) = fixture_authenticator(state);
1614        let err = auth
1615            .check_hello(&hello_for(&ed))
1616            .expect_err("a rotated-out key is not a current subject key");
1617        assert!(matches!(err, MoqlAdmissionError::KeyNotCurrent(_)), "{err}");
1618    }
1619
1620    #[test]
1621    fn current_session_rejects_removed_or_reassigned_tenant() {
1622        let (ed, pq) = keypair(7);
1623        let state = state_with(&ed, &pq, 3, 9);
1624        let authority: Arc<dyn AcceptedStateAuthority> = Arc::new({
1625            let state = state.clone();
1626            move |did: &str| (did == DID).then(|| state.clone())
1627        });
1628        let tenant = Arc::new(Mutex::new(Some("alice".to_owned())));
1629        let resolver: PeerTenantResolver = Arc::new({
1630            let tenant = Arc::clone(&tenant);
1631            move |_peer| tenant.lock().clone()
1632        });
1633        let identity = crate::stream_info::MoqlServerIdentity {
1634            did: DID.to_owned(),
1635            epoch: state.epoch,
1636            head_digest: state.head_digest.to_vec(),
1637            expires_at_unix_ms: crate::envelope::current_timestamp() + 60_000,
1638            ed25519: ed.verifying_key().to_bytes(),
1639            ml_dsa65: crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&pq),
1640        };
1641        let auth = MoqlAdmissionAuthenticator::new(authority, resolver)
1642            .with_server_identity_and_carrier(
1643                MoqlServerIdentityProof {
1644                    identity,
1645                    ed25519: ed.clone(),
1646                    ml_dsa_65: pq,
1647                },
1648                [1; 32],
1649            );
1650        let admitted = AdmittedMoqPeer {
1651            peer: PeerIdentity::authenticated(DID.to_owned()),
1652            tenant: "alice".to_owned(),
1653            epoch: state.epoch,
1654            head_digest: state.head_digest,
1655            subject_ed25519: ed.verifying_key().to_bytes(),
1656            carrier_node_id: [0; 32],
1657        };
1658        assert!(auth.is_still_current(&admitted));
1659        *tenant.lock() = None;
1660        assert!(!auth.is_still_current(&admitted));
1661        *tenant.lock() = Some("bob".to_owned());
1662        assert!(!auth.is_still_current(&admitted));
1663    }
1664
1665    #[test]
1666    fn unknown_and_non_at9p_identities_reject() {
1667        let (ed, pq) = keypair(7);
1668        let state = state_with(&ed, &pq, 3, 9);
1669        let (auth, _, _) = fixture_authenticator(state);
1670
1671        let mut hello = hello_for(&ed);
1672        hello.did = "did:at9p:someoneelse".to_owned();
1673        let err = auth
1674            .check_hello(&hello)
1675            .expect_err("unknown DID must reject");
1676        assert!(
1677            matches!(err, MoqlAdmissionError::UnknownIdentity(_)),
1678            "{err}"
1679        );
1680
1681        // A NodeId dressed as did:key is not an accepted-state identity.
1682        let mut hello = hello_for(&ed);
1683        hello.did = "did:key:z6MkNodeIdOnly".to_owned();
1684        let err = auth.check_hello(&hello).expect_err("did:key must reject");
1685        assert!(
1686            matches!(err, MoqlAdmissionError::NotAcceptedIdentity(_)),
1687            "{err}"
1688        );
1689    }
1690
1691    /// The in-daemon at9p renewal regression: a key-stable renewal advances
1692    /// the SERVER's accepted epoch/head while the service keeps the proof
1693    /// installed at process start. The proof must stay current, the
1694    /// challenge must advertise the advanced state, an admitted tunnel
1695    /// whose PEER state did not advance must survive, and a genuine key
1696    /// rotation must still fail closed.
1697    #[test]
1698    fn server_identity_survives_key_stable_renewal() {
1699        const SERVER_DID: &str = "did:at9p:testserver";
1700        let (server_ed, server_pq) = keypair(11);
1701        let (peer_ed, peer_pq) = keypair(12);
1702        // Shared mutable authority: two identities, independently advanced.
1703        let server_state = Arc::new(Mutex::new(state_with(&server_ed, &server_pq, 3, 0x31)));
1704        let peer_state = Arc::new(Mutex::new(state_with(&peer_ed, &peer_pq, 8, 0x81)));
1705        let authority: Arc<dyn AcceptedStateAuthority> = {
1706            let (server_state, peer_state) = (Arc::clone(&server_state), Arc::clone(&peer_state));
1707            Arc::new(move |did: &str| {
1708                if did == SERVER_DID {
1709                    Some(server_state.lock().clone())
1710                } else if did == "did:at9p:testsubject" {
1711                    Some(peer_state.lock().clone())
1712                } else {
1713                    None
1714                }
1715            })
1716        };
1717        let resolver: PeerTenantResolver =
1718            Arc::new(|peer: &PeerIdentity| peer.subject.as_deref().map(|_| "alice".to_owned()));
1719        let pinned_identity = crate::stream_info::MoqlServerIdentity {
1720            did: SERVER_DID.to_owned(),
1721            epoch: 3,
1722            head_digest: vec![0x31; 64],
1723            expires_at_unix_ms: crate::envelope::current_timestamp() + 60_000,
1724            ed25519: server_ed.verifying_key().to_bytes(),
1725            ml_dsa65: crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&server_pq),
1726        };
1727        let pinned_proof = MoqlServerIdentityProof {
1728            identity: pinned_identity.clone(),
1729            ed25519: server_ed.clone(),
1730            ml_dsa_65: server_pq.clone(),
1731        };
1732        let auth = MoqlAdmissionAuthenticator::new(authority, resolver)
1733            .with_server_identity_and_carrier(pinned_proof.clone(), [1; 32]);
1734        // A tunnel admitted against the peer's current (unchanged) state.
1735        let admitted = AdmittedMoqPeer {
1736            peer: PeerIdentity::authenticated(DID.to_owned()),
1737            tenant: "alice".to_owned(),
1738            epoch: 8,
1739            head_digest: [0x81; 64],
1740            subject_ed25519: peer_ed.verifying_key().to_bytes(),
1741            carrier_node_id: [0; 32],
1742        };
1743        assert!(auth.is_still_current(&admitted));
1744        assert_eq!(
1745            auth.project_server_identity(&pinned_proof).unwrap().epoch,
1746            3
1747        );
1748
1749        // ── Renewal: SERVER epoch 4, new head digest, SAME subject keys. ──
1750        *server_state.lock() = state_with(&server_ed, &server_pq, 4, 0x44);
1751        // (a) A new inbound handshake is admissible: the proof stays current
1752        // and the advertised challenge identity carries the advanced
1753        // epoch/head (keys unchanged, so the proof's signatures hold).
1754        let advertised = auth.project_server_identity(&pinned_proof).unwrap();
1755        assert_eq!(advertised.epoch, 4);
1756        assert_eq!(advertised.head_digest, vec![0x44; 64]);
1757        assert_eq!(advertised.ed25519, pinned_identity.ed25519);
1758        assert_eq!(advertised.ml_dsa65, pinned_identity.ml_dsa65);
1759        // (b) An existing tunnel whose peer state did not advance is NOT
1760        // invalidated by the server's own renewal.
1761        assert!(auth.is_still_current(&admitted));
1762
1763        // ── Fail-closed: a genuine key rotation removes the proof's keys. ──
1764        let (rotated_ed, rotated_pq) = keypair(30);
1765        *server_state.lock() = state_with(&rotated_ed, &rotated_pq, 5, 0x55);
1766        let err = auth
1767            .project_server_identity(&pinned_proof)
1768            .expect_err("rotated-out server keys must fail closed");
1769        assert!(
1770            matches!(err, MoqlAdmissionError::ServerIdentityNotCurrent),
1771            "{err}"
1772        );
1773
1774        // ── Fail-closed: the authority losing the identity entirely. ──
1775        *server_state.lock() = state_with(&server_ed, &server_pq, 4, 0x44);
1776        // (control: back to current with the original keys)
1777        assert!(auth.project_server_identity(&pinned_proof).is_ok());
1778        // Monotonicity: a proof from an epoch the store no longer reaches
1779        // (simulated regression below the pinned epoch) is rejected.
1780        *server_state.lock() = state_with(&server_ed, &server_pq, 2, 0x22);
1781        assert!(auth.project_server_identity(&pinned_proof).is_err());
1782    }
1783}