[Assignment-7] add SGX sample code from VM

Assignment 7 - SGX Hands-on/SGX101_sample_code-master/ProcessLocalAttestation/Enclave2/Enclave3/Enclave3.config.xml

@@ -0,0 +1,12 @@
+<EnclaveConfiguration> 
+  <ProdID>0</ProdID> 
+  <ISVSVN>0</ISVSVN> 
+  <StackMaxSize>0x40000</StackMaxSize> 
+  <HeapMaxSize>0x100000</HeapMaxSize> 
+  <TCSNum>1</TCSNum> 
+  <TCSPolicy>1</TCSPolicy>
+  <!-- Recommend changing 'DisableDebug' to 1 to make the enclave undebuggable for enclave release -->
+  <DisableDebug>0</DisableDebug> 
+  <MiscSelect>0</MiscSelect>
+  <MiscMask>0xFFFFFFFF</MiscMask>
+</EnclaveConfiguration>

Assignment 7 - SGX Hands-on/SGX101_sample_code-master/ProcessLocalAttestation/Enclave2/Enclave3/Enclave3.cpp

@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2011-2018 Intel Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Intel Corporation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+// Enclave3.cpp : Defines the exported functions for the DLL application
+#include "sgx_eid.h"
+#include "Enclave3_t.h"
+#include "EnclaveMessageExchange.h"
+#include "error_codes.h"
+#include "Utility_E3.h"
+#include "sgx_thread.h"
+#include "sgx_dh.h"
+#include <map>
+
+#define UNUSED(val) (void)(val)
+
+std::map<sgx_enclave_id_t, dh_session_t>g_src_session_info_map;
+
+static uint32_t e3_foo1_wrapper(ms_in_msg_exchange_t *ms, size_t param_lenth, char** resp_buffer, size_t* resp_length);
+
+//Function pointer table containing the list of functions that the enclave exposes
+const struct {
+    size_t num_funcs;
+    const void* table[1];
+} func_table = {
+    1,
+    {
+        (const void*)e3_foo1_wrapper,
+    }
+};
+
+//Makes use of the sample code function to establish a secure channel with the destination enclave
+uint32_t test_create_session(sgx_enclave_id_t src_enclave_id,
+                          sgx_enclave_id_t dest_enclave_id)
+{
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    dh_session_t dest_session_info;
+    //Core reference code function for creating a session
+    ke_status = create_session(src_enclave_id, dest_enclave_id,&dest_session_info);
+    if(ke_status == SUCCESS)
+    {
+        //Insert the session information into the map under the corresponding destination enclave id
+        g_src_session_info_map.insert(std::pair<sgx_enclave_id_t, dh_session_t>(dest_enclave_id, dest_session_info));
+    }
+    memset(&dest_session_info, 0, sizeof(dh_session_t));
+    return ke_status;
+}
+
+//Makes use of the sample code function to do an enclave to enclave call (Test Vector)
+uint32_t test_enclave_to_enclave_call(sgx_enclave_id_t src_enclave_id,
+                                          sgx_enclave_id_t dest_enclave_id)
+{
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    external_param_struct_t *p_struct_var, struct_var;
+    internal_param_struct_t internal_struct_var;
+    uint32_t target_fn_id, msg_type;
+    char* marshalled_inp_buff;
+    size_t marshalled_inp_buff_len;
+    char* out_buff;
+    size_t out_buff_len;
+    dh_session_t *dest_session_info;
+    size_t max_out_buff_size;
+    char* retval;
+
+    max_out_buff_size = 50;
+    msg_type = ENCLAVE_TO_ENCLAVE_CALL;
+    target_fn_id = 0;
+    internal_struct_var.ivar1 = 0x5;
+    internal_struct_var.ivar2 = 0x6;
+    struct_var.var1 = 0x3;
+    struct_var.var2 = 0x4;
+    struct_var.p_internal_struct = &internal_struct_var;
+    p_struct_var = &struct_var;
+
+    size_t len_data = sizeof(struct_var) - sizeof(struct_var.p_internal_struct);
+    size_t len_ptr_data = sizeof(internal_struct_var);
+
+    //Marshals the input parameters for calling function foo1 in Enclave1 into a input buffer
+    ke_status = marshal_input_parameters_e1_foo1(target_fn_id, msg_type, p_struct_var, len_data,
+                                len_ptr_data, &marshalled_inp_buff, &marshalled_inp_buff_len);
+
+    if(ke_status != SUCCESS)
+    {
+        return ke_status;
+    }
+
+    //Search the map for the session information associated with the destination enclave id passed in
+    std::map<sgx_enclave_id_t, dh_session_t>::iterator it = g_src_session_info_map.find(dest_enclave_id);
+    if(it != g_src_session_info_map.end())
+    {
+        dest_session_info = &it->second;
+    }
+    else
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        return INVALID_SESSION;
+    }
+
+    //Core Reference Code function
+    ke_status = send_request_receive_response(src_enclave_id, dest_enclave_id, dest_session_info,
+                  marshalled_inp_buff, marshalled_inp_buff_len, max_out_buff_size, &out_buff, &out_buff_len);
+
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+
+    ////Un-marshal the return value and output parameters from foo1 of Enclave1
+    ke_status = unmarshal_retval_and_output_parameters_e1_foo1(out_buff, p_struct_var, &retval);
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+
+    SAFE_FREE(marshalled_inp_buff);
+    SAFE_FREE(out_buff);
+    SAFE_FREE(retval);
+    return SUCCESS;
+}
+
+//Makes use of the sample code function to do a generic secret message exchange (Test Vector)
+uint32_t test_message_exchange(sgx_enclave_id_t src_enclave_id,
+                               sgx_enclave_id_t dest_enclave_id)
+{
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    uint32_t target_fn_id, msg_type;
+    char* marshalled_inp_buff;
+    size_t marshalled_inp_buff_len;
+    char* out_buff;
+    size_t out_buff_len;
+    dh_session_t *dest_session_info;
+    size_t max_out_buff_size;
+    char* secret_response;
+    uint32_t secret_data;
+
+    target_fn_id = 0;
+    msg_type = MESSAGE_EXCHANGE;
+    max_out_buff_size = 50;
+    secret_data = 0x12345678; //Secret Data here is shown only for purpose of demonstration.
+
+    //Marshals the parameters into a buffer
+    ke_status = marshal_message_exchange_request(target_fn_id, msg_type, secret_data, &marshalled_inp_buff, &marshalled_inp_buff_len);
+    if(ke_status != SUCCESS)
+    {
+        return ke_status;
+    }
+    //Search the map for the session information associated with the destination enclave id passed in
+    std::map<sgx_enclave_id_t, dh_session_t>::iterator it = g_src_session_info_map.find(dest_enclave_id);
+    if(it != g_src_session_info_map.end())
+    {
+        dest_session_info = &it->second;
+    }
+    else
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        return INVALID_SESSION;
+    }
+
+    //Core Reference Code function
+    ke_status = send_request_receive_response(src_enclave_id, dest_enclave_id, dest_session_info, marshalled_inp_buff,
+                                                marshalled_inp_buff_len, max_out_buff_size, &out_buff, &out_buff_len);
+
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+    //Un-marshal the secret response data
+    ke_status = umarshal_message_exchange_response(out_buff, &secret_response);
+    if(ke_status != SUCCESS)
+    {
+        SAFE_FREE(marshalled_inp_buff);
+        SAFE_FREE(out_buff);
+        return ke_status;
+    }
+
+    SAFE_FREE(marshalled_inp_buff);
+    SAFE_FREE(out_buff);
+    SAFE_FREE(secret_response);
+    return SUCCESS;
+}
+
+
+//Makes use of the sample code function to close a current session
+uint32_t test_close_session(sgx_enclave_id_t src_enclave_id,
+                                sgx_enclave_id_t dest_enclave_id)
+{
+    dh_session_t dest_session_info;
+    ATTESTATION_STATUS ke_status = SUCCESS;
+    //Search the map for the session information associated with the destination enclave id passed in
+    std::map<sgx_enclave_id_t, dh_session_t>::iterator it = g_src_session_info_map.find(dest_enclave_id);
+    if(it != g_src_session_info_map.end())
+    {
+        dest_session_info = it->second;
+    }
+    else
+    {
+        return NULL;
+    }
+    //Core reference code function for closing a session
+    ke_status = close_session(src_enclave_id, dest_enclave_id);
+
+    //Erase the session information associated with the destination enclave id
+    g_src_session_info_map.erase(dest_enclave_id);
+    return ke_status;
+}
+
+//Function that is used to verify the trust of the other enclave
+//Each enclave can have its own way verifying the peer enclave identity
+extern "C" uint32_t verify_peer_enclave_trust(sgx_dh_session_enclave_identity_t* peer_enclave_identity)
+{
+    if(!peer_enclave_identity)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    if(peer_enclave_identity->isv_prod_id != 0 || !(peer_enclave_identity->attributes.flags & SGX_FLAGS_INITTED))
+        // || peer_enclave_identity->attributes.xfrm !=3)// || peer_enclave_identity->mr_signer != xx //TODO: To be hardcoded with values to check
+    {
+        return ENCLAVE_TRUST_ERROR;
+    }
+    else
+    {
+        return SUCCESS;
+    }
+}
+
+
+//Dispatch function that calls the approriate enclave function based on the function id
+//Each enclave can have its own way of dispatching the calls from other enclave
+extern "C" uint32_t enclave_to_enclave_call_dispatcher(char* decrypted_data,
+                                                       size_t decrypted_data_length,
+                                                       char** resp_buffer,
+                                                       size_t* resp_length)
+{
+    ms_in_msg_exchange_t *ms;
+    uint32_t (*fn1)(ms_in_msg_exchange_t *ms, size_t, char**, size_t*);
+    if(!decrypted_data || !resp_length)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    ms = (ms_in_msg_exchange_t *)decrypted_data;
+    if(ms->target_fn_id >= func_table.num_funcs)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    fn1 = (uint32_t (*)(ms_in_msg_exchange_t*, size_t, char**, size_t*))func_table.table[ms->target_fn_id];
+    return fn1(ms, decrypted_data_length, resp_buffer, resp_length);
+}
+
+//Operates on the input secret and generates the output secret
+uint32_t get_message_exchange_response(uint32_t inp_secret_data)
+{
+    uint32_t secret_response;
+
+    //User should use more complex encryption method to protect their secret, below is just a simple example
+    secret_response = inp_secret_data & 0x11111111;
+
+    return secret_response;
+
+}
+//Generates the response from the request message
+extern "C" uint32_t message_exchange_response_generator(char* decrypted_data,
+                                              char** resp_buffer,
+                                              size_t* resp_length)
+{
+    ms_in_msg_exchange_t *ms;
+    uint32_t inp_secret_data;
+    uint32_t out_secret_data;
+    if(!decrypted_data || !resp_length)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    ms = (ms_in_msg_exchange_t *)decrypted_data;
+
+    if(umarshal_message_exchange_request(&inp_secret_data,ms) != SUCCESS)
+        return ATTESTATION_ERROR;
+
+    out_secret_data = get_message_exchange_response(inp_secret_data);
+
+    if(marshal_message_exchange_response(resp_buffer, resp_length, out_secret_data) != SUCCESS)
+        return MALLOC_ERROR;
+
+    return SUCCESS;
+
+}
+
+
+static uint32_t e3_foo1(param_struct_t *p_struct_var)
+{
+    if(!p_struct_var)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    p_struct_var->var1++;
+    p_struct_var->var2++;
+
+    return(p_struct_var->var1 * p_struct_var->var2);
+}
+
+//Function which is executed on request from the source enclave
+static uint32_t e3_foo1_wrapper(ms_in_msg_exchange_t *ms,
+                    size_t param_lenth,
+                    char** resp_buffer,
+                    size_t* resp_length)
+{
+    UNUSED(param_lenth);
+    
+    uint32_t ret;
+    param_struct_t *p_struct_var;
+    if(!ms || !resp_length)
+    {
+        return INVALID_PARAMETER_ERROR;
+    }
+    p_struct_var = (param_struct_t*)malloc(sizeof(param_struct_t));
+    if(!p_struct_var)
+        return MALLOC_ERROR;
+
+    if(unmarshal_input_parameters_e3_foo1(p_struct_var, ms) != SUCCESS)
+    {
+        SAFE_FREE(p_struct_var);
+        return ATTESTATION_ERROR;
+    }
+
+    ret = e3_foo1(p_struct_var);
+
+    if(marshal_retval_and_output_parameters_e3_foo1(resp_buffer, resp_length, ret, p_struct_var) != SUCCESS)
+    {
+        SAFE_FREE(p_struct_var);
+        return MALLOC_ERROR;
+    }
+    SAFE_FREE(p_struct_var);
+    return SUCCESS;
+}

