Datei-Hashing in Rust mit paralleler Verarbeitung beschleunigen

Kevin van Zonneveld

Mitgründer · Amsterdam, Niederlande · Bio anzeigen

Das Hashing von Dateien ist eine grundlegende Aufgabe in der Softwareentwicklung und entscheidend für Datenintegrität, Sicherheit und effizientes Datenmanagement. In Rust können Sie Open-Source-Bibliotheken wie ring und RustCrypto nutzen, um robustes und effizientes Datei-Hashing umzusetzen. In diesem DevTip zeigen wir, wie Sie Dateien in Rust mit diesen Bibliotheken hashen, vergleichen verschiedene Hash-Algorithmen wie SHA-256 und BLAKE2 und liefern praktische Codebeispiele für den Einstieg.

Einführung in das Datei-Hashing in Rust

Beim Datei-Hashing wird aus den Dateidaten ein Digest fester Länge erzeugt. Unterschiedliche Eingaben können denselben Digest ergeben, allerdings sollten sich Kollisionen bei einem sicheren kryptografischen Hash praktisch nicht finden lassen. Hashing prüft die Integrität von Dateien, erkennt Duplikate, unterstützt kryptografische Operationen und mehr. Rust ist mit seinen Performance- und Sicherheitsgarantien eine ausgezeichnete Wahl, um Datei-Hashing in Ihren Anwendungen umzusetzen.

Systemanforderungen

• Aktuelles stabiles Rust (aktuelle Rayon-1.x-Releases erfordern Rust 1.80 oder neuer)
• Ein C-Compiler (gcc, clang oder MSVC unter Windows)
• pkg-config (auf Unix-ähnlichen Systemen)

Ihre Rust-Umgebung einrichten

Stellen Sie zunächst sicher, dass die neueste stabile Version von Rust installiert ist. Sie können sie von der offiziellen Website⁠ herunterladen oder Ihre bestehende Installation mit folgendem Befehl aktualisieren:

rustup update stable

Legen Sie ein neues Rust-Projekt an:

cargo new file-hashing
cd file-hashing

Den richtigen Hash-Algorithmus wählen

Welcher Hash-Algorithmus geeignet ist, hängt von den Anforderungen Ihrer Anwendung ab:

• SHA-256: Eine kryptografische Hash-Funktion, die hohe Sicherheit bietet und in vielen Anwendungen weit verbreitet ist.
• BLAKE2: Eine moderne, schnellere Alternative zu den SHA-Algorithmen, die vergleichbare Sicherheit bei besserer Performance bietet.

Datei-Hashing mit ring implementieren

Das Crate ring⁠ bietet sichere und schnelle kryptografische Operationen, darunter Hashing.

Fügen Sie ring zu Ihrer Cargo.toml hinzu:

[dependencies]
ring = "0.17.8"

Eine Datei mit ring hashen

Nachfolgend finden Sie ein Beispiel für das Hashing einer Datei mit SHA-256 und ring:

use ring::digest::{Context, SHA256};
use std::io::{ErrorKind, Read};

fn sha256_digest<R: Read>(mut reader: R) -> Result<String, std::io::Error> {
    let mut context = Context::new(&SHA256);
    let mut buffer = [0u8; 8192];

    loop {
        let count = match reader.read(&mut buffer) {
            Ok(count) => count,
            Err(error) if error.kind() == ErrorKind::Interrupted => continue,
            Err(error) => return Err(error),
        };
        if count == 0 {
            break;
        }
        context.update(&buffer[..count]);
    }

    Ok(context.finish().as_ref().iter().map(|byte| format!("{byte:02x}")).collect())
}

Erläuterung

• Context und Digest: ring::digest::Context verwaltet die inkrementelle Hash-Berechnung, und der endgültige Hash wird mit context.finish() erzeugt.
• Lesen der Datei: Die Datei wird in Blöcken gelesen, um große Dateien effizient zu verarbeiten.
• Fehlerbehandlung: Die Funktion gibt Result zurück, sodass Sie I/O-Fehler wie Probleme beim Dateizugriff behandeln können.

Weitere Funktionen von ring

Über das Hashing hinaus bietet ring verschiedene kryptografische Funktionen, darunter Verschlüsselung, digitale Signaturen und Schlüsselaustauschprotokolle. Es ist auf Sicherheit und Performance ausgelegt und eignet sich damit für Anwendungen mit hohen Sicherheitsanforderungen.

Fortgeschrittenes Hashing mit RustCrypto

Für eine größere Auswahl an Algorithmen und mehr Flexibilität stellt das Projekt RustCrypto mehrere Hashing-Crates bereit.

Fügen Sie das gewünschte Crate für die Hash-Funktion zu Ihrer Cargo.toml hinzu. Zum Beispiel für die Verwendung von BLAKE2:

[dependencies]
blake2 = "0.10.6"

Blake2-Hashing implementieren

Dieses Beispiel zeigt, wie Sie eine Datei mit BLAKE2 und RustCrypto hashen:

use blake2::{Blake2b512, Digest};
use std::io::{ErrorKind, Read};

fn blake2b_digest<R: Read>(mut reader: R) -> Result<String, std::io::Error> {
    let mut hasher = Blake2b512::new();
    let mut buffer = [0u8; 8192];

    loop {
        let count = match reader.read(&mut buffer) {
            Ok(count) => count,
            Err(error) if error.kind() == ErrorKind::Interrupted => continue,
            Err(error) => return Err(error),
        };
        if count == 0 {
            break;
        }
        hasher.update(&buffer[..count]);
    }

    let result = hasher.finalize();
    Ok(format!("{:x}", result))
}

