1use 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
24const NODE_IDENTITY_SALT: &[u8] = b"hyprstream-node-identity-hkdf-v1";
27
28pub fn mesh_host_subject(label: &str) -> Subject {
36 Subject::new(format!("service:inference:host-{label}"))
37}
38
39#[allow(clippy::expect_used)] pub 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
56pub const MESH_MLDSA_PURPOSE: &str = "hyprstream-mesh-mldsa-v1";
63
64pub 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
83pub const MESH_KEM_PURPOSE: &str = "hyprstream-mesh-kem-v1";
89
90fn 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)] hk.expand(info, out)
98 .expect("HKDF-SHA256 expand within the length bound cannot fail");
99}
100
101pub 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 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
135struct 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
155pub struct NodeIdentityProvider {
164 root_seed: [u8; 32],
165 #[allow(dead_code)]
166 node_pubkey: [u8; 32],
167 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 pub fn new(root_key: &SigningKey) -> Self {
184 let node_pubkey = root_key.verifying_key().to_bytes();
185 let mut known = HashMap::new();
186 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 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)] 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 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 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 #[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; }
255 std::collections::hash_map::Entry::Vacant(slot) => {
256 slot.insert(subject);
257 }
258 }
259 }
260
261 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 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 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 let pubkey = provider.register_purpose("test-v1").unwrap();
357 assert_eq!(provider.resolve(&pubkey).name(), Some("system"));
358
359 let id = provider.identity_open("another-v1").await.unwrap();
361 assert_eq!(provider.resolve(&id.pubkey()).name(), Some("system"));
362
363 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 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 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 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 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 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 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 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 let salted = derive_purpose_key(&root, "test-purpose");
502 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 #[allow(clippy::unwrap_used)]
519 #[test]
520 fn mesh_kem_recipient_is_deterministic() {
521 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 let root = SigningKey::from_bytes(&[9u8; 32]);
543 let pubs = derive_mesh_kem_recipient(&root).unwrap().public();
544 let x25519_ek = &pubs.eks[0]; 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}