void test_exhaustive_addition(const secp256k1_ge *group, const secp256k1_gej *groupj, int order) { int i, j; /* Sanity-check (and check infinity functions) */ CHECK(secp256k1_ge_is_infinity(&group[0])); CHECK(secp256k1_gej_is_infinity(&groupj[0])); for (i = 1; i < order; i++) { CHECK(!secp256k1_ge_is_infinity(&group[i])); CHECK(!secp256k1_gej_is_infinity(&groupj[i])); } /* Check all addition formulae */ for (j = 0; j < order; j++) { secp256k1_fe fe_inv; secp256k1_fe_inv(&fe_inv, &groupj[j].z); for (i = 0; i < order; i++) { secp256k1_ge zless_gej; secp256k1_gej tmp; /* add_var */ secp256k1_gej_add_var(&tmp, &groupj[i], &groupj[j], NULL); ge_equals_gej(&group[(i + j) % order], &tmp); /* add_ge */ if (j > 0) { secp256k1_gej_add_ge(&tmp, &groupj[i], &group[j]); ge_equals_gej(&group[(i + j) % order], &tmp); } /* add_ge_var */ secp256k1_gej_add_ge_var(&tmp, &groupj[i], &group[j], NULL); ge_equals_gej(&group[(i + j) % order], &tmp); /* add_zinv_var */ zless_gej.infinity = groupj[j].infinity; zless_gej.x = groupj[j].x; zless_gej.y = groupj[j].y; secp256k1_gej_add_zinv_var(&tmp, &groupj[i], &zless_gej, &fe_inv); ge_equals_gej(&group[(i + j) % order], &tmp); } } /* Check doubling */ for (i = 0; i < order; i++) { secp256k1_gej tmp; if (i > 0) { secp256k1_gej_double_nonzero(&tmp, &groupj[i], NULL); ge_equals_gej(&group[(2 * i) % order], &tmp); } secp256k1_gej_double_var(&tmp, &groupj[i], NULL); ge_equals_gej(&group[(2 * i) % order], &tmp); } /* Check negation */ for (i = 1; i < order; i++) { secp256k1_ge tmp; secp256k1_gej tmpj; secp256k1_ge_neg(&tmp, &group[i]); ge_equals_ge(&group[order - i], &tmp); secp256k1_gej_neg(&tmpj, &groupj[i]); ge_equals_gej(&group[order - i], &tmpj); } }
void bench_group_add_var(void* arg) { int i; bench_inv_t *data = (bench_inv_t*)arg; for (i = 0; i < 200000; i++) { secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y, NULL); } }
static void bench_ecmult_teardown(void* arg) { bench_data* data = (bench_data*)arg; size_t iters = 1 + ITERS / data->count; size_t iter; /* Verify the results in teardown, to avoid doing comparisons while benchmarking. */ for (iter = 0; iter < iters; ++iter) { secp256k1_gej tmp; secp256k1_gej_add_var(&tmp, &data->output[iter], &data->expected_output[iter], NULL); CHECK(secp256k1_gej_is_infinity(&tmp)); } }
void test_point_times_order(const secp256k1_gej_t *point) { /* X * (point + G) + (order-X) * (pointer + G) = 0 */ secp256k1_scalar_t x; random_scalar_order_test(&x); secp256k1_scalar_t nx; secp256k1_scalar_negate(&nx, &x); secp256k1_gej_t res1, res2; secp256k1_ecmult(&res1, point, &x, &x); /* calc res1 = x * point + x * G; */ secp256k1_ecmult(&res2, point, &nx, &nx); /* calc res2 = (order - x) * point + (order - x) * G; */ secp256k1_gej_add_var(&res1, &res1, &res2); CHECK(secp256k1_gej_is_infinity(&res1)); CHECK(secp256k1_gej_is_valid(&res1) == 0); secp256k1_ge_t res3; secp256k1_ge_set_gej(&res3, &res1); CHECK(secp256k1_ge_is_infinity(&res3)); CHECK(secp256k1_ge_is_valid(&res3) == 0); }
void test_ge(void) { char ca[135]; char cb[68]; int rlen; secp256k1_ge_t a, b, i, n; random_group_element_test(&a); random_group_element_test(&b); rlen = sizeof(ca); secp256k1_ge_get_hex(ca,&rlen,&a); CHECK(rlen > 4 && rlen <= (int)sizeof(ca)); rlen = sizeof(cb); secp256k1_ge_get_hex(cb,&rlen,&b); /* Intentionally undersized buffer. */ n = a; secp256k1_fe_normalize(&a.y); secp256k1_fe_negate(&n.y, &a.y, 1); secp256k1_ge_set_infinity(&i); random_field_element_magnitude(&a.x); random_field_element_magnitude(&a.y); random_field_element_magnitude(&b.x); random_field_element_magnitude(&b.y); random_field_element_magnitude(&n.x); random_field_element_magnitude(&n.y); secp256k1_gej_t aj, bj, ij, nj; random_group_element_jacobian_test(&aj, &a); random_group_element_jacobian_test(&bj, &b); secp256k1_gej_set_infinity(&ij); random_group_element_jacobian_test(&nj, &n); random_field_element_magnitude(&aj.x); random_field_element_magnitude(&aj.y); random_field_element_magnitude(&aj.z); random_field_element_magnitude(&bj.x); random_field_element_magnitude(&bj.y); random_field_element_magnitude(&bj.z); random_field_element_magnitude(&nj.x); random_field_element_magnitude(&nj.y); random_field_element_magnitude(&nj.z); /* gej + gej adds */ secp256k1_gej_t aaj; secp256k1_gej_add_var(&aaj, &aj, &aj); secp256k1_gej_t abj; secp256k1_gej_add_var(&abj, &aj, &bj); secp256k1_gej_t aij; secp256k1_gej_add_var(&aij, &aj, &ij); secp256k1_gej_t anj; secp256k1_gej_add_var(&anj, &aj, &nj); secp256k1_gej_t iaj; secp256k1_gej_add_var(&iaj, &ij, &aj); secp256k1_gej_t iij; secp256k1_gej_add_var(&iij, &ij, &ij); /* gej + ge adds */ secp256k1_gej_t aa; secp256k1_gej_add_ge_var(&aa, &aj, &a); secp256k1_gej_t ab; secp256k1_gej_add_ge_var(&ab, &aj, &b); secp256k1_gej_t ai; secp256k1_gej_add_ge_var(&ai, &aj, &i); secp256k1_gej_t an; secp256k1_gej_add_ge_var(&an, &aj, &n); secp256k1_gej_t ia; secp256k1_gej_add_ge_var(&ia, &ij, &a); secp256k1_gej_t ii; secp256k1_gej_add_ge_var(&ii, &ij, &i); /* const gej + ge adds */ secp256k1_gej_t aac; secp256k1_gej_add_ge(&aac, &aj, &a); secp256k1_gej_t abc; secp256k1_gej_add_ge(&abc, &aj, &b); secp256k1_gej_t anc; secp256k1_gej_add_ge(&anc, &aj, &n); secp256k1_gej_t iac; secp256k1_gej_add_ge(&iac, &ij, &a); CHECK(secp256k1_gej_is_infinity(&an)); CHECK(secp256k1_gej_is_infinity(&anj)); CHECK(secp256k1_gej_is_infinity(&anc)); gej_equals_gej(&aa, &aaj); gej_equals_gej(&aa, &aac); gej_equals_gej(&ab, &abj); gej_equals_gej(&ab, &abc); gej_equals_gej(&an, &anj); gej_equals_gej(&an, &anc); gej_equals_gej(&ia, &iaj); gej_equals_gej(&ai, &aij); gej_equals_gej(&ii, &iij); ge_equals_gej(&a, &ai); ge_equals_gej(&a, &ai); ge_equals_gej(&a, &iaj); ge_equals_gej(&a, &iaj); ge_equals_gej(&a, &iac); }
void precomputeTable(int window_size){ secp256k1_gej_t gj; // base point in jacobian coordinates secp256k1_gej_t *table; WINDOW_SIZE = window_size; numberOfValues = (int) pow(2.0,window_size); if (256 % window_size == 0){ numberOfWindows = (256 / window_size); }else{ numberOfWindows = (256 / window_size) + 1; } remmining = 256 % window_size; table = (secp256k1_gej_t *)malloc(numberOfWindows*numberOfValues*sizeof(secp256k1_gej_t)); prec = (secp256k1_ge_t *)malloc(numberOfWindows*numberOfValues*sizeof(secp256k1_ge_t)); secp256k1_gej_set_ge(&gj, &secp256k1_ge_const_g); printf("%d %d %d %d\n",window_size,numberOfWindows,numberOfValues,remmining); secp256k1_ge_const_g; { static const unsigned char nums_b32[33] = "The scalar for this x is unknown"; secp256k1_fe_t nums_x; secp256k1_ge_t nums_ge; VERIFY_CHECK(secp256k1_fe_set_b32(&nums_x, nums_b32)); VERIFY_CHECK(secp256k1_ge_set_xo_var(&nums_ge, &nums_x, 0)); secp256k1_gej_set_ge(&nums_gej, &nums_ge); /* Add G to make the bits in x uniformly distributed. */ secp256k1_gej_add_ge_var(&nums_gej, &nums_gej, &secp256k1_ge_const_g, NULL); } secp256k1_gej_t gbase; secp256k1_gej_t numsbase; gbase = gj; /* (2^w_size)^num_of_windows * G */ numsbase = nums_gej; /* 2^num_of_windows * nums. */ for (int j = 0; j < numberOfWindows; j++) { //[number of windows][each value from 0 - (2^window_size - 1)] table[j*numberOfValues] = numsbase; for (int i = 1; i < numberOfValues; i++) { secp256k1_gej_add_var(&table[j*numberOfValues + i], &table[j*numberOfValues + i - 1], &gbase, NULL); } for (int i = 0; i < window_size; i++) { secp256k1_gej_double_var(&gbase, &gbase, NULL); } /* Multiply numbase by 2. */ secp256k1_gej_double_var(&numsbase, &numsbase, NULL); if (j == numberOfWindows-2) { /* In the last iteration, numsbase is (1 - 2^j) * nums instead. */ secp256k1_gej_neg(&numsbase, &numsbase); secp256k1_gej_add_var(&numsbase, &numsbase, &nums_gej, NULL); } } secp256k1_ge_set_all_gej_var(numberOfWindows*numberOfValues, prec, table, 0); printf(""); free(table); }
void test_ge(void) { secp256k1_ge_t a, b, i, n; random_group_element_test(&a); random_group_element_test(&b); n = a; secp256k1_fe_normalize(&a.y); secp256k1_fe_negate(&n.y, &a.y, 1); secp256k1_ge_set_infinity(&i); random_field_element_magnitude(&a.x); random_field_element_magnitude(&a.y); random_field_element_magnitude(&b.x); random_field_element_magnitude(&b.y); random_field_element_magnitude(&n.x); random_field_element_magnitude(&n.y); secp256k1_gej_t aj, bj, ij, nj; random_group_element_jacobian_test(&aj, &a); random_group_element_jacobian_test(&bj, &b); secp256k1_gej_set_infinity(&ij); random_group_element_jacobian_test(&nj, &n); random_field_element_magnitude(&aj.x); random_field_element_magnitude(&aj.y); random_field_element_magnitude(&aj.z); random_field_element_magnitude(&bj.x); random_field_element_magnitude(&bj.y); random_field_element_magnitude(&bj.z); random_field_element_magnitude(&nj.x); random_field_element_magnitude(&nj.y); random_field_element_magnitude(&nj.z); /* gej + gej adds */ secp256k1_gej_t aaj; secp256k1_gej_add_var(&aaj, &aj, &aj); secp256k1_gej_t abj; secp256k1_gej_add_var(&abj, &aj, &bj); secp256k1_gej_t aij; secp256k1_gej_add_var(&aij, &aj, &ij); secp256k1_gej_t anj; secp256k1_gej_add_var(&anj, &aj, &nj); secp256k1_gej_t iaj; secp256k1_gej_add_var(&iaj, &ij, &aj); secp256k1_gej_t iij; secp256k1_gej_add_var(&iij, &ij, &ij); /* gej + ge adds */ secp256k1_gej_t aa; secp256k1_gej_add_ge_var(&aa, &aj, &a); secp256k1_gej_t ab; secp256k1_gej_add_ge_var(&ab, &aj, &b); secp256k1_gej_t ai; secp256k1_gej_add_ge_var(&ai, &aj, &i); secp256k1_gej_t an; secp256k1_gej_add_ge_var(&an, &aj, &n); secp256k1_gej_t ia; secp256k1_gej_add_ge_var(&ia, &ij, &a); secp256k1_gej_t ii; secp256k1_gej_add_ge_var(&ii, &ij, &i); /* const gej + ge adds */ secp256k1_gej_t aac; secp256k1_gej_add_ge(&aac, &aj, &a); secp256k1_gej_t abc; secp256k1_gej_add_ge(&abc, &aj, &b); secp256k1_gej_t anc; secp256k1_gej_add_ge(&anc, &aj, &n); secp256k1_gej_t iac; secp256k1_gej_add_ge(&iac, &ij, &a); CHECK(secp256k1_gej_is_infinity(&an)); CHECK(secp256k1_gej_is_infinity(&anj)); CHECK(secp256k1_gej_is_infinity(&anc)); gej_equals_gej(&aa, &aaj); gej_equals_gej(&aa, &aac); gej_equals_gej(&ab, &abj); gej_equals_gej(&ab, &abc); gej_equals_gej(&an, &anj); gej_equals_gej(&an, &anc); gej_equals_gej(&ia, &iaj); gej_equals_gej(&ai, &aij); gej_equals_gej(&ii, &iij); ge_equals_gej(&a, &ai); ge_equals_gej(&a, &ai); ge_equals_gej(&a, &iaj); ge_equals_gej(&a, &iaj); ge_equals_gej(&a, &iac); }