Rust加密库warg-crypto使用指南

简介

warg-crypto是一个Rust实现的加密库，专注于提供安全高效的加密算法和数据保护工具。它设计用于需要高性能加密的场景，同时保证代码的安全性和易用性。

主要特性

• 支持多种现代加密算法
• 提供简单易用的API接口
• 注重内存安全和性能优化
• 包含常见加密操作的工具函数

安装方法

在Cargo.toml中添加依赖：

[dependencies]
warg-crypto = "0.1.0"  # 请使用最新版本

基本使用方法

1. 哈希计算

use warg_crypto::hash::{Hash, Sha256};

fn main() {
    let data = b"Hello, warg-crypto!";
    let hash = Sha256::compute(data);
    println!("SHA-256 hash: {}", hash);
}

2. 对称加密(AES)

use warg_crypto::{
    encryption::{Aes256Gcm, Key, Nonce},
    Error,
};

fn encrypt_decrypt() -> Result<(), Error> {
    // 生成随机密钥和nonce
    let key = Key::generate();
    let nonce = Nonce::generate();
    
    let plaintext = b"Secret message";
    
    // 加密
    let ciphertext = Aes256Gcm::encrypt(&key, &nonce, plaintext)?;
    
    // 解密
    let decrypted = Aes256Gcm::decrypt(&key, &nonce, &ciphertext)?;
    
    assert_eq!(plaintext, decrypted.as_slice());
    Ok(())
}

3. 非对称加密(RSA)

use warg_crypto::{
    encryption::{RsaPrivateKey, RsaPublicKey},
    Error,
};

fn rsa_example() -> Result<(), Error> {
    // 生成密钥对
    let private_key = RsaPrivateKey::generate(2048)?;
    let public_key = RsaPublicKey::from(&private_key);
    
    let message = b"Message to encrypt";
    
    // 加密
    let ciphertext = public_key.encrypt(message)?;
    
    // 解密
    let decrypted = private_key.decrypt(&ciphertext)?;
    
    assert_eq!(message, decrypted.as_slice());
    Ok(())
}

4. 数字签名

use warg_crypto::{
    signing::{Ed25519PrivateKey, Ed25519PublicKey},
    Error,
};

fn signing_example() -> Result<(), Error> {
    // 生成密钥对
    let private_key = Ed25519PrivateKey::generate();
    let public_key = Ed25519PublicKey::from(&private_key);
    
    let message = b"Important message to sign";
    
    // 签名
    let signature = private_key.sign(message);
    
    // 验证签名
    assert!(public_key.verify(message, &signature).is_ok());
    Ok(())
}

高级功能

密码派生(PBKDF2)

use warg_crypto::kdf::Pbkdf2;

fn derive_key() {
    let password = b"my secret password";
    let salt = b"unique salt";
    let mut key = [0u8; 32]; // 256-bit key
    
    Pbkdf2::derive_key(password, salt, 10000, &mut key);
    
    println!("Derived key: {:?}", key);
}

随机数生成

use warg_crypto::random::SecureRandom;

fn generate_random_data() {
    let mut rng = SecureRandom::default();
    let mut buffer = [0u8; 32];
    rng.fill_bytes(&mut buffer);
    
    println!("Random bytes: {:?}", buffer);
}

安全注意事项

1. 始终使用最新版本的库
2. 妥善管理加密密钥
3. 对敏感数据及时清零内存
4. 遵循最小权限原则

warg-crypto库提供了强大的加密功能，同时保持了Rust的安全性和性能特点。根据您的具体需求选择合适的加密算法和参数配置。

完整示例demo

1. 哈希计算完整示例

use warg_crypto::hash::{Hash, Sha256};

