enc_rust 0.2.2

A pure rust implementation of the Module-Lattice-based standards ML-KEM and (soon) ML-DSA, also known as the PQC scheme Crystals Kyber and Dilithium.
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
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

#![allow(warnings)]
#[cfg(test)]
pub(in crate::tests) mod params_tests {
    use crate::params::*;
    use proptest::prelude::*;

    pub(in crate::tests) fn sec_level_strategy() -> impl Strategy<Value = SecurityLevel> {
        prop_oneof![
            Just(SecurityLevel::new(K::Two)),
            Just(SecurityLevel::new(K::Three)),
            Just(SecurityLevel::new(K::Four)),
        ]
    }

    #[test]
    fn sec_level_test() {
        assert_eq!(
            SecurityLevel::new(K::Two),
            SecurityLevel::FiveOneTwo {
                k: K::Two,
                eta_1: Eta::Three,
                eta_2: Eta::Two,
            }
        );
        assert_eq!(
            SecurityLevel::new(K::Three),
            SecurityLevel::SevenSixEight {
                k: K::Three,
                eta_1: Eta::Two,
                eta_2: Eta::Two,
            }
        );
        assert_eq!(
            SecurityLevel::new(K::Four),
            SecurityLevel::TenTwoFour {
                k: K::Four,
                eta_1: Eta::Two,
                eta_2: Eta::Two,
            }
        );
    }

    #[test]
    fn poly_compressed_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).poly_compressed_bytes(), 128);
        assert_eq!(SecurityLevel::new(K::Three).poly_compressed_bytes(), 128);
        assert_eq!(SecurityLevel::new(K::Four).poly_compressed_bytes(), 160);
    }

    #[test]
    fn poly_vec_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).poly_vec_bytes(), 768);
        assert_eq!(SecurityLevel::new(K::Three).poly_vec_bytes(), 1152);
        assert_eq!(SecurityLevel::new(K::Four).poly_vec_bytes(), 1536);
    }

    #[test]
    fn poly_vec_compressed_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).poly_vec_compressed_bytes(), 640);
        assert_eq!(
            SecurityLevel::new(K::Three).poly_vec_compressed_bytes(),
            960
        );
        assert_eq!(
            SecurityLevel::new(K::Four).poly_vec_compressed_bytes(),
            1408
        );
    }

    #[test]
    fn indcpa_public_key_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).indcpa_public_key_bytes(), 800);
        assert_eq!(SecurityLevel::new(K::Three).indcpa_public_key_bytes(), 1184);
        assert_eq!(SecurityLevel::new(K::Four).indcpa_public_key_bytes(), 1568);
    }

    #[test]
    fn indcpa_private_key_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).indcpa_private_key_bytes(), 768);
        assert_eq!(
            SecurityLevel::new(K::Three).indcpa_private_key_bytes(),
            1152
        );
        assert_eq!(SecurityLevel::new(K::Four).indcpa_private_key_bytes(), 1536);
    }

    #[test]
    fn indcpa_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).indcpa_bytes(), 768);
        assert_eq!(SecurityLevel::new(K::Three).indcpa_bytes(), 1088);
        assert_eq!(SecurityLevel::new(K::Four).indcpa_bytes(), 1568);
    }

    #[test]
    fn public_key_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).public_key_bytes(), 800);
        assert_eq!(SecurityLevel::new(K::Three).public_key_bytes(), 1184);
        assert_eq!(SecurityLevel::new(K::Four).public_key_bytes(), 1568);
    }

    #[test]
    fn private_key_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).private_key_bytes(), 1632);
        assert_eq!(SecurityLevel::new(K::Three).private_key_bytes(), 2400);
        assert_eq!(SecurityLevel::new(K::Four).private_key_bytes(), 3168);
    }

    #[test]
    fn cipher_text_bytes_test() {
        assert_eq!(SecurityLevel::new(K::Two).ciphertext_bytes(), 768);
        assert_eq!(SecurityLevel::new(K::Three).ciphertext_bytes(), 1088);
        assert_eq!(SecurityLevel::new(K::Four).ciphertext_bytes(), 1568);
    }
}