status_t element_to_key(element_t e, uint8_t *data, int data_len, uint8_t label)
{
LEAVE_IF(e->isInitialized != TRUE, "uninitialized argument.");
// adds an extra null byte by default - will use this last byte for the label
int d_len = element_length(e), digest_len = SHA_LEN;
uint8_t d[d_len + 1];
memset(d, 0, d_len);
// write e to a tmp buf
if(d_len > 0 && digest_len <= data_len) {
element_to_bytes(d, d_len, e);
d[d_len-1] = label;
#ifdef DEBUG
printf("%s: bytes form....\n", __FUNCTION__);
print_as_hex(d, d_len);
#endif
// hash buf using md_map_sh256 and store data_len bytes in data
uint8_t digest[digest_len + 1];
memset(digest, 0, digest_len);
SHA_FUNC(digest, d, d_len);
memcpy(data, digest, digest_len);
#ifdef DEBUG
printf("%s: digest: ", __FUNCTION__);
print_as_hex(data, digest_len);
#endif
return ELEMENT_OK;
}
return ELEMENT_INVALID_ARG;
}
status_t g2_write_bin(g2_t g, uint8_t *data, int data_len)
{
if(g == NULL) return ELEMENT_UNINITIALIZED;
// int out_len = (FP_BYTES * 4) + 4;
if(data_len < G2_LEN) return ELEMENT_INVALID_ARG_LEN;
uint8_t d[G2_LEN+1];
memset(d, 0, G2_LEN);
fp_write_bin(d, FP_BYTES, g->x[0]);
uint8_t *d1 = &(d[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g->x[1]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g->y[0]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g->y[1]);
memcpy(data, d, data_len);
#ifdef DEBUG
printf("%s: size for x & y :=> '%d'\n", __FUNCTION__, FP_BYTES);
uint8_t *d2 = data;
int i;
for(i = 0; i < 4; i++) {
print_as_hex(d2, FP_BYTES+1);
d2 = &(d2[FP_BYTES + 1]);
}
#endif
memset(d, 0, G2_LEN);
return ELEMENT_OK;
}
void print_file_info(const struct transfer_info *file_info) {
printf("filename: %s\n", file_info->filename);
printf("md5: ");
print_as_hex(file_info->md5, MD5_DIGEST_LENGTH);
printf("file size: %d\n", file_info->file_size);
printf("chunk number: %d\n", file_info->chunk_number);
}
status_t element_from_hash(element_t e, unsigned char *data, int len)
{
LEAVE_IF(e->isInitialized == FALSE, "uninitialized argument.");
GroupType type = e->type;
status_t result = ELEMENT_OK;
int digest_len = SHA_LEN;
unsigned char digest[digest_len + 1];
memset(digest, 0, digest_len);
SHA_FUNC(digest, data, len);
#ifdef DEBUG
printf("%s: digest: ", __FUNCTION__);
print_as_hex(digest, digest_len);
#endif
switch(type) {
case ZR: bn_read_bin(e->bn, digest, digest_len);
if(bn_cmp(e->bn, e->order) == CMP_GT) bn_mod(e->bn, e->bn, e->order);
// bn_print(e->bn);
break;
case G1: g1_map(e->g1, digest, digest_len);
break;
case G2: g2_map(e->g2, digest, digest_len);
break;
default:
result = ELEMENT_INVALID_TYPES;
break;
}
return result;
}
int main(int argc,char *argv[]) {
unsigned char md_value[EVP_MAX_MD_SIZE];
unsigned int md_len;
if(argc!=2) {
fprintf(stderr,"usage: create <password>\n");
exit(1);
}
calculate_md5_of(argv[1],strlen(argv[1]),md_value,&md_len);
print_as_hex(md_value,md_len);
printf("\n");
return 0;
}
status_t gt_write_bin(gt_t g, uint8_t *data, int data_len)
{
if(g == NULL) return ELEMENT_UNINITIALIZED;
if(data_len < GT_LEN) return ELEMENT_INVALID_ARG_LEN;
uint8_t d[GT_LEN+1];
uint8_t *d1 = NULL;
memset(d, 0, GT_LEN);
#ifdef DEBUG
printf("%s: size for x & y :=> '%d'\n", __FUNCTION__, FP_BYTES);
#endif
// write the x-coordinate
fp_write_bin(d, FP_BYTES, g[0][0][0]);
d1 = &(d[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[0][0][1]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[0][1][0]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[0][1][1]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[0][2][0]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[0][2][1]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[1][0][0]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[1][0][1]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[1][1][0]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[1][1][1]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[1][2][0]);
d1 = &(d1[FP_BYTES + 1]);
fp_write_bin(d1, FP_BYTES, g[1][2][1]);
memcpy(data, d, data_len);
#ifdef DEBUG
uint8_t *d2 = data;
int i;
for(i = 0; i < 12; i++) {
print_as_hex(d2, FP_BYTES+1);
d2 = &(d2[FP_BYTES + 1]);
}
#endif
memset(d, 0, GT_LEN);
return ELEMENT_OK;
}
status_t hash_buffer_to_bytes(uint8_t *input, int input_len, uint8_t *output, int output_len, uint8_t label)
{
LEAVE_IF(input == NULL || output == NULL, "uninitialized argument.");
// adds an extra null byte by default - will use this last byte for the label
int digest_len = SHA_LEN;
if(digest_len <= output_len) {
// hash buf using md_map_sh256 and store data_len bytes in data
uint8_t digest[digest_len + 1];
memset(digest, 0, digest_len);
SHA_FUNC(digest, input, input_len);
memcpy(output, digest, digest_len);
#ifdef DEBUG
printf("%s: digest: ", __FUNCTION__);
print_as_hex(output, digest_len);
#endif
return ELEMENT_OK;
}
return ELEMENT_INVALID_ARG;
}
status_t g1_write_bin(g1_t g, uint8_t *data, int data_len)
{
if(g == NULL) return ELEMENT_UNINITIALIZED;
if(data_len < G1_LEN) return ELEMENT_INVALID_ARG_LEN;
uint8_t *d = data;
memset(d, 0, G1_LEN);
fp_write_bin(d, FP_BYTES, g->x);
fp_write_bin(&(d[FP_BYTES + 1]), FP_BYTES, g->y);
#ifdef DEBUG
printf("%s: size for x & y :=> '%d'\n", __FUNCTION__, FP_BYTES);
uint8_t *d2 = data;
int i;
for(i = 0; i < 2; i++) {
print_as_hex(d2, FP_BYTES+1);
d2 = &(d2[FP_BYTES + 1]);
}
#endif
return ELEMENT_OK;
}
