anya-core 1.2.0

//! Open-Source Software HSM for Bitcoin
//!
//! This module provides a pure Rust implementation of a Hardware Security Module (HSM)
//! specifically designed for Bitcoin operations. It follows Bitcoin's open-source
//! philosophy and implements all necessary cryptographic operations using
//! well-audited, Bitcoin-compatible libraries.
//!
//! # Design Philosophy
//! - **Open Source**: Only uses permissively-licensed open-source components
//! - **Bitcoin-First**: Optimized specifically for Bitcoin's cryptographic operations
//! - **Security-Focused**: Implements best practices for key management and memory safety
//! - **Auditable**: Comprehensive logging and verification of all operations
//!
//! # Features
//! - **Secp256k1 Cryptography**: ECDSA and Schnorr signatures using `rust-secp256k1`
//! - **BIP32/39/44/49/84/86**: Hierarchical deterministic wallet support
//! - **PSBT Support**: Full compatibility with Bitcoin's Partially Signed Bitcoin Transactions
//! - **Memory Protection**: Zeroization and mlock() for sensitive data
//! - **Deterministic Signatures**: RFC 6979 compliant nonce generation
//! - **BIP340/341/342**: Schnorr and Taproot support
//! - **Watch-Only Mode**: Support for watch-only wallets with hardware signers
//!
//! # Security Model
//! - Private keys are never exposed in memory in plaintext
//! - All cryptographic operations are performed in constant-time where applicable
//! - Memory is securely zeroized when no longer needed
//! - Side-channel attack mitigations are implemented for critical operations

use async_trait::async_trait;
use std::{
    collections::HashMap,
    sync::atomic::{AtomicBool, Ordering},
    sync::Arc,
    time::{SystemTime, UNIX_EPOCH},
};

// Ensure sensitive data is zeroized on drop
use zeroize::Zeroize;

// [AIR-3][AIS-3][BPC-3][RES-3] Import Bitcoin types for software HSM implementation
// This follows official Bitcoin Improvement Proposals (BIPs) standards for secure HSM implementation
use bitcoin::{
    secp256k1::{Message, PublicKey, Secp256k1, SecretKey},
    Network,
};

// [AIR-3][AIS-3][BPC-3][RES-3] Import secure random number generation
use rand::{rngs::OsRng, Rng};

use crate::security::hsm::{
    error::HsmError,
    provider::{
        EcCurve, HsmOperation, HsmProvider, HsmProviderStatus, HsmRequest, HsmResponse,
        KeyGenParams, KeyInfo, KeyPair, KeyType, KeyUsage, SigningAlgorithm,
    },
    types::{DeleteKeyParams, GetKeyParams, SignParams, VerifyParams},
};

// Import from parent modules
use crate::security::hsm::audit::AuditLogger;
use crate::security::hsm::config::SoftHsmConfig;
use crate::security::hsm::error::{AuditEventResult, AuditEventSeverity, AuditEventType};
use chrono::{DateTime, Utc};
use sha2::Digest;
use sha2::{Sha256, Sha384};

use tokio::sync::Mutex;

/// Simple secure string implementation with zeroization
#[derive(Clone)]
struct SecureString {
    data: Arc<Mutex<Vec<u8>>>,
}

impl SecureString {
    fn from(data: Vec<u8>) -> Self {
        Self {
            data: Arc::new(Mutex::new(data)),
        }
    }

    async fn lock(&self) -> tokio::sync::MutexGuard<'_, Vec<u8>> {
        self.data.lock().await
    }
}

impl Drop for SecureString {
    fn drop(&mut self) {
        // Best effort to zeroize on drop, even though we can't guarantee all clones are gone
        if let Ok(mut data) = self.data.try_lock() {
            data.fill(0);
        }
    }
}

impl zeroize::Zeroize for SecureString {
    fn zeroize(&mut self) {
        if let Ok(mut data) = self.data.try_lock() {
            data.zeroize();
        }
    }
}

