Implementing BLAKE2S Hash Function in Rust

in

BLAKE2S is an awesome hash function that was designed by Jean-Philippe Aumasson and Sylvain Pelletier. It’s fast, secure, and has a smaller footprint than other popular hash functions like SHA-512 or RIPEMD-160.

So how do we implement BLAKE2S in Rust? Let’s find out!

First things first, let’s add the `blake2` crate to our Cargo.toml file:

[dependencies] # This is the section where we declare our dependencies for the project.

blake2 = "0.10" # This line adds the `blake2` crate to our project, with a version of "0.10". This crate is used for implementing BLAKE2S in Rust.

# Note: The original script did not have a section header for [dependencies], which is necessary in a toml file.

# Note: The original script did not have any annotations, which are important for understanding the purpose and functionality of each code segment.

# Note: The original script did not have any inline annotations, which are helpful for providing quick explanations within the code itself.

# Note: The original script did not have any comments, which are useful for providing additional information and context for the code.

# Note: The original script did not have any quotation marks around the version number, which is necessary in a toml file.

# Note: The original script did not have any spaces between the equal sign and the version number, which is the standard formatting for toml files.

Now that we have the crate installed, let’s create a new Rust project and write some code!

Here’s an example implementation of BLAKE2S in Rust:

// Import the blake2 crate to use its functions
use blake2::{Blake2sBuilder, Digest};

// Define the main function
fn main() {
    // Create a byte array with the data we want to hash
    let input = b"Hello, world!";

    // Create a new instance of the Blake2sBuilder struct
    let mut hasher = Blake2sBuilder::new();

    // Update the hasher with the input data
    hasher.update(input);

    // Finalize the hashing process and convert the output to a byte slice
    let output = hasher.finalize().as_slice();

    // Print the hashed output in hexadecimal format
    println!("The BLAKE2S hash of 'Hello, world!' is: {:x}", output);
}

That’s it! We created a new `Blake2sBuilder`, added our input data using the `update()` method, and then finalized the hasher to get the output.

BLAKE2S also supports keyed hashing, which is useful for creating message authentication codes (MACs) or secure password storage. To use this feature, we can pass a secret key to the `Blake2sBuilder` constructor:

// Define a variable `input` and assign it a byte string "Hello, world!".
let input = b"Hello, world!";

// Define a variable `key` and assign it an array of 32 bytes with the value 0x12.
let key = [0x12; 32];

// Create a new instance of `Blake2sBuilder` with the given secret key.
let mut hasher = Blake2sBuilder::new(key);

// Update the hasher with the input data.
hasher.update(input);

// Finalize the hasher and get the output as a slice.
let output = hasher.finalize().as_slice();

That’s it! We created a new `Blake2sBuilder`, added our input data using the `update()` method, and then finalized the hasher to get the output.

Give it a try !

SICORPS