cryptocol 0.19.9

A cryptographic library that includes big number arithmetic operations, hash algorithms, symmetric-key encryption/decryption algorithms, asymmetric-key (public-key) encryption/decryption algorithms, pseudo random number generators, etc. Hash algorithms includes MD4, MD5, SHA224, SHA256, SHA384, SHA512, SHA3, etc. Symmetric key encryption algorithms include DES, AES, etc. Public key encryption algorithms include RSA, ECC, etc.
Documentation 
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

// Copyright 2024, 2025 PARK Youngho.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your option.
// This file may not be copied, modified, or distributed
// except according to those terms.


use crate::number::SmallUInt;
use crate::hash::{  MD4, MD5, SHA0, SHA1,
                    SHA2_224, SHA2_256, SHA2_384,
                    SHA2_512, SHA2_512_256, SHA2_512_t_224,
                    Keccak_Generic, SHA3_256, SHA3_384, SHA3_512 };


#[allow(non_camel_case_types)]
pub trait Hash
{
    fn new() -> Self;
    fn get_default_length_in_bytes(&self) -> usize;
    fn calculate_hash_code<const N: usize>(&mut self, message: &[u8; N], counter: u32) -> [u8; N];
}

macro_rules! trait_Hash_impl {
    ($($hash_type:ty), *) => {
        $(
            impl Hash for $hash_type
            {
                fn new() -> Self
                {
                    Self::new()
                }

                #[inline]
                fn get_default_length_in_bytes(&self) -> usize
                {
                    Self::DEFUALT_OUTPUT_LENGTH_IN_BYTES
                }

                fn calculate_hash_code<const N: usize>(&mut self, message: &[u8; N], counter: u32) -> [u8; N]
                {
                    let mut message_array = Vec::<u8>::from(message);
                    let counter = counter.to_be_bytes();
                    for i in 0..4
                        { message_array.push(counter[i]); }
                    let mut hash = [0_u8; N];
                    self.digest_vec(&message_array);
                    self.put_hash_value_in_array(&mut hash);
                    hash
                }
            }
        )*
    };
}

trait_Hash_impl!{ MD4, MD5, SHA0, SHA1,
                  SHA2_224, SHA2_256, SHA2_384, SHA2_512, SHA2_512_256, SHA2_512_t_224,
                  SHA3_256, SHA3_384, SHA3_512 }



impl<const RATE: usize, const PADDING: usize, const ROUNDS: usize, T, const LFSR: u8,
    const THETA_SUB: usize, const THETA_ADD: usize, const THETA_ROT: u32,
    const RHO_MUL_X: usize, const RHO_MUL_Y: usize, const RHO_T: u32,
    const PI_MUL_X: usize, const PI_MUL_Y: usize,
    const CHI_ADD_1: usize, const CHI_ADD_2: usize>
Keccak_Generic<RATE, PADDING, ROUNDS, T, LFSR,
                THETA_SUB, THETA_ADD, THETA_ROT,
                RHO_MUL_X, RHO_MUL_Y, RHO_T,
                PI_MUL_X, PI_MUL_Y, CHI_ADD_1, CHI_ADD_2>
where T: SmallUInt
{
    fn put_hash_value_in_array<const N: usize>(&mut self, hash_value: &mut [u8; N])
    {
        self.get_hash_value(hash_value.as_mut_ptr(), N);
    }
}