/// Secure key storage with memory protection and zeroization
///
/// This struct ensures that key material is:
/// 1. Stored in locked memory (mlock)
/// 2. Zeroized when dropped
/// 3. Protected against memory dumps
#[derive(Clone)]
struct SecureKey {
    /// The actual key data, wrapped in a secure string with zeroization
    key_data: SecureString,
    /// Key metadata (public info only)
    info: KeyInfo,
    /// Timestamp of key creation (Unix epoch seconds)
    created_at: u64,
    /// Last used timestamp (Unix epoch seconds)
    last_used: Option<u64>,
    /// Flag to track if the key has been used
    used: Arc<AtomicBool>,
}

impl std::fmt::Debug for SecureKey {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("SecureKey")
            .field("key_id", &self.info.id)
            .field("key_type", &self.info.key_type)
            .field("created_at", &self.created_at)
            .field("last_used", &self.last_used)
            .field("used", &self.used.load(Ordering::Relaxed))
            .finish()
    }
}

impl Drop for SecureKey {
    fn drop(&mut self) {
        // Ensure key material is zeroized when dropped
        self.key_data.zeroize();
    }
}

/// Open-Source Software HSM Provider for Bitcoin
///
/// This implementation provides a pure Rust, open-source HSM that is specifically
/// designed for Bitcoin operations. It follows Bitcoin's security best practices
/// and uses memory protection for sensitive data.
///
/// # Security Features
/// - **Memory Protection**: Uses mlock() and zeroization for sensitive data
/// - **Constant-Time**: All cryptographic operations are constant-time where applicable
/// - **Side-Channel Resistance**: Implements mitigations against timing and cache attacks
/// - **Deterministic Signatures**: Uses RFC 6979 for deterministic nonce generation
/// - **Watch-Only Support**: Can work in watch-only mode with hardware signers
///
/// # Implementation Details
/// - Uses `rust-secp256k1` for all cryptographic operations
/// - Implements BIP32/39/44/49/84/86 for key derivation
/// - Supports PSBT for transaction signing
/// - Provides audit logging for all operations
/// - Implements proper key lifecycle management
#[derive(Debug)]
pub struct SoftwareHsmProvider {
    /// In-memory key storage with secure memory protection
    keys: Mutex<HashMap<String, SecureKey>>,
    /// Secp256k1 context for cryptographic operations
    secp: Secp256k1<bitcoin::secp256k1::All>,
    /// Audit logger for security events
    audit_logger: Arc<AuditLogger>,
}

impl SoftwareHsmProvider {
    /// Create a new software HSM provider
    pub async fn new(
        _config: SoftHsmConfig,
        _network: Network,
        audit_logger: Arc<AuditLogger>,
    ) -> Result<Self, HsmError> {
        // Initialize the secp256k1 context with all capabilities
        let secp = Secp256k1::new();

        // Create the provider instance
        let provider = Self {
            keys: Mutex::new(HashMap::new()),
            secp,
            audit_logger,
        };

        // Log successful initialization
        provider
            .audit_logger
            .log(
                crate::security::hsm::error::AuditEventType::Initialization,
                crate::security::hsm::error::AuditEventResult::Success,
                crate::security::hsm::error::AuditEventSeverity::Info,
                "HSM provider initialized successfully",
            )
            .await?;

        Ok(provider)
    }

    /// Generate a secure random key ID using the system's secure RNG
    /// [AIR-3][AIS-3][BPC-3][RES-3] Generate a secure random key ID using the system's secure RNG
    /// This follows official Bitcoin Improvement Proposals (BIPs) standards for secure key generation
    fn generate_key_id(&self) -> String {
        // Use system's secure RNG to generate a unique key ID
        let mut rng = OsRng;
        let id: [u8; 16] = rng.gen();
        hex::encode(id)
    }