fn main() {
    // 计算字符串的SHA-256哈希
    let data = b"Hello, warg-crypto!";
    let hash = Sha256::compute(data);
    
    // 输出16进制格式的哈希值
    println!("输入数据: {:?}", data);
    println!("SHA-256哈希: {}", hash);
    
    // 计算文件的哈希
    if let Ok(file_data) = std::fs::read("example.txt") {
        let file_hash = Sha256::compute(&file_data);
        println!("文件哈希: {}", file_hash);
    }
}

2. 对称加密完整示例

use warg_crypto::{
    encryption::{Aes256Gcm, Key, Nonce},
    Error,
};

fn main() -> Result<(), Error> {
    // 生成随机密钥和nonce
    let key = Key::generate();
    let nonce = Nonce::generate();
    
    // 要加密的明文数据
    let plaintext = b"这是一个需要加密的秘密消息";
    
    // 加密过程
    let ciphertext = Aes256Gcm::encrypt(&key, &nonce, plaintext)?;
    println!("加密后的数据: {:?}", ciphertext);
    
    // 解密过程
    let decrypted = Aes256Gcm::decrypt(&key, &nonce, &ciphertext)?;
    println!("解密后的数据: {:?}", String::from_utf8_lossy(&decrypted));
    
    assert_eq!(plaintext, decrypted.as_slice());
    Ok(())
}

3. 非对称加密完整示例

use warg_crypto::{
    encryption::{RsaPrivateKey, RsaPublicKey},
    Error,
};

fn main() -> Result<(), Error> {
    // 生成2048位的RSA密钥对
    let private_key = RsaPrivateKey::generate(2048)?;
    let public_key = RsaPublicKey::from(&private_key);
    
    // 要加密的消息
    let message = b"这是使用RSA加密的消息";
    
    // 使用公钥加密
    let ciphertext = public_key.encrypt(message)?;
    println!("加密后的数据长度: {}字节", ciphertext.len());
    
    // 使用私钥解密
    let decrypted = private_key.decrypt(&ciphertext)?;
    println!("解密后的消息: {}", String::from_utf8_lossy(&decrypted));
    
    assert_eq!(message, decrypted.as_slice());
    Ok(())
}

4. 数字签名完整示例

use warg_crypto::{
    signing::{Ed25519PrivateKey, Ed25519PublicKey},
    Error,
};

fn main() -> Result<(), Error> {
    // 生成Ed25519密钥对
    let private_key = Ed25519PrivateKey::generate();
    let public_key = Ed25519PublicKey::from(&private_key);
    
    // 要签名的消息
    let message = b"这是一条需要签名的消息";
    
    // 生成签名
    let signature = private_key.sign(message);
    println!("签名结果: {:?}", signature);
    
    // 验证签名
    if public_key.verify(message, &signature).is_ok() {
        println!("签名验证成功!");
    } else {
        println!("签名验证失败!");
    }
    
    Ok(())
}

5. 密码派生完整示例

use warg_crypto::kdf::Pbkdf2;

fn main() {
    // 用户密码和盐值
    let password = b"my_secure_password_123";
    let salt = b"unique_salt_value";
    
    // 派生256位密钥
    let mut key = [0u8; 32]; // 32字节 = 256位
    let iterations = 100_000; // 高迭代次数增强安全性
    
    Pbkdf2::derive_key(password, salt, iterations, &mut key);
    
    println!("派生出的密钥: {:?}", key);
    println!("密钥长度: {}位", key.len() * 8);
}

6. 随机数生成完整示例

use warg_crypto::random::SecureRandom;

fn main() {
    let mut rng = SecureRandom::default();
    
    // 生成随机字节数组
    let mut random_bytes = [0u8; 32];
    rng.fill_bytes(&mut random_bytes);
    println!("随机字节: {:?}", random_bytes);
    
    // 生成随机数
    let random_number: u32 = rng.gen();
    println!("随机数: {}", random_number);
    
    // 生成安全随机密码
    let mut password = [0u8; 16];
    rng.fill_bytes(&mut password);
    println!("随机密码: {:?}", password);
}