use bls::*;
use errors::ErrorCode;
use errors::ToErrorCode;
use std::os::raw::c_void;
use std::slice;
#[no_mangle]
pub extern fn indy_crypto_bls_generator_new(gen_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_generator_new: >>> gen_p: {:?}", gen_p);
check_useful_c_ptr!(gen_p, ErrorCode::CommonInvalidParam1);
let res = match Generator::new() {
Ok(gen) => {
trace!("indy_crypto_bls_generator_new: gen: {:?}", gen);
unsafe {
*gen_p = Box::into_raw(Box::new(gen)) as *const c_void;
trace!("indy_crypto_bls_generator_new: *gen_p: {:?}", *gen_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_generator_new: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_generator_from_bytes(bytes: *const u8, bytes_len: usize,
gen_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_generator_from_bytes: >>> bytes: {:?}, bytes_len: {:?}, gen_p: {:?}", bytes, bytes_len, gen_p);
check_useful_c_byte_array!(bytes, bytes_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(gen_p, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_generator_from_bytes: bytes: {:?}", bytes);
let res = match Generator::from_bytes(bytes) {
Ok(gen) => {
trace!("indy_crypto_bls_generator_from_bytes: gen: {:?}", gen);
unsafe {
*gen_p = Box::into_raw(Box::new(gen)) as *const c_void;
trace!("indy_crypto_bls_generator_from_bytes: *gen_p: {:?}", *gen_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_generator_from_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_generator_as_bytes(gen: *const c_void,
bytes_p: *mut *const u8, bytes_len_p: *mut usize) -> ErrorCode {
trace!("indy_crypto_bls_generator_as_bytes: >>> gen: {:?}, bytes_p: {:?}, bytes_len_p: {:?}", gen, bytes_p, bytes_len_p);
check_useful_c_reference!(gen, Generator, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(bytes_p, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(bytes_len_p, ErrorCode::CommonInvalidParam3);
trace!("indy_crypto_bls_generator_as_bytes: >>> gen: {:?}", gen);
unsafe {
*bytes_p = gen.as_bytes().as_ptr();
*bytes_len_p = gen.as_bytes().len();
};
let res = ErrorCode::Success;
trace!("indy_crypto_bls_generator_as_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_generator_free(gen: *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_generator_free: >>> gen: {:?}", gen);
check_useful_c_ptr!(gen, ErrorCode::CommonInvalidParam1);
unsafe { Box::from_raw(gen as *mut Generator); }
let res = ErrorCode::Success;
trace!("indy_crypto_bls_generator_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_sign_key_new(seed: *const u8,
seed_len: usize,
sign_key_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_sign_key_new: >>> seed: {:?}, seed_len: {:?}, sign_key_p: {:?}", seed, seed_len, sign_key_p);
check_useful_opt_c_byte_array!(seed, seed_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_bls_sign_key_new: seed: {:?}", secret!(&seed));
let res = match SignKey::new(seed) {
Ok(sign_key) => {
trace!("indy_crypto_bls_generator_new: gen: {:?}", secret!(&sign_key));
unsafe {
*sign_key_p = Box::into_raw(Box::new(sign_key)) as *const c_void;
trace!("indy_crypto_bls_sign_key_new: *sign_key_p: {:?}", *sign_key_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_sign_key_new: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_sign_key_from_bytes(bytes: *const u8, bytes_len: usize,
sign_key_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_sign_key_from_bytes: >>> bytes: {:?}, bytes_len: {:?}, gen_p: {:?}", bytes, bytes_len, sign_key_p);
check_useful_c_byte_array!(bytes, bytes_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(sign_key_p, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_sign_key_from_bytes: bytes: {:?}", secret!(&bytes));
let res = match SignKey::from_bytes(bytes) {
Ok(sign_key) => {
trace!("indy_crypto_bls_sign_key_from_bytes: sign_key: {:?}", secret!(&sign_key));
unsafe {
*sign_key_p = Box::into_raw(Box::new(sign_key)) as *const c_void;
trace!("indy_crypto_bls_sign_key_from_bytes: *sign_key_p: {:?}", *sign_key_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_sign_key_from_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_sign_key_as_bytes(sign_key: *const c_void,
bytes_p: *mut *const u8, bytes_len_p: *mut usize) -> ErrorCode {
trace!("indy_crypto_bls_sign_key_as_bytes: >>> sign_key: {:?}, bytes_p: {:?}, bytes_len_p: {:?}", sign_key, bytes_p, bytes_len_p);
check_useful_c_reference!(sign_key, SignKey, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(bytes_p, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(bytes_len_p, ErrorCode::CommonInvalidParam3);
trace!("indy_crypto_bls_sign_key_as_bytes: sign_key: {:?}", secret!(sign_key));
unsafe {
*bytes_p = sign_key.as_bytes().as_ptr();
*bytes_len_p = sign_key.as_bytes().len();
};
let res = ErrorCode::Success;
trace!("indy_crypto_bls_sign_key_as_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_sign_key_free(sign_key: *const c_void) -> ErrorCode {
check_useful_c_ptr!(sign_key, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_sign_key_free: >>> sign_key: {:?}", secret!(sign_key));
unsafe { Box::from_raw(sign_key as *mut SignKey); }
let res = ErrorCode::Success;
trace!("indy_crypto_bls_sign_key_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_ver_key_new(gen: *const c_void,
sign_key: *const c_void,
ver_key_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_ver_key_new: >>> gen: {:?}, sign_key: {:?}, ver_key_p: {:?}", gen, sign_key, ver_key_p);
check_useful_c_reference!(gen, Generator, ErrorCode::CommonInvalidParam1);
check_useful_c_reference!(sign_key, SignKey, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_bls_ver_key_new: gen: {:?}, sign_key: {:?}", gen, secret!(sign_key));
let res = match VerKey::new(gen, sign_key) {
Ok(ver_key) => {
trace!("indy_crypto_bls_ver_key_new: ver_key: {:?}", ver_key);
unsafe {
*ver_key_p = Box::into_raw(Box::new(ver_key)) as *const c_void;
trace!("indy_crypto_bls_ver_key_new: *ver_key_p: {:?}", *ver_key_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_sign_key_new: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_ver_key_from_bytes(bytes: *const u8, bytes_len: usize,
ver_key_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_ver_key_from_bytes: >>> bytes: {:?}, bytes_len: {:?}, gen_p: {:?}", bytes, bytes_len, ver_key_p);
check_useful_c_byte_array!(bytes, bytes_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(ver_key_p, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_ver_key_from_bytes: bytes: {:?}", bytes);
let res = match VerKey::from_bytes(bytes) {
Ok(ver_key) => {
trace!("indy_crypto_bls_ver_key_from_bytes: sign_key: {:?}", ver_key);
unsafe {
*ver_key_p = Box::into_raw(Box::new(ver_key)) as *const c_void;
trace!("indy_crypto_bls_ver_key_from_bytes: *ver_key_p: {:?}", *ver_key_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_ver_key_from_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_ver_key_as_bytes(ver_key: *const c_void,
bytes_p: *mut *const u8, bytes_len_p: *mut usize) -> ErrorCode {
trace!("indy_crypto_bls_sign_key_as_bytes: >>> ver_key: {:?}, bytes_p: {:?}, bytes_len_p: {:?}", ver_key, bytes_p, bytes_len_p);
check_useful_c_reference!(ver_key, VerKey, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(bytes_p, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(bytes_len_p, ErrorCode::CommonInvalidParam3);
trace!("indy_crypto_bls_ver_key_as_bytes: ver_key: {:?}", ver_key);
unsafe {
*bytes_p = ver_key.as_bytes().as_ptr();
*bytes_len_p = ver_key.as_bytes().len();
};
let res = ErrorCode::Success;
trace!("indy_crypto_bls_ver_key_as_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_ver_key_free(ver_key: *const c_void) -> ErrorCode {
check_useful_c_ptr!(ver_key, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_ver_key_free: >>> ver_key: {:?}", ver_key);
unsafe { Box::from_raw(ver_key as *mut VerKey); }
let res = ErrorCode::Success;
trace!("indy_crypto_bls_ver_key_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_pop_new(ver_key: *const c_void,
sign_key: *const c_void,
pop_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_pop_new: >>> ver_key: {:?}, sign_key: {:?}, pop_p: {:?}", ver_key, sign_key, pop_p);
check_useful_c_reference!(ver_key, VerKey, ErrorCode::CommonInvalidParam1);
check_useful_c_reference!(sign_key, SignKey, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_bls_pop_new: ver_key: {:?}, sign_key: {:?}", ver_key, sign_key);
let res = match ProofOfPossession::new(ver_key, sign_key) {
Ok(pop) => {
trace!("indy_crypto_bls_pop_new: pop: {:?}", pop);
unsafe {
*pop_p = Box::into_raw(Box::new(pop)) as *const c_void;
trace!("indy_crypto_bls_pop_new: *pop_p: {:?}", *pop_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_pop_new: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_pop_from_bytes(bytes: *const u8, bytes_len: usize,
pop_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_pop_from_bytes: >>> bytes: {:?}, bytes_len: {:?}, gen_p: {:?}", bytes, bytes_len, pop_p);
check_useful_c_byte_array!(bytes, bytes_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(pop_p, ErrorCode::CommonInvalidParam3);
trace!("indy_crypto_bls_pop_from_bytes: bytes: {:?}", bytes);
let res = match ProofOfPossession::from_bytes(bytes) {
Ok(pop) => {
trace!("indy_crypto_bls_pop_from_bytes: pop: {:?}", pop);
unsafe {
*pop_p = Box::into_raw(Box::new(pop)) as *const c_void;
trace!("indy_crypto_bls_pop_from_bytes: *pop_p: {:?}", *pop_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_pop_from_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_pop_as_bytes(pop: *const c_void,
bytes_p: *mut *const u8, bytes_len_p: *mut usize) -> ErrorCode {
trace!("indy_crypto_bls_pop_as_bytes: >>> pop: {:?}, bytes_p: {:?}, bytes_len_p: {:?}", pop, bytes_p, bytes_len_p);
check_useful_c_reference!(pop, ProofOfPossession, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(bytes_p, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(bytes_len_p, ErrorCode::CommonInvalidParam3);
trace!("indy_crypto_bls_pop_as_bytes: pop: {:?}", pop);
unsafe {
*bytes_p = pop.as_bytes().as_ptr();
*bytes_len_p = pop.as_bytes().len();
};
let res = ErrorCode::Success;
trace!("indy_crypto_bls_pop_as_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_pop_free(pop: *const c_void) -> ErrorCode {
check_useful_c_ptr!(pop, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_pop_free: >>> pop: {:?}", pop);
unsafe { Box::from_raw(pop as *mut ProofOfPossession); }
let res = ErrorCode::Success;
trace!("indy_crypto_bls_pop_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_signature_from_bytes(bytes: *const u8, bytes_len: usize,
signature_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_signature_from_bytes: >>> bytes: {:?}, bytes_len: {:?}, signature_p: {:?}", bytes, bytes_len, signature_p);
check_useful_c_byte_array!(bytes, bytes_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(signature_p, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_signature_from_bytes: bytes: {:?}", bytes);
let res = match Signature::from_bytes(bytes) {
Ok(signature) => {
trace!("indy_crypto_bls_signature_from_bytes: signature: {:?}", signature);
unsafe {
*signature_p = Box::into_raw(Box::new(signature)) as *const c_void;
trace!("indy_crypto_bls_signature_from_bytes: *signature_p: {:?}", *signature_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_signature_from_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_signature_as_bytes(signature: *const c_void,
bytes_p: *mut *const u8, bytes_len_p: *mut usize) -> ErrorCode {
trace!("indy_crypto_bls_signature_as_bytes: >>> signature: {:?}, bytes_p: {:?}, bytes_len_p: {:?}", signature, bytes_p, bytes_len_p);
check_useful_c_reference!(signature, Signature, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(bytes_p, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(bytes_len_p, ErrorCode::CommonInvalidParam3);
trace!("indy_crypto_bls_signature_as_bytes: signature: {:?}", signature);
unsafe {
*bytes_p = signature.as_bytes().as_ptr();
*bytes_len_p = signature.as_bytes().len();
};
let res = ErrorCode::Success;
trace!("indy_crypto_bls_signature_as_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_signature_free(signature: *const c_void) -> ErrorCode {
check_useful_c_ptr!(signature, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_signature_free: >>> signature: {:?}", signature);
unsafe { Box::from_raw(signature as *mut Signature); }
let res = ErrorCode::Success;
trace!("indy_crypto_bls_signature_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_multi_signature_new(signatures: *const *const c_void,
signatures_len: usize,
multi_sig_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_multi_signature_new: >>> signatures: {:?}, signatures_len: {:?}, multi_sig_p: {:?}", signatures, signatures_len, multi_sig_p);
check_useful_c_reference_array!(signatures, signatures_len, Signature, ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(multi_sig_p, ErrorCode::CommonInvalidParam3);
trace!("indy_crypto_bls_multi_signature_new: signatures: {:?}", signatures);
let res = match MultiSignature::new(&signatures) {
Ok(multi_sig) => {
trace!("indy_crypto_bls_multi_signature_new: multi_sig: {:?}", multi_sig);
unsafe {
*multi_sig_p = Box::into_raw(Box::new(multi_sig)) as *const c_void;
trace!("indy_crypto_bls_multi_signature_new: *multi_sig_p: {:?}", *multi_sig_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_multi_signature_new: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_multi_signature_from_bytes(bytes: *const u8, bytes_len: usize,
multi_sig_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_multi_signature_from_bytes: >>> bytes: {:?}, bytes_len: {:?}, multi_sig_p: {:?}", bytes, bytes_len, multi_sig_p);
check_useful_c_byte_array!(bytes, bytes_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(multi_sig_p, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_multi_signature_from_bytes: bytes: {:?}", bytes);
let res = match MultiSignature::from_bytes(bytes) {
Ok(multi_sig) => {
trace!("indy_crypto_bls_multi_signature_from_bytes: multi_sig: {:?}", multi_sig);
unsafe {
*multi_sig_p = Box::into_raw(Box::new(multi_sig)) as *const c_void;
trace!("indy_crypto_bls_multi_signature_from_bytes: *multi_sig_p: {:?}", *multi_sig_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_multi_signature_from_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_multi_signature_as_bytes(multi_sig: *const c_void,
bytes_p: *mut *const u8, bytes_len_p: *mut usize) -> ErrorCode {
trace!("indy_crypto_bls_multi_signature_as_bytes: >>> multi_sig: {:?}, bytes_p: {:?}, bytes_len_p: {:?}", multi_sig, bytes_p, bytes_len_p);
check_useful_c_ptr!(multi_sig, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(bytes_p, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(bytes_len_p, ErrorCode::CommonInvalidParam3);
let multi_sig = unsafe { &*(multi_sig as *const MultiSignature) };
trace!("indy_crypto_bls_multi_signature_as_bytes: multi_sig: {:?}", multi_sig);
unsafe {
*bytes_p = multi_sig.as_bytes().as_ptr();
*bytes_len_p = multi_sig.as_bytes().len();
};
let res = ErrorCode::Success;
trace!("indy_crypto_bls_multi_signature_as_bytes: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_multi_signature_free(multi_sig: *const c_void) -> ErrorCode {
check_useful_c_ptr!(multi_sig, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_bls_multi_signature_free: >>> multi_sig: {:?}", multi_sig);
unsafe { Box::from_raw(multi_sig as *mut MultiSignature); }
let res = ErrorCode::Success;
trace!("indy_crypto_bls_multi_signature_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_sign(message: *const u8,
message_len: usize,
sign_key: *const c_void,
signature_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_bls_sign: >>> message: {:?}, message_len: {:?}, sign_key: {:?}, signature_p: {:?}", message, message_len, sign_key, signature_p);
check_useful_c_byte_array!(message, message_len,
ErrorCode::CommonInvalidParam1, ErrorCode::CommonInvalidParam2);
check_useful_c_reference!(sign_key, SignKey, ErrorCode::CommonInvalidParam3);
check_useful_c_ptr!(signature_p, ErrorCode::CommonInvalidParam5);
trace!("indy_crypto_bls_sign: message: {:?}, sign_key: {:?}", message, secret!(sign_key));
let res = match Bls::sign(message, sign_key) {
Ok(signature) => {
unsafe {
trace!("indy_crypto_bls_sign: signature: {:?}", signature);
*signature_p = Box::into_raw(Box::new(signature)) as *const c_void;
trace!("indy_crypto_bls_sign: *signature_p: {:?}", *signature_p);
}
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_sign: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bsl_verify(signature: *const c_void,
message: *const u8,
message_len: usize,
ver_key: *const c_void,
gen: *const c_void,
valid_p: *mut bool) -> ErrorCode {
trace!("indy_crypto_bsl_verify: >>> signature: {:?}, message: {:?}, message_len: {:?}, ver_key: {:?}, gen: {:?}, valid_p: {:?}", signature, message, message_len, ver_key, gen, valid_p);
check_useful_c_reference!(signature, Signature, ErrorCode::CommonInvalidParam1);
check_useful_c_byte_array!(message, message_len,
ErrorCode::CommonInvalidParam2, ErrorCode::CommonInvalidParam3);
check_useful_c_reference!(ver_key, VerKey, ErrorCode::CommonInvalidParam4);
check_useful_c_reference!(gen, Generator, ErrorCode::CommonInvalidParam5);
check_useful_c_ptr!(valid_p, ErrorCode::CommonInvalidParam6);
trace!("indy_crypto_bsl_verify: signature: {:?}, message: {:?}, ver_key: {:?}, gen: {:?}", signature, message, ver_key, gen);
let res = match Bls::verify(signature, message, ver_key, gen) {
Ok(valid) => {
trace!("indy_crypto_bsl_verify: valid: {:?}", valid);
unsafe { *valid_p = valid; }
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bsl_verify: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bls_verify_multi_sig(multi_sig: *const c_void,
message: *const u8,
message_len: usize,
ver_keys: *const *const c_void,
ver_keys_len: usize,
gen: *const c_void,
valid_p: *mut bool) -> ErrorCode {
trace!("indy_crypto_bls_verify_multi_sig: >>> multi_sig: {:?}, message: {:?}, message_len: {:?}, ver_keys: {:?}, ver_keys_len: {:?}, gen: {:?}, valid_p: {:?}", multi_sig, message, message_len, ver_keys, ver_keys_len, gen, valid_p);
check_useful_c_reference!(multi_sig, MultiSignature, ErrorCode::CommonInvalidParam1);
check_useful_c_byte_array!(message, message_len, ErrorCode::CommonInvalidParam2, ErrorCode::CommonInvalidParam3);
check_useful_c_reference_array!(ver_keys, ver_keys_len, VerKey, ErrorCode::CommonInvalidParam4, ErrorCode::CommonInvalidParam5);
check_useful_c_reference!(gen, Generator, ErrorCode::CommonInvalidParam6);
check_useful_c_ptr!(valid_p, ErrorCode::CommonInvalidParam7);
trace!("indy_crypto_bls_verify_multi_sig: multi_sig: {:?}, message: {:?}, ver_keys: {:?}, gen: {:?}", multi_sig, message, ver_keys, gen);
let res = match Bls::verify_multi_sig(multi_sig, message, &ver_keys, gen) {
Ok(valid) => {
trace!("indy_crypto_bls_verify_multi_sig: valid: {:?}", valid);
unsafe { *valid_p = valid; }
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bls_verify_multi_sig: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_bsl_verify_pop(pop: *const c_void,
ver_key: *const c_void,
gen: *const c_void,
valid_p: *mut bool) -> ErrorCode {
trace!("indy_crypto_bsl_verify_pop: >>> pop: {:?}, ver_key: {:?}, gen: {:?}, valid_p: {:?}", pop, ver_key, gen, valid_p);
check_useful_c_reference!(pop, ProofOfPossession, ErrorCode::CommonInvalidParam1);
check_useful_c_reference!(ver_key, VerKey, ErrorCode::CommonInvalidParam2);
check_useful_c_reference!(gen, Generator, ErrorCode::CommonInvalidParam3);
check_useful_c_ptr!(valid_p, ErrorCode::CommonInvalidParam4);
trace!("indy_crypto_bsl_verify_pop: pop: {:?}, ver_key: {:?}, gen: {:?}", pop, ver_key, gen);
let res = match Bls::verify_proof_of_posession(pop, ver_key, gen) {
Ok(valid) => {
trace!("indy_crypto_bsl_verify_pop: valid: {:?}", valid);
unsafe { *valid_p = valid; }
ErrorCode::Success
}
Err(err) => err.to_error_code()
};
trace!("indy_crypto_bsl_verify_pop: <<< res: {:?}", res);
res
}
#[cfg(test)]
mod tests {
use super::*;
use std::ptr;
#[test]
fn indy_crypto_bls_generator_new_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
assert!(!gen.is_null());
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_generator_as_bytes_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_generator_as_bytes(gen, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!gen.is_null());
assert!(bytes_len > 0);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_generator_from_bytes_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_generator_as_bytes(gen, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
let mut gen2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_from_bytes(bytes, bytes_len, &mut gen2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_generator_free(gen2);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_generator_free_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
assert!(!gen.is_null());
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_sign_key_new_works() {
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
assert!(!sign_key.is_null());
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_sign_key_new_works_for_seed() {
let mut sign_key: *const c_void = ptr::null();
let seed_v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 2, 3, 4, 5, 6, 7, 8, 9, 10,
21, 2, 3, 4, 5, 6, 7, 8, 9, 10, 31, 32];
let seed = seed_v.as_ptr();
let seed_len = seed_v.len();
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
assert!(!sign_key.is_null());
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_sign_key_as_bytes_works() {
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_as_bytes(sign_key, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_sign_key_from_bytes_works() {
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_as_bytes(sign_key, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign_key_from_bytes(bytes, bytes_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_sign_key_free_works() {
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_ver_key_new_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
assert!(!ver_key.is_null());
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_ver_key_as_bytes_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_ver_key_as_bytes(ver_key, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_ver_key_from_bytes_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_ver_key_as_bytes(ver_key, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let mut ver_key2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_from_bytes(bytes, bytes_len, &mut ver_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key2);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_ver_key_free_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_signature_as_bytes_works() {
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key, &mut signature);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_signature_as_bytes(signature, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_signature_from_bytes_works() {
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key, &mut signature);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_signature_as_bytes(signature, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let mut signature2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_signature_from_bytes(bytes, bytes_len, &mut signature2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature2);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_signature_free_works() {
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key, &mut signature);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_multi_signature_new_works() {
let mut sign_key1: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key1, &mut signature1);
assert_eq!(err_code, ErrorCode::Success);
let mut signature2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key2, &mut signature2);
assert_eq!(err_code, ErrorCode::Success);
let signatures = [signature1, signature2];
let mut multi_sig: *const c_void = ptr::null();
let err_code = indy_crypto_bls_multi_signature_new(signatures.as_ptr(), signatures.len(), &mut multi_sig);
assert_eq!(err_code, ErrorCode::Success);
assert!(!multi_sig.is_null());
let err_code = indy_crypto_bls_sign_key_free(sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_multi_signature_free(multi_sig);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_multi_signature_as_bytes_works() {
let mut sign_key1: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key1, &mut signature1);
assert_eq!(err_code, ErrorCode::Success);
let mut signature2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key2, &mut signature2);
assert_eq!(err_code, ErrorCode::Success);
let signatures = [signature1, signature2];
let mut multi_sig: *const c_void = ptr::null();
let err_code = indy_crypto_bls_multi_signature_new(signatures.as_ptr(), signatures.len(), &mut multi_sig);
assert_eq!(err_code, ErrorCode::Success);
assert!(!multi_sig.is_null());
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_multi_signature_as_bytes(multi_sig, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let err_code = indy_crypto_bls_sign_key_free(sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_multi_signature_free(multi_sig);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_multi_signature_from_bytes_works() {
let mut sign_key1: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key1, &mut signature1);
assert_eq!(err_code, ErrorCode::Success);
let mut signature2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key2, &mut signature2);
assert_eq!(err_code, ErrorCode::Success);
let signatures = [signature1, signature2];
let mut multi_sig: *const c_void = ptr::null();
let err_code = indy_crypto_bls_multi_signature_new(signatures.as_ptr(), signatures.len(), &mut multi_sig);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_multi_signature_as_bytes(multi_sig, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let mut multi_sig2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_multi_signature_from_bytes(bytes, bytes_len, &mut multi_sig2);
assert_eq!(err_code, ErrorCode::Success);
assert!(!multi_sig2.is_null());
let err_code = indy_crypto_bls_sign_key_free(sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_multi_signature_free(multi_sig);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_multi_signature_free(multi_sig2);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_multi_signature_free_works() {
let mut sign_key1: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key1, &mut signature1);
assert_eq!(err_code, ErrorCode::Success);
let mut signature2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key2, &mut signature2);
assert_eq!(err_code, ErrorCode::Success);
let signatures = [signature1, signature2];
let mut multi_sig: *const c_void = ptr::null();
let err_code = indy_crypto_bls_multi_signature_new(signatures.as_ptr(), signatures.len(), &mut multi_sig);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_multi_signature_free(multi_sig);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bsl_verify_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key, &mut signature);
assert_eq!(err_code, ErrorCode::Success);
let mut valid = false;
let err_code = indy_crypto_bsl_verify(signature,
message, message_len,
ver_key,
gen, &mut valid);
assert_eq!(err_code, ErrorCode::Success);
assert!(valid);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bsl_verify_works_for_invalid() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key2, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key, &mut signature);
assert_eq!(err_code, ErrorCode::Success);
let mut valid = false;
let err_code = indy_crypto_bsl_verify(signature,
message, message_len,
ver_key,
gen, &mut valid);
assert_eq!(err_code, ErrorCode::Success);
assert!(!valid);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_pop_new_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
assert!(!ver_key.is_null());
let mut pop: *const c_void = ptr::null();
let err_code = indy_crypto_bls_pop_new(ver_key, sign_key, &mut pop);
assert_eq!(err_code, ErrorCode::Success);
assert!(!pop.is_null());
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_pop_free(pop);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_pop_as_bytes_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let mut pop: *const c_void = ptr::null();
let err_code = indy_crypto_bls_pop_new(ver_key, sign_key, &mut pop);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_pop_as_bytes(pop, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_pop_free(pop);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_pop_from_bytes_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let mut pop: *const c_void = ptr::null();
let err_code = indy_crypto_bls_pop_new(ver_key, sign_key, &mut pop);
assert_eq!(err_code, ErrorCode::Success);
let mut bytes: *const u8 = ptr::null();
let mut bytes_len: usize = 0;
let err_code = indy_crypto_bls_pop_as_bytes(pop, &mut bytes, &mut bytes_len);
assert_eq!(err_code, ErrorCode::Success);
assert!(!bytes.is_null());
assert!(bytes_len > 0);
let mut pop2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_pop_from_bytes(bytes, bytes_len, &mut pop2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_pop_free(pop);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_pop_free(pop2);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_pop_free_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let mut pop: *const c_void = ptr::null();
let err_code = indy_crypto_bls_pop_new(ver_key, sign_key, &mut pop);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_pop_free(pop);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bsl_verify_pop_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key, &mut ver_key);
assert_eq!(err_code, ErrorCode::Success);
let mut pop: *const c_void = ptr::null();
let err_code = indy_crypto_bls_pop_new(ver_key, sign_key, &mut pop);
assert_eq!(err_code, ErrorCode::Success);
let mut valid = false;
let err_code = indy_crypto_bsl_verify_pop(pop,
ver_key,
gen,
&mut valid);
assert_eq!(err_code, ErrorCode::Success);
assert!(valid);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_pop_free(pop);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_verify_multi_sig_works() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key1: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key1, &mut signature1);
assert_eq!(err_code, ErrorCode::Success);
let mut signature2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key2, &mut signature2);
assert_eq!(err_code, ErrorCode::Success);
let signatures = [signature1, signature2];
let mut multi_sig: *const c_void = ptr::null();
let err_code = indy_crypto_bls_multi_signature_new(signatures.as_ptr(), signatures.len(), &mut multi_sig);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key1, &mut ver_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key2, &mut ver_key2);
assert_eq!(err_code, ErrorCode::Success);
let ver_keys = [ver_key1, ver_key2];
let mut valid = false;
let err_code = indy_crypto_bls_verify_multi_sig(multi_sig,
message, message_len,
ver_keys.as_ptr(), ver_keys.len(),
gen,
&mut valid);
assert_eq!(err_code, ErrorCode::Success);
assert!(valid);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_multi_signature_free(multi_sig);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_bls_verify_multi_sig_works_for_invalid() {
let mut gen: *const c_void = ptr::null();
let err_code = indy_crypto_bls_generator_new(&mut gen);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key1: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key2: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let mut sign_key3: *const c_void = ptr::null();
let seed: *const u8 = ptr::null();
let seed_len: usize = 0;
let err_code = indy_crypto_bls_sign_key_new(seed, seed_len, &mut sign_key3);
assert_eq!(err_code, ErrorCode::Success);
let message_v = vec![1, 2, 3, 4, 5];
let message = message_v.as_ptr();
let message_len = message_v.len();
let mut signature1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key1, &mut signature1);
assert_eq!(err_code, ErrorCode::Success);
let mut signature2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_sign(message, message_len, sign_key2, &mut signature2);
assert_eq!(err_code, ErrorCode::Success);
let signatures = [signature1, signature2];
let mut multi_sig: *const c_void = ptr::null();
let err_code = indy_crypto_bls_multi_signature_new(signatures.as_ptr(), signatures.len(), &mut multi_sig);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key1: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key1, &mut ver_key1);
assert_eq!(err_code, ErrorCode::Success);
let mut ver_key2: *const c_void = ptr::null();
let err_code = indy_crypto_bls_ver_key_new(gen, sign_key3, &mut ver_key2);
assert_eq!(err_code, ErrorCode::Success);
let ver_keys = [ver_key1, ver_key2];
let mut valid = false;
let err_code = indy_crypto_bls_verify_multi_sig(multi_sig,
message, message_len,
ver_keys.as_ptr(), ver_keys.len(),
gen,
&mut valid);
assert_eq!(err_code, ErrorCode::Success);
assert!(!valid);
let err_code = indy_crypto_bls_generator_free(gen);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_sign_key_free(sign_key3);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_ver_key_free(ver_key2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature1);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_signature_free(signature2);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_bls_multi_signature_free(multi_sig);
assert_eq!(err_code, ErrorCode::Success);
}
}