feat: add blake2 and sha3 hash support

Author: brianheineman

Cargo.lock

@@ -24,6 +24,7 @@ version = "0.12.0"
 [workspace.dependencies]
 anyhow = "1.0.86"
 async-trait = "0.1.80"
+blake2 = "0.10.6"
 bytes = "1.6.0"
 criterion = "0.5.1"
 flate2 = "1.0.30"
@@ -43,6 +44,7 @@ semver = "1.0.23"
 serde = "1.0.203"
 serde_json = "1.0.118"
 sha2 = "0.10.8"
+sha3 = "0.10.8"
 tar = "0.4.41"
 target-triple = "0.1.3"
 test-log = "0.2.16"

Cargo.toml

@@ -12,6 +12,7 @@ version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 async-trait = { workspace = true }
+blake2 = { workspace = true }
 bytes = { workspace = true }
 flate2 = { workspace = true }
 hex = { workspace = true }
@@ -28,6 +29,7 @@ semver = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
+sha3 = { workspace = true }
 tar = { workspace = true }
 target-triple = { workspace = true }
 tempfile = { workspace = true }

postgresql_archive/Cargo.toml

@@ -0,0 +1,35 @@
+use crate::Result;
+use blake2::{Blake2b512, Digest};
+
+/// Hashes the data using blake2b-512.
+///
+/// # Arguments
+/// * `data` - The data to hash.
+///
+/// # Returns
+/// * The hash of the data.
+///
+/// # Errors
+/// * If the data cannot be hashed.
+pub fn hash(data: &Vec<u8>) -> Result<String> {
+    let mut hasher = Blake2b512::new();
+    hasher.update(data);
+    let hash = hex::encode(hasher.finalize());
+    Ok(hash)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hash() -> Result<()> {
+        let data = vec![4, 2];
+        let hash = hash(&data)?;
+        assert_eq!(
+            "e487ff1a06742b6054c76387d7a0bf9e0f62964358b850d80d9f88071508ef855e745a8ba67617f850cf563b20f4ec0d5bd8233b2e85eb0ba4f31a14075fb3d9",
+            hash
+        );
+        Ok(())
+    }
+}

postgresql_archive/src/hasher/blake2b_512.rs

@@ -0,0 +1,35 @@
+use crate::Result;
+use blake2::{Blake2s256, Digest};
+
+/// Hashes the data using blake2s-256.
+///
+/// # Arguments
+/// * `data` - The data to hash.
+///
+/// # Returns
+/// * The hash of the data.
+///
+/// # Errors
+/// * If the data cannot be hashed.
+pub fn hash(data: &Vec<u8>) -> Result<String> {
+    let mut hasher = Blake2s256::new();
+    hasher.update(data);
+    let hash = hex::encode(hasher.finalize());
+    Ok(hash)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hash() -> Result<()> {
+        let data = vec![4, 2];
+        let hash = hash(&data)?;
+        assert_eq!(
+            "d2e78507a899636d20314690e1683fd2116dd438b502645a8aa8f79fd579fb70",
+            hash
+        );
+        Ok(())
+    }
+}

postgresql_archive/src/hasher/blake2s_256.rs

@@ -1,3 +1,7 @@
+pub mod blake2b_512;
+pub mod blake2s_256;
 pub mod registry;
 pub mod sha2_256;
 pub mod sha2_512;
+pub mod sha3_256;
+pub mod sha3_512;

postgresql_archive/src/hasher/mod.rs

@@ -1,4 +1,4 @@
-use crate::hasher::{sha2_256, sha2_512};
+use crate::hasher::{blake2b_512, blake2s_256, sha2_256, sha2_512, sha3_256, sha3_512};
 use crate::Result;
 use lazy_static::lazy_static;
 use std::collections::HashMap;
@@ -59,8 +59,12 @@ impl HasherRegistry {
 impl Default for HasherRegistry {
     fn default() -> Self {
         let mut registry = Self::new();
+        registry.register("blake2s", blake2s_256::hash);
+        registry.register("blake2b", blake2b_512::hash);
         registry.register("sha256", sha2_256::hash);
         registry.register("sha512", sha2_512::hash);
+        registry.register("sha3-256", sha3_256::hash);
+        registry.register("sha3-512", sha3_512::hash);
         registry
     }
 }
@@ -145,4 +149,56 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn test_sha3_256() -> Result<()> {
+        let hasher = get("sha3-256").unwrap();
+        let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+        let hash = hasher(&data)?;
+
+        assert_eq!(
+            "c0188232190e0427fc9cc78597221c76c799528660889bd6ce1f3563148ff84d",
+            hash
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_sha3_512() -> Result<()> {
+        let hasher = get("sha3-512").unwrap();
+        let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+        let hash = hasher(&data)?;
+
+        assert_eq!(
+            "9429fc1f9772cc1d8039fe75cc1b033cd60f0ec4face0f8a514d25b0649ba8a5954b6c7a41cc3697a56db3ff321475be1fa14b70c7eb78fec6ce62dbfc54c9d3",
+            hash
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_blake2s_256() -> Result<()> {
+        let hasher = get("blake2s").unwrap();
+        let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+        let hash = hasher(&data)?;
+
+        assert_eq!(
+            "7125921e06071710350390fe902856dbea366a5d6f5ee26c18e741143ac80061",
+            hash
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_blake2s_512() -> Result<()> {
+        let hasher = get("blake2s").unwrap();
+        let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
+        let hash = hasher(&data)?;
+
+        assert_eq!(
+            "7125921e06071710350390fe902856dbea366a5d6f5ee26c18e741143ac80061",
+            hash
+        );
+        Ok(())
+    }
 }

postgresql_archive/src/hasher/registry.rs

@@ -0,0 +1,35 @@
+use crate::Result;
+use sha3::{Digest, Sha3_256};
+
+/// Hashes the data using SHA3-256.
+///
+/// # Arguments
+/// * `data` - The data to hash.
+///
+/// # Returns
+/// * The hash of the data.
+///
+/// # Errors
+/// * If the data cannot be hashed.
+pub fn hash(data: &Vec<u8>) -> Result<String> {
+    let mut hasher = Sha3_256::new();
+    hasher.update(data);
+    let hash = hex::encode(hasher.finalize());
+    Ok(hash)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hash() -> Result<()> {
+        let data = vec![4, 2];
+        let hash = hash(&data)?;
+        assert_eq!(
+            "10a0812b3335c2f6de6dd195c77950e20dbd2e87ee95086db4e2fd42f1a78eed",
+            hash
+        );
+        Ok(())
+    }
+}

postgresql_archive/src/hasher/sha3_256.rs

@@ -0,0 +1,35 @@
+use crate::Result;
+use sha3::{Digest, Sha3_512};
+
+/// Hashes the data using SHA3-512.
+///
+/// # Arguments
+/// * `data` - The data to hash.
+///
+/// # Returns
+/// * The hash of the data.
+///
+/// # Errors
+/// * If the data cannot be hashed.
+pub fn hash(data: &Vec<u8>) -> Result<String> {
+    let mut hasher = Sha3_512::new();
+    hasher.update(data);
+    let hash = hex::encode(hasher.finalize());
+    Ok(hash)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_hash() -> Result<()> {
+        let data = vec![4, 2];
+        let hash = hash(&data)?;
+        assert_eq!(
+            "4bcb3a87557684ff56272f6bc7f542d728d1b953d8b0beb94ffdd97d9ba872550629c9eb98357060c7dce1786f91e6af948eb1ae21ec304f558a4651ff2b134f",
+            hash
+        );
+        Ok(())
+    }
+}