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;
}
double do_regular_ciphermul(int size_input, mpz_t *plain, mpz_t *cipher,
int prime_size, mpz_t prime) {
mpz_t out1, out2;
alloc_init_scalar(out1);
alloc_init_scalar(out2);
Measurement m;
m.begin_with_init();
crypto->dot_product_regular_enc(size_input, cipher, plain, out1, out2);
m.end();
clear_scalar(out1);
clear_scalar(out2);
return m.get_ru_elapsed_time();
}
void bisect_sfdlProverExo::baseline(const mpq_t* input_q, int num_inputs,
mpq_t* output_recomputed, int num_outputs) {
int m = bisect_sfdl_cons::m;
int L = bisect_sfdl_cons::L;
mpq_t temp_q;
alloc_init_scalar(temp_q);
mpq_t* a = output_recomputed;
mpq_t* b = output_recomputed + m;
mpq_t& f = temp_q;
for(int i = 0; i < m; i++) {
mpq_set(a[i], input_q[i]);
mpq_set(b[i], input_q[i+m]);
}
for(int i = 0; i < L; i++) {
exogenous_fAtMidpt(f, a, b);
if (mpq_sgn(f) > 0) {
for(int j = 0; j < m; j++) {
mpq_add(b[j], a[j], b[j]);
mpq_div_2exp(b[j], b[j], 1);
}
} else {
for(int j = 0; j < m; j++) {
mpq_add(a[j], a[j], b[j]);
mpq_div_2exp(a[j], a[j], 1);
}
}
}
clear_scalar(temp_q);
}
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);
}
int main(int argc, char **argv) {
// TODO: the parameter "128" below should be made "192" or "220"
// depending on the field size. Modify the code to create one crypto
// object for each field size. This matters for performance of
// encryption
crypto = new Crypto(CRYPTO_TYPE_PRIVATE, CRYPTO_ELGAMAL, PNG_CHACHA, false, 128, 1024, 160);
alloc_init_scalar(prime_128);
alloc_init_scalar(prime_192);
alloc_init_scalar(prime_220);
load_prime(128, prime_128);
load_prime(192, prime_192);
load_prime(220, prime_220);
measure_plaintext_ops();
measure_ciphertext_ops();
delete crypto;
clear_scalar(prime_128);
clear_scalar(prime_192);
clear_scalar(prime_220);
return 0;
}
void ZComputationVerifier::init_qap(const char *file_name_qap) {
// compute these based on values set by the compiler
poly_A = (poly_compressed *) malloc(num_aij * sizeof(poly_compressed));
poly_B = (poly_compressed *) malloc(num_bij * sizeof(poly_compressed));
poly_C = (poly_compressed *) malloc(num_cij * sizeof(poly_compressed));
for (int i=0; i<num_aij; i++)
alloc_init_scalar(poly_A[i].coefficient);
for (int i=0; i<num_bij; i++)
alloc_init_scalar(poly_B[i].coefficient);
for (int i=0; i<num_cij; i++)
alloc_init_scalar(poly_C[i].coefficient);
// create vectors to store the evaluations of the polynomial at tau
alloc_init_vec(&eval_poly_A, n+1);
alloc_init_vec(&eval_poly_B, n+1);
alloc_init_vec(&eval_poly_C, n+1);
alloc_init_vec(&A_tau_io, num_repetitions*(size_input+size_output+1));
alloc_init_vec(&B_tau_io, num_repetitions*(size_input+size_output+1));
alloc_init_vec(&C_tau_io, num_repetitions*(size_input+size_output+1));
// open the file
FILE *fp = fopen(file_name_qap, "r");
if (fp == NULL) {
cout<<"Cannot read "<<file_name_qap<<endl;
exit(1);
}
char line[BUFLEN];
mpz_t temp;
alloc_init_scalar(temp);
// fill the array of struct: poly_A, poly_B, and poly_C
int line_num = 0;
while (fgets(line, sizeof line, fp) != NULL) {
if (line[0] == '\n')
continue;
if (line_num < num_aij) {
gmp_sscanf(line, "%d %d %Zd", &poly_A[line_num].i, &poly_A[line_num].j, poly_A[line_num].coefficient);
} else if (line_num >= num_aij && line_num < num_aij+num_bij) {
gmp_sscanf(line, "%d %d %Zd", &poly_B[line_num-num_aij].i, &poly_B[line_num-num_aij].j, poly_B[line_num-num_aij].coefficient);
} else {
gmp_sscanf(line, "%d %d %Zd", &poly_C[line_num-num_aij-num_bij].i, &poly_C[line_num-num_aij-num_bij].j, poly_C[line_num-num_aij-num_bij].coefficient);
}
line_num++;
}
fclose(fp);
clear_scalar(temp);
// set prime size based on name of the computation in case of Zaatar
string str(file_name_qap);
if (str.find("bisect_sfdl") != std::string::npos) {
num_bits_in_prime = 220;
} else if (str.find("pd2_sfdl") != std::string::npos) {
num_bits_in_prime = 220;
} else {
num_bits_in_prime = 128;
}
cout<<"LOG: Using a prime of size "<<num_bits_in_prime<<endl;
}
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();
}