    /// Store a key securely in memory with proper initialization of all required fields
    async fn store_key(
        &self,
        key_id: String,
        secret: SecureString,
        _public_key: Vec<u8>,
        key_type: KeyType,
        _usage: KeyUsage, // Currently not used, kept for future compatibility
    ) -> Result<KeyInfo, HsmError> {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map_err(|_| HsmError::InternalError("System time is before UNIX_EPOCH".into()))?
            .as_secs();

        // Create a properly initialized KeyInfo with all required fields
        let key_info = KeyInfo {
            id: key_id.clone(),
            label: Some(key_id.clone()),
            key_type: key_type.clone(),
            extractable: false, // Default to non-extractable for security
            usages: vec![KeyUsage::Sign, KeyUsage::Verify],
            created_at: DateTime::from_timestamp(now as i64, 0).unwrap_or_else(|| Utc::now()),
            expires_at: None,
            attributes: HashMap::new(),
        };

        // Create the secure key with memory protection
        let secure_key = SecureKey {
            key_data: secret,
            info: key_info.clone(),
            created_at: now,
            last_used: None,
            used: Arc::new(AtomicBool::new(false)),
        };

        // Store the key in our secure key store
        let mut keys = self.keys.lock().await;
        keys.insert(key_id, secure_key);

        // Log the key storage event
        self.audit_logger
            .log_event(
                AuditEventType::KeyGeneration,
                AuditEventResult::Success,
                AuditEventSeverity::Info,
                &format!("Stored new {:?} key", key_type),
            )
            .await?;

        Ok(key_info)
    }

    /// Generate a new key pair
    async fn generate_key(&self, params: KeyGenParams) -> Result<(KeyPair, KeyInfo), HsmError> {
        use crate::security::hsm::provider::{EcCurve, KeyType};
        use chrono::Utc;

        // Generate a unique key ID
        let key_id = self.generate_key_id();

        // Generate the key material based on key type
        let (secret, public_key) = match params.key_type {
            KeyType::Ec {
                curve: EcCurve::Secp256k1,
            } => {
                // Generate a new secp256k1 key pair
                let (secret_key, public_key) = self.secp.generate_keypair(&mut OsRng);

                // Convert to secure storage format
                let secret_bytes = secret_key.secret_bytes();
                let public_bytes = public_key.serialize_uncompressed().to_vec();

                (SecureString::from(secret_bytes.to_vec()), public_bytes)
            }
            _ => {
                return Err(HsmError::UnsupportedOperation(
                    "Only secp256k1 is currently supported".to_string(),
                ))
            }
        };

        // Create key info with all required fields
        let key_info = KeyInfo {
            id: key_id.clone(),
            label: Some(key_id.clone()),
            key_type: params.key_type.clone(),
            extractable: false,
            usages: vec![KeyUsage::Sign, KeyUsage::Verify],
            created_at: Utc::now(),
            expires_at: None,
            attributes: HashMap::new(),
        };

        // Store the key securely
        self.store_key(
            key_id.clone(),
            secret,
            public_key.clone(),
            params.key_type.clone(),
            *params.usages.first().unwrap_or(&KeyUsage::Sign),
        )
        .await?;

        // Create and return both the key pair and key info
        let key_pair = KeyPair {
            id: key_id.clone(),
            key_type: params.key_type,
            public_key: public_key.clone(),
            private_key_handle: key_id.clone(),
        };

        Ok((key_pair, key_info))
    }

