|
| 1 | +//! Cardano hashing functions |
| 2 | +
|
| 3 | +use std::{fmt, str::FromStr}; |
| 4 | + |
| 5 | +use blake2b_simd::Params; |
| 6 | +use displaydoc::Display; |
| 7 | +use pallas_crypto::hash::Hash; |
| 8 | +use thiserror::Error; |
| 9 | + |
| 10 | +/// Number of bytes in a blake2b 224 hash. |
| 11 | +pub const BLAKE_2B224_SIZE: usize = 224 / 8; |
| 12 | + |
| 13 | +/// `Blake2B` 224bit Hash. |
| 14 | +pub type Blake2b224Hash = Blake2bHash<BLAKE_2B224_SIZE>; |
| 15 | + |
| 16 | +/// Number of bytes in a blake2b 256 hash. |
| 17 | +pub const BLAKE_2B256_SIZE: usize = 256 / 8; |
| 18 | + |
| 19 | +/// `Blake2B` 256bit Hash |
| 20 | +pub type Blake2b256Hash = Blake2bHash<BLAKE_2B256_SIZE>; |
| 21 | + |
| 22 | +/// Number of bytes in a blake2b 128 hash. |
| 23 | +pub const BLAKE_2B128_SIZE: usize = 128 / 8; |
| 24 | + |
| 25 | +/// `Blake2B` 128bit Hash |
| 26 | +pub type Blake2b128Hash = Blake2bHash<BLAKE_2B128_SIZE>; |
| 27 | + |
| 28 | +/// Errors that can occur when converting to a `Blake2bHash`. |
| 29 | +#[derive(Display, Debug, Error)] |
| 30 | +pub enum Blake2bHashError { |
| 31 | + /// Invalid length: expected {expected} bytes, got {actual} |
| 32 | + InvalidLength { |
| 33 | + /// The expected number of bytes (must be 32 or 28). |
| 34 | + expected: usize, |
| 35 | + /// The actual number of bytes in the provided input. |
| 36 | + actual: usize, |
| 37 | + }, |
| 38 | + /// Invalid hex string: {source} |
| 39 | + InvalidHex { |
| 40 | + /// The underlying error from `hex`. |
| 41 | + #[from] |
| 42 | + source: hex::FromHexError, |
| 43 | + }, |
| 44 | +} |
| 45 | + |
| 46 | +/// data that is a blake2b [`struct@Hash`] of `BYTES` long. |
| 47 | +/// |
| 48 | +/// Possible values with Cardano are 32 bytes long (block hash or transaction |
| 49 | +/// hash). Or 28 bytes long (as used in addresses) |
| 50 | +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] |
| 51 | +pub struct Blake2bHash<const BYTES: usize>(Hash<BYTES>); |
| 52 | + |
| 53 | +impl<const BYTES: usize> Blake2bHash<BYTES> { |
| 54 | + /// Create a new `Blake2bHash` from a slice of bytes by hashing them. |
| 55 | + #[must_use] |
| 56 | + pub fn new(input_bytes: &[u8]) -> Self { |
| 57 | + let mut bytes: [u8; BYTES] = [0u8; BYTES]; |
| 58 | + |
| 59 | + // Generate a unique hash of the data. |
| 60 | + let mut hasher = Params::new().hash_length(BYTES).to_state(); |
| 61 | + |
| 62 | + hasher.update(input_bytes); |
| 63 | + let hash = hasher.finalize(); |
| 64 | + |
| 65 | + // Create a new array containing the first BYTES elements from the original array |
| 66 | + bytes.copy_from_slice(hash.as_bytes()); |
| 67 | + |
| 68 | + bytes.into() |
| 69 | + } |
| 70 | +} |
| 71 | + |
| 72 | +impl<const BYTES: usize> From<[u8; BYTES]> for Blake2bHash<BYTES> { |
| 73 | + #[inline] |
| 74 | + fn from(bytes: [u8; BYTES]) -> Self { |
| 75 | + let hash: Hash<BYTES> = bytes.into(); |
| 76 | + hash.into() |
| 77 | + } |
| 78 | +} |
| 79 | + |
| 80 | +impl<const BYTES: usize> From<Hash<BYTES>> for Blake2bHash<BYTES> { |
| 81 | + #[inline] |
| 82 | + fn from(bytes: Hash<BYTES>) -> Self { |
| 83 | + Self(bytes) |
| 84 | + } |
| 85 | +} |
| 86 | + |
| 87 | +impl<const BYTES: usize> From<Blake2bHash<BYTES>> for Vec<u8> { |
| 88 | + fn from(val: Blake2bHash<BYTES>) -> Self { |
| 89 | + val.0.to_vec() |
| 90 | + } |
| 91 | +} |
| 92 | + |
| 93 | +/// Convert hash in a form of byte array into the `Blake2bHash` type. |
| 94 | +impl<const BYTES: usize> TryFrom<&[u8]> for Blake2bHash<BYTES> { |
| 95 | + type Error = Blake2bHashError; |
| 96 | + |
| 97 | + fn try_from(value: &[u8]) -> Result<Self, Self::Error> { |
| 98 | + if value.len() < BYTES { |
| 99 | + return Err(Blake2bHashError::InvalidLength { |
| 100 | + expected: BYTES, |
| 101 | + actual: value.len(), |
| 102 | + }); |
| 103 | + } |
| 104 | + |
| 105 | + let mut hash = [0; BYTES]; |
| 106 | + hash.copy_from_slice(value); |
| 107 | + let hash: Hash<BYTES> = hash.into(); |
| 108 | + Ok(hash.into()) |
| 109 | + } |
| 110 | +} |
| 111 | + |
| 112 | +impl<const BYTES: usize> TryFrom<&Vec<u8>> for Blake2bHash<BYTES> { |
| 113 | + type Error = Blake2bHashError; |
| 114 | + |
| 115 | + fn try_from(value: &Vec<u8>) -> Result<Self, Self::Error> { |
| 116 | + value.as_slice().try_into() |
| 117 | + } |
| 118 | +} |
| 119 | + |
| 120 | +impl<const BYTES: usize> TryFrom<Vec<u8>> for Blake2bHash<BYTES> { |
| 121 | + type Error = Blake2bHashError; |
| 122 | + |
| 123 | + fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> { |
| 124 | + value.as_slice().try_into() |
| 125 | + } |
| 126 | +} |
| 127 | + |
| 128 | +impl<const BYTES: usize> fmt::Debug for Blake2bHash<BYTES> { |
| 129 | + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 130 | + f.write_str(&format!("{:?}", self.0)) |
| 131 | + } |
| 132 | +} |
| 133 | + |
| 134 | +impl<const BYTES: usize> fmt::Display for Blake2bHash<BYTES> { |
| 135 | + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| 136 | + f.write_str(&format!("{}", self.0)) |
| 137 | + } |
| 138 | +} |
| 139 | + |
| 140 | +impl<const BYTES: usize> FromStr for Blake2bHash<BYTES> { |
| 141 | + type Err = Blake2bHashError; |
| 142 | + |
| 143 | + fn from_str(s: &str) -> Result<Self, Self::Err> { |
| 144 | + let hash: Hash<BYTES> = s.parse().map_err(Blake2bHashError::from)?; |
| 145 | + Ok(hash.into()) |
| 146 | + } |
| 147 | +} |
| 148 | + |
| 149 | +impl<C, const BYTES: usize> minicbor::Encode<C> for Blake2bHash<BYTES> { |
| 150 | + fn encode<W: minicbor::encode::Write>( |
| 151 | + &self, e: &mut minicbor::Encoder<W>, _ctx: &mut C, |
| 152 | + ) -> Result<(), minicbor::encode::Error<W::Error>> { |
| 153 | + e.bytes(self.0.as_ref())?.ok() |
| 154 | + } |
| 155 | +} |
| 156 | + |
| 157 | +impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Blake2bHash<BYTES> { |
| 158 | + fn decode( |
| 159 | + d: &mut minicbor::Decoder<'a>, _ctx: &mut C, |
| 160 | + ) -> Result<Self, minicbor::decode::Error> { |
| 161 | + let bytes = d.bytes()?; |
| 162 | + bytes.try_into().map_err(|_| { |
| 163 | + minicbor::decode::Error::message("Invalid hash size for Blake2bHash cbor decode") |
| 164 | + }) |
| 165 | + } |
| 166 | +} |
| 167 | + |
| 168 | +#[cfg(test)] |
| 169 | +mod tests { |
| 170 | + use super::*; |
| 171 | + |
| 172 | + #[test] |
| 173 | + fn test_blake2b_hash_init() { |
| 174 | + let data = b"Cardano"; |
| 175 | + let hash_224 = Blake2b224Hash::new(data); |
| 176 | + let hash_256 = Blake2b256Hash::new(data); |
| 177 | + let hash_128 = Blake2b128Hash::new(data); |
| 178 | + |
| 179 | + assert_eq!(hash_224.0.as_ref().len(), BLAKE_2B224_SIZE); |
| 180 | + assert_eq!(hash_256.0.as_ref().len(), BLAKE_2B256_SIZE); |
| 181 | + assert_eq!(hash_128.0.as_ref().len(), BLAKE_2B128_SIZE); |
| 182 | + } |
| 183 | + |
| 184 | + #[test] |
| 185 | + fn test_blake2b_hash_conversion() { |
| 186 | + let data = b"Cardano"; |
| 187 | + let hash = Blake2b224Hash::new(data); |
| 188 | + |
| 189 | + let as_vec: Vec<u8> = hash.into(); |
| 190 | + let from_vec = Blake2b224Hash::try_from(&as_vec).unwrap(); |
| 191 | + assert_eq!(hash, from_vec); |
| 192 | + |
| 193 | + let from_slice = Blake2b224Hash::try_from(as_vec.as_slice()).unwrap(); |
| 194 | + assert_eq!(hash, from_slice); |
| 195 | + } |
| 196 | + |
| 197 | + #[test] |
| 198 | + fn test_blake2b_hash_invalid_length() { |
| 199 | + let invalid_data = vec![0u8; 10]; |
| 200 | + let result = Blake2b224Hash::try_from(&invalid_data); |
| 201 | + assert!(result.is_err()); |
| 202 | + |
| 203 | + if let Err(Blake2bHashError::InvalidLength { expected, actual }) = result { |
| 204 | + assert_eq!(expected, BLAKE_2B224_SIZE); |
| 205 | + assert_eq!(actual, invalid_data.len()); |
| 206 | + } else { |
| 207 | + panic!("Expected InvalidLength error"); |
| 208 | + } |
| 209 | + } |
| 210 | +} |
0 commit comments