Hashing de archivos en Rust acelerado con procesamiento paralelo

Kevin van Zonneveld

Cofundador · Ámsterdam, Países Bajos · Mostrar bio

Hashear archivos es una tarea fundamental en el desarrollo de software, esencial para la integridad de los datos, la seguridad y una gestión eficiente de la información. En Rust, puedes aprovechar bibliotecas de código abierto como ring y RustCrypto para implementar un hashing de archivos robusto y eficiente. En este DevTip, exploramos cómo hashear archivos en Rust con estas bibliotecas, comparamos distintos algoritmos de hashing como SHA-256 y BLAKE2, y ofrecemos ejemplos de código prácticos para que empieces.

Introducción al hashing de archivos en Rust

El hashing de archivos genera un digest de tamaño fijo a partir de los datos de un archivo. Entradas distintas pueden compartir un digest, aunque encontrar colisiones debería ser inviable con un hash criptográfico seguro. El hashing verifica la integridad de los archivos, detecta duplicados, admite operaciones criptográficas y más. Rust, con sus garantías de rendimiento y seguridad, es una excelente opción para implementar el hashing de archivos en tus aplicaciones.

Requisitos del sistema

• Rust estable actual (las versiones actuales de Rayon 1.x requieren Rust 1.80 o posterior)
• Un compilador de C (gcc, clang o MSVC en Windows)
• pkg-config (en sistemas tipo Unix)

Configurar tu entorno de Rust

Primero, asegúrate de tener instalada la última versión estable de Rust. Puedes descargarla desde el sitio web oficial⁠ o actualizar tu instalación existente con:

rustup update stable

Crea un nuevo proyecto de Rust:

cargo new file-hashing
cd file-hashing

Elegir el algoritmo de hashing adecuado

La elección del algoritmo de hashing adecuado depende de los requisitos de tu aplicación:

• SHA-256: una función hash criptográfica que ofrece alta seguridad y se usa ampliamente en diversas aplicaciones.
• BLAKE2: una alternativa moderna y más rápida a los algoritmos SHA, que brinda una seguridad comparable con un mejor rendimiento.

Implementar el hashing de archivos con ring

El crate ring⁠ ofrece operaciones criptográficas seguras y rápidas, incluido el hashing.

Agrega ring a tu Cargo.toml:

[dependencies]
ring = "0.17.8"

Hashear un archivo usando ring

A continuación se muestra un ejemplo de cómo hashear un archivo con SHA-256 usando 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())
}

Explicación

• Context y Digest: ring::digest::Context gestiona el cálculo incremental del hash, y el hash final se produce mediante context.finish().
• Lectura del archivo: el archivo se lee en fragmentos para manejar archivos grandes de forma eficiente.
• Manejo de errores: la función devuelve un Result, lo que te permite manejar errores de E/S, como problemas de acceso a los archivos.

Funciones adicionales de ring

Más allá del hashing, ring ofrece diversas funciones criptográficas, incluidos el cifrado, las firmas digitales y los protocolos de acuerdo de claves. Está diseñado para ser seguro y eficiente, lo que lo hace adecuado para aplicaciones con altos requisitos de seguridad.

Explorar el hashing avanzado con RustCrypto

Para una gama más amplia de algoritmos y mayor flexibilidad, el proyecto RustCrypto ofrece varios crates de hashing.

Agrega a tu Cargo.toml el crate de la función hash que quieras. Por ejemplo, para usar BLAKE2:

[dependencies]
blake2 = "0.10.6"

Implementar el hashing Blake2

Este ejemplo muestra cómo hashear un archivo con BLAKE2 usando RustCrypto:

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))
}

Explicación

• Blake2b512: implementa la función hash BLAKE2b con una salida de 512 bits.
• Lectura y hashing: de forma similar al ejemplo de ring, el archivo se procesa en fragmentos para calcular el hash de manera eficiente.

Análisis comparativo de los métodos de hashing

Al elegir un algoritmo de hashing, ten en cuenta los siguientes factores:

• Seguridad: SHA-256 y BLAKE2 ofrecen una seguridad robusta para fines criptográficos.
• Rendimiento: BLAKE2 suele superar a SHA-256 y ofrece un hashing más rápido con una seguridad similar.
• Compatibilidad: para la interoperabilidad, elige un algoritmo ampliamente compatible con distintas plataformas.

Mejores prácticas para el hashing de archivos en proyectos de Rust

• Usa lectura con búfer: emplea un BufReader para optimizar el rendimiento de E/S de archivos.
• Maneja los errores con elegancia: aprovecha el manejo de errores de Rust (con el tipo Result) para gestionar errores de E/S y de otro tipo.
• Evita la E/S bloqueante: en aplicaciones que procesan varios archivos, considera la E/S asíncrona o el procesamiento paralelo para mejorar el rendimiento.

Acelerar el hashing de archivos con procesamiento paralelo

Hashear archivos de forma secuencial puede resultar ineficiente cuando trabajas con varios archivos. Con el crate rayon, puedes procesar archivos de forma concurrente.

Agrega rayon junto a ring en la sección de dependencias existente de tu Cargo.toml (no dupliques el encabezado [dependencies]). Conserva Cargo.lock para reproducir las versiones de las dependencias de tu aplicación:

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

Ejemplo de hashing de archivos en paralelo

Coloca la función sha256_digest y sus importaciones del ejemplo anterior de ring encima de esta función main en src/main.rs. Ejecútala con cargo run --release -- file1.bin file2.bin.

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(())
         })
}

Consideraciones de rendimiento

Este ejemplo hashea distintos archivos de forma concurrente; no paraleliza los fragmentos de un mismo archivo. Cada digest sigue cubriendo el archivo completo en orden de bytes. Un archivo individual no obtiene aquí ninguna aceleración por paralelismo. Para varios archivos, mide el rendimiento en tu dispositivo de almacenamiento: la contención de E/S y la sobrecarga de planificación pueden superar cualquier ganancia. El orden de la salida no está especificado, y un error de E/S detiene la operación con un error, posiblemente después de que ya se hayan impreso los hashes de otros archivos.

Cómo contribuye el hashing de archivos a la integridad y la seguridad de los datos

• Integridad de los datos: compara el digest de un archivo con una referencia de confianza para detectar cambios durante la transmisión o el almacenamiento. Un atacante que pueda reemplazar tanto el archivo como su hash de referencia puede burlar esta comprobación.
• Seguridad: los hashes criptográficos son bloques de construcción para la autenticación y las firmas digitales. SHA-256 o BLAKE2 por sí solos no son adecuados para almacenar contraseñas; usa para ello un esquema de hashing de contraseñas como Argon2id.
• Deduplicación: el hashing permite identificar archivos duplicados, lo que optimiza el uso del almacenamiento.

Conclusión

El hashing de archivos en Rust es sencillo y eficiente con la ayuda de bibliotecas de código abierto como ring y RustCrypto. Al elegir el algoritmo de hashing adecuado y aprovechar el procesamiento paralelo con Rayon, puedes crear aplicaciones robustas para garantizar la integridad de los datos, la seguridad y una gestión eficiente de la información. Para más soluciones de procesamiento de archivos, considera explorar el servicio de Catalogación de medios de Transloadit.