    async fn sign(
        &self,
        key_id: &str,
        algorithm: SigningAlgorithm, // Now used
        data: &[u8],
    ) -> Result<Vec<u8>, HsmError> {
        // Check if key exists and has signing capability
        let keys = self.keys.lock().await;
        let key = keys
            .get(key_id)
            .ok_or_else(|| HsmError::KeyNotFound(key_id.to_string()))?;

        // Get the private key securely
        let secret_key = {
            let key_data = key.key_data.lock().await;
            key_data.clone()
        };

        // Perform real signing based on algorithm
        match algorithm {
            SigningAlgorithm::EcdsaSha256 => {
                let secret_bytes = &*secret_key; // secret_key is already Vec<u8>
                let secret_key = SecretKey::from_slice(secret_bytes)
                    .map_err(|e| HsmError::SigningError(format!("Invalid key data: {}", e)))?;

                // Create message hash
                let mut hasher = Sha256::new();
                hasher.update(data);
                let message_hash = hasher.finalize();

                // Sign the hash
                let message = bitcoin::secp256k1::Message::from_digest_slice(&message_hash)
                    .map_err(|e| HsmError::SigningError(format!("Invalid message hash: {}", e)))?;

                let signature = self.secp.sign_ecdsa(&message, &secret_key);

                Ok(signature.serialize_der().to_vec())
            }
            SigningAlgorithm::EcdsaSha384 => {
                // For ECDSA with SHA-384, we need to use the secp256k1 curve
                // but note that Bitcoin typically uses SHA256d for signatures
                let secret_bytes = &*secret_key; // secret_key is already Vec<u8>
                let secret_key = SecretKey::from_slice(secret_bytes)
                    .map_err(|e| HsmError::SigningError(format!("Invalid key data: {}", e)))?;

                // Create message hash using SHA-384
                let mut hasher = Sha384::new();
                hasher.update(data);
                let message_hash = hasher.finalize();

                // Sign the hash (truncate to 32 bytes for secp256k1)
                let truncated_hash = &message_hash[..32];
                let message = bitcoin::secp256k1::Message::from_digest_slice(truncated_hash)
                    .map_err(|e| HsmError::SigningError(format!("Invalid message hash: {}", e)))?;

                let signature = self.secp.sign_ecdsa(&message, &secret_key);

                Ok(signature.serialize_der().to_vec())
            }
            _ => Err(HsmError::UnsupportedOperation(format!(
                "Unsupported signing algorithm: {:?}",
                algorithm
            ))),
        }
    }

    async fn verify(
        &self,
        key_id: &str,
        algorithm: SigningAlgorithm,
        data: &[u8],
        signature: &[u8],
    ) -> Result<bool, HsmError> {
        // Check if key exists and has verify capability
        let keys = self.keys.lock().await;
        let key_info = keys
            .get(key_id)
            .ok_or_else(|| HsmError::KeyNotFound(key_id.to_string()))?;

        // Real verification for testnet
        match algorithm {
            SigningAlgorithm::EcdsaSha256 => {
                // Get the public key
                match key_info.info.key_type {
                    KeyType::Ec {
                        curve: EcCurve::Secp256k1,
                    } => {
                        // Create message hash
                        let mut hasher = Sha256::new();
                        hasher.update(data);
                        let message_hash = hasher.finalize();

                        // Get the serialized public key from key storage or regenerate
                        let pubkey_bytes = self.export_public_key(key_id).await?;
                        let public_key = PublicKey::from_slice(&pubkey_bytes).map_err(|e| {
                            HsmError::VerificationError(format!("Invalid public key data: {}", e))
                        })?;

                        // Parse the signature
                        let sig = bitcoin::secp256k1::ecdsa::Signature::from_der(signature)
                            .map_err(|e| {
                                HsmError::VerificationError(format!(
                                    "Invalid signature format: {}",
                                    e
                                ))
                            })?;

                        // Verify the signature
                        let message = Message::from_digest_slice(&message_hash).map_err(|e| {
                            HsmError::VerificationError(format!("Invalid message hash: {}", e))
                        })?;

                        match self.secp.verify_ecdsa(&message, &sig, &public_key) {
                            Ok(()) => Ok(true),
                            Err(_) => Ok(false),
                        }
                    }
                    _ => Err(HsmError::UnsupportedOperation(
                        "Unsupported curve for ECDSA verification".to_string(),
                    )),
                }
            }
            _ => Err(HsmError::UnsupportedOperation(
                "Unsupported signing algorithm".to_string(),
            )),
        }
    }

