Rust密钥存储与管理库storekey使用指南

storekey是一个Rust库，提供了安全高效的密钥存储与管理功能，适用于需要处理敏感密钥数据的应用场景。

主要特性

• 安全的密钥存储机制
• 多种加密算法支持
• 密钥生命周期管理
• 跨平台兼容性
• 内存安全保证（得益于Rust的所有权模型）

安装方法

在Cargo.toml中添加依赖：

[dependencies]
storekey = "0.3.0"  # 请使用最新版本

基本使用方法

1. 创建密钥存储

use storekey::{KeyStore, SecurityLevel};

fn main() -> Result<(), storekey::Error> {
    // 创建一个新的密钥存储实例
    let mut keystore = KeyStore::new(SecurityLevel::High);
    
    // 生成并存储一个新密钥
    let key_id = keystore.generate_key("my_encryption_key")?;
    
    Ok(())
}

2. 存储和检索密钥

use storekey::{KeyStore, SecurityLevel};

fn main() -> Result<(), storekey::Error> {
    let mut keystore = KeyStore::new(SecurityLevel::Medium);
    
    // 存储现有密钥
    let existing_key = b"my_secret_key_bytes".to_vec();
    keystore.store_key("existing_key", existing_key)?;
    
    // 检索密钥
    if let Some(key) = keystore.get_key("existing_key")? {
        println!("Retrieved key: {:?}", key);
    }
    
    Ok(())
}

3. 加密解密数据

use storekey::{KeyStore, SecurityLevel};

fn main() -> Result<(), storekey::Error> {
    let mut keystore = KeyStore::new(SecurityLevel::High);
    let key_id = keystore.generate_key("encryption_key")?;
    
    let plaintext = b"secret message".to_vec();
    
    // 加密数据
    let ciphertext = keystore.encrypt(&key_id, &plaintext)?;
    
    // 解密数据
    let decrypted = keystore.decrypt(&key_id, &ciphertext)?;
    
    assert_eq!(plaintext, decrypted);
    Ok(())
}

高级功能

1. 密钥轮换

use storekey::{KeyStore, SecurityLevel};

fn rotate_key_example() -> Result<(), storekey::Error> {
    let mut keystore = KeyStore::new(SecurityLevel::High);
    let old_key_id = keystore.generate_key("db_encryption")?;
    
    // 执行密钥轮换
    let new_key_id = keystore.rotate_key(&old_key_id, "db_encryption_v2")?;
    
    println!("Key rotated from {} to {}", old_key_id, new_key_id);
    Ok(())
}

2. 安全删除密钥

use storekey::{KeyStore, SecurityLevel};

fn secure_delete_example() -> Result<(), storekey::Error> {
    let mut keystore = KeyStore::new(SecurityLevel::High);
    let key_id = keystore.generate_key("temp_key")?;
    
    // 安全删除密钥
    keystore.secure_erase(&key_id)?;
    
    // 尝试获取已删除的密钥将返回None
    assert!(keystore.get_key(&key_id)?.is_none());
    
    Ok(())
}

最佳实践

1. 安全级别选择：根据敏感程度选择适当的安全级别

   • SecurityLevel::Low - 性能优先，基本保护
   • SecurityLevel::Medium - 平衡安全与性能
   • SecurityLevel::High - 最高安全性，可能影响性能

2. 密钥生命周期管理：

   • 定期轮换关键密钥
   • 不再使用的密钥应及时删除

3. 错误处理：

   • 总是处理storekey::Error
   • 敏感操作失败时应彻底终止流程

实际应用示例

数据库连接字符串加密

use storekey::{KeyStore, SecurityLevel};

struct DatabaseConfig {
    encrypted_conn_string: Vec<u8>,
    key_id: String,
}

impl DatabaseConfig {
    fn new(keystore: &mut KeyStore, conn_string: &str) -> Result<Self, storekey::Error> {
        let key_id = keystore.generate_key("db_conn")?;
        let encrypted = keystore.encrypt(&key_id, conn_string.as_bytes())?;
        
        Ok(Self {
            encrypted_conn_string: encrypted,
            key_id,
        })
    }
    
