kris/pqcrypto
1
1
Fork 0
mirror of https://github.com/henrydcase/pqc.git synced 2024-11-22 23:48:58 +00:00
Code Issues 1 Releases Wiki Activity

prefix structs with pqc_

Browse Source
This commit is contained in:
Henry Case 2021-05-10 16:01:48 +01:00
parent 895d9c0abd
commit 4e10c0925f
4 changed files with 146 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
public/pqc/pqc.h
View File

@ -75,7 +75,7 @@ enum { PQC_SUPPORTED_KEMS(DEFNUM) PQC_ALG_KEM_MAX };
#undef DEFNUM #undef DEFNUM
// Parameters of the scheme // Parameters of the scheme
typedef struct params_t { typedef struct pqc_ctx_t {
const uint8_t alg_id; const uint8_t alg_id;
const char* alg_name; const char* alg_name;
const uint32_t prv_key_bsz; const uint32_t prv_key_bsz;
@ -83,73 +83,59 @@ typedef struct params_t {
const bool is_kem; const bool is_kem;
int (*keygen)(uint8_t *sk, uint8_t *pk); int (*keygen)(uint8_t *sk, uint8_t *pk);
} params_t; } pqc_ctx_t;
typedef struct kem_params_t { typedef struct pqc_kem_ctx_t {
params_t p; pqc_ctx_t p;
const uint32_t ciphertext_bsz; const uint32_t ciphertext_bsz;
const uint32_t secret_bsz; const uint32_t secret_bsz;
int (*encapsulate)(uint8_t *ct, uint8_t *ss, const uint8_t *pk); int (*encapsulate)(uint8_t *ct, uint8_t *ss, const uint8_t *pk);
int (*decapsulate)(uint8_t *ss, const uint8_t *ct, const uint8_t *sk); int (*decapsulate)(uint8_t *ss, const uint8_t *ct, const uint8_t *sk);
} kem_params_t; } pqc_kem_ctx_t;
typedef struct sig_params_t { typedef struct pqc_sig_ctx_t {
params_t p; pqc_ctx_t p;
const uint32_t sign_bsz; const uint32_t sign_bsz;
int (*sign)(uint8_t *sig, uint64_t *siglen, const uint8_t *m, uint64_t mlen, const uint8_t *sk); int (*sign)(uint8_t *sig, uint64_t *siglen, const uint8_t *m, uint64_t mlen, const uint8_t *sk);
int (*verify)(const uint8_t *sig, uint64_t siglen, const uint8_t *m, uint64_t mlen, const uint8_t *pk); int (*verify)(const uint8_t *sig, uint64_t siglen, const uint8_t *m, uint64_t mlen, const uint8_t *pk);
} sig_params_t; } pqc_sig_ctx_t;
inline uint32_t ciphertext_bsz(const params_t *p) {
return ((kem_params_t *)p)->ciphertext_bsz;
}
inline uint32_t shared_secret_bsz(const params_t *p) {
return ((kem_params_t *)p)->secret_bsz;
}
inline uint32_t signature_bsz(const params_t *p) {
return ((sig_params_t *)p)->sign_bsz;
}
inline uint32_t public_key_bsz(const params_t *p) {
return p->pub_key_bsz;
}
inline uint32_t private_key_bsz(const params_t *p) {
return p->prv_key_bsz;
}
bool pqc_keygen( bool pqc_keygen(
const params_t *p, const pqc_ctx_t *p,
uint8_t *pk, uint8_t *sk); uint8_t *pk, uint8_t *sk);
bool pqc_kem_encapsulate( bool pqc_kem_encapsulate(
const params_t *p, const pqc_ctx_t *p,
uint8_t *ct, uint8_t *ss, uint8_t *ct, uint8_t *ss,
const uint8_t *pk); const uint8_t *pk);
bool pqc_kem_decapsulate( bool pqc_kem_decapsulate(
const params_t *p, const pqc_ctx_t *p,
uint8_t *ss, const uint8_t *ct, uint8_t *ss, const uint8_t *ct,
const uint8_t *sk); const uint8_t *sk);
bool pqc_sig_create( bool pqc_sig_create(
const params_t *p, const pqc_ctx_t *p,
uint8_t *sig, uint64_t *siglen, uint8_t *sig, uint64_t *siglen,
const uint8_t *m, uint64_t mlen, const uint8_t *m, uint64_t mlen,
const uint8_t *sk); const uint8_t *sk);
bool pqc_sig_verify( bool pqc_sig_verify(
const params_t *p, const pqc_ctx_t *p,
const uint8_t *sig, uint64_t siglen, const uint8_t *sig, uint64_t siglen,
const uint8_t *m, uint64_t mlen, const uint8_t *m, uint64_t mlen,
const uint8_t *pk); const uint8_t *pk);
const params_t *pqc_kem_alg_by_id(uint8_t id); const pqc_ctx_t *pqc_kem_alg_by_id(uint8_t id);
const params_t *pqc_sig_alg_by_id(uint8_t id); const pqc_ctx_t *pqc_sig_alg_by_id(uint8_t id);
uint32_t pqc_ciphertext_bsz(const pqc_ctx_t *p);
uint32_t pqc_shared_secret_bsz(const pqc_ctx_t *p);
uint32_t pqc_signature_bsz(const pqc_ctx_t *p);
uint32_t pqc_public_key_bsz(const pqc_ctx_t *p);
uint32_t pqc_private_key_bsz(const pqc_ctx_t *p);
#ifdef __cplusplus #ifdef __cplusplus
} }