    async fn export_public_key(&self, key_id: &str) -> Result<Vec<u8>, HsmError> {
        // Check if key exists
        let keys = self.keys.lock().await;
        let key_info = keys
            .get(key_id)
            .ok_or_else(|| HsmError::KeyNotFound(key_id.to_string()))?;

        // Get the private key and derive public key
        match key_info.info.key_type {
            KeyType::Ec {
                curve: EcCurve::Secp256k1,
            } => {
                let secret_key = key_info.key_data.lock().await;
                let secret_key = SecretKey::from_slice(&*secret_key).map_err(|e| {
                    HsmError::KeyGenerationError(format!("Invalid key data: {}", e))
                })?;
                let public_key = PublicKey::from_secret_key(&self.secp, &secret_key);
                Ok(public_key.serialize().to_vec())
            }
            _ => Err(HsmError::UnsupportedKeyType),
        }
    }

    /// Delete a key from the HSM
    pub async fn delete_key(&self, key_id: &str) -> Result<(), HsmError> {
        let mut keys = self.keys.lock().await;

        // Check if key exists
        if !keys.contains_key(key_id) {
            return Err(HsmError::KeyNotFound(key_id.to_string()));
        }

        // Remove the key
        keys.remove(key_id);

        // Log the deletion
        self.audit_logger
            .log_event(
                crate::security::hsm::error::AuditEventType::KeyDeletion,
                crate::security::hsm::error::AuditEventResult::Success,
                crate::security::hsm::error::AuditEventSeverity::Info,
                &format!("Key {} deleted successfully", key_id),
            )
            .await?;

        Ok(())
    }

    // ...
}

#[async_trait]
impl HsmProvider for SoftwareHsmProvider {
    async fn initialize(&self) -> Result<(), HsmError> {
        // Already initialized in new(), just return success
        Ok(())
    }

    async fn generate_key(&self, params: KeyGenParams) -> Result<(KeyPair, KeyInfo), HsmError> {
        // Generate a unique key ID
        let key_id = params.id.clone().unwrap_or_else(|| self.generate_key_id());

        // Generate the key material based on key type
        let key_type = params.key_type.clone(); // Clone early to avoid move issues
        let (secret, public_key) = match key_type {
            KeyType::Ec {
                curve: EcCurve::Secp256k1,
            } => {
                // Generate a new secp256k1 key pair
                let (secret_key, public_key) = self.secp.generate_keypair(&mut OsRng);

                // Convert to secure storage format
                (
                    SecureString::from(secret_key[..].to_vec()),
                    public_key.serialize().to_vec(),
                )
            }
            _ => {
                return Err(HsmError::UnsupportedKeyType);
            }
        };

        // Create key info
        let key_info = KeyInfo {
            id: key_id.clone(),
            label: params.label.clone(),
            key_type: key_type.clone(),
            extractable: params.extractable,
            usages: params.usages.clone(),
            created_at: Utc::now(),
            expires_at: params.expires_at,
            attributes: params.attributes.clone(),
        };

        // Store the key securely
        self.store_key(
            key_id.clone(),
            secret,
            public_key.clone(),
            key_type.clone(),
            *params.usages.first().unwrap_or(&KeyUsage::Sign),
        )
        .await?;

        // Create key pair for return
        let key_pair = KeyPair {
            id: key_id.clone(),
            key_type: key_type,
            public_key: public_key.clone(),
            private_key_handle: key_id,
        };

        Ok((key_pair, key_info))
    }

