/*
* Convert an unsigned char array to an element
* Elements from G1 or G2 will also be decompressed!
*/
void BilinearMappingHandler::byteArrayToElement(element_t saveHere, unsigned char* compressedElem, bool isElementOfGT)
{
if (isElementOfGT)
element_from_bytes(saveHere,compressedElem);
else
element_from_bytes_compressed(saveHere, compressedElem);
}//end of byteArrayToElement()
static inline int in(element_t elem, unsigned char *my_feed) {
int sz;
// fprintf(stderr, "Prepare reading sz\n");
memcpy(&sz, my_feed, 4);
// fprintf(stderr, "Size of pbc element: %d\n", sz);
unsigned char* data = pbc_malloc(sz);
memcpy(data, my_feed+4, sz);
element_from_bytes_compressed(elem, data);
pbc_free(data);
return sz+4;
}
FENC_ERROR
import_components_from_buffer(uint8* buffer, size_t buf_len, size_t *imported_len, char* fmt, ...)
{
FENC_ERROR result = FENC_ERROR_NONE;
va_list comp_list;
uint32 deserialized_len = 0;
fenc_attribute_list *attr_list = NULL;
fenc_attribute_policy *pol_tree = NULL;
char *attrs;
size_t len;
int32 temp_int;
uint8* buf_ptr;
char* fmt_ptr;
element_t *elt;
/* 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;
}
buf_ptr = (uint8*)(buffer + deserialized_len);
switch(*++fmt_ptr) {
case 'E':
/* Uncompressed element. */
elt = va_arg(comp_list, element_t*);
deserialized_len += element_from_bytes(*elt, buf_ptr);
break;
case 'C':
/* Compressed element. */
elt = va_arg(comp_list, element_t*);
deserialized_len += element_from_bytes_compressed(*elt, buf_ptr);
break;
case 's':
strcpy(va_arg(comp_list, char *), (const char *) buf_ptr);
deserialized_len += strlen((char *)buf_ptr) + 1;
break;
case 'd':
IMPORT_INT32(temp_int, buf_ptr);
*(va_arg(comp_list, int32*)) = temp_int;
deserialized_len += sizeof(int32);
break;
case 'A':
len = strlen((char *)buf_ptr); /* assume attribute list is NULL terminated */
attrs = SAFE_MALLOC(len+1);
memset(attrs, 0, len+1);
strncpy(attrs, (const char *) buf_ptr, len);
// printf("Raw list: '%s'\n", attrs);
deserialized_len += len + 1;
attr_list = va_arg(comp_list, fenc_attribute_list*);
/* tokenize the string and place in attribute_list */
fenc_buffer_to_attribute_list(&attrs, attr_list);
free(attrs);
break;
case 'P':
len = strlen((char *) buf_ptr); /* assume policy is NULL terminated */
pol_tree = va_arg(comp_list, fenc_attribute_policy *); /* get the users ptr to fenc_attribute_policy */
fenc_policy_from_string(pol_tree, (char *) buf_ptr); /* store policy into given policy structure */
deserialized_len += len + 1; /* increment pointer to next component */
break;
default:
/* Unrecognized symbol. */
result = FENC_ERROR_INVALID_INPUT;
break;
}
if (deserialized_len > buf_len) {
/* Return the length we read. */
if (imported_len != NULL) {
*imported_len = deserialized_len;
}
return FENC_ERROR_BUFFER_TOO_SMALL;
}
}
va_end(comp_list);
/* Return the length we read. */
if (imported_len != NULL) {
*imported_len = deserialized_len;
}
return result;
}
void BSActivity(unsigned char *da, unsigned char *db, unsigned char *dc, unsigned char *dcu) {
//signature decompress
//printf("Verifying....\n");
element_t cu, A, B, C;
element_init_G1(A, pairing);
element_init_G1(B, pairing);
element_init_G1(C, pairing);
element_init_Zr(cu, pairing2);
element_from_bytes_compressed(A, da);
element_from_bytes_compressed(B, db);
element_from_bytes_compressed(C, dc);
element_from_bytes(cu, dcu);
pbc_free(da);
pbc_free(db);
pbc_free(dc);
pbc_free(dcu);
//verification I
element_t exbcu;
element_t tmp1, tmp2, right, left;
element_init_GT(exbcu, pairing);
element_init_GT(tmp1, pairing);
element_init_GT(tmp2, pairing);
element_init_GT(right, pairing);
element_init_GT(left, pairing);
element_pairing(tmp1, X, A);
element_pairing(tmp2, X, B);
element_pow_zn(exbcu, tmp2, cu);
element_mul(left, tmp1, exbcu);
element_pairing(right, g, C);
if (!element_cmp(left, right)) {
//printf("part 1 verifies\n");
} else {
printf("*BUG* part 1 does not verify *BUG*\n");
}
//verification II
element_pairing(left, A, Y);
element_pairing(right, g, B);
if (!element_cmp(left, right)) {
//printf("part 2 verifies\n");
} else {
printf("*BUG* part 2 does not verify *BUG*\n");
}
if(ifsize) {
int totalsize = sizeof(tmp1) + sizeof(tmp2) + sizeof(right) + sizeof(left) +
sizeof(A) + sizeof(B) + sizeof(C) + sizeof(cu);
printf("Memory used at base station is %d bytes. \n", totalsize);
}
element_clear(exbcu);
element_clear(tmp1);
element_clear(tmp2);
element_clear(right);
element_clear(left);
element_clear(A);
element_clear(B);
element_clear(C);
element_clear(cu);
return;
}
