status_t element_pow_int(element_t c, element_t a, integer_t b)
{
GroupType type = a->type;
// TODO: c (type) = a (type) ^ b (ZR)
LEAVE_IF( c->isInitialized != TRUE || a->isInitialized != TRUE, "uninitialized argument.");
EXIT_IF_NOT_SAME(c, a);
LEAVE_IF(b == NULL, "uninitialized integer.");
status_t result = ELEMENT_OK;
LEAVE_IF( c->type != type, "result initialized but invalid type.");
switch(type) {
case ZR: bn_mxp(c->bn, a->bn, b, a->order);
break;
case G1: g1_mul(c->g1, a->g1, b);
break;
case G2: g2_mul(c->g2, a->g2, b);
break;
case GT: gt_exp(c->gt, a->gt, b);
break;
default:
result = ELEMENT_INVALID_TYPES;
break;
}
return result;
}
status_t element_pow_zr(element_t c, element_t a, element_t b)
{
GroupType type = a->type;
// c (type) = a (type) ^ b (ZR)
LEAVE_IF( c->isInitialized != TRUE || a->isInitialized != TRUE, "uninitialized argument.");
EXIT_IF_NOT_SAME(c, a);
LEAVE_IF(a->isInitialized != TRUE, "invalid argument.");
LEAVE_IF(b->isInitialized != TRUE || b->type != ZR, "invalid type.");
if(type == ZR) {
bn_mxp(c->bn, a->bn, b->bn, a->order);
}
else if(type == G1) {
g1_mul(c->g1, a->g1, b->bn);
}
else if(type == G2) {
g2_mul(c->g2, a->g2, b->bn);
}
else if(type == GT) {
gt_exp(c->gt, a->gt, b->bn);
}
else {
return ELEMENT_INVALID_TYPES;
}
return ELEMENT_OK;
}
status_t element_mul_int(element_t c, element_t a, integer_t b)
{
GroupType type = a->type;
// TODO: c (type) = a (type) * b (ZR)
LEAVE_IF(a->isInitialized != TRUE, "invalid argument.");
LEAVE_IF(c->isInitialized != TRUE || c->type != type, "result not initialized or invalid type.");
if(type == ZR) {
bn_mul(c->bn, a->bn, b);
bn_mod(c->bn, c->bn, c->order);
}
else if(type == G1) {
g1_mul(c->g1, a->g1, b);
}
else if(type == G2) {
g2_mul(c->g2, a->g2, b);
}
else if(type == GT) {
gt_exp(c->gt, a->gt, b);
}
else {
return ELEMENT_INVALID_TYPES;
}
return ELEMENT_OK;
}
int element_is_member(element_t e)
{
LEAVE_IF(e->isInitialized != TRUE, "uninitialized argument.");
int result;
if(e->type == ZR) {
if(bn_cmp(e->bn, e->order) <= CMP_EQ)
result = TRUE;
else
result = FALSE;
}
else if(e->type == G1) {
g1_t r;
g1_inits(r);
g1_mul(r, e->g1, e->order);
if(g1_is_infty(r) == 1)
result = TRUE;
else
result = FALSE;
g1_free(r);
}
else if(e->type == G2) {
g2_t r;
g2_inits(r);
g2_mul(r, e->g2, e->order);
if(g2_is_infty(r) == 1)
result = TRUE;
else
result = FALSE;
g2_free(r);
}
else if(e->type == GT) {
gt_t r;
gt_inits(r);
gt_exp(r, e->gt, e->order);
if(gt_is_unity(r) == 1)
result = TRUE;
else
result = FALSE;
gt_free(r);
}
else {
result = ELEMENT_INVALID_ARG;
}
return result;
}
int cp_bgn_dec(dig_t *out, gt_t in[4], bgn_t prv) {
int i, result = STS_ERR;
g1_t g;
g2_t h;
gt_t t[4];
bn_t n, r, s;
bn_null(n);
bn_null(r);
bn_null(s);
g1_null(g);
g2_null(h);
TRY {
bn_new(n);
bn_new(r);
bn_new(s);
g1_new(g);
g2_new(h);
for (i = 0; i < 4; i++) {
gt_null(t[i]);
gt_new(t[i]);
}
gt_exp(t[0], in[0], prv->x);
gt_exp(t[0], t[0], prv->x);
gt_mul(t[1], in[1], in[2]);
gt_exp(t[1], t[1], prv->x);
gt_inv(t[1], t[1]);
gt_mul(t[3], in[3], t[1]);
gt_mul(t[3], t[3], t[0]);
gt_get_ord(n);
g1_get_gen(g);
g2_get_gen(h);
bn_mul(r, prv->x, prv->y);
bn_sqr(r, r);
bn_mul(s, prv->x, prv->y);
bn_mul(s, s, prv->z);
bn_sub(r, r, s);
bn_sub(r, r, s);
bn_sqr(s, prv->z);
bn_add(r, r, s);
bn_mod(r, r, n);
pc_map(t[1], g, h);
gt_exp(t[1], t[1], r);
gt_copy(t[2], t[1]);
if (gt_is_unity(t[3]) == 1) {
*out = 0;
result = STS_OK;
} else {
for (i = 0; i < INT_MAX; i++) {
if (gt_cmp(t[2], t[3]) == CMP_EQ) {
*out = i + 1;
result = STS_OK;
break;
}
gt_mul(t[2], t[2], t[1]);
}
}
} CATCH_ANY {
result = STS_ERR;
} FINALLY {
bn_free(n);
bn_free(r);
bn_free(s);
g1_free(g);
g2_free(h);
for (i = 0; i < 4; i++) {
gt_free(t[i]);
}
}
return result;
}