    fn get_connection_string(&self, keystore: &KeyStore) -> Result<String, storekey::Error> {
        let decrypted = keystore.decrypt(&self.key_id, &self.encrypted_conn_string)?;
        String::from_utf8(decrypted).map_err(|_| storekey::Error::DecryptionError)
    }
}

fn main() -> Result<(), storekey::Error> {
    let mut keystore = KeyStore::new(SecurityLevel::High);
    let db_config = DatabaseConfig::new(&mut keystore, "postgres://user:pass@localhost:5432/db")?;
    
    // 使用时解密
    let conn_string = db_config.get_connection_string(&keystore)?;
    println!("Connection string: {}", conn_string);
    
    Ok(())
}

完整示例demo

下面是一个完整的应用程序示例，展示了如何使用storekey库来管理API密钥：

use storekey::{KeyStore, SecurityLevel};
use std::collections::HashMap;

struct ApiKeyManager {
    keystore: KeyStore,
    key_metadata: HashMap<String, String>, // 存储密钥ID与用途的映射
}

impl ApiKeyManager {
    // 创建新的API密钥管理器
    fn new(security_level: SecurityLevel) -> Result<Self, storekey::Error> {
        Ok(Self {
            keystore: KeyStore::new(security_level),
            key_metadata: HashMap::new(),
        })
    }

    // 添加新的API密钥
    fn add_api_key(&mut self, key_name: &str, purpose: &str) -> Result<(), storekey::Error> {
        let key_id = self.keystore.generate_key(key_name)?;
        self.key_metadata.insert(key_id, purpose.to_string());
        Ok(())
    }

    // 获取所有API密钥的元数据
    fn list_keys(&self) -> Vec<(String, String)> {
        self.key_metadata.iter()
            .map(|(id, purpose)| (id.clone(), purpose.clone()))
            .collect()
    }

    // 使用API密钥签名消息
    fn sign_message(&self, key_id: &str, message: &str) -> Result<Vec<u8>, storekey::Error> {
        if let Some(key) = self.keystore.get_key(key_id)? {
            // 在实际应用中，这里应该使用更安全的签名算法
            let mut signature = Vec::new();
            signature.extend_from_slice(key.as_slice());
            signature.extend_from_slice(message.as_bytes());
            Ok(signature)
        } else {
            Err(storekey::Error::KeyNotFound)
        }
    }

    // 安全删除API密钥
    fn remove_api_key(&mut self, key_id: &str) -> Result<(), storekey::Error> {
        self.keystore.secure_erase(key_id)?;
        self.key_metadata.remove(key_id);
        Ok(())
    }
}

fn main() -> Result<(), storekey::Error> {
    // 创建API密钥管理器，使用高安全级别
    let mut api_manager = ApiKeyManager::new(SecurityLevel::High)?;

    // 添加几个API密钥
    api_manager.add_api_key("payment_service", "处理支付请求")?;
    api_manager.add_api_key("data_export", "导出敏感数据")?;

    // 列出所有密钥
    println!("当前管理的API密钥:");
    for (id, purpose) in api_manager.list_keys() {
        println!("ID: {}, 用途: {}", id, purpose);
    }

    // 使用密钥签名消息
    let payment_key = api_manager.list_keys()[0].0.clone();
    let signature = api_manager.sign_message(&payment_key, "amount=100&currency=USD")?;
    println!("生成的签名长度: {}字节", signature.len());

    // 安全删除一个密钥
    api_manager.remove_api_key(&payment_key)?;
    println!("已删除支付服务密钥");

    Ok(())
}

注意事项

1. 确保在生产环境中妥善备份主密钥
2. 定期审计密钥使用情况
3. 考虑使用硬件安全模块(HSM)集成以获得更高安全性
4. 密钥材料不应记录到日志中

storekey库通过Rust的内存安全特性提供了强大的密钥管理功能，开发者可以专注于业务逻辑而无需过多担心密钥的安全存储问题。