Skip to main content

hyprstream_rpc/crypto/
signing.rs

1//! Ed25519 digital signatures for request envelope authentication.
2//!
3//! All ZMQ messages are signed to provide:
4//! - Authentication: Proves who created the request
5//! - Integrity: Detects tampering
6//! - Non-repudiation: Signature survives message forwarding
7//!
8//! # Signing Flow
9//!
10//! 1. API server validates bearer token or JWT
11//! 2. Signs `RequestEnvelope` (request_id, payload, nonce, iat) with Ed25519 key
12//! 3. ZMQ service verifies signature before processing
13
14use zeroize::Zeroizing;
15
16use crate::error::{EnvelopeError, EnvelopeResult};
17
18#[cfg(test)]
19use ed25519_dalek::{Signature, Signer, Verifier};
20#[cfg(test)]
21use sha2::{Digest, Sha512};
22
23// Re-export key types
24pub use ed25519_dalek::{SigningKey, VerifyingKey};
25
26/// Sign a message using Ed25519 with pre-hashing (Ed25519ph).
27///
28/// Uses streaming hash to avoid allocating the full message.
29///
30/// Note: Only used in tests. The production signing path uses
31/// `SignedEnvelope::new_signed` which signs canonicalized envelope bytes directly.
32#[cfg(test)]
33pub fn sign_message(
34    signing_key: &SigningKey,
35    request_id: u64,
36    identity_bytes: &[u8],
37    payload: &[u8],
38) -> [u8; 64] {
39    // Build the message to sign using streaming hash
40    let mut hasher = Sha512::new();
41    hasher.update(request_id.to_le_bytes());
42    hasher.update(identity_bytes);
43    hasher.update(payload);
44    let hash = hasher.finalize();
45
46    // Sign the hash
47    // Note: ed25519-dalek internally hashes again, but we pre-hash for
48    // consistency with the streaming approach. This is effectively Ed25519ph.
49    let signature = signing_key.sign(&hash);
50    signature.to_bytes()
51}
52
53/// Verify an Ed25519 pre-hashed signature.
54///
55/// Note: Only used in tests alongside `sign_message`.
56#[cfg(test)]
57pub fn verify_message(
58    verifying_key: &VerifyingKey,
59    signature: &[u8; 64],
60    request_id: u64,
61    identity_bytes: &[u8],
62    payload: &[u8],
63) -> EnvelopeResult<()> {
64    // Reconstruct the hash that was signed
65    let mut hasher = Sha512::new();
66    hasher.update(request_id.to_le_bytes());
67    hasher.update(identity_bytes);
68    hasher.update(payload);
69    let hash = hasher.finalize();
70
71    // Verify
72    let sig = Signature::from_bytes(signature);
73    verifying_key.verify(&hash, &sig)?;
74    Ok(())
75}
76
77/// Generate a new Ed25519 signing keypair.
78///
79/// Uses the system's secure random number generator.
80pub fn generate_signing_keypair() -> (SigningKey, VerifyingKey) {
81    let signing_key = SigningKey::generate(&mut rand::thread_rng());
82    let verifying_key = signing_key.verifying_key();
83    (signing_key, verifying_key)
84}
85
86/// Load a signing key from 32 secret bytes.
87///
88/// # Security
89///
90/// The input bytes are wrapped in `Zeroizing` to ensure they are
91/// securely erased from memory when dropped.
92pub fn signing_key_from_bytes(bytes: &[u8; 32]) -> SigningKey {
93    let secret = Zeroizing::new(*bytes);
94    SigningKey::from_bytes(&secret)
95}
96
97/// Load a verifying key from 32 public key bytes.
98///
99/// # Errors
100///
101/// Returns `EnvelopeError::InvalidPublicKey` if the bytes are not a valid
102/// Ed25519 public key.
103pub fn verifying_key_from_bytes(bytes: &[u8; 32]) -> EnvelopeResult<VerifyingKey> {
104    VerifyingKey::from_bytes(bytes).map_err(EnvelopeError::InvalidSignature)
105}
106
107#[cfg(test)]
108mod tests {
109    use super::*;
110
111    #[test]
112    fn test_sign_verify_roundtrip() -> crate::EnvelopeResult<()> {
113        let (signing_key, verifying_key) = generate_signing_keypair();
114
115        let request_id = 12345u64;
116        let identity_bytes = b"local:alice";
117        let payload = b"test payload data";
118
119        let signature = sign_message(&signing_key, request_id, identity_bytes, payload);
120
121        // Should verify successfully
122        verify_message(
123            &verifying_key,
124            &signature,
125            request_id,
126            identity_bytes,
127            payload,
128        )?;
129        Ok(())
130    }
131
132    #[test]
133    fn test_tampered_payload_fails() {
134        let (signing_key, verifying_key) = generate_signing_keypair();
135
136        let request_id = 12345u64;
137        let identity_bytes = b"local:alice";
138        let payload = b"original payload";
139
140        let signature = sign_message(&signing_key, request_id, identity_bytes, payload);
141
142        // Tampered payload should fail
143        let tampered = b"tampered payload";
144        let result = verify_message(
145            &verifying_key,
146            &signature,
147            request_id,
148            identity_bytes,
149            tampered,
150        );
151        assert!(result.is_err());
152    }
153
154    #[test]
155    fn test_tampered_request_id_fails() {
156        let (signing_key, verifying_key) = generate_signing_keypair();
157
158        let request_id = 12345u64;
159        let identity_bytes = b"local:alice";
160        let payload = b"test payload";
161
162        let signature = sign_message(&signing_key, request_id, identity_bytes, payload);
163
164        // Different request_id should fail
165        let result = verify_message(&verifying_key, &signature, 99999, identity_bytes, payload);
166        assert!(result.is_err());
167    }
168
169    #[test]
170    fn test_wrong_key_fails() {
171        let (signing_key, _) = generate_signing_keypair();
172        let (_, wrong_verifying_key) = generate_signing_keypair();
173
174        let request_id = 12345u64;
175        let identity_bytes = b"local:alice";
176        let payload = b"test payload";
177
178        let signature = sign_message(&signing_key, request_id, identity_bytes, payload);
179
180        // Wrong key should fail
181        let result = verify_message(
182            &wrong_verifying_key,
183            &signature,
184            request_id,
185            identity_bytes,
186            payload,
187        );
188        assert!(result.is_err());
189    }
190
191    #[test]
192    fn test_key_serialization_roundtrip() -> crate::EnvelopeResult<()> {
193        let (signing_key, verifying_key) = generate_signing_keypair();
194
195        // Serialize and deserialize signing key
196        let signing_bytes = signing_key.to_bytes();
197        let restored_signing = signing_key_from_bytes(&signing_bytes);
198        assert_eq!(signing_key.to_bytes(), restored_signing.to_bytes());
199
200        // Serialize and deserialize verifying key
201        let verifying_bytes = verifying_key.to_bytes();
202        let restored_verifying = verifying_key_from_bytes(&verifying_bytes)?;
203        assert_eq!(verifying_key.to_bytes(), restored_verifying.to_bytes());
204        Ok(())
205    }
206}