huddle_core/
identity.rs

1use ed25519_dalek::{Signer, SigningKey};
2use libp2p::identity::{self, Keypair};
3use libp2p::PeerId;
4use sha2::{Digest, Sha256};
5
6use crate::error::{HuddleError, Result};
7
8pub struct Identity {
9    signing_key: SigningKey,
10    libp2p_keypair: Keypair,
11    peer_id: PeerId,
12    fingerprint: String,
13}
14
15impl Identity {
16    pub fn generate() -> Result<Self> {
17        let mut rng = rand::thread_rng();
18        let signing_key = SigningKey::generate(&mut rng);
19        Self::from_signing_key(signing_key)
20    }
21
22    pub fn from_secret_bytes(bytes: [u8; 32]) -> Result<Self> {
23        let signing_key = SigningKey::from_bytes(&bytes);
24        Self::from_signing_key(signing_key)
25    }
26
27    fn from_signing_key(signing_key: SigningKey) -> Result<Self> {
28        let secret = signing_key.to_bytes();
29        let public = signing_key.verifying_key().to_bytes();
30        let mut combined = [0u8; 64];
31        combined[..32].copy_from_slice(&secret);
32        combined[32..].copy_from_slice(&public);
33
34        let ed25519_kp = identity::ed25519::Keypair::try_from_bytes(&mut combined)
35            .map_err(|e| HuddleError::Identity(e.to_string()))?;
36        let libp2p_keypair = Keypair::from(ed25519_kp);
37        let peer_id = PeerId::from(libp2p_keypair.public());
38        let fingerprint = compute_fingerprint(&public);
39
40        Ok(Self {
41            signing_key,
42            libp2p_keypair,
43            peer_id,
44            fingerprint,
45        })
46    }
47
48    pub fn fingerprint(&self) -> &str {
49        &self.fingerprint
50    }
51
52    pub fn peer_id(&self) -> PeerId {
53        self.peer_id
54    }
55
56    pub fn keypair(&self) -> &Keypair {
57        &self.libp2p_keypair
58    }
59
60    pub fn secret_bytes(&self) -> [u8; 32] {
61        self.signing_key.to_bytes()
62    }
63
64    pub fn public_bytes(&self) -> [u8; 32] {
65        self.signing_key.verifying_key().to_bytes()
66    }
67
68    /// Ed25519-sign `msg` with our identity key. The signature binds
69    /// arbitrary bytes to this fingerprint; used by protocol envelopes
70    /// (`SignedRoomMessage`) so receivers can prove the sender's identity
71    /// at the application layer (gossipsub only proves transport-level).
72    pub fn sign(&self, msg: &[u8]) -> [u8; 64] {
73        self.signing_key.sign(msg).to_bytes()
74    }
75}
76
77/// Derive the human-facing 24-char fingerprint from an Ed25519 public key.
78/// Format: `xxxx-xxxx-xxxx-xxxx-xxxx-xxxx` (6 groups of 4 hex chars, 24 hex
79/// chars total = 12 bytes = 96 bits of SHA-256 over the pubkey). Public so
80/// `crypto::verify_signed` can re-derive it from a signed envelope's pubkey
81/// and check that it matches the asserted fingerprint.
82pub fn compute_fingerprint(public_key: &[u8; 32]) -> String {
83    let hash = Sha256::digest(public_key);
84    let hex_str = hex::encode(&hash[..12]);
85    hex_str
86        .as_bytes()
87        .chunks(4)
88        .map(|chunk| std::str::from_utf8(chunk).unwrap())
89        .collect::<Vec<&str>>()
90        .join("-")
91}
92
93#[cfg(test)]
94mod tests {
95    use super::*;
96
97    #[test]
98    fn fingerprint_is_deterministic() {
99        let key_bytes = [42u8; 32];
100        let id = Identity::from_secret_bytes(key_bytes).unwrap();
101        let id2 = Identity::from_secret_bytes(key_bytes).unwrap();
102        assert_eq!(id.fingerprint(), id2.fingerprint());
103    }
104
105    #[test]
106    fn fingerprint_format_is_correct() {
107        let id = Identity::generate().unwrap();
108        let fp = id.fingerprint();
109        let parts: Vec<&str> = fp.split('-').collect();
110        assert_eq!(parts.len(), 6);
111        for part in &parts {
112            assert_eq!(part.len(), 4);
113            assert!(part.chars().all(|c| c.is_ascii_hexdigit()));
114        }
115    }
116
117    #[test]
118    fn different_keys_produce_different_fingerprints() {
119        let id1 = Identity::generate().unwrap();
120        let id2 = Identity::generate().unwrap();
121        assert_ne!(id1.fingerprint(), id2.fingerprint());
122    }
123
124    #[test]
125    fn round_trip_through_bytes() {
126        let id1 = Identity::generate().unwrap();
127        let bytes = id1.secret_bytes();
128        let id2 = Identity::from_secret_bytes(bytes).unwrap();
129        assert_eq!(id1.fingerprint(), id2.fingerprint());
130        assert_eq!(id1.peer_id(), id2.peer_id());
131    }
132
133    #[test]
134    fn peer_id_is_derived_from_same_key() {
135        let id = Identity::generate().unwrap();
136        let pid = id.peer_id();
137        assert!(!pid.to_string().is_empty());
138    }
139}
huddle_core/identity.rs

huddle_core/
identity.rs
