void bisect_sfdlProverExo::exogenous_fAtMidpt(mpq_t& f, mpq_t* a, mpq_t* b) {
mpq_t t2;
mpq_t t3;
alloc_init_scalar(t2);
alloc_init_scalar(t3);
mpq_set_ui(f, 0, 1);
int m = bisect_sfdl_cons::m;
int rctr = 0;
for(int i = 0; i < m; i++) {
mpq_add(t2, a[i], b[i]);
mpq_set_si(t3, bisect_sfdl_cons::fAtMidpt_FUNCTION_STATIC_RANDOM_INT[rctr++], 1);
mpq_mul(t2, t3, t2);
mpq_div_2exp(t2, t2, 1);
mpq_add(f, f, t2);
}
for(int i = 0; i < m; i++) {
for(int j = 0; j < m; j++) {
mpq_add(t2, a[i], b[i]);
mpq_add(t3, a[j], b[j]);
mpq_mul(t2, t2, t3);
mpq_set_si(t3, bisect_sfdl_cons::fAtMidpt_FUNCTION_STATIC_RANDOM_INT[rctr++], 1);
mpq_mul(t2, t2, t3);
mpq_div_2exp(t2, t2, 2);
mpq_add(f, f, t2);
}
}
mpq_clear(t2);
mpq_clear(t3);
}
Verifier::Verifier(int batch, int reps, int ip_size, int opt_answers,
char *prover_url, const char *prover_name) {
batch_size = batch;
num_repetitions = reps;
input_size = ip_size;
optimize_answers = opt_answers;
#if NONINTERACTIVE == 0
alloc_init_vec(&c_values, batch_size * num_repetitions);
#endif
network_bytes_sent = 0;
network_bytes_rcvd = 0;
network_bytes_input_sent = 0;
network_bytes_output_rcvd = 0;
network_send_time_elapsed = 0;
network_rcv_time_elapsed = 0;
if (prover_url[0] != '\0')
init_server_variables(prover_url, prover_name);
alloc_init_scalar(a);
alloc_init_scalar(f_s);
#ifdef INTERFACE_MPI
mkdir(FOLDER_STATE, S_IRWXU);
mkdir(FOLDER_PERSIST_STATE, S_IRWXU);
#endif
}
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);
}
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 PolyEvalD3Prover::
init_state() {
num_bits_in_prime = 192;
num_bits_in_input = 12;
crypto_in_use= CRYPTO_ELGAMAL;
png_in_use = PNG_CHACHA;
Prover::init_state();
size_f1_vec = m;
size_f2_vec = m*m;
size_f3_vec = m*m*m;
num_coefficients = (size_f3_vec + 3*size_f2_vec + 2*size_f1_vec)/6 + (size_f1_vec * size_f1_vec + 3*size_f1_vec)/2 + 1;
num_lin_pcp_queries = NUM_LIN_PCP_QUERIES;
num_local_runs = NUM_LOCAL_RUNS;
alloc_init_vec(&F1, size_f1_vec);
alloc_init_vec(&F2, size_f2_vec);
alloc_init_vec(&F3, size_f3_vec);
alloc_init_vec(&output, expansion_factor);
alloc_init_vec(&variables, size_f1_vec);
alloc_init_vec(&coefficients, num_coefficients);
alloc_init_vec(&f1_q1, size_f1_vec);
alloc_init_vec(&f1_q2, size_f1_vec);
alloc_init_vec(&f1_q3, size_f1_vec);
alloc_init_vec(&f1_q4, size_f1_vec);
alloc_init_vec(&f1_q5, size_f1_vec);
alloc_init_vec(&F1, size_f1_vec);
alloc_init_vec(&f1_commitment, expansion_factor*m);
alloc_init_vec(&f1_consistency, size_f1_vec);
alloc_init_vec(&f2_q1, size_f2_vec);
alloc_init_vec(&f2_q2, size_f2_vec);
alloc_init_vec(&f2_q3, size_f2_vec);
alloc_init_vec(&f2_q4, size_f2_vec);
alloc_init_vec(&F2, size_f2_vec);
alloc_init_vec(&f2_commitment, expansion_factor*size_f2_vec);
alloc_init_vec(&f2_consistency, size_f2_vec);
alloc_init_vec(&f3_q1, size_f3_vec);
alloc_init_vec(&f3_q2, size_f3_vec);
alloc_init_vec(&f3_q3, size_f3_vec);
alloc_init_vec(&f3_q4, size_f3_vec);
alloc_init_vec(&F3, size_f3_vec);
alloc_init_vec(&f3_commitment, expansion_factor*size_f3_vec);
alloc_init_vec(&f3_consistency, size_f3_vec);
alloc_init_vec(&alpha, size_f1_vec+1);
alloc_init_vec(&f_answers, num_lin_pcp_queries);
alloc_init_scalar(neg);
alloc_init_scalar(answer);
alloc_init_scalar(temp);
alloc_init_scalar(temp2);
F_ptrs.clear();
F_ptrs.push_back(F1);
F_ptrs.push_back(F2);
F_ptrs.push_back(F3);
f_q_ptrs.clear();
f_q_ptrs.push_back(f1_q1);
f_q_ptrs.push_back(f2_q1);
f_q_ptrs.push_back(f3_q1);
f_q2_ptrs.clear();
f_q2_ptrs.push_back(f1_q2);
f_q2_ptrs.push_back(f2_q2);
f_q2_ptrs.push_back(f3_q2);
f_q3_ptrs.clear();
f_q3_ptrs.push_back(f1_q3);
f_q3_ptrs.push_back(f2_q3);
f_q3_ptrs.push_back(f3_q3);
find_cur_qlengths();
}
void alloc_init_vec(mpq_t **arr, uint32_t size) {
*arr = new mpq_t[size];
for (uint32_t i=0; i<size; i++) {
alloc_init_scalar((*arr)[i]);
}
}
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::init_state() {
// num_bits_in_prime = 128; this is set in init_qap based on the
// computation for zaatar
num_bits_in_input = 32;
crypto_in_use = CRYPTO_ELGAMAL;
png_in_use = PNG_CHACHA;
num_lin_pcp_queries = NUM_LIN_PCP_QUERIES;
Verifier::init_state();
// allocate input and output contiguously
alloc_init_vec(&input, size_input+size_output);
output = &input[size_input];
alloc_init_vec(&input_q, size_input);
alloc_init_vec(&set_v, size_f2_vec);
#if FAST_FOURIER_INTERPOLATION ==1
alloc_init_scalar(omega);
v->generate_root_of_unity(size_f2_vec, prime);
v->get_root_of_unity(&omega);
v->compute_set_v(size_f2_vec, set_v, omega, prime);
#else
v->compute_set_v(size_f2_vec, set_v, prime);
#endif
alloc_init_vec(&f1_commitment, expansion_factor*size_f1_vec);
alloc_init_vec(&f2_commitment, expansion_factor*size_f2_vec);
alloc_init_vec(&f1_consistency, size_f1_vec);
alloc_init_vec(&f2_consistency, size_f2_vec);
alloc_init_vec(&f1_q1, size_f1_vec);
alloc_init_vec(&f1_q2, size_f1_vec);
alloc_init_vec(&f1_q3, size_f1_vec);
alloc_init_vec(&f1_q4, size_f1_vec);
alloc_init_vec(&f2_q1, size_f2_vec);
alloc_init_vec(&f2_q2, size_f2_vec);
alloc_init_vec(&f2_q3, size_f2_vec);
alloc_init_vec(&f2_q4, size_f2_vec);
alloc_init_vec(&f_answers, num_repetitions * num_lin_pcp_queries);
alloc_init_vec(&temp_arr, expansion_factor);
alloc_init_vec(&temp_arr2, expansion_factor);
alloc_init_scalar(temp);
alloc_init_scalar(temp2);
alloc_init_scalar(temp3);
alloc_init_scalar(lhs);
alloc_init_scalar(rhs);
alloc_init_vec(&d_star, NUM_REPS_PCP);
alloc_init_scalar(A_tau);
alloc_init_scalar(B_tau);
alloc_init_scalar(C_tau);
// To create consistency and commitment queries.
commitment_query_sizes.clear();
commitment_query_sizes.push_back(size_f1_vec);
commitment_query_sizes.push_back(size_f2_vec);
f_commitment_ptrs.clear();
f_commitment_ptrs.push_back(f1_commitment);
f_commitment_ptrs.push_back(f2_commitment);
f_consistency_ptrs.clear();
f_consistency_ptrs.push_back(f1_consistency);
f_consistency_ptrs.push_back(f2_consistency);
temp_arr_ptrs.clear();
temp_arr_ptrs.push_back(temp_arr);
temp_arr_ptrs.push_back(temp_arr2);
Q_list.clear();
for (int i=0; i<NUM_REPS_PCP*NUM_LIN_PCP_QUERIES; i++)
Q_list.push_back(i);
}
void MatrixCubicVerifier::init_state() {
num_bits_in_prime = NUM_BITS_PRIME;
num_bits_in_input = NUM_BITS_INPUT;
crypto_in_use = CRYPTO_ELGAMAL;
png_in_use = PNG_CHACHA;
cout<<"Running verifier with a prime of size "<<num_bits_in_prime<<endl;
hadamard_code_size = input_size * input_size * input_size;
num_lin_pcp_queries = NUM_LIN_PCP_QUERIES;
num_verification_runs = NUM_VERIFICATION_RUNS;
Verifier::init_state();
alloc_init_vec(&input, size_input);
alloc_init_vec(&output, size_output);
alloc_init_vec(&A, size_input);
B = &A[size_input/2];
//alloc_init_vec(&B, size_input);
alloc_init_vec(&C, size_output);
alloc_init_vec(&f1_commitment, expansion_factor*hadamard_code_size);
alloc_init_vec(&f1_consistency, hadamard_code_size);
alloc_init_vec(&f1_q1, hadamard_code_size);
alloc_init_vec(&f1_q2, hadamard_code_size);
alloc_init_vec(&f1_q3, hadamard_code_size);
alloc_init_vec(&f1_q4, hadamard_code_size);
alloc_init_vec(&f2_q1, 2*input_size*input_size);
alloc_init_vec(&f2_q2, 2*input_size*input_size);
alloc_init_vec(&gamma, input_size*input_size);
//alloc_init_vec(&f1_con_coins, num_repetitions * NUM_LIN_PCP_QUERIES);
alloc_init_vec(&f_answers, num_repetitions * num_lin_pcp_queries);
alloc_init_vec(&f1_answers, num_repetitions * num_lin_pcp_queries);
alloc_init_vec(&ckt_answers, 2);
alloc_init_vec(&temp_arr, expansion_factor);
alloc_init_scalar(a1);
alloc_init_scalar(a2);
alloc_init_scalar(a3);
alloc_init_scalar(temp);
alloc_init_scalar(temp2);
// To create consistency and commitment queries.
commitment_query_sizes.clear();
commitment_query_sizes.push_back(hadamard_code_size);
f_commitment_ptrs.clear();
f_commitment_ptrs.push_back(f1_commitment);
f_consistency_ptrs.clear();
f_consistency_ptrs.push_back(f1_consistency);
con_coins_ptrs.clear();
con_coins_ptrs.push_back(f1_con_coins);
temp_arr_ptrs.clear();
temp_arr_ptrs.push_back(temp_arr);
answers_rfetch_ptrs.clear();
answers_rfetch_ptrs.push_back(f1_answers);
answers_ptrs.clear();
answers_ptrs.push_back(f1_answers);
Q_list.clear();
int query_id = 0;
for(int j=0; j<NUM_REPS_LIN; j++) {
Q_list.push_back(query_id++);
Q_list.push_back(query_id++);
Q_list.push_back(query_id++);
}
query_id +=2;
Q_list.push_back(query_id++);
Q_list.push_back(query_id++);
}
