//Refer to apps_sfdl_gen/insertion_sort_q_cons.h for constants to use in this exogenous
//check.
bool insertion_sort_qProverExo::exogenous_check(const mpz_t* input, const mpq_t* input_q,
int num_inputs, const mpz_t* output, const mpq_t* output_q, int num_outputs, mpz_t prime) {
bool lists_equal = true;
#ifdef ENABLE_EXOGENOUS_CHECKING
mpq_t *output_q_recomputed;
alloc_init_vec(&output_q_recomputed, num_inputs);
// call baseline to compute output
baseline(input_q, num_inputs, output_q_recomputed, num_outputs);
mpz_t *output_recomputed;
alloc_init_vec(&output_recomputed, num_outputs);
convert_to_z(num_outputs, output_recomputed, output_q_recomputed, prime);
for(int j = 0; j < num_outputs; j++) {
if (mpz_cmp(output[j], output_recomputed[j]) == 0)
continue;
else
lists_equal = false;
}
clear_vec(num_outputs, output_recomputed);
clear_vec(num_outputs, output_q_recomputed);
#else
gmp_printf("Exogeneous checking disabled\n");
lists_equal = true;
#endif
return lists_equal;
};
// cost of field addition
// cost of generating a random number
void measure_plaintext_ops() {
int size_input = 1000000;
mpz_t *vec1, *vec2, *vec3;
alloc_init_vec(&vec1, size_input);
alloc_init_vec(&vec2, size_input);
alloc_init_vec(&vec3, size_input);
// cost of a field multiplication followed by a field addition
measure_field_mult(size_input, vec1, vec2, vec3, 128, prime_128);
measure_field_mult(size_input, vec1, vec2, vec3, 192, prime_192);
measure_field_mult(size_input, vec1, vec2, vec3, 220, prime_220);
// cost of a regular multiplication followed by an addition
measure_mult(size_input, vec1, vec2, vec3, 32, 32);
measure_mult(size_input, vec1, vec2, vec3, 128, 32);
measure_mult(size_input, vec1, vec2, vec3, 192, 32);
measure_mult(size_input, vec1, vec2, vec3, 220, 32);
measure_mult(size_input, vec1, vec2, vec3, 128, 128);
measure_mult(size_input, vec1, vec2, vec3, 192, 192);
measure_mult(size_input, vec1, vec2, vec3, 220, 220);
measure_div(size_input, vec1, vec2, vec3, 128, 128, prime_128);
measure_div(size_input, vec1, vec2, vec3, 220, 220, prime_220);
// cost of generating pseudorandom numbers
measure_rand(size_input, vec1, 128, prime_128);
measure_rand(size_input, vec1, 192, prime_192);
measure_rand(size_input, vec1, 220, prime_220);
// cleanup
clear_vec(size_input, vec1);
clear_vec(size_input, vec2);
clear_vec(size_input, vec3);
}
Verifier::~Verifier(void) {
#if NONINTERACTIVE == 0
clear_vec(batch_size * num_repetitions, c_values);
clear_vec(num_repetitions * num_lin_pcp_queries, f_con_coins);
#endif
clear_scalar(a);
clear_scalar(f_s);
mpz_clear(prime);
delete v;
delete curl;
}
//Refer to apps_sfdl_gen/bisect_sfdl_cons.h for constants to use in this exogenous
//check.
bool bisect_sfdlProverExo::exogenous_check(const mpz_t* input, const mpq_t* input_q,
int input_size, const mpz_t* output, const mpq_t* output_q, int output_size, mpz_t prime) {
bool success = true;
#ifdef ENABLE_EXOGENOUS_CHECKING
int m = bisect_sfdl_cons::m;
mpq_t* buffer;
alloc_init_vec(&buffer, m + m);
baseline(input_q, input_size, buffer, output_size);
mpq_t* a = buffer;
mpq_t* b = buffer + m;
for(int i = 0; i < m; i++) {
success &= mpq_equal(a[i], output_q[i]);
success &= mpq_equal(b[i], output_q[i+m]);
}
clear_vec(m+m, buffer);
#else
gmp_printf("Exogeneous checking disabled\n");
#endif
return success;
};
/* void vit_dec_reset(void)
* Resets the decoder for new message
* -another part that is hardcoded so needs to be changed for more states
* -sets up decoder with assumption that initial state is 0,0
*/
void vit_dec_reset() {
isOddRec = FALSE;
// int i;
// for(i = 0; i < NUM_STATES; i++) {
// pm[i] = NUM_STATES+1;
// clear_vec(paths[i]);
// }
pm[0] = 0;
pm[1] = NUM_STATES+1;
pm[2] = NUM_STATES+1;
pm[3] = NUM_STATES+1;
clear_vec(paths[0]);
clear_vec(paths[1]);
clear_vec(paths[2]);
clear_vec(paths[3]);
}
//Testing Function
void vit_dec(bv_t dest, bv_t src) {
//printf("%d\n", Trellis[0][2]);
clear_vec(dest);
short i;
short num_bits = src->num_bits;
vit_dec_reset();
// for each bit in src, find the ML set of paths ending at each state
i = num_bits-1;
while(i >= 0) {
if(puncturedRec && isOddRec) {
//printf("m = %d\n", get_bit(src,i));
vit_dec_bmh(get_bit(src,i));
i--;
}
else {
//printf("m = %d\n", get(src,i-1,i));
vit_dec_bmh(get(src,i-1,i));
i -= 2;
}
//vit_dec_ACS();
}
//choose ML path based on node with smallest accumulated pm
vit_dec_get(dest);
}
bool kmapdset_iterator_impl_base::find_pos(const void* k1, const void* k2, bool bulk, const char* func)
{
PortableDataOutput<AutoGrownMemIO> oKey1, oKey2;
m_owner->save_key1(oKey1, k1);
m_owner->save_key2(oKey2, k2);
DBT tk1; memset(&tk1, 0, sizeof(DBT)); tk1.data = oKey1.begin(); tk1.size = oKey1.tell();
DBT tk2; memset(&tk2, 0, sizeof(DBT)); tk2.data = oKey2.begin(); tk2.size = oKey2.tell();
m_ret = m_curp->get(m_curp, &tk1, &tk2, DB_GET_BOTH);
if (0 == m_ret)
{
if (bulk) {
m_ret = m_curp->get(m_curp, &tk1, &m_bulk, DB_CURRENT|DB_MULTIPLE);
if (0 == m_ret) {
bulk_load(&tk1);
return true;
}
} else {
clear_vec();
load_key1(tk1.data, tk1.size);
push_back(tk2.data, tk2.size);
return true;
}
}
else if (DB_NOTFOUND == m_ret)
{
return false;
}
string_appender<> oss;
oss << db_strerror(m_ret)
<< "... at: " << func
<< "\n"
;
throw std::runtime_error(oss.str());
}
void merge_vec_to_file(const QVector<word_t*>& vec, const QString& filename)
{
QVector<word_t*> target_vec;
load_file_to_vec(target_vec, filename);
merge_vec_to_vec(vec, target_vec);
save_vec_to_file(target_vec, filename);
// memory cleanup
clear_vec(target_vec);
}
//Refer to apps_sfdl_gen/fannkuch_cons.h for constants to use in this exogenous
//check.
bool fannkuchProverExo::exogenous_check(const mpz_t* input, const mpq_t* input_q,
int input_size, const mpz_t* output, const mpq_t* output_q, int output_size, mpz_t prime) {
bool success = true;
#ifdef ENABLE_EXOGENOUS_CHECKING
mpq_t *output_recomputed;
alloc_init_vec(&output_recomputed, 1);
baseline(input_q, input_size, output_recomputed, output_size);
success = mpq_class(output_recomputed[0]) == mpq_class(output_q[0]);
clear_vec(1, output_recomputed);
#else
gmp_printf("Exogeneous checking disabled");
#endif
return success;
};
//Refer to apps_sfdl_gen/dna_align_cons.h for constants to use in this exogenous
//check.
bool dna_alignProverExo::exogenous_check(const mpz_t* input, const mpq_t* input_q,
int num_inputs, const mpz_t* output, const mpq_t* output_q, int num_outputs, mpz_t prime) {
#ifdef ENABLE_EXOGENOUS_CHECKING
mpq_t *output_recomputed;
alloc_init_vec(&output_recomputed, num_outputs);
for (int i=0; i<num_outputs; i++)
mpq_set(output_recomputed[i], output_q[i]);
baseline(input_q, num_inputs, output_recomputed, num_outputs);
bool match = mpz_get_ui(mpq_numref(output_recomputed[0]));
clear_vec(num_outputs, output_recomputed);
return match;
#else
cout<<"Exogeneous checking disabled"<<endl;
return true;
#endif
};
//Refer to apps_sfdl_gen/mr_bstore_dotp_map_cons.h for constants to use when generating input.
void mr_bstore_dotp_mapVerifierInpGenHw::create_input(mpq_t* input_q, int num_inputs)
{
mpz_t *exo_input;
alloc_init_vec(&exo_input, 2*SIZE_INPUT);
v->get_random_vec_priv(2*SIZE_INPUT, exo_input, 32);
MapperIn mapper_in;
for (int i=0; i<SIZE_INPUT; i++) {
mapper_in.vec_a[i] = mpz_get_ui(exo_input[i]);
mapper_in.vec_b[i] = mpz_get_ui(exo_input[SIZE_INPUT+i]);
}
hash_t digest;
export_exo_inputs(&mapper_in, sizeof(MapperIn), &digest);
for (int i=0; i<num_inputs; i++) {
mpz_set_ui(mpq_numref(input_q[i]), digest.bit[i]);
}
clear_vec(2*SIZE_INPUT, exo_input);
}
//Refer to apps_sfdl_gen/tolling_cons.h for constants to use in this exogenous
//check.
bool tollingProverExo::exogenous_check(const mpz_t* input, const mpq_t* input_q,
int num_inputs, const mpz_t* output, const mpq_t* output_q, int num_outputs, mpz_t prime) {
bool passed_test = true;
#ifdef ENABLE_EXOGENOUS_CHECKING
mpq_t *output_recomputed;
alloc_init_vec(&output_recomputed, num_outputs);
baseline(input_q, num_inputs, output_recomputed, num_outputs);
for(int i = 0; i < num_outputs; i++) {
if (mpq_equal(output_recomputed[i], output_q[i]) == 0) {
passed_test = false;
break;
}
}
clear_vec(num_outputs, output_recomputed);
#else
gmp_printf("<Exogenous check disabled>\n");
#endif
return passed_test;
};
ZComputationVerifier::~ZComputationVerifier() {
clear_scalar(A_tau);
clear_scalar(B_tau);
clear_scalar(C_tau);
clear_vec(size_input+size_output, input);
clear_vec(size_input, input_q);
clear_vec(size_f2_vec, set_v);
clear_vec(num_repetitions * num_lin_pcp_queries, f_answers);
clear_vec(expansion_factor, temp_arr);
clear_vec(expansion_factor, temp_arr2);
clear_scalar(temp);
clear_scalar(temp2);
clear_scalar(temp3);
clear_scalar(lhs);
clear_scalar(rhs);
clear_vec(NUM_REPS_PCP, d_star);
clear_scalar(omega);
}
void kmapdset_iterator_impl_base::bulk_load(DBT* tk1)
{
NARK_RT_assert(0 == m_ret, std::logic_error);
load_key1(tk1->data, tk1->size);
clear_vec();
int ret;
do {
void *bptr, *data;
DB_MULTIPLE_INIT(bptr, &m_bulk);
assert(NULL != bptr);
for (;;)
{
size_t size = 0;
DB_MULTIPLE_NEXT(bptr, &m_bulk, data, size);
if (nark_likely(NULL != bptr))
this->push_back(data, size);
else
break;
}
ret = m_curp->get(m_curp, tk1, &m_bulk, DB_MULTIPLE|DB_NEXT_DUP);
} while (0 == ret);
}
void ZComputationVerifier::create_plain_queries() {
clear_vec(size_f1_vec*expansion_factor, f1_commitment);
clear_vec(size_f2_vec*expansion_factor, f2_commitment);
m_plainq.begin_with_init();
// keeps track of #filled coins
int f_con_filled = -1;
int query_id;
for (int rho=0; rho<num_repetitions; rho++) {
if (rho == 0) m_plainq.begin_with_init();
else m_plainq.begin_with_history();
// create linearity test queries
query_id = 1;
for (int i=0; i<NUM_REPS_LIN; i++) {
v->create_lin_test_queries(size_f1_vec, f1_q1, f1_q2, f1_q3, f1_consistency,
f_con_filled, f_con_coins, prime);
f_con_filled += 3;
v->create_lin_test_queries(size_f2_vec, f2_q1, f2_q2, f2_q3, f2_consistency,
f_con_filled, f_con_coins, prime);
f_con_filled += 3;
//TODO: can be folded into a function
/*
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q1, scratch_str);
send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q2, scratch_str);
send_file(scratch_str);
// don't dump, but increment query_id
query_id++;
//snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
//dump_vector(size_f1_vec, f1_q3, scratch_str);
//send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q1, scratch_str);
send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q2, scratch_str);
send_file(scratch_str);
query_id++;
//snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
//dump_vector(size_f2_vec, f2_q3, scratch_str);
//send_file(scratch_str);
*/
// use one of the linearity queries as self correction queries
if (i == 0) {
for (int i=0; i<size_f1_vec; i++)
mpz_set(f1_q4[i], f1_q1[i]);
for (int i=0; i<size_f2_vec; i++)
mpz_set(f2_q4[i], f2_q1[i]);
}
}
for (int i=0; i<n+1; i++) {
mpz_set_ui(eval_poly_A[i], 0);
mpz_set_ui(eval_poly_B[i], 0);
mpz_set_ui(eval_poly_C[i], 0);
}
// create zquad correction queries: create q9, q10, q11, and q12
v->create_div_corr_test_queries(n, size_f1_vec, size_f2_vec, f1_q1, f1_q2, f1_q3, f2_q1, f_con_coins, f_con_filled, f1_consistency, f_con_coins, f_con_filled+3, f2_consistency, f1_q4, f2_q4, d_star[rho], num_aij, num_bij, num_cij, set_v, poly_A, poly_B, poly_C, eval_poly_A, eval_poly_B, eval_poly_C, prime);
f_con_filled += 4;
int base = rho * (1 + size_input + size_output);
mpz_set(A_tau_io[base+0], eval_poly_A[0]);
mpz_set(B_tau_io[base+0], eval_poly_B[0]);
mpz_set(C_tau_io[base+0], eval_poly_C[0]);
for (int i=0; i<size_input+size_output; i++) {
mpz_set(A_tau_io[base+1+i], eval_poly_A[1+n_prime+i]);
mpz_set(B_tau_io[base+1+i], eval_poly_B[1+n_prime+i]);
mpz_set(C_tau_io[base+1+i], eval_poly_C[1+n_prime+i]);
}
/*
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q1, scratch_str);
send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q2, scratch_str);
send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f1_vec, f1_q3, scratch_str);
send_file(scratch_str);
snprintf(scratch_str, BUFLEN-1, "q%d_qquery_r_%d", query_id++, rho);
dump_vector(size_f2_vec, f2_q1, scratch_str);
send_file(scratch_str);
*/
}
dump_vector(size_f1_vec, f1_consistency, (char *)"f1_consistency_query");
send_file((char *)"f1_consistency_query");
dump_vector(size_f2_vec, f2_consistency, (char *)"f2_consistency_query");
send_file((char *)"f2_consistency_query");
m_plainq.end();
// cleanup time
clear_vec(n+1, eval_poly_A);
clear_vec(n+1, eval_poly_B);
clear_vec(n+1, eval_poly_C);
clear_vec(size_f1_vec, f1_consistency);
clear_vec(size_f2_vec, f2_consistency);
for (int i=0; i<num_aij; i++)
clear_scalar(poly_A[i].coefficient);
for (int i=0; i<num_bij; i++)
clear_scalar(poly_B[i].coefficient);
for (int i=0; i<num_cij; i++)
clear_scalar(poly_C[i].coefficient);
free(poly_A);
free(poly_B);
free(poly_C);
clear_vec(size_f1_vec, f1_q1);
clear_vec(size_f1_vec, f1_q2);
clear_vec(size_f1_vec, f1_q3);
clear_vec(size_f1_vec, f1_q4);
clear_vec(size_f2_vec, f2_q1);
clear_vec(size_f2_vec, f2_q2);
clear_vec(size_f2_vec, f2_q3);
clear_vec(size_f2_vec, f2_q4);
// Ginger's codebase did some run test part of work in plain query
// creation; so the base class calls with history;
m_runtests.reset();
}
/** void setupDecoder(void)
/ Uses the current Convolutional Encoder to generate
/ the appropriate tables for an efficient Viterbi decoder
/ Should be called in main() before interrupt initialized
*/
void setupDecoder() {
setPuncturing(FALSE);
int i;
int j;
bv_t a = malloc (sizeof(struct bitvec));
bv_new(a, 1);
bv_t b = malloc (sizeof(struct bitvec));
bv_new(b, 1);
//*** this finds the properties of each state
//generate the trellis (messages produced by state transitions)
//generate decoding given two states
for(i = 0; i < NUM_STATES; i++) {
for(j = 0; j < NUM_STATES; j++) {
Trellis[i][j] = -1;
Decode[i][j] = -1;
if(j < 2)
InverseTransitions[i][j] = -1;
}
}
// Trellis[0][0] = Trellis[1][2] = 0;
// Trellis[1][0] = Trellis[0][2] = 3;
// Trellis[2][1] = Trellis[3][3] = 1;
// Trellis[3][1] = Trellis[2][3] = 2;
for(i = 0; i < NUM_STATES; i++) {
clear_vec(a);
clear_vec(b);
//get message and next state for input 0
setState(i);
encode(a,0);
Transitions[i][0] = getState();
if(InverseTransitions[getState()][0] == -1)
InverseTransitions[getState()][0] = i;
else
InverseTransitions[getState()][1] = i;
Trellis[i][getState()] = get(a,0,1);
Decode[i][getState()] = 0;
//get message and next state for input 1
setState(i);
encode(b,1);
Transitions[i][1] = getState();
if(InverseTransitions[getState()][0] == -1)
InverseTransitions[getState()][0] = i;
else
InverseTransitions[getState()][1] = i;
Trellis[i][getState()] = get(b,0,1);
Decode[i][getState()] = 1;
//initialize the decoded survivor paths
paths[i] = malloc(sizeof(struct bitvec));
bv_new(paths[i], 32);
paths_next[i] = malloc (sizeof(struct bitvec));
bv_new(paths_next[i], 32);
}
// for(i = 0; i < NUM_CODES; i++) {
// for(j = 0; j < 2; j++) {
// printf("%d: %d -> %d \n", Decode[i][Transitions[i][j]], i, Transitions[i][j]);
// }
// }
// for(i = 0; i < NUM_CODES; i++) {
// for(j = 0; j < 2; j++) {
// printf("%d: %d -> %d \n", Decode[InverseTransitions[i][j]][i], InverseTransitions[i][j], i);
// }
// }
for(i = 0; i < NUM_CODES; i++) {
for(j = 0; j < NUM_CODES; j++) {
printf("%d ", Trellis[i][j]);
}
printf("\n");
}
printf("Hamming distance \n");
//pre-generate hamming distances for all messages
for(i = 0; i < NUM_CODES; i++) {
load(a,i);
for(j = 0; j < NUM_CODES; j++) {
load(b,j);
HammingDistance[i][j] = hammingDistance(a,b);
printf("%d ", HammingDistance[i][j]);
}
printf("\n");
}
//reset the encoder and decoder
clearState();
vit_dec_reset();
bv_free(a);
bv_free(b);
free(a);
free(b);
//set puncturing (only accomodates 2/3 puncture)
setPuncturing(puncturedRec);
}
