Resolved a stupid error due to wrongly reseting an output pointer.

Also added in a couple functions for writing to a filename to FileIO.
(Can remove later if needed)

App/App.cpp

@@ -26,7 +26,7 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[])
     status = sgx_create_enclave(Decryptor_PATH, SGX_DEBUG_FLAG, &launch_token, &launch_token_updated, &enclave_id, NULL);
     if(status != SGX_SUCCESS)
     {
-        printf("\nLoad Enclave Failure");
+        printf("\nLoad Enclave Failure: 0x%02x \n", status);
         return -1;
     }
     printf("\nDecryptor - EnclaveID %" PRIx64, enclave_id);
@@ -35,7 +35,7 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[])
     ret_status = SealingUntrusted::look_for_signing_key_or_regenerate_it(enclave_id, "sealed_signing_key.txt");
     if(ret_status != 0)
     {
-        printf("Some error \n");
+        printf("Error in unsealing or generating LT signing verification keypair: 0x%02x \n", ret_status);
         fflush(stdout);
         sgx_destroy_enclave(enclave_id);
         return 0xFFFFFFFF;

App/FileIO.cpp

@@ -5,17 +5,6 @@
 #include "UntrustedInclude/FileIO.h"
 
 namespace FileIO {
-    /*
-        FILE* file;
-        file = fopen(filename, "w");
-        if(file == NULL)
-            return errno;
-
-        fd = fileno(file);
-        if(fd == -1)
-            return errno;
-        */
-
     int write_to_fd(int fd, uint8_t* msg, size_t* expected_msg_length)
     {
         ssize_t bytes_written;
@@ -42,7 +31,45 @@ namespace FileIO {
         return 0;
     }
 
-    size_t check_if_file_exists_return_size(char* filename, int* fd_ptr)
+    int write_to_filename(char* filename, uint8_t* msg, size_t* expected_msg_length)
+    {
+        ssize_t bytes_written;
+        FILE* file;
+
+        file = fopen(filename, "w");
+        if(file == NULL)
+            return 2;
+
+        bytes_written = fwrite(msg, 1, *expected_msg_length, file);
+        if(bytes_written == -1)
+            return -1;
+
+        fsync(fileno(file));
+        *expected_msg_length = bytes_written;
+        fclose(file);
+        return 0;
+    }
+
+    int read_from_filename(char* filename, uint8_t* msg, size_t* expected_msg_length)
+    {
+        ssize_t bytes_read;
+        FILE* file;
+
+        file = fopen(filename, "r");
+        if(file == NULL)
+            return 2;
+
+        int fd = fileno(file);
+
+        bytes_read = fread(msg, 1, *expected_msg_length, file);
+        if(bytes_read == -1)
+            return -1;
+        *expected_msg_length = bytes_read;
+        fclose(file);
+        return 0;
+    }
+
+    size_t check_if_file_exists_return_size(char* filename)
     {
         int fd, ret_status;
         FILE* file;
@@ -65,8 +92,7 @@ namespace FileIO {
             fflush(stderr);
             return 0;
         }
-
-        *fd_ptr = fd;
+        fclose(file);
         return st.st_size;
     }
 };

App/SealingUntrusted.cpp

@@ -7,7 +7,7 @@
 namespace SealingUntrusted {
 
     namespace {
-        int create_and_seal_signing_key_pair_to_disk(sgx_enclave_id_t enclave_id, int fd)
+        int create_and_seal_signing_key_pair_to_disk(sgx_enclave_id_t enclave_id, char* filename)
         {
             uint32_t ret_status=0, counter=0;
             size_t length=0;
@@ -30,27 +30,28 @@ namespace SealingUntrusted {
             for(counter=0; counter<length; counter++)
                 printf("%02x ", sealed_data[counter]);
 
-            ret_status = FileIO::write_to_fd(fd, sealed_data, &length);
+            ret_status = FileIO::write_to_filename(filename, sealed_data, &length);
             free(sealed_data);
 
             return ret_status;
         }
 
-        int unseal_signing_key_pair_from_disk(sgx_enclave_id_t enclave_id, int fd, size_t sealed_msg_length_in_file)
+        int unseal_signing_key_pair_from_disk(sgx_enclave_id_t enclave_id, char* filename, size_t sealed_msg_length_in_file)
         {
             uint32_t ret_status=0, counter=0;
             size_t length=sealed_msg_length_in_file;
             uint8_t* sealed_data;
 
             sealed_data = (uint8_t*) malloc(sealed_msg_length_in_file);
-            ret_status = FileIO::read_from_fd(fd, sealed_data, &length);
+            ret_status = FileIO::read_from_filename(filename, sealed_data, &length);
             if(ret_status == -1)
             {
                 free(sealed_data);
                 return -1;
             }
-            length=ret_status;
 
+            printf("Here's the chars my dudes: they are of length %d.\n", length);
+            fflush(stdout);
             for(counter=0;counter<length;counter++)
                 printf("%x ", *(sealed_data+counter));
             printf("\n");  fflush(stdout);
@@ -67,18 +68,18 @@ namespace SealingUntrusted {
         uint32_t ret_status;
         int fd;
 
-        sealed_key_size = FileIO::check_if_file_exists_return_size(filename, &fd);
+        sealed_key_size = FileIO::check_if_file_exists_return_size(filename);
         if(sealed_key_size == 0) // File is empty. create signing key pair.
         {
             printf("Creating new keypair.\n"); fflush(stdout);
-            ret_status = create_and_seal_signing_key_pair_to_disk(enclave_id, fd);
+            ret_status = create_and_seal_signing_key_pair_to_disk(enclave_id, filename);
         }
         else
         {
-            printf("Unsealing keypair.\n"); fflush(stdout);
-            ret_status = unseal_signing_key_pair_from_disk(enclave_id, fd, sealed_key_size);
+            printf("Unsealing keypair of size %d.\n", sealed_key_size); fflush(stdout);
+            ret_status = unseal_signing_key_pair_from_disk(enclave_id, filename, sealed_key_size);
         }
-        close(fd);
+
         return ret_status;
     }
 }

App/UntrustedInclude/FileIO.h

@@ -16,11 +16,15 @@
 #include <stdio.h> // For fopen
 
 namespace FileIO {
+    int write_to_filename(char* filename, uint8_t* msg, size_t* expected_msg_length);
+
+    int read_from_filename(char* filename, uint8_t* msg, size_t* expected_msg_length);
+
     int write_to_fd(int fd, uint8_t* msg, size_t* expected_msg_length);
 
     int read_from_fd(int fd, uint8_t* msg, size_t* expected_msg_length);
 
-    size_t check_if_file_exists_return_size(char* filename, int* fd_ptr);
+    size_t check_if_file_exists_return_size(char* filename);
 };