Skip to main content

hyprstream_rpc/
node_identity.rs

1//! Node identity provider — native key management with HKDF purpose derivation.
2//!
3//! Wraps a root Ed25519 signing key and derives purpose-keyed identities via HKDF.
4//! The root key comes from `identity_store.rs` (file-based) or OS keyring.
5//!
6//! HKDF derivation: `HKDF-SHA256(ikm=root_seed, info=purpose_bytes)` → 32-byte Ed25519 seed.
7//! Same purpose always produces the same keypair from the same root.
8//!
9//! Derived pubkeys are tracked automatically — `resolve()` recognizes both
10//! the root node pubkey and any purpose-derived pubkeys opened via `identity_open()`.
11
12use anyhow::Result;
13use async_trait::async_trait;
14use ed25519_dalek::SigningKey;
15use hkdf::Hkdf;
16use parking_lot::RwLock;
17use sha2::Sha256;
18use std::collections::HashMap;
19use zeroize::Zeroize;
20
21use crate::identity::{IdentityProvider, SigningIdentity};
22use crate::Subject;
23
24/// Domain-separated HKDF salt for node identity derivation.
25/// Prevents cross-protocol confusion if the same seed material is used elsewhere.
26const NODE_IDENTITY_SALT: &[u8] = b"hyprstream-node-identity-hkdf-v1";
27
28/// Build the per-host mesh-peer subject for an enrolled host label (#328).
29///
30/// Extends the existing `service:<name>` convention (see
31/// `EnvelopeContext::from_callback_service`) with a per-host third segment so
32/// every mesh peer authenticates as its OWN granular principal
33/// (`service:inference:host-<label>`) rather than collapsing to the omnipotent
34/// `"system"` principal. The label is the operator-assigned `mesh_peers` key.
35pub fn mesh_host_subject(label: &str) -> Subject {
36    Subject::new(format!("service:inference:host-{label}"))
37}
38
39/// Derive a purpose-keyed Ed25519 signing key from a root key.
40///
41/// Standalone function for use in sync contexts (e.g., JWT signing)
42/// where the full async `IdentityProvider` isn't needed.
43#[allow(clippy::expect_used)] // HKDF-SHA256 expand to 32 bytes cannot fail
44pub fn derive_purpose_key(root_key: &SigningKey, purpose: &str) -> SigningKey {
45    assert!(!purpose.is_empty(), "purpose must be non-empty");
46    assert!(purpose.len() <= 255, "purpose must be at most 255 bytes");
47    let hk = Hkdf::<Sha256>::new(Some(NODE_IDENTITY_SALT), &root_key.to_bytes());
48    let mut okm = [0u8; 32];
49    hk.expand(purpose.as_bytes(), &mut okm)
50        .expect("HKDF-SHA256 expand to 32 bytes cannot fail");
51    let key = SigningKey::from_bytes(&okm);
52    okm.zeroize();
53    key
54}
55
56/// HKDF purpose label for the mesh ML-DSA-65 signing key (#157).
57///
58/// Distinct from any Ed25519 / JWT purpose label so the post-quantum mesh key
59/// satisfies the PQUIP key-separation restriction (a derived key is bound to
60/// exactly one cryptographic purpose). The `-v1` suffix allows a future
61/// rotation by bumping the version without changing the root node key.
62pub const MESH_MLDSA_PURPOSE: &str = "hyprstream-mesh-mldsa-v1";
63
64/// Deterministically derive the node's mesh ML-DSA-65 signing key from its
65/// persisted Ed25519 root/signing key (#157).
66///
67/// Uses [`derive_purpose_key`] (HKDF-SHA256 over the Ed25519 seed) with the
68/// dedicated [`MESH_MLDSA_PURPOSE`] label, then re-keys that 32-byte output as
69/// an ML-DSA-65 seed via [`crate::crypto::pq::ml_dsa_sk_from_seed`]. This is
70/// stable across restarts (no new key file) and key-separated from both the
71/// Ed25519 identity and the JWT ML-DSA keyset.
72///
73/// The matching public key (`signing_key.verifying_key()`) is what peers must
74/// anchor in their `KeyedPqTrustStore`, keyed by the Ed25519 signer identity.
75pub fn derive_mesh_mldsa_key(ed25519_key: &SigningKey) -> crate::crypto::pq::MlDsaSigningKey {
76    let derived = derive_purpose_key(ed25519_key, MESH_MLDSA_PURPOSE);
77    let mut seed = derived.to_bytes();
78    let sk = crate::crypto::pq::ml_dsa_sk_from_seed(&seed);
79    seed.zeroize();
80    sk
81}
82
83/// HKDF purpose-label namespace for the node's `#mesh-kem` hybrid keyAgreement
84/// identity (S1 / #552). Distinct from the Ed25519, JWT, and [`MESH_MLDSA_PURPOSE`]
85/// labels so the KEM identity is key-separated (PQUIP key separation). Each suite
86/// component derives an independent seed under a per-component sub-label
87/// `"<MESH_KEM_PURPOSE>/<kem>"`.
88pub const MESH_KEM_PURPOSE: &str = "hyprstream-mesh-kem-v1";
89
90/// Expand `out.len()` bytes from the node root via HKDF-SHA256 (node-identity
91/// salt, given `info`). Used for the variable-length `#mesh-kem` component seeds
92/// (X25519 = 32B, ML-KEM-768 = 64B), which [`derive_purpose_key`] (fixed 32B)
93/// cannot produce.
94fn expand_purpose_bytes(root_key: &SigningKey, info: &[u8], out: &mut [u8]) {
95    let hk = Hkdf::<Sha256>::new(Some(NODE_IDENTITY_SALT), &root_key.to_bytes());
96    #[allow(clippy::expect_used)] // HKDF-SHA256 expand of <= 255*32 bytes cannot fail
97    hk.expand(info, out)
98        .expect("HKDF-SHA256 expand within the length bound cannot fail");
99}
100
101/// Deterministically derive the node's `#mesh-kem` hybrid-KEM recipient keypair
102/// (S1 / #552) from its persisted Ed25519 root key — the confidentiality-side
103/// parallel of [`derive_mesh_mldsa_key`].
104///
105/// Each suite component gets an independent HKDF-derived seed under a distinct
106/// per-component sub-label (`"<MESH_KEM_PURPOSE>/<kem>"`), so the X25519 and
107/// ML-KEM-768 legs are independent of each other and key-separated from the
108/// Ed25519 identity and the `#mesh-mldsa` key. Stable across restarts (no key
109/// file). The published [`crate::crypto::hybrid_kem::RecipientPublic`] is what
110/// peers anchor in their [`crate::crypto::hybrid_kem::KemTrustStore`] (resolved
111/// from the DID `keyAgreement` set).
112pub fn derive_mesh_kem_recipient(
113    ed25519_key: &SigningKey,
114) -> anyhow::Result<crate::crypto::hybrid_kem::RecipientKeypair> {
115    use crate::crypto::hybrid_kem::{recipient_from_seeds, KemId, SuiteId};
116    let suite = SuiteId::HyKemX25519MlKem768;
117    // Fail closed if the pinned suite's shape ever changes out from under this
118    // hard-coded per-component seeding (a new suite must update this derivation).
119    debug_assert_eq!(suite.components(), &[KemId::X25519, KemId::MlKem768]);
120
121    let x_info = format!("{MESH_KEM_PURPOSE}/x25519");
122    let m_info = format!("{MESH_KEM_PURPOSE}/mlkem768");
123    let mut x_seed = [0u8; 32];
124    let mut m_seed = [0u8; 64];
125    expand_purpose_bytes(ed25519_key, x_info.as_bytes(), &mut x_seed);
126    expand_purpose_bytes(ed25519_key, m_info.as_bytes(), &mut m_seed);
127
128    let seeds: [&[u8]; 2] = [&x_seed, &m_seed];
129    let kp = recipient_from_seeds(suite, &seeds);
130    x_seed.zeroize();
131    m_seed.zeroize();
132    kp
133}
134
135/// A purpose-derived Ed25519 signing identity.
136/// Inner SigningKey is zeroized on drop via ed25519-dalek's `zeroize` feature.
137struct DerivedIdentity {
138    signing_key: SigningKey,
139    pubkey: [u8; 32],
140}
141
142#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
143#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
144impl SigningIdentity for DerivedIdentity {
145    fn pubkey(&self) -> [u8; 32] {
146        self.pubkey
147    }
148
149    async fn sign(&self, canonical_bytes: &[u8]) -> Result<[u8; 64]> {
150        use ed25519_dalek::Signer as _;
151        Ok(self.signing_key.sign(canonical_bytes).to_bytes())
152    }
153}
154
155/// Native identity provider backed by a root Ed25519 key.
156///
157/// Derives purpose-keyed identities via HKDF. Maps every recognized pubkey to a
158/// specific authorization [`Subject`] (#328): the node's own root/derived keys
159/// map to `"system"` (genuine in-process authority), while enrolled mesh-peer
160/// keys map to their per-host subject (`service:inference:host-<label>`). An
161/// unrecognized pubkey resolves to [`Subject::anonymous`] — deny-by-default,
162/// never the `"system"` god principal.
163pub struct NodeIdentityProvider {
164    root_seed: [u8; 32],
165    #[allow(dead_code)]
166    node_pubkey: [u8; 32],
167    /// Recognized pubkey → authorization subject.
168    ///
169    /// The node's own root and purpose-derived keys are inserted with
170    /// `Subject::new("system")`; mesh peers are inserted via
171    /// [`NodeIdentityProvider::register_peer`] with their per-host subject.
172    known_pubkeys: RwLock<HashMap<[u8; 32], Subject>>,
173}
174
175impl Drop for NodeIdentityProvider {
176    fn drop(&mut self) {
177        self.root_seed.zeroize();
178    }
179}
180
181impl NodeIdentityProvider {
182    /// Create from a root signing key.
183    pub fn new(root_key: &SigningKey) -> Self {
184        let node_pubkey = root_key.verifying_key().to_bytes();
185        let mut known = HashMap::new();
186        // The node's own root key is genuine in-process authority → "system".
187        known.insert(node_pubkey, Subject::new("system"));
188        Self {
189            root_seed: root_key.to_bytes(),
190            node_pubkey,
191            known_pubkeys: RwLock::new(known),
192        }
193    }
194
195    /// Derive a purpose-keyed Ed25519 signing key via HKDF.
196    fn derive(&self, purpose: &str) -> Result<SigningKey> {
197        if purpose.is_empty() {
198            anyhow::bail!("purpose must be non-empty");
199        }
200        if purpose.len() > 255 {
201            anyhow::bail!("purpose must be at most 255 bytes");
202        }
203        let hk = Hkdf::<Sha256>::new(Some(NODE_IDENTITY_SALT), &self.root_seed);
204        let mut okm = [0u8; 32];
205        #[allow(clippy::expect_used)] // HKDF-SHA256 expand to 32 bytes cannot fail
206        hk.expand(purpose.as_bytes(), &mut okm)
207            .expect("HKDF-SHA256 expand to 32 bytes cannot fail");
208        let key = SigningKey::from_bytes(&okm);
209        okm.zeroize();
210        Ok(key)
211    }
212
213    /// Pre-register a purpose so its derived pubkey is recognized by `resolve()`.
214    ///
215    /// The derived key belongs to THIS node, so it maps to the in-process
216    /// `"system"` authority. Called automatically by `identity_open()`, but can
217    /// also be called at startup to register purposes used internally.
218    pub fn register_purpose(&self, purpose: &str) -> Result<[u8; 32]> {
219        let key = self.derive(purpose)?;
220        let pubkey = key.verifying_key().to_bytes();
221        self.known_pubkeys
222            .write()
223            .insert(pubkey, Subject::new("system"));
224        Ok(pubkey)
225    }
226
227    /// Enroll a networked mesh peer's Ed25519 signer key → per-host subject (#328).
228    ///
229    /// The peer authenticates as its OWN granular principal
230    /// (`service:inference:host-<label>`), NEVER as `"system"`. The roster is
231    /// populated from the operator-configured `mesh_peers` enrollment record
232    /// (see `hyprstream::auth::mesh_trust`), so a peer whose key is not enrolled
233    /// resolves to [`Subject::anonymous`] (fail-closed, deny-by-default).
234    ///
235    /// A peer key MUST NOT shadow the node's own `"system"` keys: if the pubkey
236    /// is already registered (e.g. the node's root/derived key), the existing
237    /// binding is kept and the peer entry is rejected to prevent a misconfigured
238    /// roster from downgrading in-process authority.
239    pub fn register_peer(&self, pubkey: [u8; 32], subject: Subject) {
240        let mut map = self.known_pubkeys.write();
241        match map.entry(pubkey) {
242            std::collections::hash_map::Entry::Occupied(existing) => {
243                // `tracing` is a native-only dependency for this crate (see Cargo.toml:
244                // it lives under `[target.'cfg(not(target_arch = "wasm32"))'.dependencies]`),
245                // so the macro must be cfg-gated to keep the wasm32 build compiling (#468).
246                #[cfg(not(target_arch = "wasm32"))]
247                tracing::warn!(
248                    existing = ?existing.get().name(),
249                    rejected = ?subject.name(),
250                    "node_identity: mesh peer key collides with an existing binding; keeping existing, rejecting peer enrollment"
251                );
252                #[cfg(target_arch = "wasm32")]
253                let _ = &existing; // silence unused warning on wasm where tracing is absent
254            }
255            std::collections::hash_map::Entry::Vacant(slot) => {
256                slot.insert(subject);
257            }
258        }
259    }
260
261    /// Check if a pubkey is recognized by this node (root, derived, or enrolled peer).
262    pub fn is_known(&self, pubkey: &[u8; 32]) -> bool {
263        self.known_pubkeys.read().contains_key(pubkey)
264    }
265}
266
267#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
268#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
269impl IdentityProvider for NodeIdentityProvider {
270    async fn identity_open(&self, purpose: &str) -> Result<Box<dyn SigningIdentity>> {
271        let signing_key = self.derive(purpose)?;
272        let pubkey = signing_key.verifying_key().to_bytes();
273        // Track this derived pubkey so resolve() recognizes it as in-process "system".
274        self.known_pubkeys
275            .write()
276            .insert(pubkey, Subject::new("system"));
277        Ok(Box::new(DerivedIdentity {
278            signing_key,
279            pubkey,
280        }))
281    }
282
283    fn resolve(&self, pubkey: &[u8; 32]) -> Subject {
284        // Return the per-key subject: "system" for the node's own root/derived
285        // keys, a per-host subject for enrolled mesh peers, anonymous otherwise
286        // (#328 — no "any known key → system" collapse, deny-by-default).
287        self.known_pubkeys
288            .read()
289            .get(pubkey)
290            .cloned()
291            .unwrap_or_else(Subject::anonymous)
292    }
293}
294
295#[cfg(test)]
296mod tests {
297    use super::*;
298    use ed25519_dalek::SigningKey;
299
300    #[allow(clippy::unwrap_used)]
301    #[tokio::test]
302    async fn same_purpose_same_key() {
303        let root = SigningKey::generate(&mut rand::rngs::OsRng);
304        let provider = NodeIdentityProvider::new(&root);
305
306        let id1 = provider.identity_open("test-purpose-v1").await.unwrap();
307        let id2 = provider.identity_open("test-purpose-v1").await.unwrap();
308        assert_eq!(id1.pubkey(), id2.pubkey());
309    }
310
311    #[allow(clippy::unwrap_used)]
312    #[tokio::test]
313    async fn different_purpose_different_key() {
314        let root = SigningKey::generate(&mut rand::rngs::OsRng);
315        let provider = NodeIdentityProvider::new(&root);
316
317        let id1 = provider.identity_open("purpose-a").await.unwrap();
318        let id2 = provider.identity_open("purpose-b").await.unwrap();
319        assert_ne!(id1.pubkey(), id2.pubkey());
320    }
321
322    #[allow(clippy::unwrap_used)]
323    #[tokio::test]
324    async fn sign_and_verify() {
325        let root = SigningKey::generate(&mut rand::rngs::OsRng);
326        let provider = NodeIdentityProvider::new(&root);
327
328        let id = provider.identity_open("test-sign-v1").await.unwrap();
329        let msg = b"hello world";
330        let sig = id.sign(msg).await.unwrap();
331
332        let vk = ed25519_dalek::VerifyingKey::from_bytes(&id.pubkey()).unwrap();
333        let signature = ed25519_dalek::Signature::from_bytes(&sig);
334        use ed25519_dalek::Verifier;
335        assert!(vk.verify(msg, &signature).is_ok());
336    }
337
338    #[allow(clippy::unwrap_used)]
339    #[test]
340    fn resolve_node_key() {
341        let root = SigningKey::generate(&mut rand::rngs::OsRng);
342        let provider = NodeIdentityProvider::new(&root);
343        let node_pub = root.verifying_key().to_bytes();
344
345        assert_eq!(provider.resolve(&node_pub).name(), Some("system"));
346        assert_eq!(provider.resolve(&[0u8; 32]).name(), None);
347    }
348
349    #[allow(clippy::unwrap_used)]
350    #[tokio::test]
351    async fn resolve_derived_key() {
352        let root = SigningKey::generate(&mut rand::rngs::OsRng);
353        let provider = NodeIdentityProvider::new(&root);
354
355        // Before opening, derived pubkey is unknown
356        let pubkey = provider.register_purpose("test-v1").unwrap();
357        assert_eq!(provider.resolve(&pubkey).name(), Some("system"));
358
359        // identity_open also registers
360        let id = provider.identity_open("another-v1").await.unwrap();
361        assert_eq!(provider.resolve(&id.pubkey()).name(), Some("system"));
362
363        // Unknown key still anonymous
364        assert_eq!(provider.resolve(&[0u8; 32]).name(), None);
365    }
366
367    #[allow(clippy::unwrap_used)]
368    #[test]
369    fn enrolled_peer_resolves_to_per_host_subject() {
370        // #328: an enrolled mesh peer must resolve to its OWN granular per-host
371        // subject, never to "system".
372        let root = SigningKey::generate(&mut rand::rngs::OsRng);
373        let provider = NodeIdentityProvider::new(&root);
374
375        let peer = SigningKey::generate(&mut rand::rngs::OsRng);
376        let peer_pub = peer.verifying_key().to_bytes();
377        provider.register_peer(peer_pub, mesh_host_subject("gpu-node-7"));
378
379        assert_eq!(
380            provider.resolve(&peer_pub).name(),
381            Some("service:inference:host-gpu-node-7"),
382        );
383    }
384
385    #[allow(clippy::unwrap_used)]
386    #[test]
387    fn unenrolled_peer_resolves_to_anonymous_not_system() {
388        // #328 regression: the old "any known key → system god principal"
389        // behavior is gone. A networked peer key that is NOT in the roster must
390        // resolve to anonymous, never "system".
391        let root = SigningKey::generate(&mut rand::rngs::OsRng);
392        let provider = NodeIdentityProvider::new(&root);
393
394        let stranger = SigningKey::generate(&mut rand::rngs::OsRng);
395        let stranger_pub = stranger.verifying_key().to_bytes();
396
397        let resolved = provider.resolve(&stranger_pub);
398        assert!(resolved.is_anonymous(), "unenrolled peer must be anonymous");
399        assert_ne!(resolved.name(), Some("system"));
400    }
401
402    #[allow(clippy::unwrap_used)]
403    #[test]
404    fn node_root_key_still_resolves_to_system() {
405        // #328 no-regression: the node's own root key (genuine in-process
406        // authority) must keep resolving to "system".
407        let root = SigningKey::generate(&mut rand::rngs::OsRng);
408        let node_pub = root.verifying_key().to_bytes();
409        let provider = NodeIdentityProvider::new(&root);
410        assert_eq!(provider.resolve(&node_pub).name(), Some("system"));
411    }
412
413    #[allow(clippy::unwrap_used)]
414    #[test]
415    fn peer_enrollment_cannot_shadow_system_keys() {
416        // #328: a misconfigured roster must not be able to downgrade the node's
417        // own "system" authority by re-binding the node's root key.
418        let root = SigningKey::generate(&mut rand::rngs::OsRng);
419        let node_pub = root.verifying_key().to_bytes();
420        let provider = NodeIdentityProvider::new(&root);
421
422        provider.register_peer(node_pub, mesh_host_subject("evil"));
423        assert_eq!(
424            provider.resolve(&node_pub).name(),
425            Some("system"),
426            "existing system binding must win over a colliding peer enrollment"
427        );
428    }
429
430    #[allow(clippy::unwrap_used)]
431    #[tokio::test]
432    async fn empty_purpose_rejected() {
433        let root = SigningKey::generate(&mut rand::rngs::OsRng);
434        let provider = NodeIdentityProvider::new(&root);
435        assert!(provider.identity_open("").await.is_err());
436    }
437
438    #[allow(clippy::unwrap_used)]
439    #[tokio::test]
440    async fn long_purpose_rejected() {
441        let root = SigningKey::generate(&mut rand::rngs::OsRng);
442        let provider = NodeIdentityProvider::new(&root);
443        let long = "x".repeat(256);
444        assert!(provider.identity_open(&long).await.is_err());
445    }
446
447    #[allow(clippy::unwrap_used)]
448    #[test]
449    fn mesh_mldsa_key_is_deterministic() {
450        // #157: deriving the mesh ML-DSA key from the same node Ed25519 key must
451        // be stable across calls (so it survives restarts without a key file).
452        let root = SigningKey::from_bytes(&[3u8; 32]);
453        let sk1 = derive_mesh_mldsa_key(&root);
454        let sk2 = derive_mesh_mldsa_key(&root);
455        assert_eq!(
456            crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&sk1),
457            crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&sk2),
458            "same node seed must derive the same mesh ML-DSA key"
459        );
460    }
461
462    #[allow(clippy::unwrap_used)]
463    #[test]
464    fn mesh_mldsa_key_differs_per_node() {
465        let root_a = SigningKey::generate(&mut rand::rngs::OsRng);
466        let root_b = SigningKey::generate(&mut rand::rngs::OsRng);
467        let vk_a = crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&derive_mesh_mldsa_key(&root_a));
468        let vk_b = crate::crypto::pq::ml_dsa_sk_to_vk_bytes(&derive_mesh_mldsa_key(&root_b));
469        assert_ne!(
470            vk_a, vk_b,
471            "different node seeds must derive different mesh keys"
472        );
473    }
474
475    #[allow(clippy::unwrap_used)]
476    #[test]
477    fn mesh_mldsa_key_separated_from_ed25519() {
478        // PQUIP key separation: the derived ML-DSA seed must not equal the
479        // Ed25519 node seed (it goes through a dedicated purpose label).
480        let root = SigningKey::from_bytes(&[9u8; 32]);
481        let mesh_sk = derive_mesh_mldsa_key(&root);
482        let mesh_seed = crate::crypto::pq::ml_dsa_sk_to_seed(&mesh_sk);
483        assert_ne!(
484            mesh_seed,
485            root.to_bytes(),
486            "mesh ML-DSA seed must be key-separated from the Ed25519 node seed"
487        );
488        // And it equals the explicit two-step derivation (purpose key -> seed).
489        let expected_seed = derive_purpose_key(&root, MESH_MLDSA_PURPOSE).to_bytes();
490        assert_eq!(
491            mesh_seed, expected_seed,
492            "derivation must match the purpose-key path"
493        );
494    }
495
496    #[allow(clippy::unwrap_used)]
497    #[test]
498    fn salt_produces_different_keys_than_none() {
499        let root = SigningKey::generate(&mut rand::rngs::OsRng);
500        // With salt (current implementation)
501        let salted = derive_purpose_key(&root, "test-purpose");
502        // Without salt (old implementation)
503        let hk = Hkdf::<Sha256>::new(None, &root.to_bytes());
504        let mut unsalted_okm = [0u8; 32];
505        hk.expand(b"test-purpose", &mut unsalted_okm).unwrap();
506        let unsalted = SigningKey::from_bytes(&unsalted_okm);
507        unsalted_okm.fill(0);
508
509        assert_ne!(
510            salted.verifying_key().to_bytes(),
511            unsalted.verifying_key().to_bytes(),
512            "Salted and unsalted HKDF must produce different keys"
513        );
514    }
515
516    // ---- #mesh-kem hybrid keyAgreement identity (S1 / #552) ----
517
518    #[allow(clippy::unwrap_used)]
519    #[test]
520    fn mesh_kem_recipient_is_deterministic() {
521        // Same node root must derive the same #mesh-kem public material so it
522        // survives restarts without a key file.
523        let root = SigningKey::from_bytes(&[5u8; 32]);
524        let a = derive_mesh_kem_recipient(&root).unwrap();
525        let b = derive_mesh_kem_recipient(&root).unwrap();
526        assert_eq!(a.public(), b.public());
527    }
528
529    #[allow(clippy::unwrap_used)]
530    #[test]
531    fn mesh_kem_recipient_differs_per_node() {
532        let a = derive_mesh_kem_recipient(&SigningKey::from_bytes(&[1u8; 32])).unwrap();
533        let b = derive_mesh_kem_recipient(&SigningKey::from_bytes(&[2u8; 32])).unwrap();
534        assert_ne!(a.public(), b.public());
535    }
536
537    #[allow(clippy::unwrap_used)]
538    #[test]
539    fn mesh_kem_is_key_separated() {
540        // The #mesh-kem X25519 leg must differ from the Ed25519 identity key and
541        // from the bare purpose-key derivation (PQUIP key separation).
542        let root = SigningKey::from_bytes(&[9u8; 32]);
543        let pubs = derive_mesh_kem_recipient(&root).unwrap().public();
544        let x25519_ek = &pubs.eks[0]; // suite component 0 = X25519 (32 bytes)
545        assert_ne!(
546            x25519_ek.as_slice(),
547            &root.verifying_key().to_bytes()[..],
548            "#mesh-kem X25519 key must differ from the Ed25519 identity key"
549        );
550        let bare = derive_purpose_key(&root, MESH_KEM_PURPOSE).to_bytes();
551        assert_ne!(
552            x25519_ek.as_slice(),
553            &bare[..],
554            "per-component sub-label seed must differ from the bare purpose key"
555        );
556    }
557}