blazehash 0.1.0

Forensic file hasher — hashdeep for the modern era, BLAKE3 by default
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use crate::algorithm::Algorithm;
use crate::hash::{hash_file, FileHashResult};
use anyhow::Result;
use rayon::prelude::*;
use std::path::{Path, PathBuf};
use std::sync::Mutex;
use walkdir::WalkDir;

/// Error encountered while walking/hashing a file.
#[derive(Debug)]
pub struct WalkError {
    pub path: PathBuf,
    pub error: String,
}

/// Result of walking a directory — both successful hashes and errors.
pub struct WalkOutput {
    pub results: Vec<FileHashResult>,
    pub errors: Vec<WalkError>,
}

/// Walk a directory and collect file paths (no hashing).
/// Returns file paths and any walk errors encountered.
pub fn walk_paths(root: &Path, recursive: bool) -> (Vec<PathBuf>, Vec<WalkError>) {
    let walker = if recursive {
        WalkDir::new(root)
    } else {
        WalkDir::new(root).max_depth(1)
    };

    let mut paths = Vec::new();
    let mut errors = Vec::new();

    for entry in walker {
        match entry {
            Ok(e) => {
                if e.file_type().is_file() {
                    paths.push(e.into_path());
                }
            }
            Err(err) => {
                let path = err.path().map(|p| p.to_path_buf()).unwrap_or_default();
                errors.push(WalkError {
                    path,
                    error: err.to_string(),
                });
            }
        }
    }

    (paths, errors)
}

/// Walk a directory, hash all files, return results and errors.
/// Uses rayon for parallel file hashing.
pub fn walk_and_hash(root: &Path, algorithms: &[Algorithm], recursive: bool) -> Result<WalkOutput> {
    let (paths, walk_errors) = walk_paths(root, recursive);

    let hash_errors = Mutex::new(Vec::new());
    let results: Vec<FileHashResult> = paths
        .par_iter()
        .filter_map(|path| match hash_file(path, algorithms) {
            Ok(result) => Some(result),
            Err(err) => {
                hash_errors.lock().unwrap().push(WalkError {
                    path: path.clone(),
                    error: err.to_string(),
                });
                None
            }
        })
        .collect();

    let mut errors = walk_errors;
    errors.extend(hash_errors.into_inner().unwrap());

    Ok(WalkOutput { results, errors })
}