1use libc::c_int;
12
13#[allow(unused_imports)]
15use pqcrypto_internals::*;
16
17pub const PQCLEAN_KYBER512_CLEAN_CRYPTO_SECRETKEYBYTES: usize = 1632;
18pub const PQCLEAN_KYBER512_CLEAN_CRYPTO_PUBLICKEYBYTES: usize = 800;
19pub const PQCLEAN_KYBER512_CLEAN_CRYPTO_CIPHERTEXTBYTES: usize = 768;
20pub const PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES: usize = 32;
21
22#[cfg(enable_x86_avx2)]
23pub const PQCLEAN_KYBER512_AVX2_CRYPTO_SECRETKEYBYTES: usize = 1632;
24#[cfg(enable_x86_avx2)]
25pub const PQCLEAN_KYBER512_AVX2_CRYPTO_PUBLICKEYBYTES: usize = 800;
26#[cfg(enable_x86_avx2)]
27pub const PQCLEAN_KYBER512_AVX2_CRYPTO_CIPHERTEXTBYTES: usize = 768;
28#[cfg(enable_x86_avx2)]
29pub const PQCLEAN_KYBER512_AVX2_CRYPTO_BYTES: usize = 32;
30
31#[cfg(enable_aarch64_neon)]
32pub const PQCLEAN_KYBER512_AARCH64_CRYPTO_SECRETKEYBYTES: usize = 1632;
33#[cfg(enable_aarch64_neon)]
34pub const PQCLEAN_KYBER512_AARCH64_CRYPTO_PUBLICKEYBYTES: usize = 800;
35#[cfg(enable_aarch64_neon)]
36pub const PQCLEAN_KYBER512_AARCH64_CRYPTO_CIPHERTEXTBYTES: usize = 768;
37#[cfg(enable_aarch64_neon)]
38pub const PQCLEAN_KYBER512_AARCH64_CRYPTO_BYTES: usize = 32;
39
40pub const PQCLEAN_KYBER768_CLEAN_CRYPTO_SECRETKEYBYTES: usize = 2400;
41pub const PQCLEAN_KYBER768_CLEAN_CRYPTO_PUBLICKEYBYTES: usize = 1184;
42pub const PQCLEAN_KYBER768_CLEAN_CRYPTO_CIPHERTEXTBYTES: usize = 1088;
43pub const PQCLEAN_KYBER768_CLEAN_CRYPTO_BYTES: usize = 32;
44
45#[cfg(enable_x86_avx2)]
46pub const PQCLEAN_KYBER768_AVX2_CRYPTO_SECRETKEYBYTES: usize = 2400;
47#[cfg(enable_x86_avx2)]
48pub const PQCLEAN_KYBER768_AVX2_CRYPTO_PUBLICKEYBYTES: usize = 1184;
49#[cfg(enable_x86_avx2)]
50pub const PQCLEAN_KYBER768_AVX2_CRYPTO_CIPHERTEXTBYTES: usize = 1088;
51#[cfg(enable_x86_avx2)]
52pub const PQCLEAN_KYBER768_AVX2_CRYPTO_BYTES: usize = 32;
53
54#[cfg(enable_aarch64_neon)]
55pub const PQCLEAN_KYBER768_AARCH64_CRYPTO_SECRETKEYBYTES: usize = 2400;
56#[cfg(enable_aarch64_neon)]
57pub const PQCLEAN_KYBER768_AARCH64_CRYPTO_PUBLICKEYBYTES: usize = 1184;
58#[cfg(enable_aarch64_neon)]
59pub const PQCLEAN_KYBER768_AARCH64_CRYPTO_CIPHERTEXTBYTES: usize = 1088;
60#[cfg(enable_aarch64_neon)]
61pub const PQCLEAN_KYBER768_AARCH64_CRYPTO_BYTES: usize = 32;
62
63pub const PQCLEAN_KYBER1024_CLEAN_CRYPTO_SECRETKEYBYTES: usize = 3168;
64pub const PQCLEAN_KYBER1024_CLEAN_CRYPTO_PUBLICKEYBYTES: usize = 1568;
65pub const PQCLEAN_KYBER1024_CLEAN_CRYPTO_CIPHERTEXTBYTES: usize = 1568;
66pub const PQCLEAN_KYBER1024_CLEAN_CRYPTO_BYTES: usize = 32;
67
68#[cfg(enable_x86_avx2)]
69pub const PQCLEAN_KYBER1024_AVX2_CRYPTO_SECRETKEYBYTES: usize = 3168;
70#[cfg(enable_x86_avx2)]
71pub const PQCLEAN_KYBER1024_AVX2_CRYPTO_PUBLICKEYBYTES: usize = 1568;
72#[cfg(enable_x86_avx2)]
73pub const PQCLEAN_KYBER1024_AVX2_CRYPTO_CIPHERTEXTBYTES: usize = 1568;
74#[cfg(enable_x86_avx2)]
75pub const PQCLEAN_KYBER1024_AVX2_CRYPTO_BYTES: usize = 32;
76
77#[cfg(enable_aarch64_neon)]
78pub const PQCLEAN_KYBER1024_AARCH64_CRYPTO_SECRETKEYBYTES: usize = 3168;
79#[cfg(enable_aarch64_neon)]
80pub const PQCLEAN_KYBER1024_AARCH64_CRYPTO_PUBLICKEYBYTES: usize = 1568;
81#[cfg(enable_aarch64_neon)]
82pub const PQCLEAN_KYBER1024_AARCH64_CRYPTO_CIPHERTEXTBYTES: usize = 1568;
83#[cfg(enable_aarch64_neon)]
84pub const PQCLEAN_KYBER1024_AARCH64_CRYPTO_BYTES: usize = 32;
85
86#[link(name = "kyber512_clean")]
87extern "C" {
88 pub fn PQCLEAN_KYBER512_CLEAN_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
89 pub fn PQCLEAN_KYBER512_CLEAN_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *const u8) -> c_int;
90 pub fn PQCLEAN_KYBER512_CLEAN_crypto_kem_dec(
91 ss: *mut u8,
92 ct: *const u8,
93 sk: *const u8,
94 ) -> c_int;
95}
96
97#[cfg(enable_x86_avx2)]
98#[link(name = "kyber512_avx2")]
99extern "C" {
100 #[cfg(enable_x86_avx2)]
101 pub fn PQCLEAN_KYBER512_AVX2_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
102 #[cfg(enable_x86_avx2)]
103 pub fn PQCLEAN_KYBER512_AVX2_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *const u8) -> c_int;
104 #[cfg(enable_x86_avx2)]
105 pub fn PQCLEAN_KYBER512_AVX2_crypto_kem_dec(ss: *mut u8, ct: *const u8, sk: *const u8)
106 -> c_int;
107}
108
109#[cfg(enable_aarch64_neon)]
110#[link(name = "kyber512_aarch64")]
111extern "C" {
112 #[cfg(enable_aarch64_neon)]
113 pub fn PQCLEAN_KYBER512_AARCH64_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
114 #[cfg(enable_aarch64_neon)]
115 pub fn PQCLEAN_KYBER512_AARCH64_crypto_kem_enc(
116 ct: *mut u8,
117 ss: *mut u8,
118 pk: *const u8,
119 ) -> c_int;
120 #[cfg(enable_aarch64_neon)]
121 pub fn PQCLEAN_KYBER512_AARCH64_crypto_kem_dec(
122 ss: *mut u8,
123 ct: *const u8,
124 sk: *const u8,
125 ) -> c_int;
126}
127
128#[link(name = "kyber768_clean")]
129extern "C" {
130 pub fn PQCLEAN_KYBER768_CLEAN_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
131 pub fn PQCLEAN_KYBER768_CLEAN_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *const u8) -> c_int;
132 pub fn PQCLEAN_KYBER768_CLEAN_crypto_kem_dec(
133 ss: *mut u8,
134 ct: *const u8,
135 sk: *const u8,
136 ) -> c_int;
137}
138
139#[cfg(enable_x86_avx2)]
140#[link(name = "kyber768_avx2")]
141extern "C" {
142 #[cfg(enable_x86_avx2)]
143 pub fn PQCLEAN_KYBER768_AVX2_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
144 #[cfg(enable_x86_avx2)]
145 pub fn PQCLEAN_KYBER768_AVX2_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *const u8) -> c_int;
146 #[cfg(enable_x86_avx2)]
147 pub fn PQCLEAN_KYBER768_AVX2_crypto_kem_dec(ss: *mut u8, ct: *const u8, sk: *const u8)
148 -> c_int;
149}
150
151#[cfg(enable_aarch64_neon)]
152#[link(name = "kyber768_aarch64")]
153extern "C" {
154 #[cfg(enable_aarch64_neon)]
155 pub fn PQCLEAN_KYBER768_AARCH64_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
156 #[cfg(enable_aarch64_neon)]
157 pub fn PQCLEAN_KYBER768_AARCH64_crypto_kem_enc(
158 ct: *mut u8,
159 ss: *mut u8,
160 pk: *const u8,
161 ) -> c_int;
162 #[cfg(enable_aarch64_neon)]
163 pub fn PQCLEAN_KYBER768_AARCH64_crypto_kem_dec(
164 ss: *mut u8,
165 ct: *const u8,
166 sk: *const u8,
167 ) -> c_int;
168}
169
170#[link(name = "kyber1024_clean")]
171extern "C" {
172 pub fn PQCLEAN_KYBER1024_CLEAN_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
173 pub fn PQCLEAN_KYBER1024_CLEAN_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *const u8)
174 -> c_int;
175 pub fn PQCLEAN_KYBER1024_CLEAN_crypto_kem_dec(
176 ss: *mut u8,
177 ct: *const u8,
178 sk: *const u8,
179 ) -> c_int;
180}
181
182#[cfg(enable_x86_avx2)]
183#[link(name = "kyber1024_avx2")]
184extern "C" {
185 #[cfg(enable_x86_avx2)]
186 pub fn PQCLEAN_KYBER1024_AVX2_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
187 #[cfg(enable_x86_avx2)]
188 pub fn PQCLEAN_KYBER1024_AVX2_crypto_kem_enc(ct: *mut u8, ss: *mut u8, pk: *const u8) -> c_int;
189 #[cfg(enable_x86_avx2)]
190 pub fn PQCLEAN_KYBER1024_AVX2_crypto_kem_dec(
191 ss: *mut u8,
192 ct: *const u8,
193 sk: *const u8,
194 ) -> c_int;
195}
196
197#[cfg(enable_aarch64_neon)]
198#[link(name = "kyber1024_aarch64")]
199extern "C" {
200 #[cfg(enable_aarch64_neon)]
201 pub fn PQCLEAN_KYBER1024_AARCH64_crypto_kem_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
202 #[cfg(enable_aarch64_neon)]
203 pub fn PQCLEAN_KYBER1024_AARCH64_crypto_kem_enc(
204 ct: *mut u8,
205 ss: *mut u8,
206 pk: *const u8,
207 ) -> c_int;
208 #[cfg(enable_aarch64_neon)]
209 pub fn PQCLEAN_KYBER1024_AARCH64_crypto_kem_dec(
210 ss: *mut u8,
211 ct: *const u8,
212 sk: *const u8,
213 ) -> c_int;
214}
215
216#[cfg(test)]
217mod test_kyber512_clean {
218 use super::*;
219 use alloc::vec;
220
221 #[test]
222 fn test_ffi() {
223 unsafe {
224 let mut pk = vec![0u8; PQCLEAN_KYBER512_CLEAN_CRYPTO_PUBLICKEYBYTES];
225 let mut sk = vec![0u8; PQCLEAN_KYBER512_CLEAN_CRYPTO_SECRETKEYBYTES];
226 let mut ct = vec![0u8; PQCLEAN_KYBER512_CLEAN_CRYPTO_CIPHERTEXTBYTES];
227 let mut ss1 = vec![0u8; PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES];
228 let mut ss2 = vec![0u8; PQCLEAN_KYBER512_CLEAN_CRYPTO_BYTES];
229
230 assert_eq!(
231 0,
232 PQCLEAN_KYBER512_CLEAN_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
233 );
234 assert_eq!(
235 0,
236 PQCLEAN_KYBER512_CLEAN_crypto_kem_enc(
237 ct.as_mut_ptr(),
238 ss1.as_mut_ptr(),
239 pk.as_ptr()
240 )
241 );
242 assert_eq!(
243 0,
244 PQCLEAN_KYBER512_CLEAN_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
245 );
246 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
247 }
248 }
249}
250
251#[cfg(all(test, enable_x86_avx2, feature = "avx2"))]
252mod test_kyber512_avx2 {
253 use super::*;
254 use alloc::vec;
255 use std::is_x86_feature_detected;
256
257 #[test]
258 fn test_ffi() {
259 if !is_x86_feature_detected!("avx2") {
260 return;
261 }
262 unsafe {
263 let mut pk = vec![0u8; PQCLEAN_KYBER512_AVX2_CRYPTO_PUBLICKEYBYTES];
264 let mut sk = vec![0u8; PQCLEAN_KYBER512_AVX2_CRYPTO_SECRETKEYBYTES];
265 let mut ct = vec![0u8; PQCLEAN_KYBER512_AVX2_CRYPTO_CIPHERTEXTBYTES];
266 let mut ss1 = vec![0u8; PQCLEAN_KYBER512_AVX2_CRYPTO_BYTES];
267 let mut ss2 = vec![0u8; PQCLEAN_KYBER512_AVX2_CRYPTO_BYTES];
268
269 assert_eq!(
270 0,
271 PQCLEAN_KYBER512_AVX2_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
272 );
273 assert_eq!(
274 0,
275 PQCLEAN_KYBER512_AVX2_crypto_kem_enc(
276 ct.as_mut_ptr(),
277 ss1.as_mut_ptr(),
278 pk.as_ptr()
279 )
280 );
281 assert_eq!(
282 0,
283 PQCLEAN_KYBER512_AVX2_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
284 );
285 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
286 }
287 }
288}
289
290#[cfg(all(test, enable_aarch64_neon, feature = "neon"))]
291mod test_kyber512_aarch64 {
292 use super::*;
293 use alloc::vec;
294
295 #[test]
296 fn test_ffi() {
297 unsafe {
298 let mut pk = vec![0u8; PQCLEAN_KYBER512_AARCH64_CRYPTO_PUBLICKEYBYTES];
299 let mut sk = vec![0u8; PQCLEAN_KYBER512_AARCH64_CRYPTO_SECRETKEYBYTES];
300 let mut ct = vec![0u8; PQCLEAN_KYBER512_AARCH64_CRYPTO_CIPHERTEXTBYTES];
301 let mut ss1 = vec![0u8; PQCLEAN_KYBER512_AARCH64_CRYPTO_BYTES];
302 let mut ss2 = vec![0u8; PQCLEAN_KYBER512_AARCH64_CRYPTO_BYTES];
303
304 assert_eq!(
305 0,
306 PQCLEAN_KYBER512_AARCH64_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
307 );
308 assert_eq!(
309 0,
310 PQCLEAN_KYBER512_AARCH64_crypto_kem_enc(
311 ct.as_mut_ptr(),
312 ss1.as_mut_ptr(),
313 pk.as_ptr()
314 )
315 );
316 assert_eq!(
317 0,
318 PQCLEAN_KYBER512_AARCH64_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
319 );
320 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
321 }
322 }
323}
324
325#[cfg(test)]
326mod test_kyber768_clean {
327 use super::*;
328 use alloc::vec;
329
330 #[test]
331 fn test_ffi() {
332 unsafe {
333 let mut pk = vec![0u8; PQCLEAN_KYBER768_CLEAN_CRYPTO_PUBLICKEYBYTES];
334 let mut sk = vec![0u8; PQCLEAN_KYBER768_CLEAN_CRYPTO_SECRETKEYBYTES];
335 let mut ct = vec![0u8; PQCLEAN_KYBER768_CLEAN_CRYPTO_CIPHERTEXTBYTES];
336 let mut ss1 = vec![0u8; PQCLEAN_KYBER768_CLEAN_CRYPTO_BYTES];
337 let mut ss2 = vec![0u8; PQCLEAN_KYBER768_CLEAN_CRYPTO_BYTES];
338
339 assert_eq!(
340 0,
341 PQCLEAN_KYBER768_CLEAN_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
342 );
343 assert_eq!(
344 0,
345 PQCLEAN_KYBER768_CLEAN_crypto_kem_enc(
346 ct.as_mut_ptr(),
347 ss1.as_mut_ptr(),
348 pk.as_ptr()
349 )
350 );
351 assert_eq!(
352 0,
353 PQCLEAN_KYBER768_CLEAN_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
354 );
355 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
356 }
357 }
358}
359
360#[cfg(all(test, enable_x86_avx2, feature = "avx2"))]
361mod test_kyber768_avx2 {
362 use super::*;
363 use alloc::vec;
364 use std::is_x86_feature_detected;
365
366 #[test]
367 fn test_ffi() {
368 if !is_x86_feature_detected!("avx2") {
369 return;
370 }
371 unsafe {
372 let mut pk = vec![0u8; PQCLEAN_KYBER768_AVX2_CRYPTO_PUBLICKEYBYTES];
373 let mut sk = vec![0u8; PQCLEAN_KYBER768_AVX2_CRYPTO_SECRETKEYBYTES];
374 let mut ct = vec![0u8; PQCLEAN_KYBER768_AVX2_CRYPTO_CIPHERTEXTBYTES];
375 let mut ss1 = vec![0u8; PQCLEAN_KYBER768_AVX2_CRYPTO_BYTES];
376 let mut ss2 = vec![0u8; PQCLEAN_KYBER768_AVX2_CRYPTO_BYTES];
377
378 assert_eq!(
379 0,
380 PQCLEAN_KYBER768_AVX2_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
381 );
382 assert_eq!(
383 0,
384 PQCLEAN_KYBER768_AVX2_crypto_kem_enc(
385 ct.as_mut_ptr(),
386 ss1.as_mut_ptr(),
387 pk.as_ptr()
388 )
389 );
390 assert_eq!(
391 0,
392 PQCLEAN_KYBER768_AVX2_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
393 );
394 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
395 }
396 }
397}
398
399#[cfg(all(test, enable_aarch64_neon, feature = "neon"))]
400mod test_kyber768_aarch64 {
401 use super::*;
402 use alloc::vec;
403
404 #[test]
405 fn test_ffi() {
406 unsafe {
407 let mut pk = vec![0u8; PQCLEAN_KYBER768_AARCH64_CRYPTO_PUBLICKEYBYTES];
408 let mut sk = vec![0u8; PQCLEAN_KYBER768_AARCH64_CRYPTO_SECRETKEYBYTES];
409 let mut ct = vec![0u8; PQCLEAN_KYBER768_AARCH64_CRYPTO_CIPHERTEXTBYTES];
410 let mut ss1 = vec![0u8; PQCLEAN_KYBER768_AARCH64_CRYPTO_BYTES];
411 let mut ss2 = vec![0u8; PQCLEAN_KYBER768_AARCH64_CRYPTO_BYTES];
412
413 assert_eq!(
414 0,
415 PQCLEAN_KYBER768_AARCH64_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
416 );
417 assert_eq!(
418 0,
419 PQCLEAN_KYBER768_AARCH64_crypto_kem_enc(
420 ct.as_mut_ptr(),
421 ss1.as_mut_ptr(),
422 pk.as_ptr()
423 )
424 );
425 assert_eq!(
426 0,
427 PQCLEAN_KYBER768_AARCH64_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
428 );
429 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
430 }
431 }
432}
433
434#[cfg(test)]
435mod test_kyber1024_clean {
436 use super::*;
437 use alloc::vec;
438
439 #[test]
440 fn test_ffi() {
441 unsafe {
442 let mut pk = vec![0u8; PQCLEAN_KYBER1024_CLEAN_CRYPTO_PUBLICKEYBYTES];
443 let mut sk = vec![0u8; PQCLEAN_KYBER1024_CLEAN_CRYPTO_SECRETKEYBYTES];
444 let mut ct = vec![0u8; PQCLEAN_KYBER1024_CLEAN_CRYPTO_CIPHERTEXTBYTES];
445 let mut ss1 = vec![0u8; PQCLEAN_KYBER1024_CLEAN_CRYPTO_BYTES];
446 let mut ss2 = vec![0u8; PQCLEAN_KYBER1024_CLEAN_CRYPTO_BYTES];
447
448 assert_eq!(
449 0,
450 PQCLEAN_KYBER1024_CLEAN_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
451 );
452 assert_eq!(
453 0,
454 PQCLEAN_KYBER1024_CLEAN_crypto_kem_enc(
455 ct.as_mut_ptr(),
456 ss1.as_mut_ptr(),
457 pk.as_ptr()
458 )
459 );
460 assert_eq!(
461 0,
462 PQCLEAN_KYBER1024_CLEAN_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
463 );
464 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
465 }
466 }
467}
468
469#[cfg(all(test, enable_x86_avx2, feature = "avx2"))]
470mod test_kyber1024_avx2 {
471 use super::*;
472 use alloc::vec;
473 use std::is_x86_feature_detected;
474
475 #[test]
476 fn test_ffi() {
477 if !is_x86_feature_detected!("avx2") {
478 return;
479 }
480 unsafe {
481 let mut pk = vec![0u8; PQCLEAN_KYBER1024_AVX2_CRYPTO_PUBLICKEYBYTES];
482 let mut sk = vec![0u8; PQCLEAN_KYBER1024_AVX2_CRYPTO_SECRETKEYBYTES];
483 let mut ct = vec![0u8; PQCLEAN_KYBER1024_AVX2_CRYPTO_CIPHERTEXTBYTES];
484 let mut ss1 = vec![0u8; PQCLEAN_KYBER1024_AVX2_CRYPTO_BYTES];
485 let mut ss2 = vec![0u8; PQCLEAN_KYBER1024_AVX2_CRYPTO_BYTES];
486
487 assert_eq!(
488 0,
489 PQCLEAN_KYBER1024_AVX2_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
490 );
491 assert_eq!(
492 0,
493 PQCLEAN_KYBER1024_AVX2_crypto_kem_enc(
494 ct.as_mut_ptr(),
495 ss1.as_mut_ptr(),
496 pk.as_ptr()
497 )
498 );
499 assert_eq!(
500 0,
501 PQCLEAN_KYBER1024_AVX2_crypto_kem_dec(ss2.as_mut_ptr(), ct.as_ptr(), sk.as_ptr())
502 );
503 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
504 }
505 }
506}
507
508#[cfg(all(test, enable_aarch64_neon, feature = "neon"))]
509mod test_kyber1024_aarch64 {
510 use super::*;
511 use alloc::vec;
512
513 #[test]
514 fn test_ffi() {
515 unsafe {
516 let mut pk = vec![0u8; PQCLEAN_KYBER1024_AARCH64_CRYPTO_PUBLICKEYBYTES];
517 let mut sk = vec![0u8; PQCLEAN_KYBER1024_AARCH64_CRYPTO_SECRETKEYBYTES];
518 let mut ct = vec![0u8; PQCLEAN_KYBER1024_AARCH64_CRYPTO_CIPHERTEXTBYTES];
519 let mut ss1 = vec![0u8; PQCLEAN_KYBER1024_AARCH64_CRYPTO_BYTES];
520 let mut ss2 = vec![0u8; PQCLEAN_KYBER1024_AARCH64_CRYPTO_BYTES];
521
522 assert_eq!(
523 0,
524 PQCLEAN_KYBER1024_AARCH64_crypto_kem_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
525 );
526 assert_eq!(
527 0,
528 PQCLEAN_KYBER1024_AARCH64_crypto_kem_enc(
529 ct.as_mut_ptr(),
530 ss1.as_mut_ptr(),
531 pk.as_ptr()
532 )
533 );
534 assert_eq!(
535 0,
536 PQCLEAN_KYBER1024_AARCH64_crypto_kem_dec(
537 ss2.as_mut_ptr(),
538 ct.as_ptr(),
539 sk.as_ptr()
540 )
541 );
542 assert_eq!(&ss1[..], &ss2[..], "Shared secrets should be equal");
543 }
544 }
545}