aura_composition/adapters/
crypto.rs

1//! Crypto handler adapter
2
3use crate::adapters::collect_ops;
4use crate::adapters::utils::{deserialize_operation_params, serialize_operation_result};
5use crate::registry::{HandlerContext, HandlerError, RegistrableHandler};
6use async_trait::async_trait;
7use aura_core::effects::crypto::{FrostSigningPackage, KeyDerivationContext, SigningMode};
8use aura_core::effects::{CryptoCoreEffects, CryptoExtendedEffects};
9use aura_core::{EffectType, ExecutionMode};
10use aura_effects::crypto::RealCryptoHandler;
11use std::sync::Arc;
12
13/// Adapter for RealCryptoHandler
14pub struct CryptoHandlerAdapter {
15    core: Arc<dyn CryptoCoreEffects>,
16    extended: Option<Arc<dyn CryptoExtendedEffects>>,
17}
18
19impl CryptoHandlerAdapter {
20    pub fn new(handler: RealCryptoHandler) -> Self {
21        let handler = Arc::new(handler);
22        let core: Arc<dyn CryptoCoreEffects> = handler.clone();
23        let extended: Arc<dyn CryptoExtendedEffects> = handler;
24        Self {
25            core,
26            extended: Some(extended),
27        }
28    }
29
30    pub fn new_core(handler: Arc<dyn CryptoCoreEffects>) -> Self {
31        Self {
32            core: handler,
33            extended: None,
34        }
35    }
36
37    pub fn new_extended<T: CryptoExtendedEffects + 'static>(handler: T) -> Self {
38        let handler = Arc::new(handler);
39        let core: Arc<dyn CryptoCoreEffects> = handler.clone();
40        let extended: Arc<dyn CryptoExtendedEffects> = handler;
41        Self {
42            core,
43            extended: Some(extended),
44        }
45    }
46}
47
48#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
49#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
50impl RegistrableHandler for CryptoHandlerAdapter {
51    async fn execute_operation_bytes(
52        &self,
53        effect_type: EffectType,
54        operation: &str,
55        parameters: &[u8],
56        _ctx: &HandlerContext,
57    ) -> Result<Vec<u8>, HandlerError> {
58        if effect_type != EffectType::Crypto {
59            return Err(HandlerError::UnsupportedEffect { effect_type });
60        }
61
62        match operation {
63            "kdf_derive" => {
64                // Parameters would be (ikm, salt, info, length)
65                let params: (Vec<u8>, Option<Vec<u8>>, Vec<u8>, u32) =
66                    deserialize_operation_params(effect_type, operation, parameters)?;
67                let salt = params.1.unwrap_or_default();
68                let result = self
69                    .core
70                    .kdf_derive(&params.0, &salt, &params.2, params.3)
71                    .await
72                    .map_err(|e| HandlerError::ExecutionFailed {
73                        source: Box::new(e),
74                    })?;
75                serialize_operation_result(effect_type, operation, &result)
76            }
77            "derive_key" => {
78                let params: (Vec<u8>, KeyDerivationContext) =
79                    deserialize_operation_params(effect_type, operation, parameters)?;
80                let result = self
81                    .core
82                    .derive_key(&params.0, &params.1)
83                    .await
84                    .map_err(|e| HandlerError::ExecutionFailed {
85                        source: Box::new(e),
86                    })?;
87                serialize_operation_result(effect_type, operation, &result)
88            }
89            "ed25519_generate_keypair" => {
90                let result = self.core.ed25519_generate_keypair().await.map_err(|e| {
91                    HandlerError::ExecutionFailed {
92                        source: Box::new(e),
93                    }
94                })?;
95                serialize_operation_result(effect_type, operation, &result)
96            }
97            "ed25519_sign" => {
98                let params: (Vec<u8>, Vec<u8>) =
99                    deserialize_operation_params(effect_type, operation, parameters)?;
100                let result = self
101                    .core
102                    .ed25519_sign(&params.0, &params.1)
103                    .await
104                    .map_err(|e| HandlerError::ExecutionFailed {
105                        source: Box::new(e),
106                    })?;
107                serialize_operation_result(effect_type, operation, &result)
108            }
109            "ed25519_verify" => {
110                let params: (Vec<u8>, Vec<u8>, Vec<u8>) =
111                    deserialize_operation_params(effect_type, operation, parameters)?;
112                let result = self
113                    .core
114                    .ed25519_verify(&params.0, &params.1, &params.2)
115                    .await
116                    .map_err(|e| HandlerError::ExecutionFailed {
117                        source: Box::new(e),
118                    })?;
119                serialize_operation_result(effect_type, operation, &result)
120            }
121            "ed25519_public_key" => {
122                let handler =
123                    self.extended
124                        .as_ref()
125                        .ok_or_else(|| HandlerError::UnknownOperation {
126                            effect_type,
127                            operation: operation.to_string(),
128                        })?;
129                let private_key: Vec<u8> =
130                    deserialize_operation_params(effect_type, operation, parameters)?;
131                let result = handler
132                    .ed25519_public_key(&private_key)
133                    .await
134                    .map_err(|e| HandlerError::ExecutionFailed {
135                        source: Box::new(e),
136                    })?;
137                serialize_operation_result(effect_type, operation, &result)
138            }
139            "generate_signing_keys" => {
140                let handler =
141                    self.extended
142                        .as_ref()
143                        .ok_or_else(|| HandlerError::UnknownOperation {
144                            effect_type,
145                            operation: operation.to_string(),
146                        })?;
147                let (threshold, max_signers): (u16, u16) =
148                    deserialize_operation_params(effect_type, operation, parameters)?;
149                let result = handler
150                    .generate_signing_keys(threshold, max_signers)
151                    .await
152                    .map_err(|e| HandlerError::ExecutionFailed {
153                        source: Box::new(e),
154                    })?;
155                serialize_operation_result(effect_type, operation, &result)
156            }
157            "sign_with_key" => {
158                let handler =
159                    self.extended
160                        .as_ref()
161                        .ok_or_else(|| HandlerError::UnknownOperation {
162                            effect_type,
163                            operation: operation.to_string(),
164                        })?;
165                let params: (Vec<u8>, Vec<u8>, SigningMode) =
166                    deserialize_operation_params(effect_type, operation, parameters)?;
167                let result = handler
168                    .sign_with_key(&params.0, &params.1, params.2)
169                    .await
170                    .map_err(|e| HandlerError::ExecutionFailed {
171                        source: Box::new(e),
172                    })?;
173                serialize_operation_result(effect_type, operation, &result)
174            }
175            "verify_signature" => {
176                let handler =
177                    self.extended
178                        .as_ref()
179                        .ok_or_else(|| HandlerError::UnknownOperation {
180                            effect_type,
181                            operation: operation.to_string(),
182                        })?;
183                let params: (Vec<u8>, Vec<u8>, Vec<u8>, SigningMode) =
184                    deserialize_operation_params(effect_type, operation, parameters)?;
185                let result = handler
186                    .verify_signature(&params.0, &params.1, &params.2, params.3)
187                    .await
188                    .map_err(|e| HandlerError::ExecutionFailed {
189                        source: Box::new(e),
190                    })?;
191                serialize_operation_result(effect_type, operation, &result)
192            }
193            "frost_generate_keys" => {
194                let handler =
195                    self.extended
196                        .as_ref()
197                        .ok_or_else(|| HandlerError::UnknownOperation {
198                            effect_type,
199                            operation: operation.to_string(),
200                        })?;
201                let (threshold, max_signers): (u16, u16) =
202                    deserialize_operation_params(effect_type, operation, parameters)?;
203                let result = handler
204                    .frost_generate_keys(threshold, max_signers)
205                    .await
206                    .map_err(|e| HandlerError::ExecutionFailed {
207                        source: Box::new(e),
208                    })?;
209                serialize_operation_result(effect_type, operation, &result)
210            }
211            "frost_generate_nonces" => {
212                let handler =
213                    self.extended
214                        .as_ref()
215                        .ok_or_else(|| HandlerError::UnknownOperation {
216                            effect_type,
217                            operation: operation.to_string(),
218                        })?;
219                let key_package: Vec<u8> =
220                    deserialize_operation_params(effect_type, operation, parameters)?;
221                let result = handler
222                    .frost_generate_nonces(&key_package)
223                    .await
224                    .map_err(|e| HandlerError::ExecutionFailed {
225                        source: Box::new(e),
226                    })?;
227                serialize_operation_result(effect_type, operation, &result)
228            }
229            "frost_create_signing_package" => {
230                let handler =
231                    self.extended
232                        .as_ref()
233                        .ok_or_else(|| HandlerError::UnknownOperation {
234                            effect_type,
235                            operation: operation.to_string(),
236                        })?;
237                let params: (Vec<u8>, Vec<Vec<u8>>, Vec<u16>, Vec<u8>) =
238                    deserialize_operation_params(effect_type, operation, parameters)?;
239                let result = handler
240                    .frost_create_signing_package(&params.0, &params.1, &params.2, &params.3)
241                    .await
242                    .map_err(|e| HandlerError::ExecutionFailed {
243                        source: Box::new(e),
244                    })?;
245                serialize_operation_result(effect_type, operation, &result)
246            }
247            "frost_sign_share" => {
248                let handler =
249                    self.extended
250                        .as_ref()
251                        .ok_or_else(|| HandlerError::UnknownOperation {
252                            effect_type,
253                            operation: operation.to_string(),
254                        })?;
255                let params: (FrostSigningPackage, Vec<u8>, Vec<u8>) =
256                    deserialize_operation_params(effect_type, operation, parameters)?;
257                let result = handler
258                    .frost_sign_share(&params.0, &params.1, &params.2)
259                    .await
260                    .map_err(|e| HandlerError::ExecutionFailed {
261                        source: Box::new(e),
262                    })?;
263                serialize_operation_result(effect_type, operation, &result)
264            }
265            "frost_aggregate_signatures" => {
266                let handler =
267                    self.extended
268                        .as_ref()
269                        .ok_or_else(|| HandlerError::UnknownOperation {
270                            effect_type,
271                            operation: operation.to_string(),
272                        })?;
273                let params: (FrostSigningPackage, Vec<Vec<u8>>) =
274                    deserialize_operation_params(effect_type, operation, parameters)?;
275                let result = handler
276                    .frost_aggregate_signatures(&params.0, &params.1)
277                    .await
278                    .map_err(|e| HandlerError::ExecutionFailed {
279                        source: Box::new(e),
280                    })?;
281                serialize_operation_result(effect_type, operation, &result)
282            }
283            "frost_verify" => {
284                let handler =
285                    self.extended
286                        .as_ref()
287                        .ok_or_else(|| HandlerError::UnknownOperation {
288                            effect_type,
289                            operation: operation.to_string(),
290                        })?;
291                let params: (Vec<u8>, Vec<u8>, Vec<u8>) =
292                    deserialize_operation_params(effect_type, operation, parameters)?;
293                let result = handler
294                    .frost_verify(&params.0, &params.1, &params.2)
295                    .await
296                    .map_err(|e| HandlerError::ExecutionFailed {
297                        source: Box::new(e),
298                    })?;
299                serialize_operation_result(effect_type, operation, &result)
300            }
301            "aes_gcm_encrypt" => {
302                let handler =
303                    self.extended
304                        .as_ref()
305                        .ok_or_else(|| HandlerError::UnknownOperation {
306                            effect_type,
307                            operation: operation.to_string(),
308                        })?;
309                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
310                    deserialize_operation_params(effect_type, operation, parameters)?;
311                let result = handler
312                    .aes_gcm_encrypt(&params.0, &params.1, &params.2)
313                    .await
314                    .map_err(|e| HandlerError::ExecutionFailed {
315                        source: Box::new(e),
316                    })?;
317                serialize_operation_result(effect_type, operation, &result)
318            }
319            "aes_gcm_decrypt" => {
320                let handler =
321                    self.extended
322                        .as_ref()
323                        .ok_or_else(|| HandlerError::UnknownOperation {
324                            effect_type,
325                            operation: operation.to_string(),
326                        })?;
327                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
328                    deserialize_operation_params(effect_type, operation, parameters)?;
329                let result = handler
330                    .aes_gcm_decrypt(&params.0, &params.1, &params.2)
331                    .await
332                    .map_err(|e| HandlerError::ExecutionFailed {
333                        source: Box::new(e),
334                    })?;
335                serialize_operation_result(effect_type, operation, &result)
336            }
337            "chacha20_encrypt" => {
338                let handler =
339                    self.extended
340                        .as_ref()
341                        .ok_or_else(|| HandlerError::UnknownOperation {
342                            effect_type,
343                            operation: operation.to_string(),
344                        })?;
345                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
346                    deserialize_operation_params(effect_type, operation, parameters)?;
347                let result = handler
348                    .chacha20_encrypt(&params.0, &params.1, &params.2)
349                    .await
350                    .map_err(|e| HandlerError::ExecutionFailed {
351                        source: Box::new(e),
352                    })?;
353                serialize_operation_result(effect_type, operation, &result)
354            }
355            "chacha20_decrypt" => {
356                let handler =
357                    self.extended
358                        .as_ref()
359                        .ok_or_else(|| HandlerError::UnknownOperation {
360                            effect_type,
361                            operation: operation.to_string(),
362                        })?;
363                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
364                    deserialize_operation_params(effect_type, operation, parameters)?;
365                let result = handler
366                    .chacha20_decrypt(&params.0, &params.1, &params.2)
367                    .await
368                    .map_err(|e| HandlerError::ExecutionFailed {
369                        source: Box::new(e),
370                    })?;
371                serialize_operation_result(effect_type, operation, &result)
372            }
373            "frost_rotate_keys" => {
374                let handler =
375                    self.extended
376                        .as_ref()
377                        .ok_or_else(|| HandlerError::UnknownOperation {
378                            effect_type,
379                            operation: operation.to_string(),
380                        })?;
381                let params: (Vec<Vec<u8>>, u16, u16, u16) =
382                    deserialize_operation_params(effect_type, operation, parameters)?;
383                let result = handler
384                    .frost_rotate_keys(&params.0, params.1, params.2, params.3)
385                    .await
386                    .map_err(|e| HandlerError::ExecutionFailed {
387                        source: Box::new(e),
388                    })?;
389                serialize_operation_result(effect_type, operation, &result)
390            }
391            _ => Err(HandlerError::UnknownOperation {
392                effect_type,
393                operation: operation.to_string(),
394            }),
395        }
396    }
397
398    fn supported_operations(&self, effect_type: EffectType) -> Vec<String> {
399        collect_ops(effect_type, self.extended.is_some())
400    }
401
402    fn supports_effect(&self, effect_type: EffectType) -> bool {
403        effect_type == EffectType::Crypto
404    }
405
406    fn execution_mode(&self) -> ExecutionMode {
407        ExecutionMode::Production
408    }
409}
aura_composition/adapters/crypto.rs

aura_composition/adapters/
crypto.rs
