krystals 0.0.1

Rust implementation of CRYSTALS-Kyber and CRYSTALS-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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

pub trait FlattenArray<T, const L: usize, const M: usize, const N: usize> {
    fn flatten_array(&self) -> &[T; N];
}
pub trait FlattenArrayMut<T, const L: usize, const M: usize, const N: usize> {
    fn flatten_array_mut(&mut self) -> &mut [T; N];
}

pub(crate) trait FlattenArrayCheck<const L: usize, const M: usize, const N: usize> {
    const REQUIREMENT: bool = L * M == N;
    const __ASSERT: &'static str =
        ["FlattenArrayCheck failure! L * M != N"][(!Self::REQUIREMENT) as usize];

    const __ASSERT_X: usize = Self::REQUIREMENT as usize - 1;
}

impl<T, const L: usize, const M: usize, const N: usize> FlattenArrayCheck<L, M, N> for [[T; L]; M] {}
impl<T, const L: usize, const M: usize, const N: usize> FlattenArrayCheck<L, M, N>
    for &[[T; L]; M]
{
}
impl<T, const L: usize, const M: usize, const N: usize> FlattenArrayCheck<L, M, N>
    for &mut [[T; L]; M]
{
}

impl<T, const L: usize, const M: usize, const N: usize> FlattenArray<T, L, M, N> for [[T; L]; M] {
    fn flatten_array(&self) -> &[T; N] {
        // assert_eq!(L * M, N);
        debug_assert_eq!(L * M, N); // checked at compiled time with FlattenArrayCheck:
        let _ = <Self as FlattenArrayCheck<L, M, N>>::__ASSERT;

        // Safety: size is checked above
        #[allow(unsafe_code)]
        unsafe {
            &*(self.as_ptr() as *const _)
        }
    }
}

impl<T, const L: usize, const M: usize, const N: usize> FlattenArray<T, L, M, N> for &[[T; L]; M] {
    fn flatten_array(&self) -> &[T; N] {
        // assert_eq!(L * M, N);
        debug_assert_eq!(L * M, N); // checked at compiled time with FlattenArrayCheck:
        let _ = <Self as FlattenArrayCheck<L, M, N>>::__ASSERT;

        // Safety: size is checked above
        #[allow(unsafe_code)]
        unsafe {
            &*(self.as_ptr() as *const _)
        }
    }
}

impl<T, const L: usize, const M: usize, const N: usize> FlattenArrayMut<T, L, M, N>
    for &mut [[T; L]; M]
{
    fn flatten_array_mut(&mut self) -> &mut [T; N] {
        // assert_eq!(L * M, N);
        debug_assert_eq!(L * M, N); // checked at compiled time with FlattenArrayCheck:
        let _ = <Self as FlattenArrayCheck<L, M, N>>::__ASSERT;

        // Safety: size is checked above
        #[allow(unsafe_code)]
        unsafe {
            &mut *(self.as_mut_ptr() as *mut _)
        }
    }
}

pub trait FlattenSlice<'a, T, const L: usize> {
    fn flatten_slice(&'a self) -> &'a [T];
}
pub trait FlattenSliceMut<'a, T, const L: usize> {
    fn flatten_slice_mut(&'a mut self) -> &'a mut [T];
}

pub trait FlattenTwice<T, const L: usize> {
    fn flatten_twice(&self) -> &[T];
}

pub trait FlattenTwiceMut<T, const L: usize> {
    fn flatten_twice_mut(&mut self) -> &mut [T];
}

impl<'a, T: 'a, const L: usize> FlattenSlice<'a, T, L> for &'a [[T; L]] {
    fn flatten_slice(&'a self) -> &'a [T] {
        // Safety: self is a slice of arrays each L elements (of type T), self.len() * L elements in total
        // generated slice is the exact same length (self.len() * L) and same type (T) as the original slice.
        #[allow(unsafe_code)]
        unsafe {
            core::slice::from_raw_parts(self.as_ptr() as *const _, self.len() * L)
        }
    }
}

impl<'a, T: 'a, const L: usize, const M: usize> FlattenSlice<'a, T, L> for [[T; L]; M] {
    fn flatten_slice(&'a self) -> &'a [T] {
        // Safety: self is a slice of arrays each L elements (of type T), M * L elements in total
        // generated slice is the exact same length (M * L) and same type (T) as the original slice.
        #[allow(unsafe_code)]
        unsafe {
            core::slice::from_raw_parts(self.as_ptr() as *const _, M * L)
        }
    }
}

impl<'a, T: 'a + Sized, const L: usize, const M: usize> FlattenSliceMut<'a, T, L> for [[T; L]; M] {
    fn flatten_slice_mut(&'a mut self) -> &'a mut [T] {
        // Safety: self is a slice of arrays each L elements (of type T), M * L elements in total
        // generated slice is the exact same length (M * L) and same type (T) as the original slice.
        #[allow(unsafe_code)]
        unsafe {
            core::slice::from_raw_parts_mut(self.as_mut_ptr() as *mut _, M * L)
        }
    }
}

impl<T: Sized, const L: usize, const M: usize, const X: usize> FlattenTwice<T, L>
    for [[[T; L]; M]; X]
{
    fn flatten_twice(&self) -> &[T] {
        // Safety: Number of total elements and total size remains unchanged (X * M * L)
        #[allow(unsafe_code)]
        unsafe {
            core::slice::from_raw_parts(self.as_ptr() as *const _, X * M * L)
        }
    }
}

impl<T: Sized, const L: usize, const M: usize, const X: usize> FlattenTwiceMut<T, L>
    for [[[T; L]; M]; X]
{
    fn flatten_twice_mut(&mut self) -> &mut [T] {
        // Safety: Number of total elements and total size remains unchanged (X * M * L)
        #[allow(unsafe_code)]
        unsafe {
            core::slice::from_raw_parts_mut(self.as_mut_ptr() as *mut _, X * M * L)
        }
    }
}