/*
* Convert an element to a byte array.
* Elements from G1 or G2 will also be compressed!
*/
void BilinearMappingHandler::elementToByteArray(unsigned char* saveHere, element_t elem, bool isElementOfGT)
{
if (isElementOfGT)
element_to_bytes(saveHere,elem);
else
element_to_bytes_compressed(saveHere, elem);
}//end of elementToByteArray()
//write bytes stream of element_t to a file
static inline void out(element_t elem, FILE *myfile)
{
int sz = element_length_in_bytes_compressed(elem);
fwrite(&sz, 4, 1, myfile);
unsigned char* data = pbc_malloc(sz);
if(!data)
printf("DATA IS NULL\n");
element_to_bytes_compressed(data, elem);
fwrite(data, sz, 1, myfile);
pbc_free(data);
}
FENC_ERROR
export_components_to_buffer(uint8* buffer, size_t max_len, size_t *result_len, char* fmt, ...)
{
FENC_ERROR result = FENC_ERROR_NONE;
va_list comp_list;
uint8* buf_ptr = buffer;
char* fmt_ptr;
element_t *elt;
fenc_attribute_policy *policy;
fenc_attribute_list *attribute_list;
size_t i_index=0, tmp_len=0;
*result_len = 0;
/* Iterate through the variable-length argument list. */
va_start(comp_list, fmt);
for(fmt_ptr = fmt; *fmt_ptr != '\0'; fmt_ptr++) {
if(*fmt_ptr != '%') {
continue;
}
/* Point buf_ptr to the correct offset, unless the buffer is NULL. */
if (buffer != NULL) {
buf_ptr = (uint8*)(buffer + *result_len);
}
switch(*++fmt_ptr) {
case 'E':
/* Uncompressed element. */
elt = va_arg(comp_list, element_t*);
*result_len += element_length_in_bytes(*elt);
if (buffer != NULL && *result_len <= max_len) {
element_to_bytes(buf_ptr, *elt);
}
break;
case 'C':
/* Compressed element. */
elt = va_arg(comp_list, element_t*);
tmp_len = element_length_in_bytes_compressed(*elt);
*result_len += tmp_len;
if (buffer != NULL && *result_len < max_len) {
element_to_bytes_compressed(buf_ptr, *elt);
}
// printf("len of C = '%zu'\n", *result_len);
// printf_buffer_as_hex(buf_ptr, tmp_len);
break;
case 'P':
policy = va_arg(comp_list, fenc_attribute_policy*);
result = fenc_attribute_policy_to_string(policy->root, (char *)buf_ptr, (max_len - *result_len));
i_index = strchr((char *) buf_ptr, 0) - (char *) buf_ptr;
*result_len += i_index + 1;
// printf("policy_root: '%s', strlen: '%d', index: '%d'\n", (char *) buf_ptr, strlen((char *) buf_ptr), i_index);
break;
case 'A':
attribute_list = va_arg(comp_list, fenc_attribute_list*);
fenc_attribute_list_to_buffer(attribute_list, buf_ptr, (max_len - *result_len), &i_index);
*result_len += i_index + 1;
// printf("attribute_list: '%s'\n\tlength: '%zu'\n", (char *)buf_ptr, strlen((char *)buf_ptr));
break;
case 's':
*result_len += strlen(va_arg(comp_list, char *)) + 1;
if (buffer != NULL && *result_len <= max_len) {
strcpy((char *)buf_ptr, va_arg(comp_list, char *));
}
break;
case 'd':
*result_len += sizeof(int32);
if (buffer != NULL && *result_len < max_len) {
EXPORT_INT32(buf_ptr, va_arg(comp_list, int32));
}
break;
default:
/* Unrecognized symbol. */
result = FENC_ERROR_INVALID_INPUT;
break;
}
if (buffer != NULL && *result_len > max_len) {
return FENC_ERROR_BUFFER_TOO_SMALL;
}
}
void UEActivity(unsigned char **da, unsigned char **db, unsigned char **dc, unsigned char **dcu) {
//printf("Generating keys.....\n");
element_t a, b, c, cu, r, A, B, C;
element_t ax, a1cuxy;
element_t xy, cuxy;
element_init_G1(a, pairing);
element_init_G1(b, pairing);
element_init_G1(c, pairing);
element_init_Zr(r, pairing);
element_init_G1(A, pairing);
element_init_G1(B, pairing);
element_init_G1(C, pairing);
element_init_G1(ax, pairing);
element_init_G1(a1cuxy, pairing);
//temporarily regard p and q are independent
//instead of p = 2q ＋ 1
element_init_Zr(xy, pairing2);
element_init_Zr(cuxy, pairing2);
element_init_Zr(cu, pairing2);
//temporarily regard cu as a random number in Zr
//instead of Cu = r^k&^ru
element_random(cu);
element_random(a);
if(verbose) element_printf("sig component a = %B\n", a);
element_pow_zn(b, a, y);
// mpz_t mpz_a, mpz_b, mpz_c;
// mpz_inits(mpz_a, mpz_b, mpz_c, NULL);
// element_to_mpz(mpz_a, a);
// mpz_powm(mpz_b, mpz_a, mpz_y, pairing->r);
// element_set_mpz(b, mpz_b);
//element_pow_zn(b, a, y);
if(verbose) element_printf("sig component b = %B\n", b);
element_pow_zn(ax, a, x);
// mpz_t mpz_ax, mpz_a1cuxy, mpz_cuxy;
// mpz_inits(mpz_ax, mpz_a1cuxy, mpz_cuxy, NULL);
// mpz_powm(mpz_ax, mpz_a, mpz_x, pairing->r);
// element_set_mpz(ax, mpz_ax);
element_mul(xy, x, y);
element_mul(cuxy, xy, cu);
element_pow_zn(a1cuxy, a, cuxy);
// element_to_mpz(mpz_cuxy, cuxy);
// mpz_powm(mpz_a1cuxy, mpz_a, mpz_cuxy, pairing->r);
// element_set_mpz(a1cuxy, mpz_a1cuxy);
element_mul(c, ax, a1cuxy);
if(verbose) element_printf("sig component c = %B\n", c);
//blind the signature
// mpz_t mpz_A, mpz_B, mpz_C, mpz_r;
// mpz_inits(mpz_A, mpz_B, mpz_C, mpz_r, NULL);
element_random(r);
element_pow_zn(A, a, r);
element_pow_zn(B, b, r);
element_pow_zn(C, c, r);
// element_to_mpz(mpz_r, r);
// mpz_powm(mpz_A, mpz_a, mpz_r, pairing->r);
// mpz_powm(mpz_B, mpz_b, mpz_r, pairing->r);
// mpz_powm(mpz_C, mpz_c, mpz_r, pairing->r);
// element_set_mpz(A, mpz_A);
// element_set_mpz(B, mpz_B);
// element_set_mpz(C, mpz_C);
//clear meta elements
element_clear(ax);
element_clear(a1cuxy);
element_clear(xy);
element_clear(cuxy);
element_clear(r);
element_clear(a);
element_clear(b);
element_clear(c);
// mpz_clear(mpz_a);
// mpz_clear(mpz_b);
// mpz_clear(mpz_c);
// mpz_clear(mpz_ax);
// mpz_clear(mpz_a1cuxy);
// mpz_clear(mpz_cuxy);
// mpz_clear(mpz_A);
// mpz_clear(mpz_B);
// mpz_clear(mpz_C);
// mpz_clear(mpz_r);
//signature compress
int n = pairing_length_in_bytes_compressed_G1(pairing);
int m = pairing_length_in_bytes_Zr(pairing2);
*da = pbc_malloc(n);
*db = pbc_malloc(n);
*dc = pbc_malloc(n);
*dcu = pbc_malloc(m);
element_to_bytes_compressed(*da, A);
element_to_bytes_compressed(*db, B);
element_to_bytes_compressed(*dc, C);
element_to_bytes(*dcu, cu);
return;
}
