1use crate::error::{Error, Result};
2use aes_gcm::{
3 aead::{Aead, KeyInit},
4 Aes256Gcm, Nonce,
5};
6use base64::{engine::general_purpose::STANDARD as BASE64, Engine};
7use hkdf::Hkdf;
8use p256::{
9 ecdh::diffie_hellman,
10 elliptic_curve::Generate,
11 pkcs8::{DecodePrivateKey, EncodePrivateKey, EncodePublicKey},
12 PublicKey, SecretKey,
13};
14use serde::{Deserialize, Serialize};
15use sha2::Sha256;
16use uuid::Uuid;
17
18pub const PUSH_NOTIFICATION_KEY_ALGORITHM: &str = "p256_ecdh_v1";
19pub const PUSH_NOTIFICATION_ENVELOPE_ALGORITHM: &str = "p256-hkdf-sha256-aes256gcm";
20const PUSH_NOTIFICATION_PAYLOAD_VERSION: i32 = 1;
21const PUSH_NOTIFICATION_PREVIEW_INFO: &[u8] = b"opensecret-push-preview-v1";
22
23#[cfg(test)]
24mod compatibility_tests;
25
26#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
27pub struct EncryptedPushPreviewEnvelope {
28 #[serde(alias = "v")]
29 pub enc_v: i32,
30 pub alg: String,
31 pub kid: String,
32 pub epk: String,
33 pub salt: String,
34 pub nonce: String,
35 pub ciphertext: String,
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
39pub struct PushNotificationPreviewPayload {
40 pub v: i32,
41 pub notification_id: Uuid,
42 pub message_id: Uuid,
43 pub kind: String,
44 pub title: String,
45 pub body: String,
46 pub deep_link: String,
47 pub thread_id: String,
48 pub sent_at: i64,
49}
50
51pub struct PushNotificationKeyPair {
52 private_key: SecretKey,
53}
54
55impl PushNotificationKeyPair {
56 pub fn generate() -> Self {
57 Self {
58 private_key: SecretKey::generate(),
59 }
60 }
61
62 pub fn from_pkcs8_der(private_key_der: &[u8]) -> Result<Self> {
63 let private_key = SecretKey::from_pkcs8_der(private_key_der).map_err(|e| {
64 Error::Configuration(format!("Invalid push notification private key: {e}"))
65 })?;
66
67 Ok(Self { private_key })
68 }
69
70 pub fn from_pkcs8_base64(private_key_base64: &str) -> Result<Self> {
71 let private_key_der = BASE64.decode(private_key_base64)?;
72 Self::from_pkcs8_der(&private_key_der)
73 }
74
75 pub fn private_key_pkcs8_der(&self) -> Result<Vec<u8>> {
76 Ok(self
77 .private_key
78 .to_pkcs8_der()
79 .map_err(|e| {
80 Error::Configuration(format!(
81 "Failed to export push notification private key: {e}"
82 ))
83 })?
84 .as_bytes()
85 .to_vec())
86 }
87
88 pub fn private_key_pkcs8_base64(&self) -> Result<String> {
89 Ok(BASE64.encode(self.private_key_pkcs8_der()?))
90 }
91
92 pub fn public_key_spki_der(&self) -> Result<Vec<u8>> {
93 Ok(self
94 .private_key
95 .public_key()
96 .to_public_key_der()
97 .map_err(|e| {
98 Error::Configuration(format!(
99 "Failed to export push notification public key: {e}"
100 ))
101 })?
102 .as_bytes()
103 .to_vec())
104 }
105
106 pub fn public_key_spki_base64(&self) -> Result<String> {
107 Ok(BASE64.encode(self.public_key_spki_der()?))
108 }
109
110 pub fn decrypt_preview_envelope(
111 &self,
112 envelope: &EncryptedPushPreviewEnvelope,
113 ) -> Result<PushNotificationPreviewPayload> {
114 if envelope.enc_v != PUSH_NOTIFICATION_PAYLOAD_VERSION {
115 return Err(Error::InvalidResponse(format!(
116 "Unsupported push preview version: {}",
117 envelope.enc_v
118 )));
119 }
120
121 if envelope.alg != PUSH_NOTIFICATION_ENVELOPE_ALGORITHM {
122 return Err(Error::InvalidResponse(format!(
123 "Unsupported push preview algorithm: {}",
124 envelope.alg
125 )));
126 }
127
128 let epk_bytes = BASE64.decode(&envelope.epk)?;
129 let salt = BASE64.decode(&envelope.salt)?;
130 let nonce_bytes = BASE64.decode(&envelope.nonce)?;
131 let ciphertext = BASE64.decode(&envelope.ciphertext)?;
132
133 if salt.len() != 32 {
134 return Err(Error::InvalidResponse(format!(
135 "Invalid push preview salt length: {}",
136 salt.len()
137 )));
138 }
139
140 let nonce_bytes: [u8; 12] = nonce_bytes
141 .try_into()
142 .map_err(|_| Error::InvalidResponse("Invalid push preview nonce length".to_string()))?;
143
144 let ephemeral_public = PublicKey::from_sec1_bytes(&epk_bytes)
145 .map_err(|e| Error::Decryption(format!("Invalid push preview ephemeral key: {e}")))?;
146 let shared_secret = diffie_hellman(
147 self.private_key.to_nonzero_scalar(),
148 ephemeral_public.as_affine(),
149 );
150
151 let hkdf = Hkdf::<Sha256>::new(Some(&salt), shared_secret.raw_secret_bytes().as_ref());
152 let mut key = [0_u8; 32];
153 hkdf.expand(PUSH_NOTIFICATION_PREVIEW_INFO, &mut key)
154 .map_err(|_| Error::Crypto("Failed to derive push preview key".to_string()))?;
155
156 let cipher = Aes256Gcm::new_from_slice(&key)
157 .map_err(|e| Error::Crypto(format!("Failed to create push preview cipher: {e}")))?;
158 let nonce = Nonce::from(nonce_bytes);
159 let plaintext = cipher.decrypt(&nonce, ciphertext.as_ref()).map_err(|e| {
160 Error::Decryption(format!("Failed to decrypt push preview payload: {e}"))
161 })?;
162
163 let payload: PushNotificationPreviewPayload = serde_json::from_slice(&plaintext)
164 .map_err(|e| Error::InvalidResponse(format!("Invalid push preview payload: {e}")))?;
165
166 if payload.v != PUSH_NOTIFICATION_PAYLOAD_VERSION {
167 return Err(Error::InvalidResponse(format!(
168 "Unsupported push preview payload version: {}",
169 payload.v
170 )));
171 }
172
173 Ok(payload)
174 }
175}
176
177#[cfg(test)]
178mod tests {
179 use super::*;
180 use crate::crypto::generate_random_bytes;
181 use aes_gcm::{
182 aead::{Aead, KeyInit},
183 Aes256Gcm, Nonce,
184 };
185 use p256::{
186 ecdh::EphemeralSecret, elliptic_curve::sec1::ToSec1Point, pkcs8::DecodePublicKey, PublicKey,
187 };
188
189 fn encrypt_preview_payload_for_test(
190 recipient_public_key_der: &[u8],
191 payload: &PushNotificationPreviewPayload,
192 ) -> EncryptedPushPreviewEnvelope {
193 let recipient_key = PublicKey::from_public_key_der(recipient_public_key_der).unwrap();
194 let ephemeral_secret = EphemeralSecret::generate();
195 let ephemeral_public = PublicKey::from(&ephemeral_secret);
196 let shared_secret = ephemeral_secret.diffie_hellman(&recipient_key);
197
198 let salt = generate_random_bytes::<32>();
199 let hkdf = Hkdf::<Sha256>::new(Some(&salt), shared_secret.raw_secret_bytes().as_ref());
200 let mut key = [0_u8; 32];
201 hkdf.expand(PUSH_NOTIFICATION_PREVIEW_INFO, &mut key)
202 .unwrap();
203
204 let nonce_bytes = generate_random_bytes::<12>();
205 let cipher = Aes256Gcm::new_from_slice(&key).unwrap();
206 let nonce = Nonce::from(nonce_bytes);
207 let plaintext = serde_json::to_vec(payload).unwrap();
208 let ciphertext = cipher.encrypt(&nonce, plaintext.as_ref()).unwrap();
209
210 EncryptedPushPreviewEnvelope {
211 enc_v: 1,
212 alg: PUSH_NOTIFICATION_ENVELOPE_ALGORITHM.to_string(),
213 kid: Uuid::new_v4().to_string(),
214 epk: BASE64.encode(ephemeral_public.to_sec1_point(false).as_bytes()),
215 salt: BASE64.encode(salt),
216 nonce: BASE64.encode(nonce_bytes),
217 ciphertext: BASE64.encode(ciphertext),
218 }
219 }
220
221 #[test]
222 fn push_keypair_pkcs8_round_trips() {
223 let key_pair = PushNotificationKeyPair::generate();
224 let pkcs8_base64 = key_pair.private_key_pkcs8_base64().unwrap();
225
226 let restored = PushNotificationKeyPair::from_pkcs8_base64(&pkcs8_base64).unwrap();
227
228 assert_eq!(
229 key_pair.public_key_spki_base64().unwrap(),
230 restored.public_key_spki_base64().unwrap()
231 );
232 }
233
234 #[test]
235 fn decrypt_preview_envelope_round_trips() {
236 let key_pair = PushNotificationKeyPair::generate();
237 let payload = PushNotificationPreviewPayload {
238 v: PUSH_NOTIFICATION_PAYLOAD_VERSION,
239 notification_id: Uuid::new_v4(),
240 message_id: Uuid::new_v4(),
241 kind: "agent.message".to_string(),
242 title: "New Maple message".to_string(),
243 body: "Open Maple to view your encrypted message".to_string(),
244 deep_link: "opensecret://agent/subagent/123".to_string(),
245 thread_id: "agent:subagent:123".to_string(),
246 sent_at: 1_772_800_000,
247 };
248
249 let envelope =
250 encrypt_preview_payload_for_test(&key_pair.public_key_spki_der().unwrap(), &payload);
251 let decrypted = key_pair.decrypt_preview_envelope(&envelope).unwrap();
252
253 assert_eq!(decrypted, payload);
254 }
255
256 #[test]
257 fn decrypt_preview_envelope_rejects_unknown_algorithm() {
258 let key_pair = PushNotificationKeyPair::generate();
259 let payload = PushNotificationPreviewPayload {
260 v: PUSH_NOTIFICATION_PAYLOAD_VERSION,
261 notification_id: Uuid::new_v4(),
262 message_id: Uuid::new_v4(),
263 kind: "agent.message".to_string(),
264 title: "New Maple message".to_string(),
265 body: "Open Maple to view your encrypted message".to_string(),
266 deep_link: "opensecret://agent".to_string(),
267 thread_id: "agent:main".to_string(),
268 sent_at: 1_772_800_000,
269 };
270
271 let mut envelope =
272 encrypt_preview_payload_for_test(&key_pair.public_key_spki_der().unwrap(), &payload);
273 envelope.alg = "not-supported".to_string();
274
275 let error = key_pair.decrypt_preview_envelope(&envelope).unwrap_err();
276 assert!(
277 matches!(error, Error::InvalidResponse(message) if message.contains("Unsupported push preview algorithm"))
278 );
279 }
280
281 #[test]
282 fn decrypt_preview_envelope_rejects_unknown_payload_version() {
283 let key_pair = PushNotificationKeyPair::generate();
284 let payload = PushNotificationPreviewPayload {
285 v: 2,
286 notification_id: Uuid::new_v4(),
287 message_id: Uuid::new_v4(),
288 kind: "agent.message".to_string(),
289 title: "New Maple message".to_string(),
290 body: "Open Maple to view your encrypted message".to_string(),
291 deep_link: "opensecret://agent".to_string(),
292 thread_id: "agent:main".to_string(),
293 sent_at: 1_772_800_000,
294 };
295
296 let envelope =
297 encrypt_preview_payload_for_test(&key_pair.public_key_spki_der().unwrap(), &payload);
298
299 let error = key_pair.decrypt_preview_envelope(&envelope).unwrap_err();
300 assert!(
301 matches!(error, Error::InvalidResponse(message) if message.contains("Unsupported push preview payload version"))
302 );
303 }
304}