Rust哈希计算库tenthash使用指南

简介

tenthash是一个高性能的Rust哈希计算库，提供了多种流行的哈希算法实现和数据校验功能。它针对性能进行了优化，特别适合需要快速计算大量数据哈希值的场景。

主要特性

• 支持多种哈希算法：SHA-1, SHA-2(224/256/384/512), SHA-3, MD5等
• 提供流式处理接口，适合大文件处理
• 线程安全的设计
• 简洁易用的API
• 高性能实现

安装

在Cargo.toml中添加依赖：

[dependencies]
tenthash = "0.3"

基本使用方法

计算字符串哈希

use tenthash::{Sha256, Digest};

fn main() {
    let mut hasher = Sha256::new();
    hasher.update(b"hello world");
    let result = hasher.finalize();
    println!("SHA-256 hash: {:x}", result);
}

计算文件哈希

use tenthash::{Sha256, Digest};
use std::fs::File;
use std::io::{BufReader, Read};

fn main() -> std::io::Result<()> {
    let file = File::open("large_file.bin")?;
    let mut reader = BufReader::new(file);
    let mut hasher = Sha256::new();
    
    let mut buffer = [0; 1024];
    loop {
        let count = reader.read(&mut buffer)?;
        if count == 0 {
            break;
        }
        hasher.update(&buffer[..count]);
    }
    
    let result = hasher.finalize();
    println!("File SHA-256: {:x}", result);
    Ok(())
}

支持的哈希算法

常用算法示例

use tenthash::{Md5, Sha1, Sha224, Sha256, Sha384, Sha512, Sha3_256};

fn compute_hashes(input: &[u8]) {
    // MD5
    let mut md5 = Md5::new();
    md5.update(input);
    println!("MD5: {:x}", md5.finalize());
    
    // SHA-256
    let mut sha256 = Sha256::new();
    sha256.update(input);
    println!("SHA-256: {:x}", sha256.finalize());
    
    // SHA3-256
    let mut sha3 = Sha3_256::new();
    sha3.update(input);
    println!("SHA3-256: {:x}", sha3.finalize());
}

高级用法

增量哈希计算

use tenthash::{Sha256, Digest};

fn main() {
    let mut hasher = Sha256::new();
    
    // 分多次更新数据
    hasher.update(b"hello");
    hasher.update(b" ");
    hasher.update(b"world");
    
    let result = hasher.finalize();
    println!("Incremental hash: {:x}", result);
}

哈希校验

use tenthash::{Sha256, Digest};

fn verify_data(data: &[u8], expected_hash: &str) -> bool {
    let mut hasher = Sha256::new();
    hasher.update(data);
    let computed_hash = format!("{:x}", hasher.finalize());
    computed_hash == expected_hash
}

fn main() {
    let data = b"important data";
    let expected = "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e";
    
    if verify_data(data, expected) {
        println!("Data integrity verified!");
    } else {
        println!("Data has been modified!");
    }
}

性能提示

1. 对于小数据，直接使用update和finalize即可
2. 对于大数据或文件，使用缓冲区读取并增量更新哈希
3. 重用哈希器对象可以减少内存分配

完整示例demo

下面是一个综合使用tenthash库的完整示例，展示了多种哈希算法的使用和文件校验：

use tenthash::{Md5, Sha1, Sha256, Sha512, Digest};
use std::fs::File;
use std::io::{BufReader, Read};
use std::path::Path;

// 计算文件的多种哈希值
fn compute_file_hashes(file_path: &str) -> std::io::Result<()> {
    let path = Path::new(file_path);
    let file = File::open(path)?;
    let mut reader = BufReader::new(file);
    
    // 初始化各种哈希器
    let mut md5 = Md5::new();
    let mut sha1 = Sha1::new();
    let mut sha256 = Sha256::new();
    let mut sha512 = Sha512::new();
    
    let mut buffer = [0; 4096]; // 4KB缓冲区
    
    loop {
        let count = reader.read(&mut buffer)?;
        if count == 0 {
            break;
        }
        let data = &buffer[..count];
        
        // 更新所有哈希器
        md5.update(data);
        sha1.update(data);
        sha256.update(data);
        sha512.update(data);
    }
    
    // 输出结果
    println!("File: {}", path.display());
    println!("MD5:    {:x}", md5.finalize());
    println!("SHA-1:  {:x}", sha1.finalize());
    println!("SHA-256: {:x}", sha256.finalize());
    println!("SHA-512: {:x}", sha512.finalize());
    
    Ok(())
}

// 验证字符串哈希
fn verify_string_hash() {
    let data = "Rust编程语言";
    let expected_sha256 = "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08";
    
    let mut hasher = Sha256::new();
    hasher.update(data.as_bytes());
    let computed_hash = format!("{:x}", hasher.finalize());
    
    println!("\n验证字符串哈希:");
    println!("原始数据: {}", data);
    println!("计算哈希: {}", computed_hash);
    println!("预期哈希: {}", expected_sha256);
    println!("验证结果: {}", computed_hash == expected_sha256);
}

fn main() -> std::io::Result<()> {
    // 计算文件哈希
    compute_file_hashes("example.txt")?;
    
    // 验证字符串哈希
    verify_string_hash();
    
    Ok(())
}

这个完整示例展示了：

1. 如何同时计算文件的多种哈希值(MD5, SHA-1, SHA-256, SHA-512)
2. 使用缓冲区高效处理大文件
3. 如何验证字符串的哈希值
4. 错误处理和结果输出

要运行此示例，只需在项目目录下创建一个example.txt文件，然后执行程序即可看到各种哈希计算结果。