hxrts-aura-composition 0.2.0

//! Crypto handler adapter

use crate::adapters::collect_ops;
use crate::adapters::utils::{deserialize_operation_params, serialize_operation_result};
use crate::registry::{HandlerContext, HandlerError, RegistrableHandler};
use async_trait::async_trait;
use aura_core::effects::crypto::{FrostSigningPackage, KeyDerivationContext, SigningMode};
use aura_core::effects::{CryptoCoreEffects, CryptoExtendedEffects};
use aura_core::{EffectType, ExecutionMode};
use aura_effects::crypto::RealCryptoHandler;
use std::sync::Arc;

/// Adapter for RealCryptoHandler
pub struct CryptoHandlerAdapter {
    core: Arc<dyn CryptoCoreEffects>,
    extended: Option<Arc<dyn CryptoExtendedEffects>>,
}

impl CryptoHandlerAdapter {
    pub fn new(handler: RealCryptoHandler) -> Self {
        let handler = Arc::new(handler);
        let core: Arc<dyn CryptoCoreEffects> = handler.clone();
        let extended: Arc<dyn CryptoExtendedEffects> = handler;
        Self {
            core,
            extended: Some(extended),
        }
    }

    pub fn new_core(handler: Arc<dyn CryptoCoreEffects>) -> Self {
        Self {
            core: handler,
            extended: None,
        }
    }

    pub fn new_extended<T: CryptoExtendedEffects + 'static>(handler: T) -> Self {
        let handler = Arc::new(handler);
        let core: Arc<dyn CryptoCoreEffects> = handler.clone();
        let extended: Arc<dyn CryptoExtendedEffects> = handler;
        Self {
            core,
            extended: Some(extended),
        }
    }
}

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl RegistrableHandler for CryptoHandlerAdapter {
    async fn execute_operation_bytes(
        &self,
        effect_type: EffectType,
        operation: &str,
        parameters: &[u8],
        _ctx: &HandlerContext,
    ) -> Result<Vec<u8>, HandlerError> {
        if effect_type != EffectType::Crypto {
            return Err(HandlerError::UnsupportedEffect { effect_type });
        }

        match operation {
            "kdf_derive" => {
                // Parameters would be (ikm, salt, info, length)
                let params: (Vec<u8>, Option<Vec<u8>>, Vec<u8>, u32) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let salt = params.1.unwrap_or_default();
                let result = self
                    .core
                    .kdf_derive(&params.0, &salt, &params.2, params.3)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "derive_key" => {
                let params: (Vec<u8>, KeyDerivationContext) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = self
                    .core
                    .derive_key(&params.0, &params.1)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "ed25519_generate_keypair" => {
                let result = self.core.ed25519_generate_keypair().await.map_err(|e| {
                    HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    }
                })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "ed25519_sign" => {
                let params: (Vec<u8>, Vec<u8>) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = self
                    .core
                    .ed25519_sign(&params.0, &params.1)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "ed25519_verify" => {
                let params: (Vec<u8>, Vec<u8>, Vec<u8>) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = self
                    .core
                    .ed25519_verify(&params.0, &params.1, &params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "ed25519_public_key" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let private_key: Vec<u8> =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .ed25519_public_key(&private_key)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "generate_signing_keys" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let (threshold, max_signers): (u16, u16) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .generate_signing_keys(threshold, max_signers)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "sign_with_key" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, Vec<u8>, SigningMode) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .sign_with_key(&params.0, &params.1, params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "verify_signature" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, Vec<u8>, Vec<u8>, SigningMode) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .verify_signature(&params.0, &params.1, &params.2, params.3)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "frost_generate_keys" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let (threshold, max_signers): (u16, u16) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .frost_generate_keys(threshold, max_signers)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "frost_generate_nonces" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let key_package: Vec<u8> =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .frost_generate_nonces(&key_package)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "frost_create_signing_package" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, Vec<Vec<u8>>, Vec<u16>, Vec<u8>) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .frost_create_signing_package(&params.0, &params.1, &params.2, &params.3)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "frost_sign_share" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (FrostSigningPackage, Vec<u8>, Vec<u8>) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .frost_sign_share(&params.0, &params.1, &params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "frost_aggregate_signatures" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (FrostSigningPackage, Vec<Vec<u8>>) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .frost_aggregate_signatures(&params.0, &params.1)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "frost_verify" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, Vec<u8>, Vec<u8>) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .frost_verify(&params.0, &params.1, &params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "aes_gcm_encrypt" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .aes_gcm_encrypt(&params.0, &params.1, &params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "aes_gcm_decrypt" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .aes_gcm_decrypt(&params.0, &params.1, &params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "chacha20_encrypt" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .chacha20_encrypt(&params.0, &params.1, &params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "chacha20_decrypt" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<u8>, [u8; 32], [u8; 12]) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .chacha20_decrypt(&params.0, &params.1, &params.2)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            "frost_rotate_keys" => {
                let handler =
                    self.extended
                        .as_ref()
                        .ok_or_else(|| HandlerError::UnknownOperation {
                            effect_type,
                            operation: operation.to_string(),
                        })?;
                let params: (Vec<Vec<u8>>, u16, u16, u16) =
                    deserialize_operation_params(effect_type, operation, parameters)?;
                let result = handler
                    .frost_rotate_keys(&params.0, params.1, params.2, params.3)
                    .await
                    .map_err(|e| HandlerError::ExecutionFailed {
                        source: Box::new(e),
                    })?;
                serialize_operation_result(effect_type, operation, &result)
            }
            _ => Err(HandlerError::UnknownOperation {
                effect_type,
                operation: operation.to_string(),
            }),
        }
    }

    fn supported_operations(&self, effect_type: EffectType) -> Vec<String> {
        collect_ops(effect_type, self.extended.is_some())
    }

    fn supports_effect(&self, effect_type: EffectType) -> bool {
        effect_type == EffectType::Crypto
    }

    fn execution_mode(&self) -> ExecutionMode {
        ExecutionMode::Production
    }
}