Assignment 7 - SGX Hands-on/SGX101_sample_code-master/ProcessLocalAttestation/Enclave2/Enclave3/Enclave3.edl

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2011-2018 Intel Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Intel Corporation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+enclave {
+    include "sgx_eid.h"
+    from "../LocalAttestationCode/LocalAttestationCode.edl" import *;
+    from "sgx_tstdc.edl" import *;
+    trusted{
+        public uint32_t test_create_session(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+        public uint32_t test_enclave_to_enclave_call(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+        public uint32_t test_message_exchange(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+        public uint32_t test_close_session(sgx_enclave_id_t src_enclave_id, sgx_enclave_id_t dest_enclave_id);
+    };
+};

Assignment 7 - SGX Hands-on/SGX101_sample_code-master/ProcessLocalAttestation/Enclave2/Enclave3/Enclave3.lds

@@ -0,0 +1,10 @@
+Enclave3.so
+{
+    global:
+        g_global_data_sim;
+        g_global_data;
+        enclave_entry;
+        g_peak_heap_used;
+    local:
+        *;
+};

Assignment 7 - SGX Hands-on/SGX101_sample_code-master/ProcessLocalAttestation/Enclave2/Enclave3/Enclave3_private.pem

@@ -0,0 +1,39 @@
+-----BEGIN RSA PRIVATE KEY-----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+-----END RSA PRIVATE KEY-----

Assignment 7 - SGX Hands-on/SGX101_sample_code-master/ProcessLocalAttestation/Enclave2/Enclave3/Utility_E3.cpp

@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2011-2018 Intel Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Intel Corporation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "sgx_eid.h"
+#include "EnclaveMessageExchange.h"
+#include "error_codes.h"
+#include "Utility_E3.h"
+#include "stdlib.h"
+#include "string.h"
+
+uint32_t marshal_input_parameters_e1_foo1(uint32_t target_fn_id, uint32_t msg_type, external_param_struct_t *p_struct_var, size_t len_data, size_t len_ptr_data, char** marshalled_buff, size_t* marshalled_buff_len)
+{
+    ms_in_msg_exchange_t *ms;
+    size_t param_len, ms_len;
+    char *temp_buff;
+    int* addr;
+    char* struct_data;
+    if(!p_struct_var || !marshalled_buff_len)
+        return INVALID_PARAMETER_ERROR;    
+    struct_data = (char*)p_struct_var;
+    temp_buff = (char*)malloc(len_data + len_ptr_data);
+    if(!temp_buff)
+        return MALLOC_ERROR;
+    memcpy(temp_buff, struct_data, len_data);
+    addr = *(int **)(struct_data + len_data);
+    memcpy(temp_buff + len_data, addr, len_ptr_data); //can be optimized
+    param_len = len_data + len_ptr_data;
+    ms_len =  sizeof(ms_in_msg_exchange_t) + param_len;
+    ms = (ms_in_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+    {
+        SAFE_FREE(temp_buff);
+        return MALLOC_ERROR;
+    }
+    ms->msg_type = msg_type;
+    ms->target_fn_id = target_fn_id;
+    ms->inparam_buff_len = (uint32_t)param_len;
+    memcpy(&ms->inparam_buff, temp_buff, param_len);
+    *marshalled_buff = (char*)ms;
+    *marshalled_buff_len = ms_len;
+        
+    SAFE_FREE(temp_buff);
+    return SUCCESS;
+}
+
+uint32_t marshal_retval_and_output_parameters_e3_foo1(char** resp_buffer, size_t* resp_length, uint32_t retval, param_struct_t *p_struct_var)
+{
+    ms_out_msg_exchange_t *ms;
+    size_t ret_param_len, ms_len;
+    char *temp_buff;
+    size_t retval_len;
+    if(!resp_length || !p_struct_var)
+        return INVALID_PARAMETER_ERROR;    
+    retval_len = sizeof(retval);
+    ret_param_len = sizeof(retval) + sizeof(param_struct_t);
+    temp_buff = (char*)malloc(ret_param_len);
+    if(!temp_buff)
+        return MALLOC_ERROR;
+    memcpy(temp_buff, &retval, sizeof(retval)); 
+    memcpy(temp_buff + sizeof(retval), p_struct_var, sizeof(param_struct_t));
+    ms_len = sizeof(ms_out_msg_exchange_t) + ret_param_len;
+    ms = (ms_out_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+    {
+        SAFE_FREE(temp_buff);
+        return MALLOC_ERROR;
+    }
+    ms->retval_len = (uint32_t)retval_len;
+    ms->ret_outparam_buff_len = (uint32_t)ret_param_len;
+    memcpy(&ms->ret_outparam_buff, temp_buff, ret_param_len);
+    *resp_buffer = (char*)ms;
+    *resp_length = ms_len;
+    SAFE_FREE(temp_buff);
+    return SUCCESS;
+}
+
+uint32_t unmarshal_input_parameters_e3_foo1(param_struct_t *pstruct, ms_in_msg_exchange_t* ms)
+{
+    char* buff;
+    size_t len;
+    if(!pstruct || !ms)
+        return INVALID_PARAMETER_ERROR;    
+    buff = ms->inparam_buff;
+    len = ms->inparam_buff_len;
+
+    if(len != (sizeof(pstruct->var1) + sizeof(pstruct->var2)))
+        return ATTESTATION_ERROR;
+
+    memcpy(&pstruct->var1, buff, sizeof(pstruct->var1));
+    memcpy(&pstruct->var2, buff + sizeof(pstruct->var1), sizeof(pstruct->var2)); 
+
+    return SUCCESS;
+}
+
+
+uint32_t unmarshal_retval_and_output_parameters_e1_foo1(char* out_buff, external_param_struct_t *p_struct_var, char** retval)
+{
+    size_t retval_len;
+    ms_out_msg_exchange_t *ms;
+    if(!out_buff || !p_struct_var)
+        return INVALID_PARAMETER_ERROR;    
+    ms = (ms_out_msg_exchange_t *)out_buff;
+    retval_len = ms->retval_len;
+    *retval = (char*)malloc(retval_len);
+    if(!*retval)
+    {
+        return MALLOC_ERROR;
+    }
+    memcpy(*retval, ms->ret_outparam_buff, retval_len);
+    memcpy(&p_struct_var->var1, (ms->ret_outparam_buff) + retval_len, sizeof(p_struct_var->var1));
+    memcpy(&p_struct_var->var2, (ms->ret_outparam_buff) + retval_len + sizeof(p_struct_var->var1), sizeof(p_struct_var->var2));
+    memcpy(&p_struct_var->p_internal_struct->ivar1, (ms->ret_outparam_buff) + retval_len + sizeof(p_struct_var->var1)+ sizeof(p_struct_var->var2), sizeof(p_struct_var->p_internal_struct->ivar1));
+    memcpy(&p_struct_var->p_internal_struct->ivar2, (ms->ret_outparam_buff) + retval_len + sizeof(p_struct_var->var1)+ sizeof(p_struct_var->var2) + sizeof(p_struct_var->p_internal_struct->ivar1), sizeof(p_struct_var->p_internal_struct->ivar2));
+    return SUCCESS;
+}
+
+
+uint32_t marshal_message_exchange_request(uint32_t target_fn_id, uint32_t msg_type, uint32_t secret_data, char** marshalled_buff, size_t* marshalled_buff_len)
+{
+    ms_in_msg_exchange_t *ms;
+    size_t secret_data_len, ms_len;
+    if(!marshalled_buff_len)
+        return INVALID_PARAMETER_ERROR;            
+    secret_data_len = sizeof(secret_data);
+    ms_len = sizeof(ms_in_msg_exchange_t) + secret_data_len;
+    ms = (ms_in_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+        return MALLOC_ERROR;
+
+    ms->msg_type = msg_type;
+    ms->target_fn_id = target_fn_id;
+    ms->inparam_buff_len = (uint32_t)secret_data_len;
+    memcpy(&ms->inparam_buff, &secret_data, secret_data_len);
+
+    *marshalled_buff = (char*)ms;
+    *marshalled_buff_len = ms_len;
+    return SUCCESS;
+}
+
+uint32_t umarshal_message_exchange_request(uint32_t* inp_secret_data, ms_in_msg_exchange_t* ms)
+{
+    char* buff;
+    size_t len;
+    if(!inp_secret_data || !ms)
+        return INVALID_PARAMETER_ERROR;    
+    buff = ms->inparam_buff;
+    len = ms->inparam_buff_len;
+
+    if(len != sizeof(uint32_t))
+        return ATTESTATION_ERROR;
+
+    memcpy(inp_secret_data, buff, sizeof(uint32_t));
+
+    return SUCCESS;
+}
+
+uint32_t marshal_message_exchange_response(char** resp_buffer, size_t* resp_length, uint32_t secret_response)
+{
+    ms_out_msg_exchange_t *ms;
+    size_t secret_response_len, ms_len;
+    size_t retval_len, ret_param_len;
+    if(!resp_length)
+        return INVALID_PARAMETER_ERROR;    
+    secret_response_len = sizeof(secret_response);
+    retval_len = secret_response_len;
+    ret_param_len = secret_response_len;
+    ms_len = sizeof(ms_out_msg_exchange_t) + ret_param_len;
+    ms = (ms_out_msg_exchange_t *)malloc(ms_len);
+    if(!ms)
+        return MALLOC_ERROR;
+    ms->retval_len = (uint32_t)retval_len;
+    ms->ret_outparam_buff_len = (uint32_t)ret_param_len;
+    memcpy(&ms->ret_outparam_buff, &secret_response, secret_response_len);
+    *resp_buffer = (char*)ms;
+    *resp_length = ms_len;
+     return SUCCESS;
+}
+
+uint32_t umarshal_message_exchange_response(char* out_buff, char** secret_response)
+{
+    size_t retval_len;
+    ms_out_msg_exchange_t *ms;
+    if(!out_buff)
+        return INVALID_PARAMETER_ERROR;    
+    ms = (ms_out_msg_exchange_t *)out_buff;
+    retval_len = ms->retval_len;
+    *secret_response = (char*)malloc(retval_len);
+    if(!*secret_response)
+    {
+        return MALLOC_ERROR;
+    }
+    memcpy(*secret_response, ms->ret_outparam_buff, retval_len);
+    return SUCCESS;
+}
+

Assignment 7 - SGX Hands-on/SGX101_sample_code-master/ProcessLocalAttestation/Enclave2/Enclave3/Utility_E3.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2011-2018 Intel Corporation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Intel Corporation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef UTILITY_E3_H__
+#define UTILITY_E3_H__
+
+#include "stdint.h"
+
+
+typedef struct _internal_param_struct_t
+{
+    uint32_t ivar1;
+    uint32_t ivar2;
+}internal_param_struct_t;
+
+typedef struct _external_param_struct_t
+{
+    uint32_t var1;
+    uint32_t var2;
+    internal_param_struct_t *p_internal_struct;
+}external_param_struct_t;
+
+typedef struct _param_struct_t
+{
+    uint32_t var1;
+    uint32_t var2;
+}param_struct_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint32_t marshal_input_parameters_e1_foo1(uint32_t target_fn_id, uint32_t msg_type, external_param_struct_t *p_struct_var, size_t len_data, size_t len_ptr_data, char** marshalled_buff, size_t* marshalled_buff_len);
+uint32_t unmarshal_retval_and_output_parameters_e1_foo1(char* out_buff, external_param_struct_t *p_struct_var, char** retval);
+uint32_t unmarshal_input_parameters_e3_foo1(param_struct_t *pstruct, ms_in_msg_exchange_t* ms);
+uint32_t marshal_retval_and_output_parameters_e3_foo1(char** resp_buffer, size_t* resp_length, uint32_t retval, param_struct_t *p_struct_var);
+uint32_t marshal_message_exchange_request(uint32_t target_fn_id, uint32_t msg_type, uint32_t secret_data, char** marshalled_buff, size_t* marshalled_buff_len);
+uint32_t umarshal_message_exchange_request(uint32_t* inp_secret_data, ms_in_msg_exchange_t* ms);
+uint32_t marshal_message_exchange_response(char** resp_buffer, size_t* resp_length, uint32_t secret_response);
+uint32_t umarshal_message_exchange_response(char* out_buff, char** secret_response);
+
+#ifdef __cplusplus
+ }
+#endif
+#endif