void bn_lcm(bn_t c, const bn_t a, const bn_t b) {
bn_t u, v;
bn_null(u);
bn_null(v);
TRY {
bn_new(u);
bn_new(v);
bn_gcd(u, a, b);
if (bn_cmp_abs(a, b) == CMP_LT) {
bn_div(v, a, u);
bn_mul(c, b, v);
} else {
bn_div(v, b, u);
bn_mul(c, a, v);
}
c->sign = BN_POS;
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
bn_free(u);
bn_free(v);
}
}
void ep_curve_set_endom(const fp_t b, const ep_t g, const bn_t r, const bn_t h,
const fp_t beta, const bn_t l) {
int bits = bn_bits(r);
ctx_t *ctx = core_get();
ctx->ep_is_endom = 1;
ctx->ep_is_super = 0;
fp_zero(ctx->ep_a);
fp_copy(ctx->ep_b, b);
detect_opt(&(ctx->ep_opt_a), ctx->ep_a);
detect_opt(&(ctx->ep_opt_b), ctx->ep_b);
#if EP_MUL == LWNAF || EP_FIX == COMBS || EP_FIX == LWNAF || EP_SIM == INTER || !defined(STRIP)
fp_copy(ctx->beta, beta);
bn_gcd_ext_mid(&(ctx->ep_v1[1]), &(ctx->ep_v1[2]), &(ctx->ep_v2[1]),
&(ctx->ep_v2[2]), l, r);
/* l = v1[1] * v2[2] - v1[2] * v2[1], r = l / 2. */
bn_mul(&(ctx->ep_v1[0]), &(ctx->ep_v1[1]), &(ctx->ep_v2[2]));
bn_mul(&(ctx->ep_v2[0]), &(ctx->ep_v1[2]), &(ctx->ep_v2[1]));
bn_sub(&(ctx->ep_r), &(ctx->ep_v1[0]), &(ctx->ep_v2[0]));
bn_hlv(&(ctx->ep_r), &(ctx->ep_r));
/* v1[0] = round(v2[2] * 2^|n| / l). */
bn_lsh(&(ctx->ep_v1[0]), &(ctx->ep_v2[2]), bits + 1);
if (bn_sign(&(ctx->ep_v1[0])) == BN_POS) {
bn_add(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), &(ctx->ep_r));
} else {
bn_sub(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), &(ctx->ep_r));
}
bn_dbl(&(ctx->ep_r), &(ctx->ep_r));
bn_div(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), &(ctx->ep_r));
if (bn_sign(&ctx->ep_v1[0]) == BN_NEG) {
bn_add_dig(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), 1);
}
/* v2[0] = round(v1[2] * 2^|n| / l). */
bn_lsh(&(ctx->ep_v2[0]), &(ctx->ep_v1[2]), bits + 1);
if (bn_sign(&(ctx->ep_v2[0])) == BN_POS) {
bn_add(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), &(ctx->ep_r));
} else {
bn_sub(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), &(ctx->ep_r));
}
bn_div(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), &(ctx->ep_r));
if (bn_sign(&ctx->ep_v2[0]) == BN_NEG) {
bn_add_dig(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), 1);
}
bn_neg(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]));
#endif
ep_norm(&(ctx->ep_g), g);
bn_copy(&(ctx->ep_r), r);
bn_copy(&(ctx->ep_h), h);
#if defined(EP_PRECO)
ep_mul_pre((ep_t *)ep_curve_get_tab(), &(ctx->ep_g));
#endif
}
void pp_exp_k2(fp2_t c, fp2_t a) {
bn_t e, n;
bn_null(n);
bn_null(e);
TRY {
bn_new(n);
bn_new(e);
ep_curve_get_ord(n);
fp2_conv_uni(c, a);
dv_copy(e->dp, fp_prime_get(), FP_DIGS);
e->used = FP_DIGS;
e->sign = BN_POS;
bn_add_dig(e, e, 1);
bn_div(e, e, n);
fp2_exp_uni(c, c, e);
} CATCH_ANY {
THROW(ERR_CAUGHT);
} FINALLY {
bn_free(n);
bn_free(e);
}
}
static char *
kcl_z_div(z_t *z, cint_t *a, cint_t *b, cint_t **r, cint_t **m)
{
bn_t *bn, *bn_r = NULL;
char *err;
bn = bn_div(z->z_data, NULL, a->cint_data, b->cint_data, m ? &bn_r: NULL);
err = kcl_z_set_result(r, bn);
if (m && err == NULL)
err = kcl_z_set_result(m, bn_r);
bn_freetbuf(z->z_data, bn); /* free all the results */
return(err);
}
int cp_phpe_dec(uint8_t *out, int out_len, uint8_t *in, int in_len, bn_t n,
bn_t l) {
bn_t c, u, s;
int size, result = STS_OK;
size = bn_size_bin(n);
if (in_len < 0 || in_len != 2 * size) {
return STS_ERR;
}
bn_null(c);
bn_null(u);
bn_null(s);
TRY {
bn_new(c);
bn_new(u);
bn_new(s);
/* Compute (c^l mod n^2) * u mod n. */
bn_sqr(s, n);
bn_read_bin(c, in, in_len);
bn_mxp(c, c, l, s);
bn_sub_dig(c, c, 1);
bn_div(c, c, n);
bn_gcd_ext(s, u, NULL, l, n);
if (bn_sign(u) == BN_NEG) {
bn_add(u, u, n);
}
bn_mul(c, c, u);
bn_mod(c, c, n);
size = bn_size_bin(c);
if (size <= out_len) {
memset(out, 0, out_len);
bn_write_bin(out + (out_len - size), size, c);
} else {
result = STS_ERR;
}
} CATCH_ANY {
result = STS_ERR;
}
FINALLY {
bn_free(c);
bn_free(u);
bn_free(s);
}
return result;
}
int igraph_biguint_div(igraph_biguint_t *q, igraph_biguint_t *r,
igraph_biguint_t *u, igraph_biguint_t *v) {
int ret;
long int size_q=igraph_biguint_size(q);
long int size_r=igraph_biguint_size(r);
long int size_u=igraph_biguint_size(u);
long int size_v=igraph_biguint_size(v);
long int size_qru = size_q > size_r ? size_q : size_r;
size_qru = size_u > size_qru ? size_u : size_qru;
if (size_q < size_qru) { IGRAPH_CHECK(igraph_biguint_resize(q, size_qru)); }
if (size_r < size_qru) { IGRAPH_CHECK(igraph_biguint_resize(r, size_qru)); }
if (size_u < size_qru) { IGRAPH_CHECK(igraph_biguint_resize(u, size_qru)); }
ret=bn_div( VECTOR(q->v), VECTOR(r->v), VECTOR(u->v), VECTOR(v->v),
size_qru, size_v );
if (ret) {
IGRAPH_ERROR("Bigint division by zero", IGRAPH_EDIVZERO);
}
return 0;
}