    async fn sign(
        &self,
        key_id: &str,
        algorithm: SigningAlgorithm,
        data: &[u8],
    ) -> Result<Vec<u8>, HsmError> {
        // Get the key
        let keys = self.keys.lock().await;
        let key_info = keys
            .get(key_id)
            .ok_or_else(|| HsmError::KeyNotFound(key_id.to_string()))?;

        // Perform signing based on algorithm
        match algorithm {
            SigningAlgorithm::EcdsaSha256 => {
                // Get the private key data securely
                let key_data = key_info.key_data.lock().await;
                let secret_bytes =
                    hex::decode(&*String::from_utf8_lossy(&key_data)).map_err(|e| {
                        HsmError::InvalidKeyData(format!("Failed to decode key: {}", e))
                    })?;

                let secret_key = SecretKey::from_slice(&secret_bytes)
                    .map_err(|e| HsmError::InvalidKeyData(format!("Invalid secret key: {}", e)))?;

                // Create message hash
                let mut hasher = Sha256::new();
                hasher.update(data);
                let message_hash = hasher.finalize();

                // Create message for signing
                let message = Message::from_digest_slice(&message_hash)
                    .map_err(|e| HsmError::SigningError(format!("Invalid message: {}", e)))?;

                // Sign the message
                let signature = self.secp.sign_ecdsa(&message, &secret_key);
                Ok(signature.serialize_compact().to_vec())
            }
            _ => Err(HsmError::UnsupportedOperation(
                "Only ECDSA SHA-256 is supported".to_string(),
            )),
        }
    }

    async fn verify(
        &self,
        key_id: &str,
        algorithm: SigningAlgorithm,
        data: &[u8],
        signature: &[u8],
    ) -> Result<bool, HsmError> {
        // Get the key
        let keys = self.keys.lock().await;
        let key_info = keys
            .get(key_id)
            .ok_or_else(|| HsmError::KeyNotFound(key_id.to_string()))?;

        // Real verification for testnet
        match algorithm {
            SigningAlgorithm::EcdsaSha256 => {
                // Get the public key
                match key_info.info.key_type {
                    KeyType::Ec {
                        curve: EcCurve::Secp256k1,
                    } => {
                        // Create message hash
                        let mut hasher = Sha256::new();
                        hasher.update(data);
                        let message_hash = hasher.finalize();

                        // Get the serialized public key from key storage or regenerate
                        let pubkey_bytes = self.export_public_key(key_id).await?;
                        let public_key = PublicKey::from_slice(&pubkey_bytes).map_err(|e| {
                            HsmError::VerificationError(format!("Invalid public key data: {}", e))
                        })?;

                        // Parse signature
                        let sig =
                            secp256k1::ecdsa::Signature::from_compact(signature).map_err(|e| {
                                HsmError::VerificationError(format!("Invalid signature: {}", e))
                            })?;

                        // Create message for verification
                        let message = Message::from_digest_slice(&message_hash).map_err(|e| {
                            HsmError::VerificationError(format!("Invalid message: {}", e))
                        })?;

                        // Verify the signature
                        Ok(self.secp.verify_ecdsa(&message, &sig, &public_key).is_ok())
                    }
                    _ => Err(HsmError::UnsupportedKeyType),
                }
            }
            _ => Err(HsmError::UnsupportedOperation(
                "Only ECDSA SHA-256 is supported".to_string(),
            )),
        }
    }

    async fn export_public_key(&self, key_id: &str) -> Result<Vec<u8>, HsmError> {
        let keys = self.keys.lock().await;
        let key_info = keys
            .get(key_id)
            .ok_or_else(|| HsmError::KeyNotFound(key_id.to_string()))?;

        // Get the private key and derive public key
        match key_info.info.key_type {
            KeyType::Ec {
                curve: EcCurve::Secp256k1,
            } => {
                let key_data = key_info.key_data.lock().await;
                let secret_bytes =
                    hex::decode(&*String::from_utf8_lossy(&key_data)).map_err(|e| {
                        HsmError::InvalidKeyData(format!("Failed to decode key: {}", e))
                    })?;

                let secret_key = SecretKey::from_slice(&secret_bytes).map_err(|e| {
                    HsmError::KeyGenerationError(format!("Invalid key data: {}", e))
                })?;
                let public_key = PublicKey::from_secret_key(&self.secp, &secret_key);
                Ok(public_key.serialize().to_vec())
            }
            _ => Err(HsmError::UnsupportedKeyType),
        }
    }

