use cl::prover::*;
use cl::*;
use ffi::ErrorCode;
use utils::ctypes::*;
use errors::prelude::*;
use serde_json;
use std::os::raw::c_void;
use libc::c_char;
#[no_mangle]
pub extern fn indy_crypto_cl_prover_new_master_secret(master_secret_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_prover_new_master_secret: >>> {:?}", master_secret_p);
check_useful_c_ptr!(master_secret_p, ErrorCode::CommonInvalidParam1);
let res = match Prover::new_master_secret() {
Ok(master_secret) => {
trace!("indy_crypto_cl_prover_new_master_secret: master_secret: {:?}", master_secret);
unsafe {
*master_secret_p = Box::into_raw(Box::new(master_secret)) as *const c_void;
trace!("indy_crypto_cl_prover_new_master_secret: *master_secret_p: {:?}", *master_secret_p);
}
ErrorCode::Success
}
Err(err) => err.into()
};
trace!("indy_crypto_cl_prover_new_master_secret: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_master_secret_to_json(master_secret: *const c_void,
master_secret_json_p: *mut *const c_char) -> ErrorCode {
trace!("indy_crypto_cl_master_secret_to_json: >>> master_secret: {:?}, master_secret_json_p: {:?}", master_secret, master_secret_json_p);
check_useful_c_reference!(master_secret, MasterSecret, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(master_secret_json_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_master_secret_to_json: entity >>> master_secret: {:?}", master_secret);
let res = match serde_json::to_string(master_secret) {
Ok(master_secret_json) => {
trace!("indy_crypto_cl_master_secret_to_json: master_secret_json: {:?}", master_secret_json);
unsafe {
let master_secret_json = string_to_cstring(master_secret_json);
*master_secret_json_p = master_secret_json.into_raw();
trace!("indy_crypto_cl_master_secret_to_json: master_secret_json_p: {:?}", *master_secret_json_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidState, "Unable to serialize master secret as json").into()
}
};
trace!("indy_crypto_cl_master_secret_to_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_master_secret_from_json(master_secret_json: *const c_char,
master_secret_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_master_secret_from_json: >>> master_secret_json: {:?}, master_secret_p: {:?}", master_secret_json, master_secret_p);
check_useful_c_str!(master_secret_json, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(master_secret_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_master_secret_from_json: entity: master_secret_json: {:?}", master_secret_json);
let res = match serde_json::from_str::<MasterSecret>(&master_secret_json) {
Ok(master_secret) => {
trace!("indy_crypto_cl_master_secret_from_json: master_secret: {:?}", master_secret);
unsafe {
*master_secret_p = Box::into_raw(Box::new(master_secret)) as *const c_void;
trace!("indy_crypto_cl_master_secret_from_json: *master_secret_p: {:?}", *master_secret_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidStructure, "Unable to deserialize master secret from json").into()
}
};
trace!("indy_crypto_cl_master_secret_from_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_master_secret_free(master_secret: *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_master_secret_free: >>> master_secret: {:?}", master_secret);
check_useful_c_ptr!(master_secret, ErrorCode::CommonInvalidParam1);
let master_secret = unsafe { Box::from_raw(master_secret as *mut MasterSecret); };
trace!("indy_crypto_cl_master_secret_free: entity: master_secret: {:?}", master_secret);
let res = ErrorCode::Success;
trace!("indy_crypto_cl_master_secret_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_prover_blind_credential_secrets(credential_pub_key: *const c_void,
credential_key_correctness_proof: *const c_void,
credential_values: *const c_void,
credential_nonce: *const c_void,
blinded_credential_secrets_p: *mut *const c_void,
credential_secrets_blinding_factors_p: *mut *const c_void,
blinded_credential_secrets_correctness_proof_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_prover_blind_credential_secrets: >>> credential_pub_key: {:?}, \
credential_key_correctness_proof: {:?}, \
credential_values: {:?}, \
credential_nonce: {:?}, \
blinded_credential_secrets_p: {:?}, \
credential_secrets_blinding_factors_p: {:?}, \
blinded_credential_secrets_correctness_proof_p: {:?}",
credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce,
blinded_credential_secrets_p,
credential_secrets_blinding_factors_p,
blinded_credential_secrets_correctness_proof_p);
check_useful_c_reference!(credential_pub_key, CredentialPublicKey, ErrorCode::CommonInvalidParam1);
check_useful_c_reference!(credential_key_correctness_proof, CredentialKeyCorrectnessProof, ErrorCode::CommonInvalidParam2);
check_useful_c_reference!(credential_values, CredentialValues, ErrorCode::CommonInvalidParam3);
check_useful_c_reference!(credential_nonce, Nonce, ErrorCode::CommonInvalidParam4);
check_useful_c_ptr!(blinded_credential_secrets_p, ErrorCode::CommonInvalidParam5);
check_useful_c_ptr!(credential_secrets_blinding_factors_p, ErrorCode::CommonInvalidParam6);
check_useful_c_ptr!(blinded_credential_secrets_correctness_proof_p, ErrorCode::CommonInvalidParam7);
trace!("indy_crypto_cl_prover_blind_credential_secrets: inputs: credential_pub_key: {:?}, \
credential_key_correctness_proof: {:?}, \
credential_values: {:?}, \
credential_nonce: {:?}",
credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let res = match Prover::blind_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce) {
Ok((blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof)) => {
trace!("indy_crypto_cl_prover_blind_credential_secrets: blinded_credential_secrets: {:?}, \
credential_secrets_blinding_factors: {:?}, \
blinded_credential_secrets_correctness_proof: {:?}",
blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof);
unsafe {
*blinded_credential_secrets_p = Box::into_raw(Box::new(blinded_credential_secrets)) as *const c_void;
*credential_secrets_blinding_factors_p = Box::into_raw(Box::new(credential_secrets_blinding_factors)) as *const c_void;
*blinded_credential_secrets_correctness_proof_p = Box::into_raw(Box::new(blinded_credential_secrets_correctness_proof)) as *const c_void;
trace!("indy_crypto_cl_prover_blind_credential_secrets: *blinded_credential_secrets_p: {:?}, \
*credential_secrets_blinding_factors_p: {:?}, \
*blinded_credential_secrets_correctness_proof_p: {:?}",
*blinded_credential_secrets_p,
*credential_secrets_blinding_factors_p,
*blinded_credential_secrets_correctness_proof_p);
}
ErrorCode::Success
}
Err(err) => err.into()
};
trace!("indy_crypto_cl_prover_blind_credential_secrets: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_blinded_credential_secrets_to_json(blinded_credential_secrets: *const c_void,
blinded_credential_secrets_json_p: *mut *const c_char) -> ErrorCode {
trace!("indy_crypto_cl_blinded_credential_secrets_to_json: >>> blinded_credential_secrets: {:?}\n\
blinded_credential_secrets_json_p: {:?}", blinded_credential_secrets, blinded_credential_secrets_json_p);
check_useful_c_reference!(blinded_credential_secrets, BlindedCredentialSecrets, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(blinded_credential_secrets_json_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_blinded_credential_secrets_to_json: entity >>> blinded_credential_secrets: {:?}", blinded_credential_secrets);
let res = match serde_json::to_string(blinded_credential_secrets) {
Ok(blinded_credential_secrets_json) => {
trace!("indy_crypto_cl_blinded_credential_secrets_to_json: blinded_credential_secrets_json: {:?}", blinded_credential_secrets_json);
unsafe {
let blinded_credential_secrets_json = string_to_cstring(blinded_credential_secrets_json);
*blinded_credential_secrets_json_p = blinded_credential_secrets_json.into_raw();
trace!("indy_crypto_cl_blinded_credential_secrets_to_json: blinded_credential_secrets_json_p: {:?}", *blinded_credential_secrets_json_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidState, "Unable to serialize blinded credential secret as json").into()
}
};
trace!("indy_crypto_cl_blinded_credential_secrets_to_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_blinded_credential_secrets_from_json(blinded_credential_secrets_json: *const c_char,
blinded_credential_secrets_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_blinded_credential_secrets_from_json: >>> blinded_credential_secrets_json: {:?}, blinded_credential_secrets_p: {:?}", blinded_credential_secrets_json, blinded_credential_secrets_p);
check_useful_c_str!(blinded_credential_secrets_json, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(blinded_credential_secrets_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_blinded_credential_secrets_from_json: entity: blinded_credential_secrets_json: {:?}", blinded_credential_secrets_json);
let res = match serde_json::from_str::<BlindedCredentialSecrets>(&blinded_credential_secrets_json) {
Ok(blinded_credential_secrets) => {
trace!("indy_crypto_cl_blinded_credential_secrets_from_json: blinded_credential_secrets: {:?}", blinded_credential_secrets);
unsafe {
*blinded_credential_secrets_p = Box::into_raw(Box::new(blinded_credential_secrets)) as *const c_void;
trace!("indy_crypto_cl_blinded_credential_secrets_from_json: *blinded_credential_secrets_p: {:?}", *blinded_credential_secrets_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidStructure, "Unable to deserialize blinded credential secret from json").into()
}
};
trace!("indy_crypto_cl_blinded_credential_secrets_from_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_blinded_credential_secrets_free(blinded_credential_secrets: *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_blinded_credential_secrets_free: >>> blinded_credential_secrets: {:?}", blinded_credential_secrets);
check_useful_c_ptr!(blinded_credential_secrets, ErrorCode::CommonInvalidParam1);
let blinded_credential_secrets = unsafe { Box::from_raw(blinded_credential_secrets as *mut BlindedCredentialSecrets); };
trace!("indy_crypto_cl_blinded_credential_secrets_free: entity: blinded_credential_secrets: {:?}", blinded_credential_secrets);
let res = ErrorCode::Success;
trace!("indy_crypto_cl_blinded_credential_secrets_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_credential_secrets_blinding_factors_to_json(credential_secrets_blinding_factors: *const c_void,
credential_secrets_blinding_factors_json_p: *mut *const c_char) -> ErrorCode {
trace!("indy_crypto_cl_credential_secret_blinding_factors_to_json: >>> credential_secrets_blinding_factors: {:?}\n\
credential_secrets_blinding_factors_json_p: {:?}", credential_secrets_blinding_factors, credential_secrets_blinding_factors_json_p);
check_useful_c_reference!(credential_secrets_blinding_factors, CredentialSecretsBlindingFactors, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(credential_secrets_blinding_factors_json_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_credential_secret_blinding_factors_to_json: entity >>> credential_secrets_blinding_factors: {:?}", credential_secrets_blinding_factors);
let res = match serde_json::to_string(credential_secrets_blinding_factors) {
Ok(credential_secrets_blinding_factors_json) => {
trace!("indy_crypto_cl_credential_secret_blinding_factors_to_json: credential_secrets_blinding_factors_json: {:?}", credential_secrets_blinding_factors_json);
unsafe {
let credential_secrets_blinding_factors_json = string_to_cstring(credential_secrets_blinding_factors_json);
*credential_secrets_blinding_factors_json_p = credential_secrets_blinding_factors_json.into_raw();
trace!("indy_crypto_cl_credential_secret_blinding_factors_to_json: credential_secrets_blinding_factors_json_p: {:?}", *credential_secrets_blinding_factors_json_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidState, "Unable to serialize blinded credential secret factors as json").into()
}
};
trace!("indy_crypto_cl_credential_secret_blinding_factors_to_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_credential_secrets_blinding_factors_from_json(credential_secrets_blinding_factors_json: *const c_char,
credential_secrets_blinding_factors_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_credential_secrets_blinding_factors_from_json: >>> credential_secrets_blinding_factors_json: {:?}\n\
credential_secrets_blinding_factors_p: {:?}", credential_secrets_blinding_factors_json, credential_secrets_blinding_factors_p);
check_useful_c_str!(credential_secrets_blinding_factors_json, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(credential_secrets_blinding_factors_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_credential_secrets_blinding_factors_from_json: entity: credential_secrets_blinding_factors_json: {:?}", credential_secrets_blinding_factors_json);
let res = match serde_json::from_str::<CredentialSecretsBlindingFactors>(&credential_secrets_blinding_factors_json) {
Ok(credential_secrets_blinding_factors) => {
trace!("indy_crypto_cl_credential_secrets_blinding_factors_from_json: credential_secrets_blinding_factors: {:?}", credential_secrets_blinding_factors);
unsafe {
*credential_secrets_blinding_factors_p = Box::into_raw(Box::new(credential_secrets_blinding_factors)) as *const c_void;
trace!("indy_crypto_cl_credential_secrets_blinding_factors_from_json: *credential_secrets_blinding_factors_p: {:?}", *credential_secrets_blinding_factors_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidStructure, "Unable to deserialize blinded credential secret factors from json").into()
}
};
trace!("indy_crypto_cl_credential_secrets_blinding_factors_from_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_credential_secrets_blinding_factors_free(credential_secrets_blinding_factors: *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_credential_secrets_blinding_factors_free: >>> credential_secrets_blinding_factors: {:?}", credential_secrets_blinding_factors);
check_useful_c_ptr!(credential_secrets_blinding_factors, ErrorCode::CommonInvalidParam1);
let credential_secrets_blinding_factors = unsafe { Box::from_raw(credential_secrets_blinding_factors as *mut CredentialSecretsBlindingFactors); };
trace!("indy_crypto_cl_credential_secrets_blinding_factors_free: entity: credential_secrets_blinding_factors: {:?}", credential_secrets_blinding_factors);
let res = ErrorCode::Success;
trace!("indy_crypto_cl_credential_secrets_blinding_factors_free: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json(blinded_credential_secrets_correctness_proof: *const c_void,
blinded_credential_secrets_correctness_proof_json_p: *mut *const c_char) -> ErrorCode {
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json: >>> blinded_credential_secrets_correctness_proof: {:?}\n\
blinded_credential_secrets_correctness_proof_json_p: {:?}", blinded_credential_secrets_correctness_proof, blinded_credential_secrets_correctness_proof_json_p);
check_useful_c_reference!(blinded_credential_secrets_correctness_proof, BlindedCredentialSecretsCorrectnessProof, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(blinded_credential_secrets_correctness_proof_json_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json: entity >>> blinded_credential_secrets_correctness_proof: {:?}",
blinded_credential_secrets_correctness_proof);
let res = match serde_json::to_string(blinded_credential_secrets_correctness_proof) {
Ok(blinded_credential_secrets_correctness_proof_json) => {
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json: blinded_credential_secrets_correctness_proof: {:?}",
blinded_credential_secrets_correctness_proof_json);
unsafe {
let blinded_credential_secrets_correctness_proof_json = string_to_cstring(blinded_credential_secrets_correctness_proof_json);
*blinded_credential_secrets_correctness_proof_json_p = blinded_credential_secrets_correctness_proof_json.into_raw();
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json: blinded_credential_secrets_correctness_proof_json_p: {:?}",
*blinded_credential_secrets_correctness_proof_json_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidState, "Unable to serialize blinded credential secrets correctness proof as json").into()
}
};
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_blinded_credential_secrets_correctness_proof_from_json(blinded_credential_secrets_correctness_proof_json: *const c_char,
blinded_credential_secrets_correctness_proof_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_from_json: >>> blinded_credential_secrets_correctness_proof_json: {:?},\
blinded_credential_secrets_correctness_proof_p: {:?}", blinded_credential_secrets_correctness_proof_json, blinded_credential_secrets_correctness_proof_p);
check_useful_c_str!(blinded_credential_secrets_correctness_proof_json, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(blinded_credential_secrets_correctness_proof_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_from_json: entity: blinded_credential_secrets_correctness_proof_json: {:?}",
blinded_credential_secrets_correctness_proof_json);
let res = match serde_json::from_str::<BlindedCredentialSecretsCorrectnessProof>(&blinded_credential_secrets_correctness_proof_json) {
Ok(blinded_credential_secrets_correctness_proof) => {
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_from_json: blinded_credential_secrets_correctness_proof: {:?}",
blinded_credential_secrets_correctness_proof);
unsafe {
*blinded_credential_secrets_correctness_proof_p = Box::into_raw(Box::new(blinded_credential_secrets_correctness_proof)) as *const c_void;
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_from_json: *blinded_credential_secrets_correctness_proof_p: {:?}",
*blinded_credential_secrets_correctness_proof_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidStructure, "Unable to deserialize blinded credential secret correctness proof from json").into()
}
};
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_from_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_blinded_credential_secrets_correctness_proof_free(blinded_credential_secrets_correctness_proof: *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_free: >>> blinded_credential_secrets_correctness_proof: {:?}",
blinded_credential_secrets_correctness_proof);
check_useful_c_ptr!(blinded_credential_secrets_correctness_proof, ErrorCode::CommonInvalidParam1);
let blinded_credential_secrets_correctness_proof = unsafe { Box::from_raw(blinded_credential_secrets_correctness_proof as *mut BlindedCredentialSecretsCorrectnessProof); };
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_free: entity: blinded_credential_secrets_correctness_proof: {:?}", blinded_credential_secrets_correctness_proof);
let res = ErrorCode::Success;
trace!("indy_crypto_cl_blinded_credential_secrets_correctness_proof_free: <<< res: {:?}", res);
res
}
#[no_mangle]
#[allow(unused_variables)]
pub extern fn indy_crypto_cl_prover_process_credential_signature(credential_signature: *const c_void,
credential_values: *const c_void,
signature_correctness_proof: *const c_void,
credential_secrets_blinding_factors: *const c_void,
credential_pub_key: *const c_void,
credential_issuance_nonce: *const c_void,
rev_key_pub: *const c_void,
rev_reg: *const c_void,
witness: *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_prover_process_credential_signature: >>> credential_signature: {:?}\n\
signature_correctness_proof: {:?}\n\
credential_secrets_blinding_factors: {:?}\n\
credential_pub_key: {:?}\n\
credential_issuance_nonce: {:?}\n\
rev_key_pub: {:?}\n\
rev_reg {:?}\n\
witness {:?}",
credential_signature, signature_correctness_proof, credential_secrets_blinding_factors, credential_pub_key, credential_issuance_nonce, rev_key_pub, rev_reg, witness);
check_useful_mut_c_reference!(credential_signature, CredentialSignature, ErrorCode::CommonInvalidParam1);
check_useful_c_reference!(credential_values, CredentialValues, ErrorCode::CommonInvalidParam2);
check_useful_c_reference!(signature_correctness_proof, SignatureCorrectnessProof, ErrorCode::CommonInvalidParam3);
check_useful_c_reference!(credential_secrets_blinding_factors, CredentialSecretsBlindingFactors, ErrorCode::CommonInvalidParam4);
check_useful_c_reference!(credential_pub_key, CredentialPublicKey, ErrorCode::CommonInvalidParam5);
check_useful_c_reference!(credential_issuance_nonce, Nonce, ErrorCode::CommonInvalidParam6);
check_useful_opt_c_reference!(rev_key_pub, RevocationKeyPublic);
check_useful_opt_c_reference!(rev_reg, RevocationRegistry);
check_useful_opt_c_reference!(witness, Witness);
trace!("indy_crypto_cl_prover_process_credential_signature: >>> credential_signature: {:?}\n\
credential_values: {:?}\n\
signature_correctness_proof: {:?}\n\
credential_secrets_blinding_factors: {:?}\n\
credential_pub_key: {:?}\n\
credential_issuance_nonce: {:?}\n\
rev_key_pub: {:?}\n\
rev_reg {:?}, witness {:?}",
credential_signature,
credential_values,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_pub_key,
credential_issuance_nonce,
rev_key_pub,
rev_reg,
witness);
let res = match Prover::process_credential_signature(credential_signature,
credential_values,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_pub_key,
credential_issuance_nonce,
rev_key_pub,
rev_reg,
witness) {
Ok(()) => ErrorCode::Success,
Err(err) => err.into()
};
trace!("indy_crypto_cl_prover_process_credential_signature: <<< res: {:?}", res);
ErrorCode::Success
}
#[no_mangle]
#[allow(unused_variables)]
pub extern fn indy_crypto_cl_prover_get_credential_revocation_index(credential_signature: *const c_void,
cred_rev_indx: *mut u32) -> ErrorCode {
trace!("indy_crypto_cl_prover_get_credential_revocation_index: >>> credential_signature: {:?}, cred_rev_indx: {:?}",
credential_signature, cred_rev_indx);
check_useful_c_reference!(credential_signature, CredentialSignature, ErrorCode::CommonInvalidParam1);
trace!("indy_crypto_cl_prover_get_credential_revocation_index: >>> credential_signature: {:?}", credential_signature);
let res = match credential_signature.extract_index() {
Some(index) => {
trace!("indy_crypto_cl_prover_get_credential_revocation_index: index: {:?}", index);
unsafe {
*cred_rev_indx = index;
}
trace!("indy_crypto_cl_prover_get_credential_revocation_index: *cred_rev_indx: {:?}", cred_rev_indx);
ErrorCode::Success
}
None => {
err_msg(IndyCryptoErrorKind::InvalidState, "Unable to extract credential revocation index").into()
}
};
trace!("indy_crypto_cl_prover_get_credential_revocation_index: <<< res: {:?}", res);
ErrorCode::Success
}
#[no_mangle]
pub extern fn indy_crypto_cl_prover_new_proof_builder(proof_builder_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_prover_new_proof_builder: >>> {:?}", proof_builder_p);
check_useful_c_ptr!(proof_builder_p, ErrorCode::CommonInvalidParam1);
let res = match Prover::new_proof_builder() {
Ok(proof_builder) => {
trace!("indy_crypto_cl_prover_new_proof_builder: proof_builder: {:?}", proof_builder);
unsafe {
*proof_builder_p = Box::into_raw(Box::new(proof_builder)) as *const c_void;
trace!("indy_crypto_cl_prover_new_proof_builder: *proof_builder_p: {:?}", *proof_builder_p);
}
ErrorCode::Success
}
Err(err) => err.into()
};
trace!("indy_crypto_cl_prover_new_proof_builder: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_proof_builder_add_sub_proof_request(proof_builder: *const c_void,
sub_proof_request: *const c_void,
credential_schema: *const c_void,
non_credential_schema: *const c_void,
credential_signature: *const c_void,
credential_values: *const c_void,
credential_pub_key: *const c_void,
rev_reg: *const c_void,
witness: *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_proof_builder_add_sub_proof_request: >>> proof_builder: {:?}, \
sub_proof_request: {:?}, \
credential_schema: {:?}, \
non_credential_schema: {:?}, \
credential_signature: {:?}, \
credential_values: {:?}, \
credential_pub_key: {:?}, \
rev_reg: {:?}, \
witness: {:?}",
proof_builder,
sub_proof_request,
credential_schema,
non_credential_schema,
credential_signature,
credential_values,
credential_pub_key,
rev_reg,
witness);
check_useful_mut_c_reference!(proof_builder, ProofBuilder, ErrorCode::CommonInvalidParam1);
check_useful_c_reference!(sub_proof_request, SubProofRequest, ErrorCode::CommonInvalidParam2);
check_useful_c_reference!(credential_schema, CredentialSchema, ErrorCode::CommonInvalidParam3);
check_useful_c_reference!(non_credential_schema, NonCredentialSchema, ErrorCode::CommonInvalidParam4);
check_useful_c_reference!(credential_signature, CredentialSignature, ErrorCode::CommonInvalidParam5);
check_useful_c_reference!(credential_values, CredentialValues, ErrorCode::CommonInvalidParam6);
check_useful_c_reference!(credential_pub_key, CredentialPublicKey, ErrorCode::CommonInvalidParam7);
check_useful_opt_c_reference!(rev_reg, RevocationRegistry);
check_useful_opt_c_reference!(witness, Witness);
trace!("indy_crypto_cl_proof_builder_add_sub_proof_request: entities: proof_builder: {:?}, \
sub_proof_request: {:?}, \
credential_schema: {:?}, \
non_credential_schema: {:?}, \
credential_signature: {:?}, \
credential_values: {:?}, \
credential_pub_key: {:?}, \
rev_reg: {:?}, \
witness: {:?}",
proof_builder,
sub_proof_request,
credential_schema,
non_credential_schema,
credential_signature,
credential_values,
credential_pub_key,
rev_reg,
witness);
let res = match proof_builder.add_sub_proof_request(sub_proof_request,
credential_schema,
non_credential_schema,
credential_signature,
credential_values,
credential_pub_key,
rev_reg,
witness) {
Ok(()) => ErrorCode::Success,
Err(err) => err.into()
};
trace!("indy_crypto_cl_proof_builder_add_sub_proof_request: <<< res: {:?}", res);
ErrorCode::Success
}
#[no_mangle]
pub extern fn indy_crypto_cl_proof_builder_finalize(proof_builder: *const c_void,
nonce: *const c_void,
proof_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_proof_builder_finalize: >>> proof_builder: {:?}, nonce: {:?}, proof_p: {:?}",
proof_builder, nonce, proof_p);
check_useful_c_ptr!(proof_builder, ErrorCode::CommonInvalidParam1);
check_useful_c_reference!(nonce, Nonce, ErrorCode::CommonInvalidParam2);
check_useful_c_ptr!(proof_p, ErrorCode::CommonInvalidParam3);
let proof_builder = unsafe { Box::from_raw(proof_builder as *mut ProofBuilder) };
trace!("indy_crypto_cl_proof_builder_finalize: entities: proof_builder: {:?}, nonce: {:?}",
proof_builder, nonce);
let res = match proof_builder.finalize(nonce) {
Ok(proof) => {
trace!("indy_crypto_cl_proof_builder_finalize: proof: {:?}", proof);
unsafe {
*proof_p = Box::into_raw(Box::new(proof)) as *const c_void;
trace!("indy_crypto_cl_proof_builder_finalize: *proof_p: {:?}", *proof_p);
}
ErrorCode::Success
}
Err(err) => err.into()
};
trace!("indy_crypto_cl_proof_builder_finalize: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_proof_to_json(proof: *const c_void,
proof_json_p: *mut *const c_char) -> ErrorCode {
trace!("indy_crypto_cl_proof_to_json: >>> proof: {:?}, proof_json_p: {:?}", proof, proof_json_p);
check_useful_c_reference!(proof, Proof, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(proof_json_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_proof_to_json: entity >>> proof: {:?}", proof);
let res = match serde_json::to_string(proof) {
Ok(proof_json) => {
trace!("indy_crypto_cl_proof_to_json: proof_json: {:?}", proof_json);
unsafe {
let proof_json = string_to_cstring(proof_json);
*proof_json_p = proof_json.into_raw();
trace!("indy_crypto_cl_proof_to_json: proof_json_p: {:?}", *proof_json_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidState, "Unable to serialize proof as json").into()
}
};
trace!("indy_crypto_cl_proof_to_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_proof_from_json(proof_json: *const c_char,
proof_p: *mut *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_proof_from_json: >>> proof_json: {:?}, proof_p: {:?}", proof_json, proof_p);
check_useful_c_str!(proof_json, ErrorCode::CommonInvalidParam1);
check_useful_c_ptr!(proof_p, ErrorCode::CommonInvalidParam2);
trace!("indy_crypto_cl_proof_from_json: entity: proof_json: {:?}", proof_json);
let res = match serde_json::from_str::<Proof>(&proof_json) {
Ok(proof) => {
trace!("indy_crypto_cl_proof_from_json: proof: {:?}", proof);
unsafe {
*proof_p = Box::into_raw(Box::new(proof)) as *const c_void;
trace!("indy_crypto_cl_proof_from_json: *proof_p: {:?}", *proof_p);
}
ErrorCode::Success
}
Err(err) => {
err.to_indy(IndyCryptoErrorKind::InvalidStructure, "Unable to deserialize proof from json").into()
}
};
trace!("indy_crypto_cl_proof_from_json: <<< res: {:?}", res);
res
}
#[no_mangle]
pub extern fn indy_crypto_cl_proof_free(proof: *const c_void) -> ErrorCode {
trace!("indy_crypto_cl_proof_free: >>> proof: {:?}", proof);
check_useful_c_ptr!(proof, ErrorCode::CommonInvalidParam1);
let proof = unsafe { Box::from_raw(proof as *mut Proof); };
trace!("indy_crypto_cl_proof_free: entity: proof: {:?}", proof);
let res = ErrorCode::Success;
trace!("indy_crypto_cl_proof_free: <<< res: {:?}", res);
res
}
#[cfg(test)]
mod tests {
use super::*;
use std::ptr;
use ffi::cl::mocks::*;
use ffi::cl::issuer::mocks::*;
use ffi::cl::prover::mocks::*;
#[test]
fn indy_crypto_cl_prover_new_master_secret_works() {
let mut master_secret_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_prover_new_master_secret(&mut master_secret_p);
assert_eq!(err_code, ErrorCode::Success);
assert!(!master_secret_p.is_null());
_free_master_secret(master_secret_p)
}
#[test]
fn indy_crypto_cl_master_secret_to_json_works() {
let master_secret = _master_secret();
let mut master_secret_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_master_secret_to_json(master_secret, &mut master_secret_json_p);
assert_eq!(err_code, ErrorCode::Success);
_free_master_secret(master_secret)
}
#[test]
fn indy_crypto_cl_master_secret_from_json_works() {
let master_secret = _master_secret();
let mut master_secret_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_master_secret_to_json(master_secret, &mut master_secret_json_p);
assert_eq!(err_code, ErrorCode::Success);
let mut master_secret_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_master_secret_from_json(master_secret_json_p, &mut master_secret_p);
assert_eq!(err_code, ErrorCode::Success);
_free_master_secret(master_secret)
}
#[test]
fn indy_crypto_cl_prover_master_secret_free_works() {
let master_secret = _master_secret();
let err_code = indy_crypto_cl_master_secret_free(master_secret);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_cl_prover_blind_credential_secrets_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let mut blinded_credential_secrets_p: *const c_void = ptr::null();
let mut credential_secrets_blinding_factors_p: *const c_void = ptr::null();
let mut blinded_credential_secrets_correctness_proof_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_prover_blind_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce,
&mut blinded_credential_secrets_p,
&mut credential_secrets_blinding_factors_p,
&mut blinded_credential_secrets_correctness_proof_p);
assert_eq!(err_code, ErrorCode::Success);
assert!(!blinded_credential_secrets_p.is_null());
assert!(!credential_secrets_blinding_factors_p.is_null());
_free_blinded_credential_secrets(blinded_credential_secrets_p,
credential_secrets_blinding_factors_p,
blinded_credential_secrets_correctness_proof_p);
_free_credential_values(credential_values);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_nonce(credential_nonce);
}
#[test]
fn indy_crypto_cl_prover_blinded_credential_secrets_free_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let (blinded_credential_secrets, credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let err_code = indy_crypto_cl_blinded_credential_secrets_free(blinded_credential_secrets);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_cl_credential_secrets_blinding_factors_free(credential_secrets_blinding_factors);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_cl_blinded_credential_secrets_correctness_proof_free(blinded_credential_secrets_correctness_proof);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
}
#[test]
fn indy_crypto_cl_prover_blinded_credential_secrets_to_json_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let (blinded_credential_secrets, credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let mut blinded_credential_secrets_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_blinded_credential_secrets_to_json(blinded_credential_secrets, &mut blinded_credential_secrets_json_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
}
#[test]
fn indy_crypto_cl_prover_proof_builder_add_sub_proof_request_works() {
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_values = _credential_values();
let credential_nonce = _nonce();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let sub_proof_request = _sub_proof_request();
let credential_schema = _credential_schema();
let non_credential_schema = _non_credential_schema();
let credential_issuance_nonce = _nonce();
let (credential_signature, signature_correctness_proof) = _credential_signature(blinded_credential_secrets,
blinded_credential_secrets_correctness_proof,
credential_nonce,
credential_issuance_nonce,
credential_values,
credential_pub_key,
credential_pub_key);
_process_credential_signature(credential_signature,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_values,
credential_pub_key,
credential_issuance_nonce,
ptr::null(),
ptr::null(),
ptr::null());
let proof_builder = _proof_builder();
let err_code = indy_crypto_cl_proof_builder_add_sub_proof_request(proof_builder,
sub_proof_request,
credential_schema,
non_credential_schema,
credential_signature,
credential_values,
credential_pub_key,
ptr::null(),
ptr::null());
assert_eq!(err_code, ErrorCode::Success);
let nonce = _nonce();
_free_proof_builder(proof_builder, nonce);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
_free_nonce(credential_nonce);
_free_nonce(credential_issuance_nonce);
_free_credential_values(credential_values);
_free_sub_proof_request(sub_proof_request);
_free_credential_signature(credential_signature, signature_correctness_proof);
_free_credential_schema(credential_schema);
_free_non_credential_schema(non_credential_schema);
}
#[test]
fn indy_crypto_cl_prover_blinded_credential_secrets_from_json_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let (blinded_credential_secrets, credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let mut blinded_credential_secrets_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_blinded_credential_secrets_to_json(blinded_credential_secrets, &mut blinded_credential_secrets_json_p);
assert_eq!(err_code, ErrorCode::Success);
let mut blinded_credential_secrets_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_blinded_credential_secrets_from_json(blinded_credential_secrets_json_p,
&mut blinded_credential_secrets_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
}
#[test]
fn indy_crypto_cl_prover_credential_secrets_blinding_factors_to_json_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let mut credential_secrets_blinding_factors_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_credential_secrets_blinding_factors_to_json(credential_secrets_blinding_factors,
&mut credential_secrets_blinding_factors_json_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
}
#[test]
fn indy_crypto_cl_prover_credential_secrets_blinding_factors_from_json_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let (blinded_credential_secrets, credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let mut credential_secrets_blinding_factors_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_credential_secrets_blinding_factors_to_json(credential_secrets_blinding_factors,
&mut credential_secrets_blinding_factors_json_p);
assert_eq!(err_code, ErrorCode::Success);
let mut credential_secrets_blinding_factors_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_credential_secrets_blinding_factors_from_json(credential_secrets_blinding_factors_json_p,
&mut credential_secrets_blinding_factors_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
}
#[test]
fn indy_crypto_cl_prover_blinded_credential_secrets_correctness_proof_to_json_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let mut blinded_credential_secrets_correctness_proof_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json(blinded_credential_secrets_correctness_proof,
&mut blinded_credential_secrets_correctness_proof_json_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
}
#[test]
fn indy_crypto_cl_prover_blinded_credential_secrets_correctness_proof_from_json_works() {
let credential_values = _credential_values();
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let mut blinded_credential_secrets_correctness_proof_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_blinded_credential_secrets_correctness_proof_to_json(blinded_credential_secrets_correctness_proof,
&mut blinded_credential_secrets_correctness_proof_json_p);
assert_eq!(err_code, ErrorCode::Success);
let mut blinded_credential_secrets_correctness_proof_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_blinded_credential_secrets_correctness_proof_from_json(blinded_credential_secrets_correctness_proof_json_p,
&mut blinded_credential_secrets_correctness_proof_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
}
#[test]
fn indy_crypto_cl_prover_process_credential_signature_signature_works() {
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let credential_values = _credential_values();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let credential_issuance_nonce = _nonce();
let (credential_signature, signature_correctness_proof) =
_credential_signature(blinded_credential_secrets,
blinded_credential_secrets_correctness_proof,
credential_nonce,
credential_issuance_nonce,
credential_values,
credential_pub_key,
credential_priv_key);
let err_code = indy_crypto_cl_prover_process_credential_signature(credential_signature,
credential_values,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_pub_key,
credential_issuance_nonce,
ptr::null(),
ptr::null(),
ptr::null());
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
_free_credential_values(credential_values);
_free_nonce(credential_nonce);
_free_nonce(credential_issuance_nonce);
_free_credential_signature(credential_signature, signature_correctness_proof);
}
#[test]
fn indy_crypto_cl_prover_proof_builder_new_works() {
let mut proof_builder: *const c_void = ptr::null();
let err_code = indy_crypto_cl_prover_new_proof_builder(&mut proof_builder);
assert_eq!(err_code, ErrorCode::Success);
assert!(!proof_builder.is_null());
let nonce = _nonce();
_free_proof_builder(proof_builder, nonce);
}
#[test]
fn indy_crypto_cl_prover_proof_builder_finalize_works() {
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_nonce = _nonce();
let credential_values = _credential_values();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let sub_proof_request = _sub_proof_request();
let credential_schema = _credential_schema();
let non_credential_schema = _non_credential_schema();
let credential_issuance_nonce = _nonce();
let (credential_signature, signature_correctness_proof) = _credential_signature(blinded_credential_secrets,
blinded_credential_secrets_correctness_proof,
credential_nonce,
credential_issuance_nonce,
credential_values,
credential_pub_key,
credential_priv_key);
_process_credential_signature(credential_signature,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_values,
credential_pub_key,
credential_issuance_nonce,
ptr::null(),
ptr::null(),
ptr::null());
let proof_builder = _proof_builder();
let err_code = indy_crypto_cl_proof_builder_add_sub_proof_request(proof_builder,
sub_proof_request,
credential_schema,
non_credential_schema,
credential_signature,
credential_values,
credential_pub_key,
ptr::null(),
ptr::null());
assert_eq!(err_code, ErrorCode::Success);
let nonce = _nonce();
let mut proof: *const c_void = ptr::null();
let err_code = indy_crypto_cl_proof_builder_finalize(proof_builder, nonce, &mut proof);
assert_eq!(err_code, ErrorCode::Success);
assert!(!proof.is_null());
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
_free_nonce(credential_nonce);
_free_nonce(credential_issuance_nonce);
_free_credential_values(credential_values);
_free_sub_proof_request(sub_proof_request);
_free_credential_signature(credential_signature, signature_correctness_proof);
_free_proof(proof);
_free_credential_schema(credential_schema);
_free_non_credential_schema(non_credential_schema);
}
#[test]
fn indy_crypto_cl_proof_to_json_works() {
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_values = _credential_values();
let credential_nonce = _nonce();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let credential_issuance_nonce = _nonce();
let (credential_signature, signature_correctness_proof) = _credential_signature(blinded_credential_secrets,
blinded_credential_secrets_correctness_proof,
credential_nonce,
credential_issuance_nonce,
credential_values,
credential_pub_key,
credential_priv_key);
_process_credential_signature(credential_signature,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_values,
credential_pub_key,
credential_issuance_nonce,
ptr::null(),
ptr::null(),
ptr::null());
let proof_building_nonce = _nonce();
let proof = _proof(credential_pub_key,
credential_signature,
proof_building_nonce,
credential_values,
ptr::null(),
ptr::null());
let mut proof_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_proof_to_json(proof, &mut proof_json_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
_free_nonce(credential_nonce);
_free_nonce(credential_issuance_nonce);
_free_nonce(proof_building_nonce);
_free_credential_signature(credential_signature, signature_correctness_proof);
_free_proof(proof);
}
#[test]
fn indy_crypto_cl_proof_from_json_works() {
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_values = _credential_values();
let credential_nonce = _nonce();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let credential_issuance_nonce = _nonce();
let (credential_signature, signature_correctness_proof) = _credential_signature(blinded_credential_secrets,
blinded_credential_secrets_correctness_proof,
credential_nonce,
credential_issuance_nonce,
credential_values,
credential_pub_key,
credential_priv_key);
_process_credential_signature(credential_signature,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_values,
credential_pub_key,
credential_issuance_nonce,
ptr::null(),
ptr::null(),
ptr::null());
let proof_building_nonce = _nonce();
let proof = _proof(credential_pub_key,
credential_signature,
proof_building_nonce,
credential_values,
ptr::null(),
ptr::null());
let mut proof_json_p: *const c_char = ptr::null();
let err_code = indy_crypto_cl_proof_to_json(proof, &mut proof_json_p);
assert_eq!(err_code, ErrorCode::Success);
let mut proof_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_proof_from_json(proof_json_p, &mut proof_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
_free_nonce(credential_nonce);
_free_nonce(credential_issuance_nonce);
_free_nonce(proof_building_nonce);
_free_credential_signature(credential_signature, signature_correctness_proof);
_free_proof(proof);
}
#[test]
fn indy_crypto_cl_proof_free_works() {
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let credential_values = _credential_values();
let credential_nonce = _nonce();
let (blinded_credential_secrets,
credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let credential_issuance_nonce = _nonce();
let (credential_signature, signature_correctness_proof) = _credential_signature(blinded_credential_secrets,
blinded_credential_secrets_correctness_proof,
credential_nonce,
credential_issuance_nonce,
credential_values,
credential_pub_key,
credential_priv_key);
_process_credential_signature(credential_signature,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_values,
credential_pub_key,
credential_issuance_nonce,
ptr::null(),
ptr::null(),
ptr::null());
let proof_building_nonce = _nonce();
let proof = _proof(credential_pub_key,
credential_signature,
proof_building_nonce,
credential_values,
ptr::null(),
ptr::null());
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
_free_nonce(credential_nonce);
_free_nonce(credential_issuance_nonce);
_free_nonce(proof_building_nonce);
_free_credential_signature(credential_signature, signature_correctness_proof);
let err_code = indy_crypto_cl_proof_free(proof);
assert_eq!(err_code, ErrorCode::Success);
}
#[test]
fn indy_crypto_cl_prover_get_credential_revocation_index_works() {
let (credential_pub_key, credential_priv_key, credential_key_correctness_proof) = _credential_def();
let (rev_key_pub, rev_key_priv, rev_reg, rev_tails_generator) = _revocation_registry_def(credential_pub_key);
let credential_values = _credential_values();
let credential_nonce = _nonce();
let (blinded_credential_secrets, credential_secrets_blinding_factors,
blinded_credential_secrets_correctness_proof) = _blinded_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce);
let credential_issuance_nonce = _nonce();
let tail_storage = FFISimpleTailStorage::new(rev_tails_generator);
let (credential_signature, signature_correctness_proof, _) =
_credential_signature_with_revoc(blinded_credential_secrets,
blinded_credential_secrets_correctness_proof,
credential_nonce,
credential_issuance_nonce,
credential_values,
credential_pub_key,
credential_priv_key,
rev_key_priv,
rev_reg,
tail_storage.get_ctx());
let mut cred_rev_idx_p: u32 = 0;
let err_code = indy_crypto_cl_prover_get_credential_revocation_index(credential_signature, &mut cred_rev_idx_p);
assert_eq!(err_code, ErrorCode::Success);
_free_credential_def(credential_pub_key, credential_priv_key, credential_key_correctness_proof);
_free_revocation_registry_def(rev_key_pub, rev_key_priv, rev_reg, rev_tails_generator);
_free_credential_values(credential_values);
_free_blinded_credential_secrets(blinded_credential_secrets, credential_secrets_blinding_factors, blinded_credential_secrets_correctness_proof);
_free_nonce(credential_nonce);
_free_nonce(credential_issuance_nonce);
_free_credential_signature(credential_signature, signature_correctness_proof);
}
}
pub mod mocks {
use super::*;
use std::ptr;
use ffi::cl::mocks::*;
pub fn _master_secret() -> *const c_void {
let mut master_secret_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_prover_new_master_secret(&mut master_secret_p);
assert_eq!(err_code, ErrorCode::Success);
assert!(!master_secret_p.is_null());
master_secret_p
}
pub fn _free_master_secret(master_secret: *const c_void) {
let err_code = indy_crypto_cl_master_secret_free(master_secret);
assert_eq!(err_code, ErrorCode::Success);
}
pub fn _blinded_credential_secrets(credential_pub_key: *const c_void,
credential_key_correctness_proof: *const c_void,
credential_values: *const c_void,
credential_nonce: *const c_void) -> (*const c_void, *const c_void, *const c_void) {
let mut blinded_credential_secrets_p: *const c_void = ptr::null();
let mut credential_secrets_blinding_factors_p: *const c_void = ptr::null();
let mut blinded_credential_secrets_correctness_proof_p: *const c_void = ptr::null();
let err_code = indy_crypto_cl_prover_blind_credential_secrets(credential_pub_key,
credential_key_correctness_proof,
credential_values,
credential_nonce,
&mut blinded_credential_secrets_p,
&mut credential_secrets_blinding_factors_p,
&mut blinded_credential_secrets_correctness_proof_p);
assert_eq!(err_code, ErrorCode::Success);
assert!(!blinded_credential_secrets_p.is_null());
assert!(!credential_secrets_blinding_factors_p.is_null());
assert!(!blinded_credential_secrets_correctness_proof_p.is_null());
(blinded_credential_secrets_p, credential_secrets_blinding_factors_p, blinded_credential_secrets_correctness_proof_p)
}
pub fn _free_blinded_credential_secrets(blinded_credential_secrets: *const c_void,
credential_secrets_blinding_factors: *const c_void,
blinded_credential_secrets_correctness_proof: *const c_void) {
let err_code = indy_crypto_cl_blinded_credential_secrets_free(blinded_credential_secrets);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_cl_credential_secrets_blinding_factors_free(credential_secrets_blinding_factors);
assert_eq!(err_code, ErrorCode::Success);
let err_code = indy_crypto_cl_blinded_credential_secrets_correctness_proof_free(blinded_credential_secrets_correctness_proof);
assert_eq!(err_code, ErrorCode::Success);
}
pub fn _process_credential_signature(credential_signature: *const c_void,
signature_correctness_proof: *const c_void,
credential_secrets_blinding_factors: *const c_void,
credential_values: *const c_void,
credential_pub_key: *const c_void,
credential_issuance_nonce: *const c_void,
rev_key_pub: *const c_void, rev_reg: *const c_void, witness: *const c_void) {
let err_code = indy_crypto_cl_prover_process_credential_signature(credential_signature,
credential_values,
signature_correctness_proof,
credential_secrets_blinding_factors,
credential_pub_key,
credential_issuance_nonce,
rev_key_pub,
rev_reg,
witness);
assert_eq!(err_code, ErrorCode::Success);
}
pub fn _proof_builder() -> *const c_void {
let mut proof_builder: *const c_void = ptr::null();
let err_code = indy_crypto_cl_prover_new_proof_builder(&mut proof_builder);
assert_eq!(err_code, ErrorCode::Success);
assert!(!proof_builder.is_null());
proof_builder
}
pub fn _free_proof_builder(proof_builder: *const c_void, nonce: *const c_void) {
let mut proof: *const c_void = ptr::null();
let err_code = indy_crypto_cl_proof_builder_finalize(proof_builder, nonce, &mut proof);
assert_eq!(err_code, ErrorCode::Success);
assert!(!proof.is_null());
}
pub fn _proof(credential_pub_key: *const c_void, credential_signature: *const c_void,
nonce: *const c_void, credential_values: *const c_void,
rev_reg: *const c_void, witness: *const c_void) -> *const c_void {
let proof_builder = _proof_builder();
let credential_schema = _credential_schema();
let non_credential_schema = _non_credential_schema();
let sub_proof_request = _sub_proof_request();
indy_crypto_cl_proof_builder_add_sub_proof_request(proof_builder,
sub_proof_request,
credential_schema,
non_credential_schema,
credential_signature,
credential_values,
credential_pub_key,
rev_reg,
witness);
let mut proof: *const c_void = ptr::null();
let err_code = indy_crypto_cl_proof_builder_finalize(proof_builder,
nonce,
&mut proof);
assert_eq!(err_code, ErrorCode::Success);
assert!(!proof.is_null());
_free_credential_schema(credential_schema);
_free_non_credential_schema(non_credential_schema);
_free_credential_values(credential_values);
_free_sub_proof_request(sub_proof_request);
proof
}
pub fn _free_proof(proof: *const c_void) {
let err_code = indy_crypto_cl_proof_free(proof);
assert_eq!(err_code, ErrorCode::Success);
}
}