use libc::c_int;
pub const PQCLEAN_MQDSS48_CLEAN_CRYPTO_SECRETKEYBYTES: usize = 16;
pub const PQCLEAN_MQDSS48_CLEAN_CRYPTO_PUBLICKEYBYTES: usize = 46;
pub const PQCLEAN_MQDSS48_CLEAN_CRYPTO_BYTES: usize = 28400;
pub const PQCLEAN_MQDSS64_CLEAN_CRYPTO_SECRETKEYBYTES: usize = 24;
pub const PQCLEAN_MQDSS64_CLEAN_CRYPTO_PUBLICKEYBYTES: usize = 64;
pub const PQCLEAN_MQDSS64_CLEAN_CRYPTO_BYTES: usize = 59928;
#[link(name = "mqdss-48_clean")]
extern "C" {
pub fn PQCLEAN_MQDSS48_CLEAN_crypto_sign_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
pub fn PQCLEAN_MQDSS48_CLEAN_crypto_sign(
sm: *mut u8,
smlen: *mut usize,
msg: *const u8,
len: usize,
sk: *const u8,
) -> c_int;
pub fn PQCLEAN_MQDSS48_CLEAN_crypto_sign_open(
m: *mut u8,
mlen: *mut usize,
sm: *const u8,
smlen: usize,
pk: *const u8,
) -> c_int;
pub fn PQCLEAN_MQDSS48_CLEAN_crypto_sign_signature(
sig: *mut u8,
siglen: *mut usize,
m: *const u8,
mlen: usize,
sk: *const u8,
) -> c_int;
pub fn PQCLEAN_MQDSS48_CLEAN_crypto_sign_verify(
sig: *const u8,
siglen: usize,
m: *const u8,
mlen: usize,
pk: *const u8,
) -> c_int;
}
#[link(name = "mqdss-64_clean")]
extern "C" {
pub fn PQCLEAN_MQDSS64_CLEAN_crypto_sign_keypair(pk: *mut u8, sk: *mut u8) -> c_int;
pub fn PQCLEAN_MQDSS64_CLEAN_crypto_sign(
sm: *mut u8,
smlen: *mut usize,
msg: *const u8,
len: usize,
sk: *const u8,
) -> c_int;
pub fn PQCLEAN_MQDSS64_CLEAN_crypto_sign_open(
m: *mut u8,
mlen: *mut usize,
sm: *const u8,
smlen: usize,
pk: *const u8,
) -> c_int;
pub fn PQCLEAN_MQDSS64_CLEAN_crypto_sign_signature(
sig: *mut u8,
siglen: *mut usize,
m: *const u8,
mlen: usize,
sk: *const u8,
) -> c_int;
pub fn PQCLEAN_MQDSS64_CLEAN_crypto_sign_verify(
sig: *const u8,
siglen: usize,
m: *const u8,
mlen: usize,
pk: *const u8,
) -> c_int;
}
#[cfg(test)]
mod test_mqdss48_clean {
use super::*;
use rand::prelude::*;
#[test]
fn test_ffi() {
unsafe {
let mut rng = rand::thread_rng();
let mut mlen: usize = rng.gen::<u16>() as usize;
let msg: Vec<u8> = (0..mlen).map(|_| rng.gen()).collect();
let mut pk = vec![0u8; PQCLEAN_MQDSS48_CLEAN_CRYPTO_PUBLICKEYBYTES];
let mut sk = vec![0u8; PQCLEAN_MQDSS48_CLEAN_CRYPTO_SECRETKEYBYTES];
let mut pk_alt = vec![0u8; PQCLEAN_MQDSS48_CLEAN_CRYPTO_PUBLICKEYBYTES];
let mut sk_alt = vec![0u8; PQCLEAN_MQDSS48_CLEAN_CRYPTO_SECRETKEYBYTES];
let mut detached_sig = vec![0u8; PQCLEAN_MQDSS48_CLEAN_CRYPTO_BYTES];
let mut sm = Vec::with_capacity(mlen + PQCLEAN_MQDSS48_CLEAN_CRYPTO_BYTES);
let mut smlen = 0;
assert_eq!(
0,
PQCLEAN_MQDSS48_CLEAN_crypto_sign_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
);
assert_eq!(
0,
PQCLEAN_MQDSS48_CLEAN_crypto_sign(
sm.as_mut_ptr(),
&mut smlen as *mut usize,
msg.as_ptr(),
mlen,
sk.as_ptr()
)
);
sm.set_len(smlen);
let mut unpacked_m = Vec::with_capacity(mlen + PQCLEAN_MQDSS48_CLEAN_CRYPTO_BYTES);
assert_eq!(
0,
PQCLEAN_MQDSS48_CLEAN_crypto_sign_open(
unpacked_m.as_mut_ptr(),
&mut mlen as *mut usize,
sm.as_ptr(),
sm.len(),
pk.as_ptr()
)
);
unpacked_m.set_len(mlen);
assert_eq!(unpacked_m, msg);
assert_eq!(
0,
PQCLEAN_MQDSS48_CLEAN_crypto_sign_keypair(pk_alt.as_mut_ptr(), sk_alt.as_mut_ptr())
);
assert!(
PQCLEAN_MQDSS48_CLEAN_crypto_sign_open(
unpacked_m.as_mut_ptr(),
&mut mlen as *mut usize,
sm.as_ptr(),
sm.len(),
pk_alt.as_ptr()
) < 0
);
assert_eq!(
0,
PQCLEAN_MQDSS48_CLEAN_crypto_sign_signature(
detached_sig.as_mut_ptr(),
&mut smlen as *mut usize,
msg.as_ptr(),
msg.len(),
sk.as_ptr()
)
);
assert!(
smlen <= PQCLEAN_MQDSS48_CLEAN_CRYPTO_BYTES,
"Signed message length should be ≤ CRYPTO_BYTES"
);
assert_eq!(
0,
PQCLEAN_MQDSS48_CLEAN_crypto_sign_verify(
detached_sig.as_ptr(),
smlen,
msg.as_ptr(),
msg.len(),
pk.as_ptr()
)
);
assert!(
PQCLEAN_MQDSS48_CLEAN_crypto_sign_verify(
detached_sig.as_ptr(),
smlen,
msg.as_ptr(),
msg.len(),
pk_alt.as_ptr()
) < 0
);
assert!(
PQCLEAN_MQDSS48_CLEAN_crypto_sign_verify(
detached_sig.as_ptr(),
smlen,
msg.as_ptr(),
msg.len() - 1,
pk.as_ptr()
) < 0
);
}
}
}
#[cfg(test)]
mod test_mqdss64_clean {
use super::*;
use rand::prelude::*;
#[test]
fn test_ffi() {
unsafe {
let mut rng = rand::thread_rng();
let mut mlen: usize = rng.gen::<u16>() as usize;
let msg: Vec<u8> = (0..mlen).map(|_| rng.gen()).collect();
let mut pk = vec![0u8; PQCLEAN_MQDSS64_CLEAN_CRYPTO_PUBLICKEYBYTES];
let mut sk = vec![0u8; PQCLEAN_MQDSS64_CLEAN_CRYPTO_SECRETKEYBYTES];
let mut pk_alt = vec![0u8; PQCLEAN_MQDSS64_CLEAN_CRYPTO_PUBLICKEYBYTES];
let mut sk_alt = vec![0u8; PQCLEAN_MQDSS64_CLEAN_CRYPTO_SECRETKEYBYTES];
let mut detached_sig = vec![0u8; PQCLEAN_MQDSS64_CLEAN_CRYPTO_BYTES];
let mut sm = Vec::with_capacity(mlen + PQCLEAN_MQDSS64_CLEAN_CRYPTO_BYTES);
let mut smlen = 0;
assert_eq!(
0,
PQCLEAN_MQDSS64_CLEAN_crypto_sign_keypair(pk.as_mut_ptr(), sk.as_mut_ptr())
);
assert_eq!(
0,
PQCLEAN_MQDSS64_CLEAN_crypto_sign(
sm.as_mut_ptr(),
&mut smlen as *mut usize,
msg.as_ptr(),
mlen,
sk.as_ptr()
)
);
sm.set_len(smlen);
let mut unpacked_m = Vec::with_capacity(mlen + PQCLEAN_MQDSS64_CLEAN_CRYPTO_BYTES);
assert_eq!(
0,
PQCLEAN_MQDSS64_CLEAN_crypto_sign_open(
unpacked_m.as_mut_ptr(),
&mut mlen as *mut usize,
sm.as_ptr(),
sm.len(),
pk.as_ptr()
)
);
unpacked_m.set_len(mlen);
assert_eq!(unpacked_m, msg);
assert_eq!(
0,
PQCLEAN_MQDSS64_CLEAN_crypto_sign_keypair(pk_alt.as_mut_ptr(), sk_alt.as_mut_ptr())
);
assert!(
PQCLEAN_MQDSS64_CLEAN_crypto_sign_open(
unpacked_m.as_mut_ptr(),
&mut mlen as *mut usize,
sm.as_ptr(),
sm.len(),
pk_alt.as_ptr()
) < 0
);
assert_eq!(
0,
PQCLEAN_MQDSS64_CLEAN_crypto_sign_signature(
detached_sig.as_mut_ptr(),
&mut smlen as *mut usize,
msg.as_ptr(),
msg.len(),
sk.as_ptr()
)
);
assert!(
smlen <= PQCLEAN_MQDSS64_CLEAN_CRYPTO_BYTES,
"Signed message length should be ≤ CRYPTO_BYTES"
);
assert_eq!(
0,
PQCLEAN_MQDSS64_CLEAN_crypto_sign_verify(
detached_sig.as_ptr(),
smlen,
msg.as_ptr(),
msg.len(),
pk.as_ptr()
)
);
assert!(
PQCLEAN_MQDSS64_CLEAN_crypto_sign_verify(
detached_sig.as_ptr(),
smlen,
msg.as_ptr(),
msg.len(),
pk_alt.as_ptr()
) < 0
);
assert!(
PQCLEAN_MQDSS64_CLEAN_crypto_sign_verify(
detached_sig.as_ptr(),
smlen,
msg.as_ptr(),
msg.len() - 1,
pk.as_ptr()
) < 0
);
}
}
}