PostLAMessaging.cpp 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171
  1. //
  2. // Created by miti on 2019-12-24.
  3. //
  4. #include "PostLAMessages.pb.h"
  5. #include "PostLAMessaging.h"
  6. #include <unistd.h>
  7. #include <stdio.h>
  8. #include "Decryptor_u.h"
  9. int PostLAMessaging::process_target_data_msg(extension_to_decryptor_msg& incomingMsg, decryptor_to_extension_msg& outgoingMsg)
  10. {
  11. const char* client_public_key;
  12. uint8_t* incoming_client_data, *outgoing_client_data;
  13. uint32_t* input_field_sizes, *output_field_sizes;
  14. std::string client_public_key_string, field_string;
  15. uint32_t sgx_ret_status, client_public_key_length, field_counter, byte_counter, field_size, no_of_fields, total_input_length, field_size_accumulator;
  16. // Initialize the client public key as an input to the decryptor ecall
  17. client_public_key_string = incomingMsg.ciphertext_client_public_key();
  18. client_public_key_length = client_public_key_string.length();
  19. // client_public_key = (uint8_t*) malloc(client_public_key_length);
  20. client_public_key = client_public_key_string.c_str();
  21. // Initialize an array of sizes of each of the incoming ciphertext fields (again an input arg. to the ecall).
  22. // Initialize an array to store the sizes of the *outgoing* fields too.
  23. no_of_fields = incomingMsg.fields_size();
  24. input_field_sizes = (uint32_t*) malloc(no_of_fields);
  25. output_field_sizes = (uint32_t*) malloc(no_of_fields);
  26. total_input_length = 0;
  27. for(field_counter=0; field_counter<no_of_fields; field_counter++)
  28. {
  29. input_field_sizes[field_counter] = incomingMsg.fields(field_counter).field().length();
  30. total_input_length+=input_field_sizes[field_counter];
  31. }
  32. // Initialize a contiguous array of bytes of the ciphertext fields.
  33. // The number of bytes in any given ciphertext field will be determined by the above array.
  34. // Also initialize an array to store the outgoing bytes for all ciphertext fields.
  35. incoming_client_data = (uint8_t*) malloc(total_input_length);
  36. outgoing_client_data = (uint8_t*) malloc(total_input_length);
  37. for(field_counter=0; field_counter<no_of_fields; field_counter++)
  38. {
  39. field_size = input_field_sizes[field_counter];
  40. field_string = incomingMsg.fields(field_counter).field().c_str();
  41. for(byte_counter=0; byte_counter<field_size; byte_counter++)
  42. {
  43. incoming_client_data[field_size_accumulator + byte_counter] = field_string[byte_counter];
  44. }
  45. field_size_accumulator += field_size;
  46. }
  47. sgx_ret_status=0;
  48. // TODO: Fix enclave ecall.
  49. // Ecall into the enclave to obtain the fields to be sent to the target enclave in response.
  50. // Decryptor_functionX(enclave_id, &sgx_ret_status, client_public_key, incoming_client_data, no_of_fields, input_field_sizes, outgoing_client_data, output_field_sizes);
  51. free(input_field_sizes);
  52. free(incoming_client_data);
  53. if(sgx_ret_status!=0)
  54. {
  55. printf("Could not process client's data. Had error: %ud\n", sgx_ret_status);
  56. free(outgoing_client_data);
  57. free(output_field_sizes);
  58. return sgx_ret_status;
  59. }
  60. // Initialize the outgoing protobuf message using the field sizes in the outgoing_field_size array and the bytes in the outgoing_client_data array.
  61. field_size_accumulator=0;
  62. for(field_counter=0; field_counter<no_of_fields; field_counter++)
  63. {
  64. field_size = output_field_sizes[field_counter];
  65. outgoingMsg.add_fields()->set_field(outgoing_client_data + field_size_accumulator,field_size);
  66. field_size_accumulator += field_size;
  67. }
  68. free(outgoing_client_data);
  69. free(output_field_sizes);
  70. return 0;
  71. }
  72. void PostLAMessaging::set_enclave_id(int given_id)
  73. {
  74. enclave_id = given_id;
  75. }
  76. int PostLAMessaging::receive_token_from_verifier()
  77. {
  78. uint8_t* token = (uint8_t*) malloc(400);
  79. uint32_t token_length = read(verifier_fd, token, 400);
  80. uint32_t sgx_ret_status;
  81. if(token_length < 0)
  82. {
  83. printf("Could not read verifier's token.\n"); fflush(stdout);
  84. return 0x1;
  85. }
  86. else if(token_length > 400)
  87. {
  88. printf("Could not fit all of verifiers token into the buffer.\n"); fflush(stdout);
  89. return 0x2;
  90. }
  91. Decryptor_process_verifiers_message_wrapper(enclave_id, &sgx_ret_status, token, token_length);
  92. free(token);
  93. return sgx_ret_status;
  94. }
  95. int PostLAMessaging::receive_decrypt_client_data_from_target()
  96. {
  97. extension_to_decryptor_msg incomingMsg;
  98. decryptor_to_extension_msg outgoingMsg;
  99. int ret_status;
  100. if( targetChannelData.read_msg(incomingMsg) != 0)
  101. {
  102. printf("Error in protobuf in receiving msg from target.\n"); fflush(stdout);
  103. return 0x1;
  104. }
  105. ret_status = process_target_data_msg(incomingMsg, outgoingMsg);
  106. if(ret_status != 0)
  107. {
  108. printf("Error in processing msg from target.\n"); fflush(stdout);
  109. return 0x2;
  110. }
  111. if( targetChannelData.write_msg(outgoingMsg) != 0)
  112. {
  113. printf("Error in protobuf in sending msg to target.\n"); fflush(stdout);
  114. return 0x3;
  115. }
  116. return 0;
  117. }
  118. int PostLAMessaging::read_and_write_header()
  119. {
  120. uint32_t sgx_ret_status, value_length, protobuf_ret_status;
  121. uint8_t* header_value = (uint8_t*) malloc(400);
  122. mitigator_header headerMsg;
  123. if(targetChannelHeaders.read_msg(headerMsg) != 0)
  124. {
  125. printf("Error in reading msg for headers.\n"); fflush(stdout); return 0x1;
  126. }
  127. Decryptor_create_and_encrypt_mitigator_header_H_wrapper(enclave_id, &sgx_ret_status, header_value, &value_length);
  128. if(sgx_ret_status != 0 )
  129. {
  130. printf("Could not create mitigator header.\n");
  131. fflush(stdout);
  132. return sgx_ret_status;
  133. }
  134. headerMsg.set_name("Mitigator-Public-Key:", 21);
  135. headerMsg.set_value(header_value, value_length);
  136. free(header_value);
  137. protobuf_ret_status = targetChannelHeaders.write_msg(headerMsg);
  138. return protobuf_ret_status;
  139. }
  140. void PostLAMessaging::set_verifier_fd(int fd)
  141. {
  142. verifier_fd = fd;
  143. }
  144. void PostLAMessaging::set_target_data_fd(int fd)
  145. {
  146. targetChannelData.set_fd(fd);
  147. }
  148. void PostLAMessaging::set_target_headers_fd(int fd)
  149. {
  150. targetChannelHeaders.set_fd(fd);
  151. }