Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_crypto/src/pqc/macros_saber.rs

6.3 KiB, 1 run

created by r1870400018:240, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1#[macro_export]
2/// Rust won't allow functions like pke_keygen to be shifted into the trait SaberAlgorithm
3/// because they use associated constants, which can be changed by each implementation. So we
4/// have these implementation-specific wrappers, they are identical in each implementation.
5macro_rules! generic_saber_api {
6 () => (
7 pub fn pke_keygen(
8 &self,
9 seed_a: [u8; SEED_BYTES],
10 seed_s: [u8; NOISE_SEED_BYTES],
11 ) -> (
12 PublicKey<{Self::PK_LEN}>,
13 SecretKeyCPA<{Self::SK_LEN}>,
14 ) {
15 Self::generic_pke_keygen::<
16 {Self::L},
17 {Self::POLY_VEC_BYTES},
18 {Self::L * Self::POLY_VEC_BYTES},
19 {Self::POLY_VEC_COMPRESSED_BYTES},
20 {Self::POLY_COIN_BYTES},
21 {Self::L * Self::POLY_COIN_BYTES},
22 >(
23 &self,
24 seed_a,
25 seed_s,
26 )
27 }
28
29 pub fn pke_enc(
30 &self,
31 m: &[u8; KEY_BYTES],
32 seed_sp:&[u8; SEED_BYTES],
33 pk: &PublicKey<{Self::POLY_VEC_COMPRESSED_BYTES}>,
34 )
35 -> CipherText<
36 {Self::SCALE_BYTES_KEM},
37 {Self::POLY_VEC_COMPRESSED_BYTES},
38 >
39 {
40 Self::generic_pke_enc::<
41 {Self::L},
42 {Self::POLY_VEC_BYTES},
43 {Self::L * Self::POLY_VEC_BYTES},
44 {Self::POLY_VEC_COMPRESSED_BYTES},
45 {Self::POLY_COIN_BYTES},
46 {Self::L * Self::POLY_COIN_BYTES},
47 {Self::SCALE_BYTES_KEM},
48 >(
49 &self,
50 m,
51 seed_sp,
52 pk,
53 )
54 }
55
56 pub fn pke_dec(
57 &self,
58 ciphertext: &CipherText<
59 {Self::SCALE_BYTES_KEM},
60 {Self::POLY_VEC_COMPRESSED_BYTES},
61 >,
62 sk: &SecretKeyCPA<{Self::POLY_VEC_BYTES}>,
63 )
64 -> [u8; KEY_BYTES]
65 {
66 Self::generic_pke_dec::<
67 {Self::L},
68 {Self::POLY_VEC_BYTES},
69 {Self::L * Self::POLY_VEC_BYTES},
70 {Self::POLY_VEC_COMPRESSED_BYTES},
71 {Self::POLY_COIN_BYTES},
72 {Self::L * Self::POLY_COIN_BYTES},
73 {Self::SCALE_BYTES_KEM},
74 >(
75 &self,
76 ciphertext,
77 sk,
78 )
79 }
80
81 pub fn kem_keygen(
82 &self,
83 ) -> (
84 PublicKey<{Self::PK_LEN}>,
85 SecretKeyCCA<{Self::SK_LEN}, {Self::PK_LEN}>,
86 ) {
87 let mut seed_a = [0_u8; SEED_BYTES];
88 OsRng.fill_bytes(&mut seed_a);
89 let mut seed_s = [0_u8; NOISE_SEED_BYTES];
90 OsRng.fill_bytes(&mut seed_s);
91 let mut rand = [0_u8; KEY_BYTES];
92 OsRng.fill_bytes(&mut rand);
93
94 Self::generic_kem_keygen::<
95 {Self::L},
96 {Self::POLY_VEC_BYTES},
97 {Self::L * Self::POLY_VEC_BYTES},
98 {Self::POLY_VEC_COMPRESSED_BYTES},
99 {Self::POLY_COIN_BYTES},
100 {Self::L * Self::POLY_COIN_BYTES},
101 >(
102 &self,
103 seed_a,
104 seed_s,
105 rand,
106 )
107 }
108
109 pub fn kem_keygen_test(
110 &self,
111 seed_a: [u8; SEED_BYTES],
112 seed_s: [u8; NOISE_SEED_BYTES],
113 rand: [u8; KEY_BYTES],
114 ) -> (
115 PublicKey<{Self::PK_LEN}>,
116 SecretKeyCCA<{Self::SK_LEN}, {Self::PK_LEN}>,
117 ) {
118 Self::generic_kem_keygen::<
119 {Self::L},
120 {Self::POLY_VEC_BYTES},
121 {Self::L * Self::POLY_VEC_BYTES},
122 {Self::POLY_VEC_COMPRESSED_BYTES},
123 {Self::POLY_COIN_BYTES},
124 {Self::L * Self::POLY_COIN_BYTES},
125 >(
126 &self,
127 seed_a,
128 seed_s,
129 rand,
130 )
131 }
132
133 pub fn kem_encap(
134 &self,
135 pk: &PublicKey<{Self::POLY_VEC_COMPRESSED_BYTES}>,
136 ) -> (
137 [u8; KEY_BYTES], // Session key
138 CipherText<{Self::SCALE_BYTES_KEM}, {Self::POLY_VEC_COMPRESSED_BYTES}>,
139 ) {
140 let mut m = [0_u8; KEY_BYTES];
141 OsRng.fill_bytes(&mut m);
142
143 Self::generic_kem_encap::<
144 {Self::L},
145 {Self::POLY_VEC_BYTES},
146 {Self::L * Self::POLY_VEC_BYTES},
147 {Self::POLY_VEC_COMPRESSED_BYTES},
148 {Self::POLY_COIN_BYTES},
149 {Self::L * Self::POLY_COIN_BYTES},
150 {Self::SCALE_BYTES_KEM},
151 {Self::CIPHERTEXT_BYTES},
152 >(
153 &self,
154 pk,
155 m,
156 )
157 }
158
159 fn kem_encap_test(
160 &self,
161 pk: &PublicKey<{Self::POLY_VEC_COMPRESSED_BYTES}>,
162 m: [u8; KEY_BYTES],
163 ) -> (
164 [u8; KEY_BYTES], // Session key
165 CipherText<{Self::SCALE_BYTES_KEM}, {Self::POLY_VEC_COMPRESSED_BYTES}>,
166 ) {
167 Self::generic_kem_encap::<
168 {Self::L},
169 {Self::POLY_VEC_BYTES},
170 {Self::L * Self::POLY_VEC_BYTES},
171 {Self::POLY_VEC_COMPRESSED_BYTES},
172 {Self::POLY_COIN_BYTES},
173 {Self::L * Self::POLY_COIN_BYTES},
174 {Self::SCALE_BYTES_KEM},
175 {Self::CIPHERTEXT_BYTES},
176 >(
177 &self,
178 pk,
179 m,
180 )
181 }
182
183 pub fn kem_decap(
184 &self,
185 ct_bytes: &[u8],
186 sk: &SecretKeyCCA<{Self::SK_LEN}, {Self::PK_LEN}>,
187 )
188 -> Outcome<[u8; KEY_BYTES]> // Session key
189 {
190 Self::generic_kem_decap::<
191 {Self::L},
192 {Self::POLY_VEC_BYTES},
193 {Self::L * Self::POLY_VEC_BYTES},
194 {Self::POLY_VEC_COMPRESSED_BYTES},
195 {Self::POLY_COIN_BYTES},
196 {Self::L * Self::POLY_COIN_BYTES},
197 {Self::SCALE_BYTES_KEM},
198 {Self::CIPHERTEXT_BYTES},
199 >(
200 &self,
201 ct_bytes,
202 sk,
203 )
204 }
205 );
206}
207