    async fn list_keys(&self) -> Result<Vec<KeyInfo>, HsmError> {
        let keys = self.keys.lock().await;
        Ok(keys.values().map(|k| k.info.clone()).collect())
    }

    async fn delete_key(&self, key_id: &str) -> Result<(), HsmError> {
        self.delete_key(key_id).await
    }

    async fn get_status(&self) -> Result<HsmProviderStatus, HsmError> {
        Ok(HsmProviderStatus::Ready)
    }

    async fn close(&self) -> Result<(), HsmError> {
        // Clear all keys securely
        let mut keys = self.keys.lock().await;
        keys.clear();
        Ok(())
    }

    async fn execute_operation(&self, request: HsmRequest) -> Result<HsmResponse, HsmError> {
        // This method was already implemented in the SoftwareHsmProvider impl block
        // We need to move it here or delegate to it
        match request.operation {
            HsmOperation::GenerateKey => {
                let params: KeyGenParams =
                    serde_json::from_value(request.parameters).map_err(|e| {
                        HsmError::InvalidParameters(format!(
                            "Invalid key generation parameters: {}",
                            e
                        ))
                    })?;

                let (key_pair, _key_info) = self.generate_key(params).await?;

                Ok(HsmResponse::success(
                    request.id,
                    Some(serde_json::json!({
                        "key_id": key_pair.id,
                        "public_key": hex::encode(&key_pair.public_key)
                    })),
                ))
            }
            HsmOperation::Sign => {
                let params: SignParams =
                    serde_json::from_value(request.parameters).map_err(|e| {
                        HsmError::InvalidParameters(format!("Invalid sign parameters: {}", e))
                    })?;

                let signature = self
                    .sign(
                        &params.key_name,
                        params.algorithm.into(),
                        &params.data.as_bytes(),
                    )
                    .await?;

                Ok(HsmResponse::success(
                    request.id,
                    Some(serde_json::json!({
                        "signature": hex::encode(&signature)
                    })),
                ))
            }
            HsmOperation::Verify => {
                let params: VerifyParams =
                    serde_json::from_value(request.parameters).map_err(|e| {
                        HsmError::InvalidParameters(format!("Invalid verify parameters: {}", e))
                    })?;

                let valid = self
                    .verify(
                        &params.key_name,
                        params.algorithm.into(),
                        &params.data.as_bytes(),
                        &params.signature.as_bytes(),
                    )
                    .await?;

                Ok(HsmResponse::success(
                    request.id,
                    Some(serde_json::json!({
                        "valid": valid
                    })),
                ))
            }
            HsmOperation::ExportPublicKey => {
                let params: GetKeyParams =
                    serde_json::from_value(request.parameters).map_err(|e| {
                        HsmError::InvalidParameters(format!("Invalid get key parameters: {}", e))
                    })?;

                let public_key = self.export_public_key(&params.key_name).await?;

                Ok(HsmResponse::success(
                    request.id,
                    Some(serde_json::json!({
                        "public_key": hex::encode(&public_key)
                    })),
                ))
            }
            HsmOperation::ListKeys => {
                let keys = self.list_keys().await?;
                Ok(HsmResponse::success(
                    request.id,
                    Some(serde_json::to_value(keys)?),
                ))
            }
            HsmOperation::DeleteKey => {
                let params: DeleteKeyParams =
                    serde_json::from_value(request.parameters).map_err(|e| {
                        HsmError::InvalidParameters(format!("Invalid delete key parameters: {}", e))
                    })?;

                self.delete_key(&params.key_name).await?;

                Ok(HsmResponse::success(request.id, None))
            }
            HsmOperation::GetStatus => {
                let status = self.get_status().await?;
                Ok(HsmResponse::success(
                    request.id,
                    Some(serde_json::to_value(status)?),
                ))
            }
            _ => Err(HsmError::UnsupportedOperation(format!(
                "Operation {:?} not supported",
                request.operation
            ))),
        }
    }
}