Erläuterung

• Blake2b512: Implementiert die BLAKE2b-Hash-Funktion mit einer Ausgabe von 512 Bit.
• Lesen und Hashen: Wie im Beispiel mit ring wird die Datei in Blöcken verarbeitet, um den Hash effizient zu berechnen.

Vergleich der Hash-Verfahren

Berücksichtigen Sie bei der Wahl eines Hash-Algorithmus die folgenden Faktoren:

• Sicherheit: SHA-256 und BLAKE2 bieten robuste Sicherheit für kryptografische Zwecke.
• Performance: BLAKE2 übertrifft SHA-256 häufig und hasht bei vergleichbarer Sicherheit schneller.
• Kompatibilität: Wählen Sie für die Interoperabilität einen Algorithmus, der plattformübergreifend breit unterstützt wird.

Bewährte Verfahren für Datei-Hashing in Rust-Projekten

• Gepuffertes Lesen verwenden: Setzen Sie BufReader ein, um die Datei-I/O-Performance zu optimieren.
• Fehler sauber behandeln: Nutzen Sie die Fehlerbehandlung von Rust (mit dem Typ Result), um I/O-Fehler und andere Fehler zu behandeln.
• Blockierende I/O vermeiden: Ziehen Sie bei Anwendungen, die mehrere Dateien verarbeiten, asynchrone I/O oder parallele Verarbeitung in Betracht, um den Durchsatz zu erhöhen.

Datei-Hashing mit paralleler Verarbeitung beschleunigen

Dateien sequenziell zu hashen, kann ineffizient sein, wenn Sie mit mehreren Dateien arbeiten. Mit dem Crate rayon verarbeiten Sie Dateien nebenläufig.

Fügen Sie rayon neben ring im vorhandenen Abhängigkeitsbereich Ihrer Cargo.toml hinzu (die Überschrift [dependencies] nicht doppelt anlegen). Behalten Sie Cargo.lock bei, um die Abhängigkeitsversionen Ihrer Anwendung reproduzieren zu können:

[dependencies]
rayon = "1.10.0"
ring = "0.17.8"

Beispiel für paralleles Datei-Hashing

Platzieren Sie die Funktion sha256_digest und ihre Imports aus dem vorherigen Beispiel mit ring oberhalb der hier gezeigten Funktion main in der Datei src/main.rs. Führen Sie sie mit cargo run --release -- file1.bin file2.bin aus.

use rayon::prelude::*;
use std::fs::File;
use std::path::PathBuf;
use std::io::{self, BufReader};

fn main() -> Result<(), io::Error> {
    let files: Vec<PathBuf> = std::env::args_os()
        .skip(1)
        .map(PathBuf::from)
        .collect();

    if files.is_empty() {
        eprintln!("Usage: {} <file1> <file2> ...", env!("CARGO_PKG_NAME"));
        return Err(io::Error::new(io::ErrorKind::InvalidInput, "No input files provided"));
    }

    files.par_iter()
         .try_for_each(|file| -> Result<(), io::Error> {
             let input = File::open(file)?;
             let reader = BufReader::new(input);
             let digest = sha256_digest(reader)?;
             println!("{} {}", digest, file.display());
             Ok(())
         })
}

Hinweise zur Performance

Dieses Beispiel hasht verschiedene Dateien nebenläufig; es parallelisiert nicht die Blöcke einer einzelnen Datei. Jeder Digest umfasst weiterhin die vollständige Datei in Byte-Reihenfolge. Eine einzelne Datei profitiert hier nicht von paralleler Beschleunigung. Führen Sie bei mehreren Dateien Benchmarks auf Ihrem Speichergerät durch: I/O-Konkurrenz und Scheduling-Overhead können jeden Gewinn aufwiegen. Die Reihenfolge der Ausgabe ist nicht festgelegt, und ein I/O-Fehler bricht den Vorgang mit einem Fehler ab, möglicherweise erst dann, wenn andere Datei-Hashes bereits ausgegeben wurden.

Wie Datei-Hashing zu Datenintegrität und Sicherheit beiträgt

• Datenintegrität: Vergleichen Sie den Digest einer Datei mit einer vertrauenswürdigen Referenz, um Änderungen bei der Übertragung oder Speicherung zu erkennen. Ein Angreifer, der sowohl die Datei als auch ihren Referenz-Hash ersetzen kann, hebelt diese Prüfung aus.
• Sicherheit: Kryptografische Hashes sind Bausteine für Authentifizierung und digitale Signaturen. Einfaches SHA-256 oder BLAKE2 eignet sich nicht zum Speichern von Passwörtern; verwenden Sie dafür ein Passwort-Hashing-Verfahren wie Argon2id.
• Deduplizierung: Hashing ermöglicht es, doppelte Dateien zu identifizieren, und optimiert so die Speichernutzung.

Fazit

Datei-Hashing in Rust ist mithilfe von Open-Source-Bibliotheken wie ring und RustCrypto unkompliziert und effizient. Wenn Sie den richtigen Hash-Algorithmus wählen und parallele Verarbeitung mit Rayon nutzen, erstellen Sie robuste Anwendungen für Datenintegrität, Sicherheit und effizientes Datenmanagement. Für weitere Lösungen zur Dateiverarbeitung lohnt sich ein Blick auf den Dienst Medienkatalogisierung von Transloadit.