/* * 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; }