Skip to main content

maple_sdk/
push.rs

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}