void pp_map_tatep_k2(fp2_t r, ep_t p, ep_t q) {
ep_t _p[1], _q[1], t[1];
bn_t n;
ep_null(_p[0]);
ep_null(_q[0]);
ep_null(t[0]);
bn_null(n);
TRY {
ep_new(t[0]);
bn_new(n);
ep_norm(_p[0], p);
ep_norm(_q[0], q);
ep_curve_get_ord(n);
/* Since p has order n, we do not have to perform last iteration. */
bn_sub_dig(n, n, 1);
fp2_set_dig(r, 1);
if (!ep_is_infty(p) && !ep_is_infty(q)) {
pp_mil_k2(r, t, _p, _q, 1, n);
pp_exp_k2(r, r);
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
ep_free(_p[0]);
ep_free(_q[0]);
ep_free(t[0]);
bn_free(n);
}
}
void pp_map_weilp_k2(fp2_t r, ep_t p, ep_t q) {
ep_t _p[1], _q[1], t0[1], t1[1];
fp2_t r0, r1;
bn_t n;
ep_null(_p[0]);
ep_null(_q[0]);
ep_null(t0[0]);
ep_null(t1[0]);
fp2_null(r0);
fp2_null(r1);
bn_null(n);
TRY {
ep_new(_p[0]);
ep_new(_q[0]);
ep_new(t0[0]);
ep_new(t1[0]);
fp2_new(r0);
fp2_new(r1);
bn_new(n);
ep_norm(_p[0], p);
ep_norm(_q[0], q);
ep_curve_get_ord(n);
/* Since p has order n, we do not have to perform last iteration. */
bn_sub_dig(n, n, 1);
fp2_set_dig(r0, 1);
fp2_set_dig(r1, 1);
if (!ep_is_infty(_p[0]) && !ep_is_infty(_q[0])) {
pp_mil_lit_k2(r0, t0, _p, _q, 1, n);
pp_mil_k2(r1, t1, _q, _p, 1, n);
fp2_inv(r1, r1);
fp2_mul(r0, r0, r1);
fp2_inv(r1, r0);
fp2_inv_uni(r0, r0);
}
fp2_mul(r, r0, r1);
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
ep_free(_p[0]);
ep_free(_q[0]);
ep_free(t0[0]);
ep_free(t1[0]);
fp2_free(r0);
fp2_free(r1);
bn_free(n);
}
}
void ep_add_projc(ep_t r, const ep_t p, const ep_t q) {
if (ep_is_infty(p)) {
ep_copy(r, q);
return;
}
if (ep_is_infty(q)) {
ep_copy(r, p);
return;
}
ep_add_projc_imp(r, p, q);
}
void ep_add_slp_basic(ep_t r, fp_t s, const ep_t p, const ep_t q) {
if (ep_is_infty(p)) {
ep_copy(r, q);
return;
}
if (ep_is_infty(q)) {
ep_copy(r, p);
return;
}
ep_add_basic_imp(r, s, p, q);
}
void ep_dbl_basic(ep_t r, const ep_t p) {
if (ep_is_infty(p)) {
ep_set_infty(r);
return;
}
ep_dbl_basic_imp(r, NULL, p);
}
int ep_size_bin(const ep_t a, int pack) {
ep_t t;
int size = 0;
ep_null(t);
if (ep_is_infty(a)) {
return 1;
}
TRY {
ep_new(t);
ep_norm(t, a);
size = 1 + FP_BYTES;
if (!pack) {
size += FP_BYTES;
}
} CATCH_ANY {
THROW(ERR_CAUGHT);
} FINALLY {
ep_free(t);
}
return size;
}
void ep_dbl_slp_basic(ep_t r, fp_t s, const ep_t p) {
if (ep_is_infty(p)) {
ep_set_infty(r);
return;
}
ep_dbl_basic_imp(r, s, p);
}
void pp_map_sim_tatep_k2(fp2_t r, ep_t *p, ep_t *q, int m) {
ep_t _p[m], _q[m], t[m];
bn_t n;
int i, j;
bn_null(n);
TRY {
bn_new(n);
for (i = 0; i < m; i++) {
ep_null(_p[i]);
ep_null(_q[i]);
ep_null(t[i]);
ep_new(_p[i]);
ep_new(_q[i]);
ep_new(t[i]);
}
j = 0;
for (i = 0; i < m; i++) {
if (!ep_is_infty(p[i]) && !ep_is_infty(q[i])) {
ep_norm(_p[j], p[i]);
ep_norm(_q[j++], q[i]);
}
}
ep_curve_get_ord(n);
fp2_set_dig(r, 1);
if (j > 0) {
pp_mil_k2(r, t, _p, _q, j, n);
pp_exp_k2(r, r);
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
bn_free(n);
for (i = 0; i < m; i++) {
ep_free(_p[i]);
ep_free(_q[i]);
ep_free(t[i]);
}
}
}
void ep_dbl_projc(ep_t r, const ep_t p) {
if (ep_is_infty(p)) {
ep_set_infty(r);
return;
}
if (fp_is_zero(p->x)) {
ep_set_infty(r);
return;
}
ep_dbl_projc_imp(r, p);
}
void ep_mul_sim_inter(ep_t r, const ep_t p, const bn_t k, const ep_t q,
const bn_t m) {
if (bn_is_zero(k) || ep_is_infty(p)) {
ep_mul(r, q, m);
return;
}
if (bn_is_zero(m) || ep_is_infty(q)) {
ep_mul(r, p, k);
return;
}
#if defined(EP_ENDOM)
if (ep_curve_is_endom()) {
ep_mul_sim_endom(r, p, k, q, m, NULL);
return;
}
#endif
#if defined(EP_PLAIN) || defined(EP_SUPER)
ep_mul_sim_plain(r, p, k, q, m, NULL);
#endif
}
void ep_mul_sim_gen(ep_t r, const bn_t k, const ep_t q, const bn_t m) {
ep_t g;
ep_null(g);
if (bn_is_zero(k)) {
ep_mul(r, q, m);
return;
}
if (bn_is_zero(m) || ep_is_infty(q)) {
ep_mul_gen(r, k);
return;
}
TRY {
ep_new(g);
ep_curve_get_gen(g);
#if defined(EP_ENDOM)
#if EP_SIM == INTER && EP_FIX == LWNAF && defined(EP_PRECO)
if (ep_curve_is_endom()) {
ep_mul_sim_endom(r, g, k, q, m, ep_curve_get_tab());
}
#else
if (ep_curve_is_endom()) {
ep_mul_sim(r, g, k, q, m);
}
#endif
#endif
#if defined(EP_PLAIN) || defined(EP_SUPER)
#if EP_SIM == INTER && EP_FIX == LWNAF && defined(EP_PRECO)
if (!ep_curve_is_endom()) {
ep_mul_sim_plain(r, g, k, q, m, ep_curve_get_tab());
}
#else
if (!ep_curve_is_endom()) {
ep_mul_sim(r, g, k, q, m);
}
#endif
#endif
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
ep_free(g);
}
}
void ep_neg_projc(ep_t r, const ep_t p) {
if (ep_is_infty(p)) {
ep_set_infty(r);
return;
}
if (r != p) {
fp_copy(r->x, p->x);
fp_copy(r->z, p->z);
}
fp_neg(r->y, p->y);
r->norm = p->norm;
}
void ep_write_bin(uint8_t *bin, int len, const ep_t a, int pack) {
ep_t t;
ep_null(t);
if (ep_is_infty(a)) {
if (len != 1) {
THROW(ERR_NO_BUFFER);
} else {
bin[0] = 0;
return;
}
}
TRY {
ep_new(t);
ep_norm(t, a);
if (pack) {
if (len != FP_BYTES + 1) {
THROW(ERR_NO_BUFFER);
} else {
ep_pck(t, t);
bin[0] = 2 | fp_get_bit(t->y, 0);
fp_write_bin(bin + 1, FP_BYTES, t->x);
}
} else {
if (len != 2 * FP_BYTES + 1) {
THROW(ERR_NO_BUFFER);
} else {
bin[0] = 4;
fp_write_bin(bin + 1, FP_BYTES, t->x);
fp_write_bin(bin + FP_BYTES + 1, FP_BYTES, t->y);
}
}
} CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
ep_free(t);
}
}
int ep_is_valid(const ep_t p) {
ep_t t;
int r = 0;
ep_null(t);
TRY {
ep_new(t);
ep_norm(t, p);
ep_rhs(t->x, t);
fp_sqr(t->y, t->y);
r = (fp_cmp(t->x, t->y) == CMP_EQ) || ep_is_infty(p);
} CATCH_ANY {
THROW(ERR_CAUGHT);
} FINALLY {
ep_free(t);
}
return r;
}
void pp_map_tatep_k12(fp12_t r, ep_t p, ep2_t q) {
ep_t _p[1], t[1];
ep2_t _q[1];
bn_t n;
ep_null(_p[0]);
ep_null(t[0]);
ep2_null(_q[0]);
bn_null(n);
TRY {
ep_new(_p[0]);
ep_new(t[0]);
ep2_new(_q[0]);
bn_new(n);
ep_norm(_p[0], p);
ep2_norm(_q[0], q);
ep_curve_get_ord(n);
fp12_set_dig(r, 1);
if (!ep_is_infty(p) && !ep2_is_infty(q)) {
pp_mil_lit_k12(r, t, _p, _q, 1, n);
pp_exp_k12(r, r);
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
ep_free(_p[0]);
ep_free(t[0]);
ep2_free(_q[0]);
bn_free(n);
}
}
void pp_map_sim_weilp_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
ep_t _p[m], t0[m];
ep2_t _q[m], t1[m];
fp12_t r0, r1;
bn_t n;
int i, j;
fp12_null(r0);
fp12_null(r1);
bn_null(r);
TRY {
fp12_new(r0);
fp12_new(r1);
bn_new(n);
for (i = 0; i < m; i++) {
ep_null(_p[i]);
ep_null(t0[i]);
ep2_null(_q[i]);
ep2_null(t1[i]);
ep_new(_p[i]);
ep_new(t0[i]);
ep2_new(_q[i]);
ep2_new(t1[i]);
}
j = 0;
for (i = 0; i < m; i++) {
if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
ep_norm(_p[j], p[i]);
ep2_norm(_q[j++], q[i]);
}
}
ep_curve_get_ord(n);
bn_sub_dig(n, n, 1);
fp12_set_dig(r0, 1);
fp12_set_dig(r1, 1);
if (j > 0) {
pp_mil_lit_k12(r0, t0, _p, _q, j, n);
pp_mil_k12(r1, t1, _q, _p, j, n);
fp12_inv(r1, r1);
fp12_mul(r0, r0, r1);
fp12_inv(r1, r0);
fp12_inv_uni(r0, r0);
}
fp12_mul(r, r0, r1);
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
fp12_free(r0);
fp12_free(r1);
bn_free(n);
for (i = 0; i < m; i++) {
ep_free(_p[i]);
ep_free(t0[i]);
ep2_free(_q[i]);
ep2_free(t1[i]);
}
}
}
void pp_map_oatep_k12(fp12_t r, ep_t p, ep2_t q) {
ep_t _p[1];
ep2_t t[1], _q[1];
bn_t a;
int len = FP_BITS, s[FP_BITS];
ep_null(_p[0]);
ep2_null(_q[0]);
ep2_null(t[0]);
bn_null(a);
TRY {
ep_new(_p[0]);
ep2_new(_q[0]);
ep2_new(t[0]);
bn_new(a);
fp_param_get_var(a);
bn_mul_dig(a, a, 6);
bn_add_dig(a, a, 2);
fp_param_get_map(s, &len);
fp12_set_dig(r, 1);
ep_norm(_p[0], p);
ep2_norm(_q[0], q);
if (!ep_is_infty(_p[0]) && !ep2_is_infty(_q[0])) {
switch (ep_param_get()) {
case BN_P158:
case BN_P254:
case BN_P256:
case BN_P638:
/* r = f_{|a|,Q}(P). */
pp_mil_sps_k12(r, t, _q, _p, 1, s, len);
if (bn_sign(a) == BN_NEG) {
/* f_{-a,Q}(P) = 1/f_{a,Q}(P). */
fp12_inv_uni(r, r);
ep2_neg(t[0], t[0]);
}
pp_fin_k12_oatep(r, t[0], _q[0], _p[0]);
pp_exp_k12(r, r);
break;
case B12_P638:
/* r = f_{|a|,Q}(P). */
pp_mil_sps_k12(r, t, _q, _p, 1, s, len);
if (bn_sign(a) == BN_NEG) {
fp12_inv_uni(r, r);
ep2_neg(t[0], t[0]);
}
pp_exp_k12(r, r);
break;
}
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
ep_free(_p[0]);
ep2_free(_q[0]);
ep2_free(t[0]);
bn_free(a);
}
}
void pp_map_sim_oatep_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
ep_t _p[m];
ep2_t t[m], _q[m];
bn_t a;
int i, j, len = FP_BITS, s[FP_BITS];
TRY {
bn_null(a);
bn_new(a);
for (i = 0; i < m; i++) {
ep_null(_p[i]);
ep2_null(_q[i]);
ep2_null(t[i]);
ep_new(_p[i]);
ep2_new(_q[i]);
ep2_new(t[i]);
}
j = 0;
for (i = 0; i < m; i++) {
if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
ep_norm(_p[j], p[i]);
ep2_norm(_q[j++], q[i]);
}
}
fp12_set_dig(r, 1);
fp_param_get_var(a);
bn_mul_dig(a, a, 6);
bn_add_dig(a, a, 2);
fp_param_get_map(s, &len);
if (j > 0) {
switch (ep_param_get()) {
case BN_P158:
case BN_P254:
case BN_P256:
case BN_P638:
/* r = f_{|a|,Q}(P). */
pp_mil_sps_k12(r, t, _q, _p, j, s, len);
if (bn_sign(a) == BN_NEG) {
/* f_{-a,Q}(P) = 1/f_{a,Q}(P). */
fp12_inv_uni(r, r);
}
for (i = 0; i < j; i++) {
if (bn_sign(a) == BN_NEG) {
ep2_neg(t[i], t[i]);
}
pp_fin_k12_oatep(r, t[i], _q[i], _p[i]);
}
pp_exp_k12(r, r);
break;
case B12_P638:
/* r = f_{|a|,Q}(P). */
pp_mil_sps_k12(r, t, _q, _p, j, s, len);
if (bn_sign(a) == BN_NEG) {
fp12_inv_uni(r, r);
}
pp_exp_k12(r, r);
break;
}
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
bn_free(a);
for (i = 0; i < m; i++) {
ep_free(_p[i]);
ep2_free(_q[i]);
ep2_free(t[i]);
}
}
}
void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
const bn_t m) {
ep_t t[5];
int i, u_i, len, offset;
int8_t jsf[2 * (FP_BITS + 1)];
if (bn_is_zero(k) || ep_is_infty(p)) {
ep_mul(r, q, m);
return;
}
if (bn_is_zero(m) || ep_is_infty(q)) {
ep_mul(r, p, k);
return;
}
TRY {
for (i = 0; i < 5; i++) {
ep_null(t[i]);
ep_new(t[i]);
}
ep_set_infty(t[0]);
ep_copy(t[1], q);
if (bn_sign(m) == BN_NEG) {
ep_neg(t[1], t[1]);
}
ep_copy(t[2], p);
if (bn_sign(k) == BN_NEG) {
ep_neg(t[2], t[2]);
}
ep_add(t[3], t[2], t[1]);
ep_sub(t[4], t[2], t[1]);
#if defined(EP_MIXED)
ep_norm_sim(t + 3, (const ep_t *)t + 3, 2);
#endif
len = 2 * (FP_BITS + 1);
bn_rec_jsf(jsf, &len, k, m);
ep_set_infty(r);
offset = MAX(bn_bits(k), bn_bits(m)) + 1;
for (i = len - 1; i >= 0; i--) {
ep_dbl(r, r);
if (jsf[i] != 0 && jsf[i] == -jsf[i + offset]) {
u_i = jsf[i] * 2 + jsf[i + offset];
if (u_i < 0) {
ep_sub(r, r, t[4]);
} else {
ep_add(r, r, t[4]);
}
} else {
u_i = jsf[i] * 2 + jsf[i + offset];
if (u_i < 0) {
ep_sub(r, r, t[-u_i]);
} else {
ep_add(r, r, t[u_i]);
}
}
}
ep_norm(r, r);
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
for (i = 0; i < 5; i++) {
ep_free(t[i]);
}
}
}
void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
const bn_t m) {
ep_t t0[1 << (EP_WIDTH / 2)], t1[1 << (EP_WIDTH / 2)], t[1 << EP_WIDTH];
bn_t n;
int l0, l1, w = EP_WIDTH / 2;
uint8_t w0[CEIL(FP_BITS + 1, w)], w1[CEIL(FP_BITS + 1, w)];
bn_null(n);
if (bn_is_zero(k) || ep_is_infty(p)) {
ep_mul(r, q, m);
return;
}
if (bn_is_zero(m) || ep_is_infty(q)) {
ep_mul(r, p, k);
return;
}
TRY {
bn_new(n);
ep_curve_get_ord(n);
for (int i = 0; i < (1 << w); i++) {
ep_null(t0[i]);
ep_null(t1[i]);
ep_new(t0[i]);
ep_new(t1[i]);
}
for (int i = 0; i < (1 << EP_WIDTH); i++) {
ep_null(t[i]);
ep_new(t[i]);
}
ep_set_infty(t0[0]);
ep_copy(t0[1], p);
if (bn_sign(k) == BN_NEG) {
ep_neg(t0[1], t0[1]);
}
for (int i = 2; i < (1 << w); i++) {
ep_add(t0[i], t0[i - 1], t0[1]);
}
ep_set_infty(t1[0]);
ep_copy(t1[1], q);
if (bn_sign(m) == BN_NEG) {
ep_neg(t1[1], t1[1]);
}
for (int i = 1; i < (1 << w); i++) {
ep_add(t1[i], t1[i - 1], t1[1]);
}
for (int i = 0; i < (1 << w); i++) {
for (int j = 0; j < (1 << w); j++) {
ep_add(t[(i << w) + j], t0[i], t1[j]);
}
}
#if defined(EP_MIXED)
ep_norm_sim(t + 1, (const ep_t *)t + 1, (1 << (EP_WIDTH)) - 1);
#endif
l0 = l1 = CEIL(FP_BITS, w);
bn_rec_win(w0, &l0, k, w);
bn_rec_win(w1, &l1, m, w);
for (int i = l0; i < l1; i++) {
w0[i] = 0;
}
for (int i = l1; i < l0; i++) {
w1[i] = 0;
}
ep_set_infty(r);
for (int i = MAX(l0, l1) - 1; i >= 0; i--) {
for (int j = 0; j < w; j++) {
ep_dbl(r, r);
}
ep_add(r, r, t[(w0[i] << w) + w1[i]]);
}
ep_norm(r, r);
} CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
bn_free(n);
for (int i = 0; i < (1 << w); i++) {
ep_free(t0[i]);
ep_free(t1[i]);
}
for (int i = 0; i < (1 << EP_WIDTH); i++) {
ep_free(t[i]);
}
}
}
