1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use crate::hasher::Hasher;
use crate::multihash::MultihashDigest;
use tiny_multihash_derive::Multihash;

/// Multihash code for Identity.
pub const IDENTITY: u64 = 0x00;
/// Multihash code for SHA1.
pub const SHA1: u64 = 0x11;
/// Multihash code for SHA2-256.
pub const SHA2_256: u64 = 0x12;
/// Multihash code for SHA2-512.
pub const SHA2_512: u64 = 0x13;
/// Multihash code for SHA3-224.
pub const SHA3_224: u64 = 0x17;
/// Multihash code for SHA3-256.
pub const SHA3_256: u64 = 0x16;
/// Multihash code for SHA3-384.
pub const SHA3_384: u64 = 0x15;
/// Multihash code for SHA3-512.
pub const SHA3_512: u64 = 0x14;
/// Multihash code for KECCAK-224.
pub const KECCAK_224: u64 = 0x1a;
/// Multihash code for KECCAK-256.
pub const KECCAK_256: u64 = 0x1b;
/// Multihash code for KECCAK-384.
pub const KECCAK_384: u64 = 0x1c;
/// Multihash code for KECCAK-512.
pub const KECCAK_512: u64 = 0x1d;
/// Multihash code for BLAKE2b-256.
pub const BLAKE2B_256: u64 = 0xb220;
/// Multihash code for BLAKE2b-512.
pub const BLAKE2B_512: u64 = 0xb240;
/// Multihash code for BLAKE2s-128.
pub const BLAKE2S_128: u64 = 0xb250;
/// Multihash code for BLAKE2s-256.
pub const BLAKE2S_256: u64 = 0xb260;

/// Default (cryptographically secure) Multihash implementation.
///
/// This is a default set of hashing algorithms. Usually applications would use their own subset of
/// algorithms. See the [`Multihash` derive] for more information.
///
/// [`Multihash` derive]: crate::derive
#[derive(Copy, Clone, Debug, Eq, Multihash, PartialEq)]
pub enum Multihash {
    /// Multihash array for hash function.
    #[mh(code = self::SHA2_256, hasher = crate::Sha2_256)]
    Sha2_256(crate::Sha2Digest<crate::U32>),
    /// Multihash array for hash function.
    #[mh(code = self::SHA2_512, hasher = crate::Sha2_512)]
    Sha2_512(crate::Sha2Digest<crate::U64>),
    /// Multihash array for hash function.
    #[mh(code = self::SHA3_224, hasher = crate::Sha3_224)]
    Sha3_224(crate::Sha3Digest<crate::U28>),
    /// Multihash array for hash function.
    #[mh(code = self::SHA3_256, hasher = crate::Sha3_256)]
    Sha3_256(crate::Sha3Digest<crate::U32>),
    /// Multihash array for hash function.
    #[mh(code = self::SHA3_384, hasher = crate::Sha3_384)]
    Sha3_384(crate::Sha3Digest<crate::U48>),
    /// Multihash array for hash function.
    #[mh(code = self::SHA3_512, hasher = crate::Sha3_512)]
    Sha3_512(crate::Sha3Digest<crate::U64>),
    /// Multihash array for hash function.
    #[mh(code = self::KECCAK_224, hasher = crate::Keccak224)]
    Keccak224(crate::KeccakDigest<crate::U28>),
    /// Multihash array for hash function.
    #[mh(code = self::KECCAK_256, hasher = crate::Keccak256)]
    Keccak256(crate::KeccakDigest<crate::U32>),
    /// Multihash array for hash function.
    #[mh(code = self::KECCAK_384, hasher = crate::Keccak384)]
    Keccak384(crate::KeccakDigest<crate::U48>),
    /// Multihash array for hash function.
    #[mh(code = self::KECCAK_512, hasher = crate::Keccak512)]
    Keccak512(crate::KeccakDigest<crate::U64>),
    /// Multihash array for hash function.
    #[mh(code = self::BLAKE2B_256, hasher = crate::Blake2b256)]
    Blake2b256(crate::Blake2bDigest<crate::U32>),
    /// Multihash array for hash function.
    #[mh(code = self::BLAKE2B_512, hasher = crate::Blake2b512)]
    Blake2b512(crate::Blake2bDigest<crate::U64>),
    /// Multihash array for hash function.
    #[mh(code = self::BLAKE2S_128, hasher = crate::Blake2s128)]
    Blake2s128(crate::Blake2sDigest<crate::U16>),
    /// Multihash array for hash function.
    #[mh(code = self::BLAKE2S_256, hasher = crate::Blake2s256)]
    Blake2s256(crate::Blake2sDigest<crate::U32>),
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::hasher::Hasher;
    use crate::hasher_impl::sha3::{Sha3_256, Sha3_512};
    use crate::multihash::MultihashDigest;

    #[test]
    fn test_hasher_256() {
        let digest = Sha3_256::digest(b"hello world");
        let hash = Multihash::from(digest);
        let hash2 = Multihash::new(SHA3_256, b"hello world").unwrap();
        assert_eq!(hash.code(), SHA3_256);
        assert_eq!(hash.size(), 32);
        assert_eq!(hash.digest(), digest.as_ref());
        assert_eq!(hash, hash2);
    }

    #[test]
    fn test_hasher_512() {
        let digest = Sha3_512::digest(b"hello world");
        let hash = Multihash::from(digest);
        let hash2 = Multihash::new(SHA3_512, b"hello world").unwrap();
        assert_eq!(hash.code(), SHA3_512);
        assert_eq!(hash.size(), 64);
        assert_eq!(hash.digest(), digest.as_ref());
        assert_eq!(hash, hash2);
    }
}