int gen_ukeys(FENC_SCHEME_TYPE scheme, char *g_params, char *public_params, char *uskfile ,char *upkfile) {
FENC_ERROR result;
fenc_context context;
fenc_group_params group_params;
fenc_global_params global_params;
pairing_t pairing;
FILE *fp;
int c;
size_t serialized_len = 0;
size_t pub_len = 0;
uint8 public_params_buf[SIZE];
uint8 *uskBuffer = NULL;
uint8 *upkBuffer = NULL;
fenc_USK_KSFCP usk;
fenc_UPK_KSFCP upk;
size_t usk_len = 0, b64_usk_len = 0;
size_t upk_len = 0, b64_upk_len = 0;
/* Clear data structures. */
memset(&context, 0, sizeof(fenc_context));
memset(&group_params, 0, sizeof(fenc_group_params));
memset(&global_params, 0, sizeof(fenc_global_params));
memset(&public_params_buf, 0, SIZE);
memset(&usk, 0, sizeof(fenc_USK_KSFCP));
memset(&upk, 0, sizeof(fenc_UPK_KSFCP));
/* Initialize the library. */
result = libfenc_init();
report_error("Initializing library", result);
// insert code here...
debug("Generating master ABE system parameters...\n");
/* Create a Sahai-Waters context. */
result = libfenc_create_context(&context, scheme);
/* Load group parameters from a file. */
fp = fopen(g_params, "r");
if (fp != NULL) {
libfenc_load_group_params_from_file(&group_params, fp);
libfenc_get_pbc_pairing(&group_params, pairing);
} else {
perror("Could not open parameters file.\n");
goto cleanup;
}
fclose(fp);
/* Set up the global parameters. */
result = context.generate_global_params(&global_params, &group_params);
report_error("Loading global parameters", result);
result = libfenc_gen_params(&context, &global_params);
report_error("Generating scheme parameters and secret key", result);
debug("Reading the public parameters file = %s\n", public_params);
/* read file */
fp = fopen(public_params, "r");
if(fp != NULL) {
while (TRUE) {
c = fgetc(fp);
if(c != EOF) {
public_params_buf[pub_len] = c;
pub_len++;
}
else {
break;
}
}
}
else {
perror("File does not exist.\n");
return -1;
}
fclose(fp);
//debug("public params input = '%s'\n", public_params_buf);
/* base-64 decode */
uint8 *bin_public_buf = NewBase64Decode((const char *) public_params_buf, pub_len, &serialized_len);
/* Import the parameters from binary buffer: */
result = libfenc_import_public_params(&context, bin_public_buf, serialized_len);
report_error("Importing public parameters", result);
result = libfenc_gen_ukey_KSFCP(&context, &usk, &upk);
uskBuffer = (uint8 *) malloc(KEYSIZE_MAX);
memset(uskBuffer, 0, KEYSIZE_MAX);
upkBuffer = (uint8 *) malloc(KEYSIZE_MAX);
memset(upkBuffer, 0, KEYSIZE_MAX);
debug("Generating USK...\n");
result = libfenc_export_usk_KSFCP(&context, &usk, uskBuffer, KEYSIZE_MAX, &usk_len);
if(result != FENC_ERROR_NONE) {
report_error("Generating USK error!", result);
return result;
}
/* base-64 encode the key and write to disk */
char *b64_usk_buf = NewBase64Encode(uskBuffer, usk_len, FALSE, &b64_usk_len);
fp = fopen(uskfile, "w");
if(fp != NULL) {
fprintf(fp, "%s", b64_usk_buf);
}
fclose(fp);
debug("Generating UPK...\n");
result = libfenc_export_upk_KSFCP(&context, &upk, upkBuffer, KEYSIZE_MAX, &upk_len);
if(result != FENC_ERROR_NONE) {
report_error("Generating UPK error!", result);
return result;
}
/* base-64 encode the key and write to disk */
char *b64_upk_buf = NewBase64Encode(upkBuffer, upk_len, FALSE, &b64_upk_len);
fp = fopen(upkfile, "w");
if(fp != NULL) {
fprintf(fp, "%s", b64_upk_buf);
}
fclose(fp);
cleanup:
/* Destroy the context. */
result = libfenc_destroy_context(&context);
report_error("Destroying context", result);
/* Shutdown the library. */
result = libfenc_shutdown();
report_error("Shutting down library", result);
free(bin_public_buf);
free(uskBuffer);
free(upkBuffer);
free(b64_usk_buf);
free(b64_upk_buf);
return 0;
}
Bool abe_decrypt(FENC_SCHEME_TYPE scheme, char *public_params, char *inputfile, char *keyfile)
{
FENC_ERROR result;
fenc_context context;
fenc_group_params group_params;
fenc_global_params global_params;
fenc_ciphertext ciphertext;
fenc_plaintext aes_session_key;
pairing_t pairing;
fenc_key secret_key;
FILE *fp;
char c;
int pub_len = 0;
size_t serialized_len = 0;
char public_params_buf[SIZE];
int magic_failed;
/* Clear data structures. */
memset(&context, 0, sizeof(fenc_context));
memset(&group_params, 0, sizeof(fenc_group_params));
memset(&global_params, 0, sizeof(fenc_global_params));
memset(&ciphertext, 0, sizeof(fenc_ciphertext));
memset(&aes_session_key, 0, sizeof(fenc_plaintext));
memset(&secret_key, 0, sizeof(fenc_key));
// all this memory must be free'd
char *input_buf = NULL,*keyfile_buf = NULL;
char *aes_blob64 = NULL, *abe_blob64 = NULL, *iv_blob64 = NULL;
ssize_t input_len, key_len;
/* Load user's input file */
fp = fopen(inputfile, "r");
if(fp != NULL) {
if((input_len = read_file(fp, &input_buf)) > 0) {
// printf("Input file: %s\n", input_buf);
tokenize_inputfile(input_buf, &abe_blob64, &aes_blob64, &iv_blob64);
debug("abe ciphertext = '%s'\n", abe_blob64);
debug("init vector = '%s'\n", iv_blob64);
debug("aes ciphertext = '%s'\n", aes_blob64);
free(input_buf);
}
}
else {
fprintf(stderr, "Could not load input file: %s\n", inputfile);
return FALSE;
}
fclose(fp);
/* make sure the abe and aes ptrs are set */
if(aes_blob64 == NULL || abe_blob64 == NULL || iv_blob64 == NULL) {
fprintf(stderr, "Input file either not well-formed or not encrypted.\n");
return FALSE;
}
/* Initialize the library. */
result = libfenc_init();
/* Create a Sahai-Waters context. */
result = libfenc_create_context(&context, scheme);
/* Load group parameters from a file. */
fp = fopen(PARAM, "r");
if (fp != NULL) {
libfenc_load_group_params_from_file(&group_params, fp);
libfenc_get_pbc_pairing(&group_params, pairing);
} else {
perror("Could not open "PARAM" parameters file");
return FALSE;
}
fclose(fp);
/* Set up the global parameters. */
result = context.generate_global_params(&global_params, &group_params);
report_error("Loading global parameters", result);
result = libfenc_gen_params(&context, &global_params);
report_error("Generating scheme parameters and secret key", result);
/* read public parameters file */
fp = fopen(public_params, "r");
if(fp != NULL) {
while (TRUE) {
c = fgetc(fp);
if(c != EOF) {
// statically allocated to prevent memory leaks
public_params_buf[pub_len] = c;
pub_len++;
}
else {
break;
}
}
}
else {
fprintf(stderr, "Could not load input file: %s\n", public_params);
return FALSE;
}
fclose(fp);
debug("public params input = '%s'\n", public_params_buf);
/* base-64 decode public parameters */
uint8 *bin_public_buf = NewBase64Decode((const char *) public_params_buf, pub_len, &serialized_len);
// printf("public params binary = '%s'\n", bin_public_buf);
/* Import the parameters from binary buffer: */
result = libfenc_import_public_params(&context, bin_public_buf, serialized_len);
report_error("Importing public parameters", result);
/* read input key file */ // (PRIVATE KEY)
debug("keyfile => '%s'\n", keyfile);
fp = fopen(keyfile, "r");
if(fp != NULL) {
if((key_len = read_file(fp, &keyfile_buf)) > 0) {
// printf("\nYour private-key:\t'%s'\n", keyfile_buf);
size_t keyLength;
uint8 *bin_keyfile_buf = NewBase64Decode((const char *) keyfile_buf, key_len, &keyLength);
/* base-64 decode user's private key */
debug("Base-64 decoded buffer:\t");
print_buffer_as_hex(bin_keyfile_buf, keyLength);
result = libfenc_import_secret_key(&context, &secret_key, bin_keyfile_buf, keyLength);
report_error("Importing secret key", result);
free(keyfile_buf);
}
}
else {
fprintf(stderr, "Could not load input file: %s\n", keyfile);
/* clear allocated possibly allocated memory */
return FALSE;
}
fclose(fp);
size_t abeLength;
uint8 *data = NewBase64Decode((const char *) abe_blob64, strlen(abe_blob64), &abeLength);
ciphertext.data = data;
ciphertext.data_len = abeLength;
ciphertext.max_len = abeLength;
/* Descrypt the resulting ciphertext. */
result = libfenc_decrypt(&context, &ciphertext, &secret_key, &aes_session_key);
report_error("Decrypting the ciphertext", result);
debug("Decrypted session key is: ");
print_buffer_as_hex(aes_session_key.data, aes_session_key.data_len);
/* decode the iv_blob64 */
size_t ivLength;
char *ivec = NewBase64Decode((const char *) iv_blob64, strlen(iv_blob64), &ivLength);
debug("IV: ");
print_buffer_as_hex((uint8 *) ivec, AES_BLOCK_SIZE);
/* decode the aesblob64 */
size_t aesLength;
char *aesblob = NewBase64Decode((const char *) aes_blob64, strlen(aes_blob64), &aesLength);
/* use the PSK to encrypt using openssl functions here */
AES_KEY sk;
char aes_result[aesLength+1];
AES_set_decrypt_key((uint8 *) aes_session_key.data, 8*SESSION_KEY_LEN, &sk);
memset(aes_result, 0, aesLength+1);
AES_cbc_encrypt((uint8 *) aesblob, (uint8 *) aes_result, aesLength, &sk, (uint8 *) ivec, AES_DECRYPT);
/* base-64 both ciphertext and write to the stdout -- in XML? */
char magic[strlen(MAGIC)+1];
memset(magic, 0, strlen(MAGIC)+1);
strncpy(magic, aes_result, strlen(MAGIC));
if(strcmp(magic, MAGIC) == 0) {
debug("Recovered magic: '%s'\n", magic);
debug("Plaintext: %s\n", (char *) (aes_result + strlen(MAGIC)));
magic_failed = FALSE;
}
else {
fprintf(stderr, "ERROR: ABE decryption unsuccessful!!\n");
magic_failed = TRUE;
}
/* free allocated memory */
free(aesblob);
free(aes_blob64);
free(ivec);
free(iv_blob64);
free(data);
free(abe_blob64);
/* Destroy the context. */
result = libfenc_destroy_context(&context);
report_error("Destroying the encryption context", result);
/* Shutdown the library. */
result = libfenc_shutdown();
report_error("Shutting down library", result);
return magic_failed;
}
void generate_keys(char *outfile, FENC_SCHEME_TYPE scheme, char *secret_params, char *public_params)
{
FENC_ERROR result;
fenc_context context;
fenc_group_params group_params;
fenc_global_params global_params;
fenc_function_input func_object_input; // could be policy or list
pairing_t pairing;
fenc_key key;
fenc_key key2;
FILE *fp;
char c;
size_t pub_len = 0, sec_len = 0;
size_t serialized_len = 0;
uint8 public_params_buf[SIZE];
uint8 secret_params_buf[SIZE];
// char session_key[SESSION_KEY_LEN];
uint8 output_str[SIZE];
size_t output_str_len = 0;
// size_t session_key_len;
/* Clear data structures. */
memset(&context, 0, sizeof(fenc_context));
memset(&group_params, 0, sizeof(fenc_group_params));
memset(&global_params, 0, sizeof(fenc_global_params));
memset(&public_params_buf, 0, SIZE);
memset(&secret_params_buf, 0, SIZE);
memset(output_str, 0, SIZE);
/* stores user's authorized attributes */
memset(&func_object_input, 0, sizeof(fenc_function_input));
/* stores the user's private key */
memset(&key, 0, sizeof(fenc_key));
memset(&key2, 0, sizeof(fenc_key));
/* Initialize the library. */
result = libfenc_init();
/* Create a Sahai-Waters context. */
result = libfenc_create_context(&context, scheme);
/* Load group parameters from a file. */
fp = fopen(PARAM, "r");
if (fp != NULL) {
libfenc_load_group_params_from_file(&group_params, fp);
libfenc_get_pbc_pairing(&group_params, pairing);
} else {
perror("Could not open parameters file.\n");
return;
}
fclose(fp);
/* Set up the global parameters. */
result = context.generate_global_params(&global_params, &group_params);
report_error("Loading global parameters", result);
result = libfenc_gen_params(&context, &global_params);
report_error("Generating scheme parameters and secret key", result);
printf("Reading the public parameters file = %s\n", public_params);
/* read file */
fp = fopen(public_params, "r");
if(fp != NULL) {
while (TRUE) {
c = fgetc(fp);
if(c != EOF) {
public_params_buf[pub_len] = c;
pub_len++;
}
else {
break;
}
}
}
else {
perror("File does not exist.\n");
return;
}
fclose(fp);
printf("Reading the secret parameters file = %s\n", secret_params);
/* read file */
fp = fopen(secret_params, "r");
if(fp != NULL) {
while (TRUE) {
c = fgetc(fp);
if(c != EOF) {
secret_params_buf[sec_len] = c;
sec_len++;
}
else {
break;
}
}
}
else {
perror("File does not exist.\n");
return;
}
fclose(fp);
printf("public params input = '%s'\n", public_params_buf);
printf("secret params input = '%s'\n", secret_params_buf);
/* base-64 decode */
uint8 *bin_public_buf = NewBase64Decode((const char *) public_params_buf, pub_len, &serialized_len);
/* Import the parameters from binary buffer: */
result = libfenc_import_public_params(&context, bin_public_buf, serialized_len);
report_error("Importing public parameters", result);
uint8 *bin_secret_buf = NewBase64Decode((const char *) secret_params_buf, sec_len, &serialized_len);
result = libfenc_import_secret_params(&context, bin_secret_buf, serialized_len, NULL, 0);
report_error("Importing secret parameters", result);
if(scheme == FENC_SCHEME_LSW) {
fenc_create_func_input_for_policy(policy_string, &func_object_input);
debug_print_policy((fenc_attribute_policy *)(func_object_input.scheme_input));
free(policy_string);
}
else if(scheme == FENC_SCHEME_WATERSCP || scheme == FENC_SCHEME_WATERSSIMPLECP) {
fenc_create_func_input_for_attributes(attribute_string, &func_object_input);
debug_print_attribute_list((fenc_attribute_list*)(func_object_input.scheme_input));
free(attribute_string);
}
result = libfenc_extract_key(&context, &func_object_input, &key);
report_error("Extracting a decryption key", result);
uint8 *buffer = malloc(KEYSIZE_MAX);
memset(buffer, 0, KEYSIZE_MAX);
result = libfenc_export_secret_key(&context, &key, buffer, KEYSIZE_MAX, &serialized_len);
report_error("Exporting key", result);
size_t keyLength;
char *secret_key_buf = NewBase64Encode(buffer, serialized_len, FALSE, &keyLength);
// printf("Your secret-key:\t'%s'\nKey-len:\t'%zd'\n", secret_key_buf, serialized_len);
fp = fopen(outfile, "w");
if(fp != NULL) {
fprintf(fp, "%s", secret_key_buf);
}
else {
perror("Error writing private key.");
}
fclose(fp);
/*
printf("........Confirming contents of exported key......\n");
printf("Buffer contents:\n");
print_buffer_as_hex(buffer, serialized_len);
if(scheme == FENC_SCHEME_LSW) {
result = libfenc_import_secret_key(&context, &key2, buffer, serialized_len);
report_error("Import secret key", result);
fenc_key_LSW *myKey2 = (fenc_key_LSW *) key2.scheme_key;
size_t serialized_len2;
uint8 *buffer2 = malloc(KEYSIZE_MAX);
memset(buffer2, 0, KEYSIZE_MAX);
result = libfenc_serialize_key_LSW(myKey2, buffer2, KEYSIZE_MAX, &serialized_len2);
report_error("Serialize user's key", result);
printf("Key-len2: '%zu'\n", serialized_len2);
printf("Buffer contents 2:\n");
print_buffer_as_hex(buffer2, serialized_len2);
} */
cleanup:
fenc_func_input_clear(&func_object_input);
/* Destroy the context. */
result = libfenc_destroy_context(&context);
report_error("Destroying context", result);
/* Shutdown the library. */
result = libfenc_shutdown();
report_error("Shutting down library", result);
/* free buffer */
free(buffer);
return;
}
