hyprstream_rpc/crypto/
signing.rs1use 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
23pub use ed25519_dalek::{SigningKey, VerifyingKey};
25
26#[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 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 let signature = signing_key.sign(&hash);
50 signature.to_bytes()
51}
52
53#[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 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 let sig = Signature::from_bytes(signature);
73 verifying_key.verify(&hash, &sig)?;
74 Ok(())
75}
76
77pub 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
86pub fn signing_key_from_bytes(bytes: &[u8; 32]) -> SigningKey {
93 let secret = Zeroizing::new(*bytes);
94 SigningKey::from_bytes(&secret)
95}
96
97pub 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 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 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 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 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 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 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}