1use 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
90pub const MOQL_ADMISSION_DOMAIN: &[u8] = b"hyprstream/moql-admission/v1";
92
93const WIRE_VERSION: u8 = 3;
96
97const MAX_DID_BYTES: usize = 256;
100
101const MAX_FRAME_BYTES: usize = 8 * 1024;
105
106pub const DEFAULT_ADMISSION_TIMEOUT: Duration = Duration::from_secs(10);
110
111const REPLAY_CACHE_MAX: usize = 4096;
115
116const REPLAY_HORIZON: Duration = Duration::from_secs(60 * 60);
119
120#[derive(Debug, thiserror::Error)]
124pub enum MoqlAdmissionError {
125 #[error("carrier I/O during moql admission: {0}")]
127 Carrier(String),
128 #[error("moql admission exchange timed out")]
130 Timeout,
131 #[error("malformed moql admission frame: {0}")]
133 Malformed(String),
134 #[error("identity {0:?} is not a did:at9p accepted-state identity")]
137 NotAcceptedIdentity(String),
138 #[error("no current accepted state for {0:?}")]
140 UnknownIdentity(String),
141 #[error("accepted state for {did:?} expired at {expired_at_unix_ms} (now {now_unix_ms})")]
143 Expired {
144 did: String,
146 expired_at_unix_ms: i64,
148 now_unix_ms: i64,
150 },
151 #[error("presented Ed25519 key is not a current accepted subject key of {0:?}")]
154 KeyNotCurrent(String),
155 #[error("accepted state for {0:?} advanced during admission")]
158 StateAdvanced(String),
159 #[error("hybrid Ed25519 + ML-DSA-65 proof verification failed")]
161 BadSignature,
162 #[error("moql admission transcript replayed")]
164 Replay,
165 #[error("admitted subject {0:?} has no tenant scope")]
167 TenantUnresolved(String),
168 #[error("resolved tenant {0:?} is not a valid single MoQ path segment")]
170 InvalidTenant(String),
171 #[error("moql server has no accepted-state signing identity")]
174 ServerIdentityUnavailable,
175 #[error("moql server signing identity does not match its accepted-state witness")]
178 ServerIdentityMismatch,
179 #[error("moql server accepted-state identity is no longer current")]
182 ServerIdentityNotCurrent,
183 #[error("moql challenge server identity does not match resolver witness")]
186 WrongServer,
187 #[error("moql server did not mutually confirm the full admission transcript")]
190 ServerUnconfirmed,
191}
192
193#[derive(Clone, Debug, PartialEq, Eq)]
196pub struct AcceptedSubjectKey {
197 pub ed25519: [u8; 32],
199 pub ml_dsa_65: Vec<u8>,
201}
202
203#[derive(Clone, Debug, PartialEq, Eq)]
208pub struct AcceptedIdentityState {
209 pub epoch: u64,
211 pub head_digest: [u8; 64],
213 pub subject_keys: Vec<AcceptedSubjectKey>,
215 pub service_ids: Vec<String>,
221 pub expires_at_unix_ms: Option<i64>,
224}
225
226impl AcceptedIdentityState {
227 pub fn subject_key_for(&self, ed25519: &[u8; 32]) -> Option<&AcceptedSubjectKey> {
230 self.subject_keys.iter().find(|k| &k.ed25519 == ed25519)
231 }
232
233 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
242pub trait AcceptedStateAuthority: Send + Sync {
250 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#[derive(Debug, Clone)]
267pub struct AdmittedMoqPeer {
268 pub peer: PeerIdentity,
270 pub tenant: String,
273 pub epoch: u64,
275 pub head_digest: [u8; 64],
277 pub subject_ed25519: [u8; 32],
281 pub carrier_node_id: [u8; 32],
283}
284
285#[derive(Clone, Debug, PartialEq, Eq)]
292pub struct AdmissionHello {
293 pub did: String,
295 pub ed25519_pub: [u8; 32],
297 pub client_nonce: [u8; 32],
299}
300
301#[derive(Clone, Debug, PartialEq)]
303pub struct AdmissionChallenge {
304 pub server_nonce: [u8; 32],
306 pub epoch: u64,
308 pub head_digest: [u8; 64],
310 pub server_identity: crate::stream_info::MoqlServerIdentity,
313}
314
315#[derive(Clone, Debug, PartialEq, Eq)]
317pub struct AdmissionResponse {
318 pub ed_sig: [u8; 64],
320 pub pq_sig: Vec<u8>,
322}
323
324#[derive(Clone, Debug, PartialEq, Eq)]
328pub struct AdmissionConfirmation {
329 pub ed_sig: [u8; 64],
331 pub pq_sig: Vec<u8>,
333}
334
335pub const VERDICT_ADMITTED: u8 = 1;
339
340pub fn encode_verdict() -> Vec<u8> {
342 vec![WIRE_VERSION, VERDICT_ADMITTED]
343}
344
345pub 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
356fn 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
411pub 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
439pub 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
475fn 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
483pub 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
494pub 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
526pub 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
539pub 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
568pub 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
578pub 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
601pub 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
609pub 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#[derive(Clone)]
672pub struct MoqlServerIdentityProof {
673 pub identity: crate::stream_info::MoqlServerIdentity,
675 pub ed25519: SigningKey,
677 pub ml_dsa_65: MlDsaSigningKey,
679}
680
681impl MoqlServerIdentityProof {
682 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 used: Mutex<HashMap<[u8; 32], i64>>,
741 server_identity: Mutex<Option<MoqlServerIdentityProof>>,
744 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 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 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 #[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 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 #[must_use]
821 pub fn with_timeout(mut self, timeout: Duration) -> Self {
822 self.timeout = timeout;
823 self
824 }
825
826 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 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 let hello = decode_hello(&read_frame(&mut recv).await?)?;
862 let state = self.check_hello(&hello)?;
863
864 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 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 if !self.is_server_identity_current(&server_identity) {
888 return Err(MoqlAdmissionError::ServerIdentityNotCurrent);
889 }
890
891 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 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 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 && (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 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 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 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 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 #[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 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 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 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 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#[derive(Clone)]
1154pub struct MoqlAdmissionProof {
1155 pub did: String,
1157 pub ed25519: SigningKey,
1159 pub ml_dsa_65: MlDsaSigningKey,
1161 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
1224pub 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 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 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 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 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 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 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 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); 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 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 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 #[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 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 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 *server_state.lock() = state_with(&server_ed, &server_pq, 4, 0x44);
1751 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 assert!(auth.is_still_current(&admitted));
1762
1763 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 *server_state.lock() = state_with(&server_ed, &server_pq, 4, 0x44);
1776 assert!(auth.project_server_identity(&pinned_proof).is_ok());
1778 *server_state.lock() = state_with(&server_ed, &server_pq, 2, 0x22);
1781 assert!(auth.project_server_identity(&pinned_proof).is_err());
1782 }
1783}