50
src/capi/pqapi.c
View File

@ -68,12 +68,12 @@
}, },
// Registers supported KEMs // Registers supported KEMs
const kem_params_t kems[] = { const pqc_kem_ctx_t kems[] = {
PQC_SUPPORTED_KEMS(REG_KEM) PQC_SUPPORTED_KEMS(REG_KEM)
}; };
// Registers supported signatures // Registers supported signatures
const sig_params_t sigs[] = { const pqc_sig_ctx_t sigs[] = {
PQC_SUPPORTED_SIGS(REG_SIG) PQC_SUPPORTED_SIGS(REG_SIG)
}; };
@ -84,55 +84,75 @@ const X86Features * const get_cpu_caps(void) {
return &CPU_CAPS; return &CPU_CAPS;
} }
const params_t *pqc_kem_alg_by_id(uint8_t id) { const pqc_ctx_t *pqc_kem_alg_by_id(uint8_t id) {
int i; int i;
for(i=0; i<PQC_ALG_KEM_MAX; i++) { for(i=0; i<PQC_ALG_KEM_MAX; i++) {
if (kems[i].p.alg_id == id) { if (kems[i].p.alg_id == id) {
return (params_t*)&kems[i]; return (pqc_ctx_t*)&kems[i];
} }
} }
return 0; return 0;
} }
const params_t *pqc_sig_alg_by_id(uint8_t id) { const pqc_ctx_t *pqc_sig_alg_by_id(uint8_t id) {
int i; int i;
for(i=0; i<PQC_ALG_SIG_MAX; i++) { for(i=0; i<PQC_ALG_SIG_MAX; i++) {
if (sigs[i].p.alg_id == id) { if (sigs[i].p.alg_id == id) {
return (params_t*)&sigs[i]; return (pqc_ctx_t*)&sigs[i];
} }
} }
return 0; return 0;
} }
bool pqc_keygen(const params_t *p, bool pqc_keygen(const pqc_ctx_t *p,
uint8_t *pk, uint8_t *sk) { uint8_t *pk, uint8_t *sk) {
return !p->keygen(pk, sk); return !p->keygen(pk, sk);
} }
bool pqc_kem_encapsulate(const params_t *p, bool pqc_kem_encapsulate(const pqc_ctx_t *p,
uint8_t *ct, uint8_t *ss, uint8_t *ct, uint8_t *ss,
const uint8_t *pk) { const uint8_t *pk) {
return !((kem_params_t*)p)->encapsulate(ct, ss, pk); return !((pqc_kem_ctx_t*)p)->encapsulate(ct, ss, pk);
} }
bool pqc_kem_decapsulate(const params_t *p, bool pqc_kem_decapsulate(const pqc_ctx_t *p,
uint8_t *ss, const uint8_t *ct, uint8_t *ss, const uint8_t *ct,
const uint8_t *sk) { const uint8_t *sk) {
return !((kem_params_t*)p)->decapsulate(ss, ct, sk); return !((pqc_kem_ctx_t*)p)->decapsulate(ss, ct, sk);
} }
bool pqc_sig_create(const params_t *p, bool pqc_sig_create(const pqc_ctx_t *p,
uint8_t *sig, uint64_t *siglen, uint8_t *sig, uint64_t *siglen,
const uint8_t *m, uint64_t mlen, const uint8_t *m, uint64_t mlen,
const uint8_t *sk) { const uint8_t *sk) {
return !((sig_params_t *)p)->sign(sig, siglen, m, mlen, sk); return !((pqc_sig_ctx_t *)p)->sign(sig, siglen, m, mlen, sk);
} }
bool pqc_sig_verify(const params_t *p, bool pqc_sig_verify(const pqc_ctx_t *p,
const uint8_t *sig, uint64_t siglen, const uint8_t *sig, uint64_t siglen,
const uint8_t *m, uint64_t mlen, const uint8_t *m, uint64_t mlen,
const uint8_t *pk) { const uint8_t *pk) {
return !((sig_params_t *)p)->verify(sig, siglen, m, mlen, pk); return !((pqc_sig_ctx_t *)p)->verify(sig, siglen, m, mlen, pk);
}
uint32_t pqc_ciphertext_bsz(const pqc_ctx_t *p) {
return ((pqc_kem_ctx_t *)p)->ciphertext_bsz;
}
uint32_t pqc_shared_secret_bsz(const pqc_ctx_t *p) {
return ((pqc_kem_ctx_t *)p)->secret_bsz;
}
uint32_t pqc_signature_bsz(const pqc_ctx_t *p) {
return ((pqc_sig_ctx_t *)p)->sign_bsz;
}
uint32_t pqc_public_key_bsz(const pqc_ctx_t *p) {
return p->pub_key_bsz;
}
uint32_t pqc_private_key_bsz(const pqc_ctx_t *p) {
return p->prv_key_bsz;
} }
void static_initialization(void) __attribute__((constructor)); void static_initialization(void) __attribute__((constructor));

141
src/rustapi/pqc-sys/src/bindings.rs
View File

@ -261,7 +261,7 @@ pub const PQC_ALG_KEM_MAX: ::std::os::raw::c_uint = 20;
pub type _bindgen_ty_2 = ::std::os::raw::c_uint; pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
#[repr(C)] #[repr(C)]
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub struct params_t { pub struct pqc_ctx_t {
pub alg_id: u8, pub alg_id: u8,
pub alg_name: *const ::std::os::raw::c_char, pub alg_name: *const ::std::os::raw::c_char,
pub prv_key_bsz: u32, pub prv_key_bsz: u32,
@ -272,87 +272,87 @@ pub struct params_t {
>, >,
} }
#[test] #[test]
fn bindgen_test_layout_params_t() { fn bindgen_test_layout_pqc_ctx_t() {
assert_eq!( assert_eq!(
::std::mem::size_of::<params_t>(), ::std::mem::size_of::<pqc_ctx_t>(),
40usize, 40usize,
concat!("Size of: ", stringify!(params_t)) concat!("Size of: ", stringify!(pqc_ctx_t))
); );
assert_eq!( assert_eq!(
::std::mem::align_of::<params_t>(), ::std::mem::align_of::<pqc_ctx_t>(),
8usize, 8usize,
concat!("Alignment of ", stringify!(params_t)) concat!("Alignment of ", stringify!(pqc_ctx_t))
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<params_t>())).alg_id as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_ctx_t>())).alg_id as *const _ as usize },
0usize, 0usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(params_t), stringify!(pqc_ctx_t),
"::", "::",
stringify!(alg_id) stringify!(alg_id)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<params_t>())).alg_name as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_ctx_t>())).alg_name as *const _ as usize },
8usize, 8usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(params_t), stringify!(pqc_ctx_t),
"::", "::",
stringify!(alg_name) stringify!(alg_name)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<params_t>())).prv_key_bsz as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_ctx_t>())).prv_key_bsz as *const _ as usize },
16usize, 16usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(params_t), stringify!(pqc_ctx_t),
"::", "::",
stringify!(prv_key_bsz) stringify!(prv_key_bsz)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<params_t>())).pub_key_bsz as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_ctx_t>())).pub_key_bsz as *const _ as usize },
20usize, 20usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(params_t), stringify!(pqc_ctx_t),
"::", "::",
stringify!(pub_key_bsz) stringify!(pub_key_bsz)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<params_t>())).is_kem as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_ctx_t>())).is_kem as *const _ as usize },
24usize, 24usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(params_t), stringify!(pqc_ctx_t),
"::", "::",
stringify!(is_kem) stringify!(is_kem)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<params_t>())).keygen as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_ctx_t>())).keygen as *const _ as usize },
32usize, 32usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(params_t), stringify!(pqc_ctx_t),
"::", "::",
stringify!(keygen) stringify!(keygen)
) )
); );
} }
impl Default for params_t { impl Default for pqc_ctx_t {
fn default() -> Self { fn default() -> Self {
unsafe { ::std::mem::zeroed() } unsafe { ::std::mem::zeroed() }
} }
} }
#[repr(C)] #[repr(C)]
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub struct kem_params_t { pub struct pqc_kem_ctx_t {
pub p: params_t, pub p: pqc_ctx_t,
pub ciphertext_bsz: u32, pub ciphertext_bsz: u32,
pub secret_bsz: u32, pub secret_bsz: u32,
pub encapsulate: ::std::option::Option< pub encapsulate: ::std::option::Option<
@ -363,77 +363,77 @@ pub struct kem_params_t {
>, >,
} }
#[test] #[test]
fn bindgen_test_layout_kem_params_t() { fn bindgen_test_layout_pqc_kem_ctx_t() {
assert_eq!( assert_eq!(
::std::mem::size_of::<kem_params_t>(), ::std::mem::size_of::<pqc_kem_ctx_t>(),
64usize, 64usize,
concat!("Size of: ", stringify!(kem_params_t)) concat!("Size of: ", stringify!(pqc_kem_ctx_t))
); );
assert_eq!( assert_eq!(
::std::mem::align_of::<kem_params_t>(), ::std::mem::align_of::<pqc_kem_ctx_t>(),
8usize, 8usize,
concat!("Alignment of ", stringify!(kem_params_t)) concat!("Alignment of ", stringify!(pqc_kem_ctx_t))
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<kem_params_t>())).p as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_kem_ctx_t>())).p as *const _ as usize },
0usize, 0usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(kem_params_t), stringify!(pqc_kem_ctx_t),
"::", "::",
stringify!(p) stringify!(p)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<kem_params_t>())).ciphertext_bsz as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_kem_ctx_t>())).ciphertext_bsz as *const _ as usize },
40usize, 40usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(kem_params_t), stringify!(pqc_kem_ctx_t),
"::", "::",
stringify!(ciphertext_bsz) stringify!(ciphertext_bsz)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<kem_params_t>())).secret_bsz as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_kem_ctx_t>())).secret_bsz as *const _ as usize },
44usize, 44usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(kem_params_t), stringify!(pqc_kem_ctx_t),
"::", "::",
stringify!(secret_bsz) stringify!(secret_bsz)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<kem_params_t>())).encapsulate as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_kem_ctx_t>())).encapsulate as *const _ as usize },
48usize, 48usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(kem_params_t), stringify!(pqc_kem_ctx_t),
"::", "::",
stringify!(encapsulate) stringify!(encapsulate)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<kem_params_t>())).decapsulate as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_kem_ctx_t>())).decapsulate as *const _ as usize },
56usize, 56usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(kem_params_t), stringify!(pqc_kem_ctx_t),
"::", "::",
stringify!(decapsulate) stringify!(decapsulate)
) )
); );
} }
impl Default for kem_params_t { impl Default for pqc_kem_ctx_t {
fn default() -> Self { fn default() -> Self {
unsafe { ::std::mem::zeroed() } unsafe { ::std::mem::zeroed() }
} }
} }
#[repr(C)] #[repr(C)]
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub struct sig_params_t { pub struct pqc_sig_ctx_t {
pub p: params_t, pub p: pqc_ctx_t,
pub sign_bsz: u32, pub sign_bsz: u32,
pub sign: ::std::option::Option< pub sign: ::std::option::Option<
unsafe extern "C" fn( unsafe extern "C" fn(
@ -455,73 +455,77 @@ pub struct sig_params_t {
>, >,
} }
#[test] #[test]
fn bindgen_test_layout_sig_params_t() { fn bindgen_test_layout_pqc_sig_ctx_t() {
assert_eq!( assert_eq!(
::std::mem::size_of::<sig_params_t>(), ::std::mem::size_of::<pqc_sig_ctx_t>(),
64usize, 64usize,
concat!("Size of: ", stringify!(sig_params_t)) concat!("Size of: ", stringify!(pqc_sig_ctx_t))
); );
assert_eq!( assert_eq!(
::std::mem::align_of::<sig_params_t>(), ::std::mem::align_of::<pqc_sig_ctx_t>(),
8usize, 8usize,
concat!("Alignment of ", stringify!(sig_params_t)) concat!("Alignment of ", stringify!(pqc_sig_ctx_t))
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<sig_params_t>())).p as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_sig_ctx_t>())).p as *const _ as usize },
0usize, 0usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(sig_params_t), stringify!(pqc_sig_ctx_t),
"::", "::",
stringify!(p) stringify!(p)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<sig_params_t>())).sign_bsz as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_sig_ctx_t>())).sign_bsz as *const _ as usize },
40usize, 40usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(sig_params_t), stringify!(pqc_sig_ctx_t),
"::", "::",
stringify!(sign_bsz) stringify!(sign_bsz)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<sig_params_t>())).sign as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_sig_ctx_t>())).sign as *const _ as usize },
48usize, 48usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(sig_params_t), stringify!(pqc_sig_ctx_t),
"::", "::",
stringify!(sign) stringify!(sign)
) )
); );
assert_eq!( assert_eq!(
unsafe { &(*(::std::ptr::null::<sig_params_t>())).verify as *const _ as usize }, unsafe { &(*(::std::ptr::null::<pqc_sig_ctx_t>())).verify as *const _ as usize },
56usize, 56usize,
concat!( concat!(
"Offset of field: ", "Offset of field: ",
stringify!(sig_params_t), stringify!(pqc_sig_ctx_t),
"::", "::",
stringify!(verify) stringify!(verify)
) )
); );
} }
impl Default for sig_params_t { impl Default for pqc_sig_ctx_t {
fn default() -> Self { fn default() -> Self {
unsafe { ::std::mem::zeroed() } unsafe { ::std::mem::zeroed() }
} }
} }
extern "C" { extern "C" {
pub fn pqc_keygen(p: *const params_t, pk: *mut u8, sk: *mut u8) -> bool; pub fn pqc_keygen(p: *const pqc_ctx_t, pk: *mut u8, sk: *mut u8) -> bool;
} }
extern "C" { extern "C" {
pub fn pqc_kem_encapsulate(p: *const params_t, ct: *mut u8, ss: *mut u8, pk: *const u8) pub fn pqc_kem_encapsulate(
-> bool; p: *const pqc_ctx_t,
ct: *mut u8,
ss: *mut u8,
pk: *const u8,
) -> bool;
} }
extern "C" { extern "C" {
pub fn pqc_kem_decapsulate( pub fn pqc_kem_decapsulate(
p: *const params_t, p: *const pqc_ctx_t,
ss: *mut u8, ss: *mut u8,
ct: *const u8, ct: *const u8,
sk: *const u8, sk: *const u8,
@ -529,7 +533,7 @@ extern "C" {
} }
extern "C" { extern "C" {
pub fn pqc_sig_create( pub fn pqc_sig_create(
p: *const params_t, p: *const pqc_ctx_t,
sig: *mut u8, sig: *mut u8,
siglen: *mut u64, siglen: *mut u64,
m: *const u8, m: *const u8,
@ -539,7 +543,7 @@ extern "C" {
} }
extern "C" { extern "C" {
pub fn pqc_sig_verify( pub fn pqc_sig_verify(
p: *const params_t, p: *const pqc_ctx_t,
sig: *const u8, sig: *const u8,
siglen: u64, siglen: u64,
m: *const u8, m: *const u8,
@ -548,8 +552,23 @@ extern "C" {
) -> bool; ) -> bool;
} }
extern "C" { extern "C" {
pub fn pqc_kem_alg_by_id(id: u8) -> *const params_t; pub fn pqc_kem_alg_by_id(id: u8) -> *const pqc_ctx_t;
} }
extern "C" { extern "C" {
pub fn pqc_sig_alg_by_id(id: u8) -> *const params_t; pub fn pqc_sig_alg_by_id(id: u8) -> *const pqc_ctx_t;
}
extern "C" {
pub fn pqc_ciphertext_bsz(p: *const pqc_ctx_t) -> u32;
}
extern "C" {
pub fn pqc_shared_secret_bsz(p: *const pqc_ctx_t) -> u32;
}
extern "C" {
pub fn pqc_signature_bsz(p: *const pqc_ctx_t) -> u32;
}
extern "C" {
pub fn pqc_public_key_bsz(p: *const pqc_ctx_t) -> u32;
}
extern "C" {
pub fn pqc_private_key_bsz(p: *const pqc_ctx_t) -> u32;
} }

20
test/ut.cpp
View File

@ -6,13 +6,13 @@
TEST(Kyber,KEMOneOff) { TEST(Kyber,KEMOneOff) {
for (int i=0; i<PQC_ALG_KEM_MAX; i++) { for (int i=0; i<PQC_ALG_KEM_MAX; i++) {
const params_t *p = pqc_kem_alg_by_id(i); const pqc_ctx_t *p = pqc_kem_alg_by_id(i);
std::vector<uint8_t> ct(ciphertext_bsz(p)); std::vector<uint8_t> ct(pqc_ciphertext_bsz(p));
std::vector<uint8_t> ss1(shared_secret_bsz(p)); std::vector<uint8_t> ss1(pqc_shared_secret_bsz(p));
std::vector<uint8_t> ss2(shared_secret_bsz(p)); std::vector<uint8_t> ss2(pqc_shared_secret_bsz(p));
std::vector<uint8_t> sk(private_key_bsz(p)); std::vector<uint8_t> sk(pqc_private_key_bsz(p));
std::vector<uint8_t> pk(public_key_bsz(p)); std::vector<uint8_t> pk(pqc_public_key_bsz(p));
ASSERT_TRUE( ASSERT_TRUE(
pqc_keygen(p, pk.data(), sk.data())); pqc_keygen(p, pk.data(), sk.data()));
@ -28,12 +28,12 @@ TEST(Kyber,KEMOneOff) {
TEST(Kyber,SIGNOneOff) { TEST(Kyber,SIGNOneOff) {
for (int i=0; i<PQC_ALG_SIG_MAX; i++) { for (int i=0; i<PQC_ALG_SIG_MAX; i++) {
const params_t *p = pqc_sig_alg_by_id(i); const pqc_ctx_t *p = pqc_sig_alg_by_id(i);
uint8_t msg[1234]; uint8_t msg[1234];
std::vector<uint8_t> sig(signature_bsz(p)); std::vector<uint8_t> sig(pqc_signature_bsz(p));
std::vector<uint8_t> sk(private_key_bsz(p)); std::vector<uint8_t> sk(pqc_private_key_bsz(p));
std::vector<uint8_t> pk(public_key_bsz(p)); std::vector<uint8_t> pk(pqc_public_key_bsz(p));
ASSERT_TRUE( ASSERT_TRUE(
pqc_keygen(p, pk.data(), sk.data())); pqc_keygen(p, pk.data(), sk.data()));